1/*
2 * Copyright 2019 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/err.h>
11#include <openssl/ui.h>
12#include <openssl/params.h>
13#include <openssl/serializer.h>
14#include <openssl/core_names.h>
15#include "internal/provider.h"
16#include "internal/property.h"
17#include "crypto/evp.h"
18#include "serializer_local.h"
19
20int OSSL_SERIALIZER_CTX_set_cipher(OSSL_SERIALIZER_CTX *ctx,
21 const char *cipher_name,
22 const char *propquery)
23{
24 OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END };
25
26 params[0] =
27 OSSL_PARAM_construct_utf8_string(OSSL_SERIALIZER_PARAM_CIPHER,
28 (void *)cipher_name, 0);
29 params[1] =
30 OSSL_PARAM_construct_utf8_string(OSSL_SERIALIZER_PARAM_PROPERTIES,
31 (void *)propquery, 0);
32
33 return OSSL_SERIALIZER_CTX_set_params(ctx, params);
34}
35
36int OSSL_SERIALIZER_CTX_set_passphrase(OSSL_SERIALIZER_CTX *ctx,
37 const unsigned char *kstr,
38 size_t klen)
39{
40 OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END };
41
42 params[0] = OSSL_PARAM_construct_octet_string(OSSL_SERIALIZER_PARAM_PASS,
43 (void *)kstr, klen);
44
45 return OSSL_SERIALIZER_CTX_set_params(ctx, params);
46}
47
48static void serializer_ctx_reset_passphrase_ui(OSSL_SERIALIZER_CTX *ctx)
49{
50 UI_destroy_method(ctx->allocated_ui_method);
51 ctx->allocated_ui_method = NULL;
52 ctx->ui_method = NULL;
53 ctx->ui_data = NULL;
54}
55
56int OSSL_SERIALIZER_CTX_set_passphrase_ui(OSSL_SERIALIZER_CTX *ctx,
57 const UI_METHOD *ui_method,
58 void *ui_data)
59{
60 if (!ossl_assert(ctx != NULL)) {
61 ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_PASSED_NULL_PARAMETER);
62 return 0;
63 }
64
65 serializer_ctx_reset_passphrase_ui(ctx);
66 ctx->ui_method = ui_method;
67 ctx->ui_data = ui_data;
68 return 1;
69}
70
71int OSSL_SERIALIZER_CTX_set_passphrase_cb(OSSL_SERIALIZER_CTX *ctx, int enc,
72 pem_password_cb *cb, void *cbarg)
73{
74 if (!ossl_assert(ctx != NULL)) {
75 ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_PASSED_NULL_PARAMETER);
76 return 0;
77 }
78
79 serializer_ctx_reset_passphrase_ui(ctx);
80 if (cb == NULL)
81 return 1;
82 ctx->ui_method =
83 ctx->allocated_ui_method = UI_UTIL_wrap_read_pem_callback(cb, enc);
84 ctx->ui_data = cbarg;
85
86 return ctx->ui_method != NULL;
87}
88
89/*
90 * Support for OSSL_SERIALIZER_CTX_new_by_TYPE:
91 * finding a suitable serializer
92 */
93
94struct selected_serializer_st {
95 OPENSSL_CTX *libctx;
96 const OSSL_PROVIDER *desired_provider;
97 const char *propquery;
98
99 /*
100 * When selecting serializers, we need to check the intended use.
101 * This is governed by the |domainparams| flag in the EVP_PKEY,
102 * we must just make sure to filter on 'type=domainparams' accordingly.
103 */
104 int want_domainparams;
105
106 /*
107 * Serializers offer two functions, one that handles object data in
108 * the form of a OSSL_PARAM array, and one that directly handles a
109 * provider side object. The latter requires that the serializer
110 * is offered by the same provider that holds that object, but is
111 * more desirable because it usually provides faster serialization.
112 *
113 * When looking up possible serializers, we save the first that can
114 * handle an OSSL_PARAM array in |first|, and the first that can
115 * handle a provider side object in |desired|.
116 */
117 OSSL_SERIALIZER *first;
118 OSSL_SERIALIZER *desired;
119};
120
121static void select_serializer(const char *name, void *data)
122{
123 struct selected_serializer_st *d = data;
124 OSSL_SERIALIZER *s = NULL;
125 OSSL_PROPERTY_LIST *check =
126 d->want_domainparams
127 ? ossl_parse_query(d->libctx, "type=domainparams")
128 : NULL;
129
130 /* No need to look further if we already have the more desirable option */
131 if (d->desired != NULL)
132 return;
133
134 if ((s = OSSL_SERIALIZER_fetch(d->libctx, name, d->propquery)) != NULL) {
135 /*
136 * Extra check if domain parameters are explicitly specified:
137 * only accept serializers that have the "type=domainparams"
138 * property.
139 *
140 * For data that isn't marked as domain parameters, a domain
141 * parameters serializer is still acceptable, because a key
142 * may hold domain parameters too.
143 */
144 if (d->want_domainparams) {
145 OSSL_PROPERTY_LIST *current_props =
146 ossl_parse_property(d->libctx, OSSL_SERIALIZER_properties(s));
147 int check_cnt = ossl_property_match_count(check, current_props);
148
149 if (check_cnt == 0) {
150 OSSL_SERIALIZER_free(s);
151 return;
152 }
153 }
154
155 if (d->first == NULL && s->serialize_data != NULL) {
156 d->first = s;
157 } else if (OSSL_SERIALIZER_provider(s) == d->desired_provider
158 && s->serialize_object != NULL) {
159 OSSL_SERIALIZER_free(d->first);
160 d->first = NULL;
161 d->desired = s;
162 } else {
163 OSSL_SERIALIZER_free(s);
164 }
165 }
166}
167
168/*
169 * Support for OSSL_SERIALIZER_CTX_new_by_TYPE and OSSL_SERIALIZER_to_bio:
170 * Passphrase callbacks
171 */
172
173/*
174 * First, we define the generic passphrase function that supports both
175 * outgoing (with passphrase verify) and incoming (without passphrase verify)
176 * passphrase reading.
177 */
178static int serializer_passphrase(char *pass, size_t pass_size,
179 size_t *pass_len, int verify,
180 const OSSL_PARAM params[], void *arg)
181{
182 OSSL_SERIALIZER_CTX *ctx = arg;
183 const OSSL_PARAM *p;
184 const char *prompt_info = NULL;
185 char *prompt = NULL, *vpass = NULL;
186 int prompt_idx = -1, verify_idx = -1;
187 UI *ui = NULL;
188 int ret = 0;
189
190 if (!ossl_assert(ctx != NULL && pass != NULL
191 && pass_size != 0 && pass_len != NULL)) {
192 ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_PASSED_NULL_PARAMETER);
193 return 0;
194 }
195
196 if ((p = OSSL_PARAM_locate_const(params,
197 OSSL_PASSPHRASE_PARAM_INFO)) != NULL) {
198 if (p->data_type != OSSL_PARAM_UTF8_STRING)
199 return 0;
200 prompt_info = p->data;
201 }
202
203 if ((ui = UI_new()) == NULL) {
204 ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_MALLOC_FAILURE);
205 return 0;
206 }
207
208 UI_set_method(ui, ctx->ui_method);
209 UI_add_user_data(ui, ctx->ui_data);
210
211 /* Get an application constructed prompt */
212 prompt = UI_construct_prompt(ui, "pass phrase", prompt_info);
213 if (prompt == NULL) {
214 ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_MALLOC_FAILURE);
215 goto end;
216 }
217
218 prompt_idx = UI_add_input_string(ui, prompt,
219 UI_INPUT_FLAG_DEFAULT_PWD,
220 pass, 0, pass_size - 1) - 1;
221 if (prompt_idx < 0) {
222 ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_UI_LIB);
223 goto end;
224 }
225
226 if (verify) {
227 /* Get a buffer for verification prompt */
228 vpass = OPENSSL_zalloc(pass_size);
229 if (vpass == NULL) {
230 ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_MALLOC_FAILURE);
231 goto end;
232 }
233 verify_idx = UI_add_verify_string(ui, prompt,
234 UI_INPUT_FLAG_DEFAULT_PWD,
235 vpass, 0, pass_size - 1,
236 pass) - 1;
237 if (verify_idx < 0) {
238 ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_UI_LIB);
239 goto end;
240 }
241 }
242
243 switch (UI_process(ui)) {
244 case -2:
245 ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_INTERRUPTED_OR_CANCELLED);
246 break;
247 case -1:
248 ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_UI_LIB);
249 break;
250 default:
251 *pass_len = (size_t)UI_get_result_length(ui, prompt_idx);
252 ret = 1;
253 break;
254 }
255
256 end:
257 OPENSSL_free(vpass);
258 OPENSSL_free(prompt);
259 UI_free(ui);
260 return ret;
261}
262
263/* Ensure correct function definition for outgoing passphrase reader */
264static OSSL_PASSPHRASE_CALLBACK serializer_passphrase_out_cb;
265static int serializer_passphrase_out_cb(char *pass, size_t pass_size,
266 size_t *pass_len,
267 const OSSL_PARAM params[], void *arg)
268{
269 return serializer_passphrase(pass, pass_size, pass_len, 1, params, arg);
270}
271
272/*
273 * Support for OSSL_SERIALIZER_to_bio:
274 * writing callback for the OSSL_PARAM (the implementation doesn't have
275 * intimate knowledge of the provider side object)
276 */
277
278struct serializer_write_data_st {
279 OSSL_SERIALIZER_CTX *ctx;
280 BIO *out;
281};
282
283static int serializer_write_cb(const OSSL_PARAM params[], void *arg)
284{
285 struct serializer_write_data_st *write_data = arg;
286 OSSL_SERIALIZER_CTX *ctx = write_data->ctx;
287 BIO *out = write_data->out;
288
289 return ctx->ser->serialize_data(ctx->serctx, params, out,
290 serializer_passphrase_out_cb, ctx);
291}
292
293/*
294 * Support for OSSL_SERIALIZER_to_bio:
295 * Perform the actual output.
296 */
297
298static int serializer_EVP_PKEY_to_bio(OSSL_SERIALIZER_CTX *ctx, BIO *out)
299{
300 const EVP_PKEY *pkey = ctx->object;
301 void *provdata = pkey->pkeys[0].provdata;
302 int domainparams = pkey->pkeys[0].domainparams;
303 EVP_KEYMGMT *keymgmt = pkey->pkeys[0].keymgmt;
304
305 /*
306 * OSSL_SERIALIZER_CTX_new() creates a context, even when the
307 * serializer it's given is NULL. Callers can detect the lack
308 * of serializer with OSSL_SERIALIZER_CTX_get_serializer() and
309 * should take precautions, possibly call a fallback instead of
310 * OSSL_SERIALIZER_to_bio() / OSSL_SERIALIZER_to_fp(). If it's
311 * come this far, we return an error.
312 */
313 if (ctx->ser == NULL)
314 return 0;
315
316 if (ctx->ser->serialize_object == NULL) {
317 struct serializer_write_data_st write_data;
318
319 write_data.ctx = ctx;
320 write_data.out = out;
321
322 if (domainparams)
323 return evp_keymgmt_exportdomparams(keymgmt, provdata,
324 serializer_write_cb,
325 &write_data);
326 return evp_keymgmt_exportkey(keymgmt, provdata,
327 serializer_write_cb, &write_data);
328 }
329
330 return ctx->ser->serialize_object(ctx->serctx, provdata, out,
331 serializer_passphrase_out_cb, ctx);
332}
333
334/*
335 * OSSL_SERIALIZER_CTX_new_by_EVP_PKEY() returns a ctx with no serializer if
336 * it couldn't find a suitable serializer. This allows a caller to detect if
337 * a suitable serializer was found, with OSSL_SERIALIZER_CTX_get_serializer(),
338 * and to use fallback methods if the result is NULL.
339 */
340OSSL_SERIALIZER_CTX *OSSL_SERIALIZER_CTX_new_by_EVP_PKEY(const EVP_PKEY *pkey,
341 const char *propquery)
342{
343 OSSL_SERIALIZER_CTX *ctx = NULL;
344 OSSL_SERIALIZER *ser = NULL;
345 EVP_KEYMGMT *keymgmt = pkey->pkeys[0].keymgmt;
346
347 if (!ossl_assert(pkey != NULL && propquery != NULL)) {
348 ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_PASSED_NULL_PARAMETER);
349 return NULL;
350 }
351
352 if (keymgmt != NULL) {
353 const OSSL_PROVIDER *desired_prov = EVP_KEYMGMT_provider(keymgmt);
354 OPENSSL_CTX *libctx = ossl_provider_library_context(desired_prov);
355 struct selected_serializer_st sel_data;
356
357 memset(&sel_data, 0, sizeof(sel_data));
358 sel_data.libctx = libctx;
359 sel_data.desired_provider = desired_prov;
360 sel_data.propquery = propquery;
361 sel_data.want_domainparams = pkey->pkeys[0].domainparams;
362 EVP_KEYMGMT_names_do_all(keymgmt, select_serializer, &sel_data);
363
364 if (sel_data.desired != NULL) {
365 ser = sel_data.desired;
366 sel_data.desired = NULL;
367 } else if (sel_data.first != NULL) {
368 ser = sel_data.first;
369 sel_data.first = NULL;
370 }
371 OSSL_SERIALIZER_free(sel_data.first);
372 OSSL_SERIALIZER_free(sel_data.desired);
373 }
374
375 ctx = OSSL_SERIALIZER_CTX_new(ser); /* refcnt(ser)++ */
376 OSSL_SERIALIZER_free(ser); /* refcnt(ser)-- */
377
378 if (ctx != NULL) {
379 /* Setup for OSSL_SERIALIZE_to_bio() */
380 ctx->object = pkey;
381 ctx->do_output = serializer_EVP_PKEY_to_bio;
382 }
383
384 return ctx;
385}
386
387