xref: /openssl/crypto/core_algorithm.c (revision e077455e)
1 /*
2  * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9 
10 #include <openssl/core.h>
11 #include <openssl/core_dispatch.h>
12 #include "internal/core.h"
13 #include "internal/property.h"
14 #include "internal/provider.h"
15 
16 struct algorithm_data_st {
17     OSSL_LIB_CTX *libctx;
18     int operation_id;            /* May be zero for finding them all */
19     int (*pre)(OSSL_PROVIDER *, int operation_id, int no_store, void *data,
20                int *result);
21     int (*reserve_store)(int no_store, void *data);
22     void (*fn)(OSSL_PROVIDER *, const OSSL_ALGORITHM *, int no_store,
23                void *data);
24     int (*unreserve_store)(void *data);
25     int (*post)(OSSL_PROVIDER *, int operation_id, int no_store, void *data,
26                 int *result);
27     void *data;
28 };
29 
30 /*
31  * Process one OSSL_ALGORITHM array, for the operation |cur_operation|,
32  * by constructing methods for all its implementations and adding those
33  * to the appropriate method store.
34  * Which method store is appropriate is given by |no_store| ("permanent"
35  * if 0, temporary if 1) and other data in |data->data|.
36  *
37  * Returns:
38  * -1 to quit adding algorithm implementations immediately
39  * 0 if not successful, but adding should continue
40  * 1 if successful so far, and adding should continue
41  */
algorithm_do_map(OSSL_PROVIDER * provider,const OSSL_ALGORITHM * map,int cur_operation,int no_store,void * cbdata)42 static int algorithm_do_map(OSSL_PROVIDER *provider, const OSSL_ALGORITHM *map,
43                             int cur_operation, int no_store, void *cbdata)
44 {
45     struct algorithm_data_st *data = cbdata;
46     int ret = 0;
47 
48     if (!data->reserve_store(no_store, data->data))
49         /* Error, bail out! */
50         return -1;
51 
52     /* Do we fulfill pre-conditions? */
53     if (data->pre == NULL) {
54         /* If there is no pre-condition function, assume "yes" */
55         ret = 1;
56     } else if (!data->pre(provider, cur_operation, no_store, data->data,
57                           &ret)) {
58         /* Error, bail out! */
59         ret = -1;
60         goto end;
61     }
62 
63     /*
64      * If pre-condition not fulfilled don't add this set of implementations,
65      * but do continue with the next.  This simply means that another thread
66      * got to it first.
67      */
68     if (ret == 0) {
69         ret = 1;
70         goto end;
71     }
72 
73     if (map != NULL) {
74         const OSSL_ALGORITHM *thismap;
75 
76         for (thismap = map; thismap->algorithm_names != NULL; thismap++)
77             data->fn(provider, thismap, no_store, data->data);
78     }
79 
80     /* Do we fulfill post-conditions? */
81     if (data->post == NULL) {
82         /* If there is no post-condition function, assume "yes" */
83         ret = 1;
84     } else if (!data->post(provider, cur_operation, no_store, data->data,
85                            &ret)) {
86         /* Error, bail out! */
87         ret = -1;
88     }
89 
90  end:
91     data->unreserve_store(data->data);
92 
93     return ret;
94 }
95 
96 /*
97  * Given a provider, process one operation given by |data->operation_id|, or
98  * if that's zero, process all known operations.
99  * For each such operation, query the associated OSSL_ALGORITHM array from
100  * the provider, then process that array with |algorithm_do_map()|.
101  */
algorithm_do_this(OSSL_PROVIDER * provider,void * cbdata)102 static int algorithm_do_this(OSSL_PROVIDER *provider, void *cbdata)
103 {
104     struct algorithm_data_st *data = cbdata;
105     int first_operation = 1;
106     int last_operation = OSSL_OP__HIGHEST;
107     int cur_operation;
108     int ok = 1;
109 
110     if (data->operation_id != 0)
111         first_operation = last_operation = data->operation_id;
112 
113     for (cur_operation = first_operation;
114          cur_operation <= last_operation;
115          cur_operation++) {
116         int no_store = 0;        /* Assume caching is ok */
117         const OSSL_ALGORITHM *map = NULL;
118         int ret = 0;
119 
120         map = ossl_provider_query_operation(provider, cur_operation,
121                                             &no_store);
122         ret = algorithm_do_map(provider, map, cur_operation, no_store, data);
123         ossl_provider_unquery_operation(provider, cur_operation, map);
124 
125         if (ret < 0)
126             /* Hard error, bail out immediately! */
127             return 0;
128 
129         /* If post-condition not fulfilled, set general failure */
130         if (!ret)
131             ok = 0;
132     }
133 
134     return ok;
135 }
136 
ossl_algorithm_do_all(OSSL_LIB_CTX * libctx,int operation_id,OSSL_PROVIDER * provider,int (* pre)(OSSL_PROVIDER *,int operation_id,int no_store,void * data,int * result),int (* reserve_store)(int no_store,void * data),void (* fn)(OSSL_PROVIDER * provider,const OSSL_ALGORITHM * algo,int no_store,void * data),int (* unreserve_store)(void * data),int (* post)(OSSL_PROVIDER *,int operation_id,int no_store,void * data,int * result),void * data)137 void ossl_algorithm_do_all(OSSL_LIB_CTX *libctx, int operation_id,
138                            OSSL_PROVIDER *provider,
139                            int (*pre)(OSSL_PROVIDER *, int operation_id,
140                                       int no_store, void *data, int *result),
141                            int (*reserve_store)(int no_store, void *data),
142                            void (*fn)(OSSL_PROVIDER *provider,
143                                       const OSSL_ALGORITHM *algo,
144                                       int no_store, void *data),
145                            int (*unreserve_store)(void *data),
146                            int (*post)(OSSL_PROVIDER *, int operation_id,
147                                        int no_store, void *data, int *result),
148                            void *data)
149 {
150     struct algorithm_data_st cbdata = { 0, };
151 
152     cbdata.libctx = libctx;
153     cbdata.operation_id = operation_id;
154     cbdata.pre = pre;
155     cbdata.reserve_store = reserve_store;
156     cbdata.fn = fn;
157     cbdata.unreserve_store = unreserve_store;
158     cbdata.post = post;
159     cbdata.data = data;
160 
161     if (provider == NULL) {
162         ossl_provider_doall_activated(libctx, algorithm_do_this, &cbdata);
163     } else {
164         OSSL_LIB_CTX *libctx2 = ossl_provider_libctx(provider);
165 
166         /*
167          * If a provider is given, its library context MUST match the library
168          * context we're passed.  If this turns out not to be true, there is
169          * a programming error in the functions up the call stack.
170          */
171         if (!ossl_assert(ossl_lib_ctx_get_concrete(libctx)
172                          == ossl_lib_ctx_get_concrete(libctx2)))
173             return;
174 
175         cbdata.libctx = libctx2;
176         algorithm_do_this(provider, &cbdata);
177     }
178 }
179 
ossl_algorithm_get1_first_name(const OSSL_ALGORITHM * algo)180 char *ossl_algorithm_get1_first_name(const OSSL_ALGORITHM *algo)
181 {
182     const char *first_name_end = NULL;
183     size_t first_name_len = 0;
184     char *ret;
185 
186     if (algo->algorithm_names == NULL)
187         return NULL;
188 
189     first_name_end = strchr(algo->algorithm_names, ':');
190     if (first_name_end == NULL)
191         first_name_len = strlen(algo->algorithm_names);
192     else
193         first_name_len = first_name_end - algo->algorithm_names;
194 
195     ret = OPENSSL_strndup(algo->algorithm_names, first_name_len);
196     return ret;
197 }
198