1 /*
2  * Copyright 2020-2023 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 /*
11  * This is a decoder that's completely internal to the 'file:' store
12  * implementation.  Only code in file_store.c know about this one.  Because
13  * of this close relationship, we can cut certain corners, such as making
14  * assumptions about the "provider context", which is currently simply the
15  * provider context that the file_store.c code operates within.
16  *
17  * All this does is to read known binary encodings (currently: DER, MSBLOB,
18  * PVK) from the input if it can, and passes it on to the data callback as
19  * an object abstraction, leaving it to the callback to figure out what it
20  * actually is.
21  *
22  * This MUST be made the last decoder in a chain, leaving it to other more
23  * specialized decoders to recognise and process their stuff first.
24  */
25 
26 #include <openssl/core_dispatch.h>
27 #include <openssl/core_names.h>
28 #include <openssl/core_object.h>
29 #include <openssl/bio.h>
30 #include <openssl/buffer.h>
31 #include <openssl/err.h>
32 #include <openssl/asn1err.h>
33 #include <openssl/params.h>
34 #include "internal/asn1.h"
35 #include "crypto/pem.h"          /* For internal PVK and "blob" headers */
36 #include "prov/bio.h"
37 #include "file_store_local.h"
38 
39 /*
40  * newctx and freectx are not strictly necessary.  However, the method creator,
41  * ossl_decoder_from_algorithm(), demands that they exist, so we make sure to
42  * oblige.
43  */
44 
45 static OSSL_FUNC_decoder_newctx_fn any2obj_newctx;
46 static OSSL_FUNC_decoder_freectx_fn any2obj_freectx;
47 
any2obj_newctx(void * provctx)48 static void *any2obj_newctx(void *provctx)
49 {
50     return provctx;
51 }
52 
any2obj_freectx(void * vctx)53 static void any2obj_freectx(void *vctx)
54 {
55 }
56 
any2obj_decode_final(void * provctx,int objtype,BUF_MEM * mem,OSSL_CALLBACK * data_cb,void * data_cbarg)57 static int any2obj_decode_final(void *provctx, int objtype, BUF_MEM *mem,
58                                 OSSL_CALLBACK *data_cb, void *data_cbarg)
59 {
60     /*
61      * 1 indicates that we successfully decoded something, or not at all.
62      * Ending up "empty handed" is not an error.
63      */
64     int ok = 1;
65 
66     if (mem != NULL) {
67         OSSL_PARAM params[3];
68 
69         params[0] =
70             OSSL_PARAM_construct_int(OSSL_OBJECT_PARAM_TYPE, &objtype);
71         params[1] =
72             OSSL_PARAM_construct_octet_string(OSSL_OBJECT_PARAM_DATA,
73                                               mem->data, mem->length);
74         params[2] = OSSL_PARAM_construct_end();
75 
76         ok = data_cb(params, data_cbarg);
77         BUF_MEM_free(mem);
78     }
79     return ok;
80 }
81 
82 static OSSL_FUNC_decoder_decode_fn der2obj_decode;
der2obj_decode(void * provctx,OSSL_CORE_BIO * cin,int selection,OSSL_CALLBACK * data_cb,void * data_cbarg,OSSL_PASSPHRASE_CALLBACK * pw_cb,void * pw_cbarg)83 static int der2obj_decode(void *provctx, OSSL_CORE_BIO *cin, int selection,
84                           OSSL_CALLBACK *data_cb, void *data_cbarg,
85                           OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
86 {
87     BIO *in = ossl_bio_new_from_core_bio(provctx, cin);
88     BUF_MEM *mem = NULL;
89     int ok;
90 
91     if (in == NULL)
92         return 0;
93 
94     ERR_set_mark();
95     ok = (asn1_d2i_read_bio(in, &mem) >= 0);
96     ERR_pop_to_mark();
97     if (!ok && mem != NULL) {
98         BUF_MEM_free(mem);
99         mem = NULL;
100     }
101     BIO_free(in);
102 
103     /* any2obj_decode_final() frees |mem| for us */
104     return any2obj_decode_final(provctx, OSSL_OBJECT_UNKNOWN, mem,
105                                 data_cb, data_cbarg);
106 }
107 
108 static OSSL_FUNC_decoder_decode_fn msblob2obj_decode;
msblob2obj_decode(void * provctx,OSSL_CORE_BIO * cin,int selection,OSSL_CALLBACK * data_cb,void * data_cbarg,OSSL_PASSPHRASE_CALLBACK * pw_cb,void * pw_cbarg)109 static int msblob2obj_decode(void *provctx, OSSL_CORE_BIO *cin, int selection,
110                              OSSL_CALLBACK *data_cb, void *data_cbarg,
111                              OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
112 {
113     BIO *in = ossl_bio_new_from_core_bio(provctx, cin);
114     BUF_MEM *mem = NULL;
115     size_t mem_len = 0, mem_want;
116     const unsigned char *p;
117     unsigned int bitlen, magic;
118     int isdss = -1;
119     int ispub = -1;
120     int ok = 0;
121 
122     if (in == NULL)
123         goto err;
124 
125     mem_want = 16;               /* The size of the MSBLOB header */
126     if ((mem = BUF_MEM_new()) == NULL
127         || !BUF_MEM_grow(mem, mem_want)) {
128         ERR_raise(ERR_LIB_PEM, ERR_R_BUF_LIB);
129         goto err;
130     }
131 
132     ERR_set_mark();
133     ok = BIO_read(in, &mem->data[0], mem_want) == (int)mem_want;
134     mem_len += mem_want;
135     ERR_pop_to_mark();
136     if (!ok)
137         goto next;
138 
139 
140     ERR_set_mark();
141     p = (unsigned char *)&mem->data[0];
142     ok = ossl_do_blob_header(&p, 16, &magic, &bitlen, &isdss, &ispub) > 0;
143     ERR_pop_to_mark();
144     if (!ok)
145         goto next;
146 
147     ok = 0;
148     mem_want = ossl_blob_length(bitlen, isdss, ispub);
149     if (!BUF_MEM_grow(mem, mem_len + mem_want)) {
150         ERR_raise(ERR_LIB_PEM, ERR_R_BUF_LIB);
151         goto err;
152     }
153 
154     ERR_set_mark();
155     ok = BIO_read(in, &mem->data[mem_len], mem_want) == (int)mem_want;
156     mem_len += mem_want;
157     ERR_pop_to_mark();
158 
159  next:
160     /* Free resources we no longer need. */
161     BIO_free(in);
162     if (!ok && mem != NULL) {
163         BUF_MEM_free(mem);
164         mem = NULL;
165     }
166 
167     /* any2obj_decode_final() frees |mem| for us */
168     return any2obj_decode_final(provctx, OSSL_OBJECT_PKEY, mem,
169                                 data_cb, data_cbarg);
170 
171  err:
172     BIO_free(in);
173     BUF_MEM_free(mem);
174     return 0;
175 }
176 
177 static OSSL_FUNC_decoder_decode_fn pvk2obj_decode;
pvk2obj_decode(void * provctx,OSSL_CORE_BIO * cin,int selection,OSSL_CALLBACK * data_cb,void * data_cbarg,OSSL_PASSPHRASE_CALLBACK * pw_cb,void * pw_cbarg)178 static int pvk2obj_decode(void *provctx, OSSL_CORE_BIO *cin, int selection,
179                              OSSL_CALLBACK *data_cb, void *data_cbarg,
180                              OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
181 {
182     BIO *in = ossl_bio_new_from_core_bio(provctx, cin);
183     BUF_MEM *mem = NULL;
184     size_t mem_len = 0, mem_want;
185     const unsigned char *p;
186     unsigned int saltlen, keylen;
187     int ok = 0;
188 
189     if (in == NULL)
190         goto err;
191 
192     mem_want = 24;               /* The size of the PVK header */
193     if ((mem = BUF_MEM_new()) == NULL
194         || !BUF_MEM_grow(mem, mem_want)) {
195         ERR_raise(ERR_LIB_PEM, ERR_R_BUF_LIB);
196         goto err;
197     }
198 
199     ERR_set_mark();
200     ok = BIO_read(in, &mem->data[0], mem_want) == (int)mem_want;
201     mem_len += mem_want;
202     ERR_pop_to_mark();
203     if (!ok)
204         goto next;
205 
206 
207     ERR_set_mark();
208     p = (unsigned char *)&mem->data[0];
209     ok = ossl_do_PVK_header(&p, 24, 0, &saltlen, &keylen) > 0;
210     ERR_pop_to_mark();
211     if (!ok)
212         goto next;
213 
214     ok = 0;
215     mem_want = saltlen + keylen;
216     if (!BUF_MEM_grow(mem, mem_len + mem_want)) {
217         ERR_raise(ERR_LIB_PEM, ERR_R_BUF_LIB);
218         goto err;
219     }
220 
221     ERR_set_mark();
222     ok = BIO_read(in, &mem->data[mem_len], mem_want) == (int)mem_want;
223     mem_len += mem_want;
224     ERR_pop_to_mark();
225 
226  next:
227     /* Free resources we no longer need. */
228     BIO_free(in);
229     if (!ok && mem != NULL) {
230         BUF_MEM_free(mem);
231         mem = NULL;
232     }
233 
234     /* any2obj_decode_final() frees |mem| for us */
235     return any2obj_decode_final(provctx, OSSL_OBJECT_PKEY, mem,
236                                 data_cb, data_cbarg);
237 
238  err:
239     BIO_free(in);
240     BUF_MEM_free(mem);
241     return 0;
242 }
243 
244 #define MAKE_DECODER(fromtype, objtype)                                      \
245     static const OSSL_DISPATCH fromtype##_to_obj_decoder_functions[] = {     \
246         { OSSL_FUNC_DECODER_NEWCTX, (void (*)(void))any2obj_newctx },        \
247         { OSSL_FUNC_DECODER_FREECTX, (void (*)(void))any2obj_freectx },      \
248         { OSSL_FUNC_DECODER_DECODE, (void (*)(void))fromtype##2obj_decode }, \
249         OSSL_DISPATCH_END                                                    \
250     }
251 
252 MAKE_DECODER(der, OSSL_OBJECT_UNKNOWN);
253 MAKE_DECODER(msblob, OSSL_OBJECT_PKEY);
254 MAKE_DECODER(pvk, OSSL_OBJECT_PKEY);
255 
256 const OSSL_ALGORITHM ossl_any_to_obj_algorithm[] = {
257     { "obj", "input=DER", der_to_obj_decoder_functions },
258     { "obj", "input=MSBLOB", msblob_to_obj_decoder_functions },
259     { "obj", "input=PVK", pvk_to_obj_decoder_functions },
260     { NULL, }
261 };
262