STORE: In preparation for coming work, mark when loading is started
[openssl.git] / crypto / store / store_lib.c
1 /*
2  * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (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 "e_os.h"
11 #include <stdlib.h>
12 #include <string.h>
13 #include <openssl/crypto.h>
14 #include <openssl/err.h>
15 #include <openssl/store.h>
16 #include "internal/thread_once.h"
17 #include "internal/store_int.h"
18 #include "store_locl.h"
19
20 struct ossl_store_ctx_st {
21     const OSSL_STORE_LOADER *loader;
22     OSSL_STORE_LOADER_CTX *loader_ctx;
23     const UI_METHOD *ui_method;
24     void *ui_data;
25     OSSL_STORE_post_process_info_fn post_process;
26     void *post_process_data;
27
28     /* 0 before the first STORE_load(), 1 otherwise */
29     int loading;
30 };
31
32 OSSL_STORE_CTX *OSSL_STORE_open(const char *uri, const UI_METHOD *ui_method,
33                                 void *ui_data,
34                                 OSSL_STORE_post_process_info_fn post_process,
35                                 void *post_process_data)
36 {
37     const OSSL_STORE_LOADER *loader = NULL;
38     OSSL_STORE_LOADER_CTX *loader_ctx = NULL;
39     OSSL_STORE_CTX *ctx = NULL;
40     char scheme_copy[256], *p, *schemes[2];
41     size_t schemes_n = 0;
42     size_t i;
43
44     /*
45      * Put the file scheme first.  If the uri does represent an existing file,
46      * possible device name and all, then it should be loaded.  Only a failed
47      * attempt at loading a local file should have us try something else.
48      */
49     schemes[schemes_n++] = "file";
50
51     /*
52      * Now, check if we have something that looks like a scheme, and add it
53      * as a second scheme.  However, also check if there's an authority start
54      * (://), because that will invalidate the previous file scheme.  Also,
55      * check that this isn't actually the file scheme, as there's no point
56      * going through that one twice!
57      */
58     OPENSSL_strlcpy(scheme_copy, uri, sizeof(scheme_copy));
59     if ((p = strchr(scheme_copy, ':')) != NULL) {
60         *p++ = '\0';
61         if (strcasecmp(scheme_copy, "file") != 0) {
62             if (strncmp(p, "//", 2) == 0)
63                 schemes_n--;         /* Invalidate the file scheme */
64             schemes[schemes_n++] = scheme_copy;
65         }
66     }
67
68     ERR_set_mark();
69
70     /* Try each scheme until we find one that could open the URI */
71     for (i = 0; loader_ctx == NULL && i < schemes_n; i++) {
72         if ((loader = ossl_store_get0_loader_int(schemes[i])) != NULL)
73             loader_ctx = loader->open(loader, uri, ui_method, ui_data);
74     }
75     if (loader_ctx == NULL)
76         goto err;
77
78     if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
79         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_OPEN, ERR_R_MALLOC_FAILURE);
80         goto err;
81     }
82
83     ctx->loader = loader;
84     ctx->loader_ctx = loader_ctx;
85     ctx->ui_method = ui_method;
86     ctx->ui_data = ui_data;
87     ctx->post_process = post_process;
88     ctx->post_process_data = post_process_data;
89
90     /*
91      * If the attempt to open with the 'file' scheme loader failed and the
92      * other scheme loader succeeded, the failure to open with the 'file'
93      * scheme loader leaves an error on the error stack.  Let's remove it.
94      */
95     ERR_pop_to_mark();
96
97     return ctx;
98
99  err:
100     ERR_clear_last_mark();
101     if (loader_ctx != NULL) {
102         /*
103          * We ignore a returned error because we will return NULL anyway in
104          * this case, so if something goes wrong when closing, that'll simply
105          * just add another entry on the error stack.
106          */
107         (void)loader->close(loader_ctx);
108     }
109     return NULL;
110 }
111
112 int OSSL_STORE_ctrl(OSSL_STORE_CTX *ctx, int cmd, ...)
113 {
114     va_list args;
115     int ret;
116
117     va_start(args, cmd);
118     ret = OSSL_STORE_vctrl(ctx, cmd, args);
119     va_end(args);
120
121     return ret;
122 }
123
124 int OSSL_STORE_vctrl(OSSL_STORE_CTX *ctx, int cmd, va_list args)
125 {
126     if (ctx->loader->ctrl != NULL)
127         return ctx->loader->ctrl(ctx->loader_ctx, cmd, args);
128     return 0;
129 }
130
131 OSSL_STORE_INFO *OSSL_STORE_load(OSSL_STORE_CTX *ctx)
132 {
133     OSSL_STORE_INFO *v = NULL;
134
135     ctx->loading = 1;
136  again:
137     if (OSSL_STORE_eof(ctx))
138         return NULL;
139
140     v = ctx->loader->load(ctx->loader_ctx, ctx->ui_method, ctx->ui_data);
141
142     if (ctx->post_process != NULL && v != NULL) {
143         v = ctx->post_process(v, ctx->post_process_data);
144
145         /*
146          * By returning NULL, the callback decides that this object should
147          * be ignored.
148          */
149         if (v == NULL)
150             goto again;
151     }
152
153     return v;
154 }
155
156 int OSSL_STORE_error(OSSL_STORE_CTX *ctx)
157 {
158     return ctx->loader->error(ctx->loader_ctx);
159 }
160
161 int OSSL_STORE_eof(OSSL_STORE_CTX *ctx)
162 {
163     return ctx->loader->eof(ctx->loader_ctx);
164 }
165
166 int OSSL_STORE_close(OSSL_STORE_CTX *ctx)
167 {
168     int loader_ret = ctx->loader->close(ctx->loader_ctx);
169
170     OPENSSL_free(ctx);
171     return loader_ret;
172 }
173
174 /*
175  * Functions to generate OSSL_STORE_INFOs, one function for each type we
176  * support having in them as well as a generic constructor.
177  *
178  * In all cases, ownership of the object is transfered to the OSSL_STORE_INFO
179  * and will therefore be freed when the OSSL_STORE_INFO is freed.
180  */
181 static OSSL_STORE_INFO *store_info_new(int type, void *data)
182 {
183     OSSL_STORE_INFO *info = OPENSSL_zalloc(sizeof(*info));
184
185     if (info == NULL)
186         return NULL;
187
188     info->type = type;
189     info->_.data = data;
190     return info;
191 }
192
193 OSSL_STORE_INFO *OSSL_STORE_INFO_new_NAME(char *name)
194 {
195     OSSL_STORE_INFO *info = store_info_new(OSSL_STORE_INFO_NAME, NULL);
196
197     if (info == NULL) {
198         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_NEW_NAME,
199                       ERR_R_MALLOC_FAILURE);
200         return NULL;
201     }
202
203     info->_.name.name = name;
204     info->_.name.desc = NULL;
205
206     return info;
207 }
208
209 int OSSL_STORE_INFO_set0_NAME_description(OSSL_STORE_INFO *info, char *desc)
210 {
211     if (info->type != OSSL_STORE_INFO_NAME) {
212         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_SET0_NAME_DESCRIPTION,
213                       ERR_R_PASSED_INVALID_ARGUMENT);
214         return 0;
215     }
216
217     info->_.name.desc = desc;
218
219     return 1;
220 }
221 OSSL_STORE_INFO *OSSL_STORE_INFO_new_PARAMS(EVP_PKEY *params)
222 {
223     OSSL_STORE_INFO *info = store_info_new(OSSL_STORE_INFO_PARAMS, params);
224
225     if (info == NULL)
226         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_NEW_PARAMS,
227                       ERR_R_MALLOC_FAILURE);
228     return info;
229 }
230
231 OSSL_STORE_INFO *OSSL_STORE_INFO_new_PKEY(EVP_PKEY *pkey)
232 {
233     OSSL_STORE_INFO *info = store_info_new(OSSL_STORE_INFO_PKEY, pkey);
234
235     if (info == NULL)
236         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_NEW_PKEY,
237                       ERR_R_MALLOC_FAILURE);
238     return info;
239 }
240
241 OSSL_STORE_INFO *OSSL_STORE_INFO_new_CERT(X509 *x509)
242 {
243     OSSL_STORE_INFO *info = store_info_new(OSSL_STORE_INFO_CERT, x509);
244
245     if (info == NULL)
246         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_NEW_CERT,
247                       ERR_R_MALLOC_FAILURE);
248     return info;
249 }
250
251 OSSL_STORE_INFO *OSSL_STORE_INFO_new_CRL(X509_CRL *crl)
252 {
253     OSSL_STORE_INFO *info = store_info_new(OSSL_STORE_INFO_CRL, crl);
254
255     if (info == NULL)
256         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_NEW_CRL,
257                       ERR_R_MALLOC_FAILURE);
258     return info;
259 }
260
261 /*
262  * Functions to try to extract data from a OSSL_STORE_INFO.
263  */
264 int OSSL_STORE_INFO_get_type(const OSSL_STORE_INFO *info)
265 {
266     return info->type;
267 }
268
269 const char *OSSL_STORE_INFO_get0_NAME(const OSSL_STORE_INFO *info)
270 {
271     if (info->type == OSSL_STORE_INFO_NAME)
272         return info->_.name.name;
273     return NULL;
274 }
275
276 char *OSSL_STORE_INFO_get1_NAME(const OSSL_STORE_INFO *info)
277 {
278     if (info->type == OSSL_STORE_INFO_NAME) {
279         char *ret = OPENSSL_strdup(info->_.name.name);
280
281         if (ret == NULL)
282             OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME,
283                           ERR_R_MALLOC_FAILURE);
284         return ret;
285     }
286     OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME,
287                   OSSL_STORE_R_NOT_A_NAME);
288     return NULL;
289 }
290
291 const char *OSSL_STORE_INFO_get0_NAME_description(const OSSL_STORE_INFO *info)
292 {
293     if (info->type == OSSL_STORE_INFO_NAME)
294         return info->_.name.desc;
295     return NULL;
296 }
297
298 char *OSSL_STORE_INFO_get1_NAME_description(const OSSL_STORE_INFO *info)
299 {
300     if (info->type == OSSL_STORE_INFO_NAME) {
301         char *ret = OPENSSL_strdup(info->_.name.desc
302                                    ? info->_.name.desc : "");
303
304         if (ret == NULL)
305             OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME_DESCRIPTION,
306                      ERR_R_MALLOC_FAILURE);
307         return ret;
308     }
309     OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_GET1_NAME_DESCRIPTION,
310                   OSSL_STORE_R_NOT_A_NAME);
311     return NULL;
312 }
313
314 EVP_PKEY *OSSL_STORE_INFO_get0_PARAMS(const OSSL_STORE_INFO *info)
315 {
316     if (info->type == OSSL_STORE_INFO_PARAMS)
317         return info->_.params;
318     return NULL;
319 }
320
321 EVP_PKEY *OSSL_STORE_INFO_get1_PARAMS(const OSSL_STORE_INFO *info)
322 {
323     if (info->type == OSSL_STORE_INFO_PARAMS) {
324         EVP_PKEY_up_ref(info->_.params);
325         return info->_.params;
326     }
327     OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_GET1_PARAMS,
328                   OSSL_STORE_R_NOT_PARAMETERS);
329     return NULL;
330 }
331
332 EVP_PKEY *OSSL_STORE_INFO_get0_PKEY(const OSSL_STORE_INFO *info)
333 {
334     if (info->type == OSSL_STORE_INFO_PKEY)
335         return info->_.pkey;
336     return NULL;
337 }
338
339 EVP_PKEY *OSSL_STORE_INFO_get1_PKEY(const OSSL_STORE_INFO *info)
340 {
341     if (info->type == OSSL_STORE_INFO_PKEY) {
342         EVP_PKEY_up_ref(info->_.pkey);
343         return info->_.pkey;
344     }
345     OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_GET1_PKEY,
346                   OSSL_STORE_R_NOT_A_KEY);
347     return NULL;
348 }
349
350 X509 *OSSL_STORE_INFO_get0_CERT(const OSSL_STORE_INFO *info)
351 {
352     if (info->type == OSSL_STORE_INFO_CERT)
353         return info->_.x509;
354     return NULL;
355 }
356
357 X509 *OSSL_STORE_INFO_get1_CERT(const OSSL_STORE_INFO *info)
358 {
359     if (info->type == OSSL_STORE_INFO_CERT) {
360         X509_up_ref(info->_.x509);
361         return info->_.x509;
362     }
363     OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_GET1_CERT,
364                   OSSL_STORE_R_NOT_A_CERTIFICATE);
365     return NULL;
366 }
367
368 X509_CRL *OSSL_STORE_INFO_get0_CRL(const OSSL_STORE_INFO *info)
369 {
370     if (info->type == OSSL_STORE_INFO_CRL)
371         return info->_.crl;
372     return NULL;
373 }
374
375 X509_CRL *OSSL_STORE_INFO_get1_CRL(const OSSL_STORE_INFO *info)
376 {
377     if (info->type == OSSL_STORE_INFO_CRL) {
378         X509_CRL_up_ref(info->_.crl);
379         return info->_.crl;
380     }
381     OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_GET1_CRL,
382                   OSSL_STORE_R_NOT_A_CRL);
383     return NULL;
384 }
385
386 /*
387  * Free the OSSL_STORE_INFO
388  */
389 void OSSL_STORE_INFO_free(OSSL_STORE_INFO *info)
390 {
391     if (info != NULL) {
392         switch (info->type) {
393         case OSSL_STORE_INFO_EMBEDDED:
394             BUF_MEM_free(info->_.embedded.blob);
395             OPENSSL_free(info->_.embedded.pem_name);
396             break;
397         case OSSL_STORE_INFO_NAME:
398             OPENSSL_free(info->_.name.name);
399             OPENSSL_free(info->_.name.desc);
400             break;
401         case OSSL_STORE_INFO_PARAMS:
402             EVP_PKEY_free(info->_.params);
403             break;
404         case OSSL_STORE_INFO_PKEY:
405             EVP_PKEY_free(info->_.pkey);
406             break;
407         case OSSL_STORE_INFO_CERT:
408             X509_free(info->_.x509);
409             break;
410         case OSSL_STORE_INFO_CRL:
411             X509_CRL_free(info->_.crl);
412             break;
413         }
414         OPENSSL_free(info);
415     }
416 }
417
418 /* Internal functions */
419 OSSL_STORE_INFO *ossl_store_info_new_EMBEDDED(const char *new_pem_name,
420                                               BUF_MEM *embedded)
421 {
422     OSSL_STORE_INFO *info = store_info_new(OSSL_STORE_INFO_EMBEDDED, NULL);
423
424     if (info == NULL) {
425         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_NEW_EMBEDDED,
426                       ERR_R_MALLOC_FAILURE);
427         return NULL;
428     }
429
430     info->_.embedded.blob = embedded;
431     info->_.embedded.pem_name =
432         new_pem_name == NULL ? NULL : OPENSSL_strdup(new_pem_name);
433
434     if (new_pem_name != NULL && info->_.embedded.pem_name == NULL) {
435         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_INFO_NEW_EMBEDDED,
436                       ERR_R_MALLOC_FAILURE);
437         OSSL_STORE_INFO_free(info);
438         info = NULL;
439     }
440
441     return info;
442 }
443
444 BUF_MEM *ossl_store_info_get0_EMBEDDED_buffer(OSSL_STORE_INFO *info)
445 {
446     if (info->type == OSSL_STORE_INFO_EMBEDDED)
447         return info->_.embedded.blob;
448     return NULL;
449 }
450
451 char *ossl_store_info_get0_EMBEDDED_pem_name(OSSL_STORE_INFO *info)
452 {
453     if (info->type == OSSL_STORE_INFO_EMBEDDED)
454         return info->_.embedded.pem_name;
455     return NULL;
456 }
457
458 OSSL_STORE_CTX *ossl_store_attach_pem_bio(BIO *bp, const UI_METHOD *ui_method,
459                                           void *ui_data)
460 {
461     OSSL_STORE_CTX *ctx = NULL;
462     const OSSL_STORE_LOADER *loader = NULL;
463     OSSL_STORE_LOADER_CTX *loader_ctx = NULL;
464
465     if ((loader = ossl_store_get0_loader_int("file")) == NULL
466         || ((loader_ctx = ossl_store_file_attach_pem_bio_int(bp)) == NULL))
467         goto done;
468     if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
469         OSSL_STOREerr(OSSL_STORE_F_OSSL_STORE_ATTACH_PEM_BIO,
470                      ERR_R_MALLOC_FAILURE);
471         goto done;
472     }
473
474     ctx->loader = loader;
475     ctx->loader_ctx = loader_ctx;
476     loader_ctx = NULL;
477     ctx->ui_method = ui_method;
478     ctx->ui_data = ui_data;
479     ctx->post_process = NULL;
480     ctx->post_process_data = NULL;
481
482  done:
483     if (loader_ctx != NULL)
484         /*
485          * We ignore a returned error because we will return NULL anyway in
486          * this case, so if something goes wrong when closing, that'll simply
487          * just add another entry on the error stack.
488          */
489         (void)loader->close(loader_ctx);
490     return ctx;
491 }
492
493 int ossl_store_detach_pem_bio(OSSL_STORE_CTX *ctx)
494 {
495     int loader_ret = ossl_store_file_detach_pem_bio_int(ctx->loader_ctx);
496
497     OPENSSL_free(ctx);
498     return loader_ret;
499 }