]> git.ipfire.org Git - thirdparty/openssl.git/blob - test/tls-provider.c
projects / thirdparty / openssl.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add OSSL_FUNC_keymgmt_im/export_types function that gets the provider context
[thirdparty/openssl.git] / test / tls-provider.c
1 /*
2 * Copyright 2019-2022 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 <string.h>
11 #include <openssl/core_names.h>
12 #include <openssl/core_dispatch.h>
13 #include <openssl/rand.h>
14 #include <openssl/params.h>
15 #include <openssl/err.h>
16 #include <openssl/proverr.h>
17 #include <openssl/pkcs12.h>
18 #include <openssl/provider.h>
19 #include <assert.h>
20 #include <openssl/asn1.h>
21 #include <openssl/asn1t.h>
22 #include <openssl/core_object.h>
23 #include "internal/asn1.h"
24 /* For TLS1_3_VERSION */
25 #include <openssl/ssl.h>
26 #include "internal/nelem.h"
27 #include "internal/refcount.h"
28
29 /* error codes */
30
31 /* xorprovider error codes */
32 #define XORPROV_R_INVALID_DIGEST 1
33 #define XORPROV_R_INVALID_SIZE 2
34 #define XORPROV_R_INVALID_KEY 3
35 #define XORPROV_R_UNSUPPORTED 4
36 #define XORPROV_R_MISSING_OID 5
37 #define XORPROV_R_OBJ_CREATE_ERR 6
38 #define XORPROV_R_INVALID_ENCODING 7
39 #define XORPROV_R_SIGN_ERROR 8
40 #define XORPROV_R_LIB_CREATE_ERR 9
41 #define XORPROV_R_NO_PRIVATE_KEY 10
42 #define XORPROV_R_BUFFER_LENGTH_WRONG 11
43 #define XORPROV_R_SIGNING_FAILED 12
44 #define XORPROV_R_WRONG_PARAMETERS 13
45 #define XORPROV_R_VERIFY_ERROR 14
46 #define XORPROV_R_EVPINFO_MISSING 15
47
48 static OSSL_FUNC_keymgmt_import_fn xor_import;
49 static OSSL_FUNC_keymgmt_import_types_fn xor_import_types;
50 static OSSL_FUNC_keymgmt_import_types_ex_fn xor_import_types_ex;
51 static OSSL_FUNC_keymgmt_export_fn xor_export;
52 static OSSL_FUNC_keymgmt_export_types_fn xor_export_types;
53 static OSSL_FUNC_keymgmt_export_types_ex_fn xor_export_types_ex;
54
55 int tls_provider_init(const OSSL_CORE_HANDLE *handle,
56 const OSSL_DISPATCH *in,
57 const OSSL_DISPATCH **out,
58 void **provctx);
59
60 #define XOR_KEY_SIZE 32
61
62 /*
63 * Top secret. This algorithm only works if no one knows what this number is.
64 * Please don't tell anyone what it is.
65 *
66 * This algorithm is for testing only - don't really use it!
67 */
68 static const unsigned char private_constant[XOR_KEY_SIZE] = {
69 0xd3, 0x6b, 0x54, 0xec, 0x5b, 0xac, 0x89, 0x96, 0x8c, 0x2c, 0x66, 0xa5,
70 0x67, 0x0d, 0xe3, 0xdd, 0x43, 0x69, 0xbc, 0x83, 0x3d, 0x60, 0xc7, 0xb8,
71 0x2b, 0x1c, 0x5a, 0xfd, 0xb5, 0xcd, 0xd0, 0xf8
72 };
73
74 typedef struct xorkey_st {
75 unsigned char privkey[XOR_KEY_SIZE];
76 unsigned char pubkey[XOR_KEY_SIZE];
77 int hasprivkey;
78 int haspubkey;
79 char *tls_name;
80 CRYPTO_REF_COUNT references;
81 CRYPTO_RWLOCK *lock;
82 } XORKEY;
83
84 /* Key Management for the dummy XOR KEX, KEM and signature algorithms */
85
86 static OSSL_FUNC_keymgmt_new_fn xor_newkey;
87 static OSSL_FUNC_keymgmt_free_fn xor_freekey;
88 static OSSL_FUNC_keymgmt_has_fn xor_has;
89 static OSSL_FUNC_keymgmt_dup_fn xor_dup;
90 static OSSL_FUNC_keymgmt_gen_init_fn xor_gen_init;
91 static OSSL_FUNC_keymgmt_gen_set_params_fn xor_gen_set_params;
92 static OSSL_FUNC_keymgmt_gen_settable_params_fn xor_gen_settable_params;
93 static OSSL_FUNC_keymgmt_gen_fn xor_gen;
94 static OSSL_FUNC_keymgmt_gen_cleanup_fn xor_gen_cleanup;
95 static OSSL_FUNC_keymgmt_load_fn xor_load;
96 static OSSL_FUNC_keymgmt_get_params_fn xor_get_params;
97 static OSSL_FUNC_keymgmt_gettable_params_fn xor_gettable_params;
98 static OSSL_FUNC_keymgmt_set_params_fn xor_set_params;
99 static OSSL_FUNC_keymgmt_settable_params_fn xor_settable_params;
100
101 /*
102 * Dummy "XOR" Key Exchange algorithm. We just xor the private and public keys
103 * together. Don't use this!
104 */
105
106 static OSSL_FUNC_keyexch_newctx_fn xor_newkemkexctx;
107 static OSSL_FUNC_keyexch_init_fn xor_init;
108 static OSSL_FUNC_keyexch_set_peer_fn xor_set_peer;
109 static OSSL_FUNC_keyexch_derive_fn xor_derive;
110 static OSSL_FUNC_keyexch_freectx_fn xor_freectx;
111 static OSSL_FUNC_keyexch_dupctx_fn xor_dupctx;
112
113 /*
114 * Dummy "XOR" Key Encapsulation Method. We just build a KEM over the xor KEX.
115 * Don't use this!
116 */
117
118 static OSSL_FUNC_kem_newctx_fn xor_newkemkexctx;
119 static OSSL_FUNC_kem_freectx_fn xor_freectx;
120 static OSSL_FUNC_kem_dupctx_fn xor_dupctx;
121 static OSSL_FUNC_kem_encapsulate_init_fn xor_init;
122 static OSSL_FUNC_kem_encapsulate_fn xor_encapsulate;
123 static OSSL_FUNC_kem_decapsulate_init_fn xor_init;
124 static OSSL_FUNC_kem_decapsulate_fn xor_decapsulate;
125
126 /*
127 * Common key management table access functions
128 */
129 static OSSL_FUNC_keymgmt_new_fn *
130 xor_prov_get_keymgmt_new(const OSSL_DISPATCH *fns)
131 {
132 /* Pilfer the keymgmt dispatch table */
133 for (; fns->function_id != 0; fns++)
134 if (fns->function_id == OSSL_FUNC_KEYMGMT_NEW)
135 return OSSL_FUNC_keymgmt_new(fns);
136
137 return NULL;
138 }
139
140 static OSSL_FUNC_keymgmt_free_fn *
141 xor_prov_get_keymgmt_free(const OSSL_DISPATCH *fns)
142 {
143 /* Pilfer the keymgmt dispatch table */
144 for (; fns->function_id != 0; fns++)
145 if (fns->function_id == OSSL_FUNC_KEYMGMT_FREE)
146 return OSSL_FUNC_keymgmt_free(fns);
147
148 return NULL;
149 }
150
151 static OSSL_FUNC_keymgmt_import_fn *
152 xor_prov_get_keymgmt_import(const OSSL_DISPATCH *fns)
153 {
154 /* Pilfer the keymgmt dispatch table */
155 for (; fns->function_id != 0; fns++)
156 if (fns->function_id == OSSL_FUNC_KEYMGMT_IMPORT)
157 return OSSL_FUNC_keymgmt_import(fns);
158
159 return NULL;
160 }
161
162 static OSSL_FUNC_keymgmt_export_fn *
163 xor_prov_get_keymgmt_export(const OSSL_DISPATCH *fns)
164 {
165 /* Pilfer the keymgmt dispatch table */
166 for (; fns->function_id != 0; fns++)
167 if (fns->function_id == OSSL_FUNC_KEYMGMT_EXPORT)
168 return OSSL_FUNC_keymgmt_export(fns);
169
170 return NULL;
171 }
172
173 static void *xor_prov_import_key(const OSSL_DISPATCH *fns, void *provctx,
174 int selection, const OSSL_PARAM params[])
175 {
176 OSSL_FUNC_keymgmt_new_fn *kmgmt_new = xor_prov_get_keymgmt_new(fns);
177 OSSL_FUNC_keymgmt_free_fn *kmgmt_free = xor_prov_get_keymgmt_free(fns);
178 OSSL_FUNC_keymgmt_import_fn *kmgmt_import =
179 xor_prov_get_keymgmt_import(fns);
180 void *key = NULL;
181
182 if (kmgmt_new != NULL && kmgmt_import != NULL && kmgmt_free != NULL) {
183 if ((key = kmgmt_new(provctx)) == NULL
184 || !kmgmt_import(key, selection, params)) {
185 kmgmt_free(key);
186 key = NULL;
187 }
188 }
189 return key;
190 }
191
192 static void xor_prov_free_key(const OSSL_DISPATCH *fns, void *key)
193 {
194 OSSL_FUNC_keymgmt_free_fn *kmgmt_free = xor_prov_get_keymgmt_free(fns);
195
196 if (kmgmt_free != NULL)
197 kmgmt_free(key);
198 }
199
200 /*
201 * We define 2 dummy TLS groups called "xorgroup" and "xorkemgroup" for test
202 * purposes
203 */
204 struct tls_group_st {
205 unsigned int group_id; /* for "tls-group-id", see provider-base(7) */
206 unsigned int secbits;
207 unsigned int mintls;
208 unsigned int maxtls;
209 unsigned int mindtls;
210 unsigned int maxdtls;
211 unsigned int is_kem; /* boolean */
212 };
213
214 #define XORGROUP_NAME "xorgroup"
215 #define XORGROUP_NAME_INTERNAL "xorgroup-int"
216 static struct tls_group_st xor_group = {
217 0, /* group_id, set by randomize_tls_alg_id() */
218 128, /* secbits */
219 TLS1_3_VERSION, /* mintls */
220 0, /* maxtls */
221 -1, /* mindtls */
222 -1, /* maxdtls */
223 0 /* is_kem */
224 };
225
226 #define XORKEMGROUP_NAME "xorkemgroup"
227 #define XORKEMGROUP_NAME_INTERNAL "xorkemgroup-int"
228 static struct tls_group_st xor_kemgroup = {
229 0, /* group_id, set by randomize_tls_alg_id() */
230 128, /* secbits */
231 TLS1_3_VERSION, /* mintls */
232 0, /* maxtls */
233 -1, /* mindtls */
234 -1, /* maxdtls */
235 1 /* is_kem */
236 };
237
238 #define ALGORITHM "XOR"
239
240 static const OSSL_PARAM xor_group_params[] = {
241 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_NAME,
242 XORGROUP_NAME, sizeof(XORGROUP_NAME)),
243 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL,
244 XORGROUP_NAME_INTERNAL,
245 sizeof(XORGROUP_NAME_INTERNAL)),
246 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_ALG, ALGORITHM,
247 sizeof(ALGORITHM)),
248 OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_ID, &xor_group.group_id),
249 OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS,
250 &xor_group.secbits),
251 OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MIN_TLS, &xor_group.mintls),
252 OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MAX_TLS, &xor_group.maxtls),
253 OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS, &xor_group.mindtls),
254 OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS, &xor_group.maxdtls),
255 OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_IS_KEM, &xor_group.is_kem),
256 OSSL_PARAM_END
257 };
258
259 static const OSSL_PARAM xor_kemgroup_params[] = {
260 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_NAME,
261 XORKEMGROUP_NAME, sizeof(XORKEMGROUP_NAME)),
262 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL,
263 XORKEMGROUP_NAME_INTERNAL,
264 sizeof(XORKEMGROUP_NAME_INTERNAL)),
265 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_ALG, ALGORITHM,
266 sizeof(ALGORITHM)),
267 OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_ID, &xor_kemgroup.group_id),
268 OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS,
269 &xor_kemgroup.secbits),
270 OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MIN_TLS, &xor_kemgroup.mintls),
271 OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MAX_TLS, &xor_kemgroup.maxtls),
272 OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS, &xor_kemgroup.mindtls),
273 OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS, &xor_kemgroup.maxdtls),
274 OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_IS_KEM, &xor_kemgroup.is_kem),
275 OSSL_PARAM_END
276 };
277
278 #define NUM_DUMMY_GROUPS 50
279 static char *dummy_group_names[NUM_DUMMY_GROUPS];
280
281 /*
282 * We define a dummy TLS sigalg called for test purposes
283 */
284 struct tls_sigalg_st {
285 unsigned int code_point; /* for "tls-sigalg-alg", see provider-base(7) */
286 unsigned int secbits;
287 unsigned int mintls;
288 unsigned int maxtls;
289 };
290
291 #define XORSIGALG_NAME "xorhmacsig"
292 #define XORSIGALG_OID "1.3.6.1.4.1.16604.998888.1"
293 #define XORSIGALG_HASH_NAME "xorhmacsha2sig"
294 #define XORSIGALG_HASH "SHA256"
295 #define XORSIGALG_HASH_OID "1.3.6.1.4.1.16604.998888.2"
296 #define XORSIGALG12_NAME "xorhmacsig12"
297 #define XORSIGALG12_OID "1.3.6.1.4.1.16604.998888.3"
298
299 static struct tls_sigalg_st xor_sigalg = {
300 0, /* alg id, set by randomize_tls_alg_id() */
301 128, /* secbits */
302 TLS1_3_VERSION, /* mintls */
303 0, /* maxtls */
304 };
305
306 static struct tls_sigalg_st xor_sigalg_hash = {
307 0, /* alg id, set by randomize_tls_alg_id() */
308 128, /* secbits */
309 TLS1_3_VERSION, /* mintls */
310 0, /* maxtls */
311 };
312
313 static struct tls_sigalg_st xor_sigalg12 = {
314 0, /* alg id, set by randomize_tls_alg_id() */
315 128, /* secbits */
316 TLS1_2_VERSION, /* mintls */
317 TLS1_2_VERSION, /* maxtls */
318 };
319
320 static const OSSL_PARAM xor_sig_nohash_params[] = {
321 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_IANA_NAME,
322 XORSIGALG_NAME, sizeof(XORSIGALG_NAME)),
323 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_NAME,
324 XORSIGALG_NAME,
325 sizeof(XORSIGALG_NAME)),
326 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_OID,
327 XORSIGALG_OID, sizeof(XORSIGALG_OID)),
328 OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_SIGALG_CODE_POINT,
329 &xor_sigalg.code_point),
330 OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_SIGALG_SECURITY_BITS,
331 &xor_sigalg.secbits),
332 OSSL_PARAM_int(OSSL_CAPABILITY_TLS_SIGALG_MIN_TLS,
333 &xor_sigalg.mintls),
334 OSSL_PARAM_int(OSSL_CAPABILITY_TLS_SIGALG_MAX_TLS,
335 &xor_sigalg.maxtls),
336 OSSL_PARAM_END
337 };
338
339 static const OSSL_PARAM xor_sig_hash_params[] = {
340 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_IANA_NAME,
341 XORSIGALG_HASH_NAME, sizeof(XORSIGALG_HASH_NAME)),
342 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_NAME,
343 XORSIGALG_HASH_NAME,
344 sizeof(XORSIGALG_HASH_NAME)),
345 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_HASH_NAME,
346 XORSIGALG_HASH, sizeof(XORSIGALG_HASH)),
347 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_OID,
348 XORSIGALG_HASH_OID, sizeof(XORSIGALG_HASH_OID)),
349 OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_SIGALG_CODE_POINT,
350 &xor_sigalg_hash.code_point),
351 OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_SIGALG_SECURITY_BITS,
352 &xor_sigalg_hash.secbits),
353 OSSL_PARAM_int(OSSL_CAPABILITY_TLS_SIGALG_MIN_TLS,
354 &xor_sigalg_hash.mintls),
355 OSSL_PARAM_int(OSSL_CAPABILITY_TLS_SIGALG_MAX_TLS,
356 &xor_sigalg_hash.maxtls),
357 OSSL_PARAM_END
358 };
359
360 static const OSSL_PARAM xor_sig_12_params[] = {
361 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_IANA_NAME,
362 XORSIGALG12_NAME, sizeof(XORSIGALG12_NAME)),
363 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_NAME,
364 XORSIGALG12_NAME,
365 sizeof(XORSIGALG12_NAME)),
366 OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_OID,
367 XORSIGALG12_OID, sizeof(XORSIGALG12_OID)),
368 OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_SIGALG_CODE_POINT,
369 &xor_sigalg12.code_point),
370 OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_SIGALG_SECURITY_BITS,
371 &xor_sigalg12.secbits),
372 OSSL_PARAM_int(OSSL_CAPABILITY_TLS_SIGALG_MIN_TLS,
373 &xor_sigalg12.mintls),
374 OSSL_PARAM_int(OSSL_CAPABILITY_TLS_SIGALG_MAX_TLS,
375 &xor_sigalg12.maxtls),
376 OSSL_PARAM_END
377 };
378
379 static int tls_prov_get_capabilities(void *provctx, const char *capability,
380 OSSL_CALLBACK *cb, void *arg)
381 {
382 int ret = 0;
383 int i;
384 const char *dummy_base = "dummy";
385 const size_t dummy_name_max_size = strlen(dummy_base) + 3;
386
387 if (strcmp(capability, "TLS-GROUP") == 0) {
388 /* Register our 2 groups */
389 ret = cb(xor_group_params, arg);
390 ret &= cb(xor_kemgroup_params, arg);
391
392 /*
393 * Now register some dummy groups > GROUPLIST_INCREMENT (== 40) as defined
394 * in ssl/t1_lib.c, to make sure we exercise the code paths for registering
395 * large numbers of groups.
396 */
397
398 for (i = 0; i < NUM_DUMMY_GROUPS; i++) {
399 OSSL_PARAM dummygroup[OSSL_NELEM(xor_group_params)];
400
401 memcpy(dummygroup, xor_group_params, sizeof(xor_group_params));
402
403 /* Give the dummy group a unique name */
404 if (dummy_group_names[i] == NULL) {
405 dummy_group_names[i] = OPENSSL_zalloc(dummy_name_max_size);
406 if (dummy_group_names[i] == NULL)
407 return 0;
408 BIO_snprintf(dummy_group_names[i],
409 dummy_name_max_size,
410 "%s%d", dummy_base, i);
411 }
412 dummygroup[0].data = dummy_group_names[i];
413 dummygroup[0].data_size = strlen(dummy_group_names[i]) + 1;
414 ret &= cb(dummygroup, arg);
415 }
416 }
417
418 if (strcmp(capability, "TLS-SIGALG") == 0) {
419 ret = cb(xor_sig_nohash_params, arg);
420 ret &= cb(xor_sig_hash_params, arg);
421 ret &= cb(xor_sig_12_params, arg);
422 }
423 return ret;
424 }
425
426 typedef struct {
427 OSSL_LIB_CTX *libctx;
428 } PROV_XOR_CTX;
429
430 static PROV_XOR_CTX *xor_newprovctx(OSSL_LIB_CTX *libctx)
431 {
432 PROV_XOR_CTX* prov_ctx = OPENSSL_malloc(sizeof(PROV_XOR_CTX));
433
434 if (prov_ctx == NULL)
435 return NULL;
436
437 if (libctx == NULL) {
438 OPENSSL_free(prov_ctx);
439 return NULL;
440 }
441 prov_ctx->libctx = libctx;
442 return prov_ctx;
443 }
444
445
446
447 #define PROV_XOR_LIBCTX_OF(provctx) (((PROV_XOR_CTX *)provctx)->libctx)
448
449 /*
450 * Dummy "XOR" Key Exchange and signature algorithm. We just xor the
451 * private and public keys together. Don't use this!
452 */
453
454 typedef struct {
455 XORKEY *key;
456 XORKEY *peerkey;
457 void *provctx;
458 } PROV_XORKEMKEX_CTX;
459
460 static void *xor_newkemkexctx(void *provctx)
461 {
462 PROV_XORKEMKEX_CTX *pxorctx = OPENSSL_zalloc(sizeof(PROV_XORKEMKEX_CTX));
463
464 if (pxorctx == NULL)
465 return NULL;
466
467 pxorctx->provctx = provctx;
468
469 return pxorctx;
470 }
471
472 static int xor_init(void *vpxorctx, void *vkey,
473 ossl_unused const OSSL_PARAM params[])
474 {
475 PROV_XORKEMKEX_CTX *pxorctx = (PROV_XORKEMKEX_CTX *)vpxorctx;
476
477 if (pxorctx == NULL || vkey == NULL)
478 return 0;
479 pxorctx->key = vkey;
480 return 1;
481 }
482
483 static int xor_set_peer(void *vpxorctx, void *vpeerkey)
484 {
485 PROV_XORKEMKEX_CTX *pxorctx = (PROV_XORKEMKEX_CTX *)vpxorctx;
486
487 if (pxorctx == NULL || vpeerkey == NULL)
488 return 0;
489 pxorctx->peerkey = vpeerkey;
490 return 1;
491 }
492
493 static int xor_derive(void *vpxorctx, unsigned char *secret, size_t *secretlen,
494 size_t outlen)
495 {
496 PROV_XORKEMKEX_CTX *pxorctx = (PROV_XORKEMKEX_CTX *)vpxorctx;
497 int i;
498
499 if (pxorctx->key == NULL || pxorctx->peerkey == NULL)
500 return 0;
501
502 *secretlen = XOR_KEY_SIZE;
503 if (secret == NULL)
504 return 1;
505
506 if (outlen < XOR_KEY_SIZE)
507 return 0;
508
509 for (i = 0; i < XOR_KEY_SIZE; i++)
510 secret[i] = pxorctx->key->privkey[i] ^ pxorctx->peerkey->pubkey[i];
511
512 return 1;
513 }
514
515 static void xor_freectx(void *pxorctx)
516 {
517 OPENSSL_free(pxorctx);
518 }
519
520 static void *xor_dupctx(void *vpxorctx)
521 {
522 PROV_XORKEMKEX_CTX *srcctx = (PROV_XORKEMKEX_CTX *)vpxorctx;
523 PROV_XORKEMKEX_CTX *dstctx;
524
525 dstctx = OPENSSL_zalloc(sizeof(*srcctx));
526 if (dstctx == NULL)
527 return NULL;
528
529 *dstctx = *srcctx;
530
531 return dstctx;
532 }
533
534 static const OSSL_DISPATCH xor_keyexch_functions[] = {
535 { OSSL_FUNC_KEYEXCH_NEWCTX, (void (*)(void))xor_newkemkexctx },
536 { OSSL_FUNC_KEYEXCH_INIT, (void (*)(void))xor_init },
537 { OSSL_FUNC_KEYEXCH_DERIVE, (void (*)(void))xor_derive },
538 { OSSL_FUNC_KEYEXCH_SET_PEER, (void (*)(void))xor_set_peer },
539 { OSSL_FUNC_KEYEXCH_FREECTX, (void (*)(void))xor_freectx },
540 { OSSL_FUNC_KEYEXCH_DUPCTX, (void (*)(void))xor_dupctx },
541 { 0, NULL }
542 };
543
544 static const OSSL_ALGORITHM tls_prov_keyexch[] = {
545 /*
546 * Obviously this is not FIPS approved, but in order to test in conjunction
547 * with the FIPS provider we pretend that it is.
548 */
549 { "XOR", "provider=tls-provider,fips=yes", xor_keyexch_functions },
550 { NULL, NULL, NULL }
551 };
552
553 /*
554 * Dummy "XOR" Key Encapsulation Method. We just build a KEM over the xor KEX.
555 * Don't use this!
556 */
557
558 static int xor_encapsulate(void *vpxorctx,
559 unsigned char *ct, size_t *ctlen,
560 unsigned char *ss, size_t *sslen)
561 {
562 /*
563 * We are building this around a KEX:
564 *
565 * 1. we generate ephemeral keypair
566 * 2. we encode our ephemeral pubkey as the outgoing ct
567 * 3. we derive using our ephemeral privkey in combination with the peer
568 * pubkey from the ctx; the result is our ss.
569 */
570 int rv = 0;
571 void *genctx = NULL, *derivectx = NULL;
572 XORKEY *ourkey = NULL;
573 PROV_XORKEMKEX_CTX *pxorctx = vpxorctx;
574
575 if (ct == NULL || ss == NULL) {
576 /* Just return sizes */
577
578 if (ctlen == NULL && sslen == NULL)
579 return 0;
580 if (ctlen != NULL)
581 *ctlen = XOR_KEY_SIZE;
582 if (sslen != NULL)
583 *sslen = XOR_KEY_SIZE;
584 return 1;
585 }
586
587 /* 1. Generate keypair */
588 genctx = xor_gen_init(pxorctx->provctx, OSSL_KEYMGMT_SELECT_KEYPAIR, NULL);
589 if (genctx == NULL)
590 goto end;
591 ourkey = xor_gen(genctx, NULL, NULL);
592 if (ourkey == NULL)
593 goto end;
594
595 /* 2. Encode ephemeral pubkey as ct */
596 memcpy(ct, ourkey->pubkey, XOR_KEY_SIZE);
597 *ctlen = XOR_KEY_SIZE;
598
599 /* 3. Derive ss via KEX */
600 derivectx = xor_newkemkexctx(pxorctx->provctx);
601 if (derivectx == NULL
602 || !xor_init(derivectx, ourkey, NULL)
603 || !xor_set_peer(derivectx, pxorctx->key)
604 || !xor_derive(derivectx, ss, sslen, XOR_KEY_SIZE))
605 goto end;
606
607 rv = 1;
608
609 end:
610 xor_gen_cleanup(genctx);
611 xor_freekey(ourkey);
612 xor_freectx(derivectx);
613 return rv;
614 }
615
616 static int xor_decapsulate(void *vpxorctx,
617 unsigned char *ss, size_t *sslen,
618 const unsigned char *ct, size_t ctlen)
619 {
620 /*
621 * We are building this around a KEX:
622 *
623 * - ct is our peer's pubkey
624 * - decapsulate is just derive.
625 */
626 int rv = 0;
627 void *derivectx = NULL;
628 XORKEY *peerkey = NULL;
629 PROV_XORKEMKEX_CTX *pxorctx = vpxorctx;
630
631 if (ss == NULL) {
632 /* Just return size */
633 if (sslen == NULL)
634 return 0;
635 *sslen = XOR_KEY_SIZE;
636 return 1;
637 }
638
639 if (ctlen != XOR_KEY_SIZE)
640 return 0;
641 peerkey = xor_newkey(pxorctx->provctx);
642 if (peerkey == NULL)
643 goto end;
644 memcpy(peerkey->pubkey, ct, XOR_KEY_SIZE);
645
646 /* Derive ss via KEX */
647 derivectx = xor_newkemkexctx(pxorctx->provctx);
648 if (derivectx == NULL
649 || !xor_init(derivectx, pxorctx->key, NULL)
650 || !xor_set_peer(derivectx, peerkey)
651 || !xor_derive(derivectx, ss, sslen, XOR_KEY_SIZE))
652 goto end;
653
654 rv = 1;
655
656 end:
657 xor_freekey(peerkey);
658 xor_freectx(derivectx);
659 return rv;
660 }
661
662 static const OSSL_DISPATCH xor_kem_functions[] = {
663 { OSSL_FUNC_KEM_NEWCTX, (void (*)(void))xor_newkemkexctx },
664 { OSSL_FUNC_KEM_FREECTX, (void (*)(void))xor_freectx },
665 { OSSL_FUNC_KEM_DUPCTX, (void (*)(void))xor_dupctx },
666 { OSSL_FUNC_KEM_ENCAPSULATE_INIT, (void (*)(void))xor_init },
667 { OSSL_FUNC_KEM_ENCAPSULATE, (void (*)(void))xor_encapsulate },
668 { OSSL_FUNC_KEM_DECAPSULATE_INIT, (void (*)(void))xor_init },
669 { OSSL_FUNC_KEM_DECAPSULATE, (void (*)(void))xor_decapsulate },
670 { 0, NULL }
671 };
672
673 static const OSSL_ALGORITHM tls_prov_kem[] = {
674 /*
675 * Obviously this is not FIPS approved, but in order to test in conjunction
676 * with the FIPS provider we pretend that it is.
677 */
678 { "XOR", "provider=tls-provider,fips=yes", xor_kem_functions },
679 { NULL, NULL, NULL }
680 };
681
682 /* Key Management for the dummy XOR key exchange algorithm */
683
684 static void *xor_newkey(void *provctx)
685 {
686 XORKEY *ret = OPENSSL_zalloc(sizeof(XORKEY));
687
688 if (ret == NULL)
689 return NULL;
690
691 ret->references = 1;
692 ret->lock = CRYPTO_THREAD_lock_new();
693 if (ret->lock == NULL) {
694 ERR_raise(ERR_LIB_USER, ERR_R_MALLOC_FAILURE);
695 OPENSSL_free(ret);
696 return NULL;
697 }
698
699 return ret;
700 }
701
702 static void xor_freekey(void *keydata)
703 {
704 XORKEY* key = (XORKEY *)keydata;
705 int refcnt;
706
707 if (key == NULL)
708 return;
709
710 if (CRYPTO_DOWN_REF(&key->references, &refcnt, key->lock) <= 0)
711 return;
712
713 if (refcnt > 0)
714 return;
715 assert(refcnt == 0);
716
717 if (key != NULL) {
718 OPENSSL_free(key->tls_name);
719 key->tls_name = NULL;
720 }
721 CRYPTO_THREAD_lock_free(key->lock);
722 OPENSSL_free(key);
723 }
724
725 static int xor_key_up_ref(XORKEY *key)
726 {
727 int refcnt;
728
729 if (CRYPTO_UP_REF(&key->references, &refcnt, key->lock) <= 0)
730 return 0;
731
732 assert(refcnt > 1);
733 return (refcnt > 1);
734 }
735
736 static int xor_has(const void *vkey, int selection)
737 {
738 const XORKEY *key = vkey;
739 int ok = 0;
740
741 if (key != NULL) {
742 ok = 1;
743
744 if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
745 ok = ok && key->haspubkey;
746 if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
747 ok = ok && key->hasprivkey;
748 }
749 return ok;
750 }
751
752 static void *xor_dup(const void *vfromkey, int selection)
753 {
754 XORKEY *tokey = xor_newkey(NULL);
755 const XORKEY *fromkey = vfromkey;
756 int ok = 0;
757
758 if (tokey != NULL && fromkey != NULL) {
759 ok = 1;
760
761 if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0) {
762 if (fromkey->haspubkey) {
763 memcpy(tokey->pubkey, fromkey->pubkey, XOR_KEY_SIZE);
764 tokey->haspubkey = 1;
765 } else {
766 tokey->haspubkey = 0;
767 }
768 }
769 if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) {
770 if (fromkey->hasprivkey) {
771 memcpy(tokey->privkey, fromkey->privkey, XOR_KEY_SIZE);
772 tokey->hasprivkey = 1;
773 } else {
774 tokey->hasprivkey = 0;
775 }
776 }
777 if (fromkey->tls_name != NULL)
778 tokey->tls_name = OPENSSL_strdup(fromkey->tls_name);
779 }
780 if (!ok) {
781 xor_freekey(tokey);
782 tokey = NULL;
783 }
784 return tokey;
785 }
786
787 static ossl_inline int xor_get_params(void *vkey, OSSL_PARAM params[])
788 {
789 XORKEY *key = vkey;
790 OSSL_PARAM *p;
791
792 if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL
793 && !OSSL_PARAM_set_int(p, XOR_KEY_SIZE))
794 return 0;
795
796 if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL
797 && !OSSL_PARAM_set_int(p, xor_group.secbits))
798 return 0;
799
800 if ((p = OSSL_PARAM_locate(params,
801 OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY)) != NULL) {
802 if (p->data_type != OSSL_PARAM_OCTET_STRING)
803 return 0;
804 p->return_size = XOR_KEY_SIZE;
805 if (p->data != NULL && p->data_size >= XOR_KEY_SIZE)
806 memcpy(p->data, key->pubkey, XOR_KEY_SIZE);
807 }
808
809 return 1;
810 }
811
812 static const OSSL_PARAM xor_params[] = {
813 OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
814 OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
815 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
816 OSSL_PARAM_END
817 };
818
819 static const OSSL_PARAM *xor_gettable_params(void *provctx)
820 {
821 return xor_params;
822 }
823
824 static int xor_set_params(void *vkey, const OSSL_PARAM params[])
825 {
826 XORKEY *key = vkey;
827 const OSSL_PARAM *p;
828
829 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY);
830 if (p != NULL) {
831 if (p->data_type != OSSL_PARAM_OCTET_STRING
832 || p->data_size != XOR_KEY_SIZE)
833 return 0;
834 memcpy(key->pubkey, p->data, XOR_KEY_SIZE);
835 key->haspubkey = 1;
836 }
837
838 return 1;
839 }
840
841 static const OSSL_PARAM xor_known_settable_params[] = {
842 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
843 OSSL_PARAM_END
844 };
845
846 static void *xor_load(const void *reference, size_t reference_sz)
847 {
848 XORKEY *key = NULL;
849
850 if (reference_sz == sizeof(key)) {
851 /* The contents of the reference is the address to our object */
852 key = *(XORKEY **)reference;
853 /* We grabbed, so we detach it */
854 *(XORKEY **)reference = NULL;
855 return key;
856 }
857 return NULL;
858 }
859
860 /* check one key is the "XOR complement" of the other */
861 static int xor_recreate(const unsigned char *kd1, const unsigned char *kd2) {
862 int i;
863
864 for (i = 0; i < XOR_KEY_SIZE; i++) {
865 if ((kd1[i] & 0xff) != ((kd2[i] ^ private_constant[i]) & 0xff))
866 return 0;
867 }
868 return 1;
869 }
870
871 static int xor_match(const void *keydata1, const void *keydata2, int selection)
872 {
873 const XORKEY *key1 = keydata1;
874 const XORKEY *key2 = keydata2;
875 int ok = 1;
876
877 if (key1->tls_name != NULL && key2->tls_name != NULL)
878 ok = ok & (strcmp(key1->tls_name, key2->tls_name) == 0);
879
880 if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) {
881 if (key1->hasprivkey) {
882 if (key2->hasprivkey)
883 ok = ok & (CRYPTO_memcmp(key1->privkey, key2->privkey,
884 XOR_KEY_SIZE) == 0);
885 else
886 ok = ok & xor_recreate(key1->privkey, key2->pubkey);
887 } else {
888 if (key2->hasprivkey)
889 ok = ok & xor_recreate(key2->privkey, key1->pubkey);
890 else
891 ok = 0;
892 }
893 }
894
895 if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0) {
896 if (key1->haspubkey) {
897 if (key2->haspubkey)
898 ok = ok & (CRYPTO_memcmp(key1->pubkey, key2->pubkey, XOR_KEY_SIZE) == 0);
899 else
900 ok = ok & xor_recreate(key1->pubkey, key2->privkey);
901 } else {
902 if (key2->haspubkey)
903 ok = ok & xor_recreate(key2->pubkey, key1->privkey);
904 else
905 ok = 0;
906 }
907 }
908
909 return ok;
910 }
911
912 static const OSSL_PARAM *xor_settable_params(void *provctx)
913 {
914 return xor_known_settable_params;
915 }
916
917 struct xor_gen_ctx {
918 int selection;
919 OSSL_LIB_CTX *libctx;
920 };
921
922 static void *xor_gen_init(void *provctx, int selection,
923 const OSSL_PARAM params[])
924 {
925 struct xor_gen_ctx *gctx = NULL;
926
927 if ((selection & (OSSL_KEYMGMT_SELECT_KEYPAIR
928 | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS)) == 0)
929 return NULL;
930
931 if ((gctx = OPENSSL_zalloc(sizeof(*gctx))) != NULL)
932 gctx->selection = selection;
933
934 gctx->libctx = PROV_XOR_LIBCTX_OF(provctx);
935
936 if (!xor_gen_set_params(gctx, params)) {
937 OPENSSL_free(gctx);
938 return NULL;
939 }
940 return gctx;
941 }
942
943 static int xor_gen_set_params(void *genctx, const OSSL_PARAM params[])
944 {
945 struct xor_gen_ctx *gctx = genctx;
946 const OSSL_PARAM *p;
947
948 if (gctx == NULL)
949 return 0;
950
951 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_GROUP_NAME);
952 if (p != NULL) {
953 if (p->data_type != OSSL_PARAM_UTF8_STRING
954 || (strcmp(p->data, XORGROUP_NAME_INTERNAL) != 0
955 && strcmp(p->data, XORKEMGROUP_NAME_INTERNAL) != 0))
956 return 0;
957 }
958
959 return 1;
960 }
961
962 static const OSSL_PARAM *xor_gen_settable_params(ossl_unused void *genctx,
963 ossl_unused void *provctx)
964 {
965 static OSSL_PARAM settable[] = {
966 OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME, NULL, 0),
967 OSSL_PARAM_END
968 };
969 return settable;
970 }
971
972 static void *xor_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
973 {
974 struct xor_gen_ctx *gctx = genctx;
975 XORKEY *key = xor_newkey(NULL);
976 size_t i;
977
978 if (key == NULL)
979 return NULL;
980
981 if ((gctx->selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0) {
982 if (RAND_bytes_ex(gctx->libctx, key->privkey, XOR_KEY_SIZE, 0) <= 0) {
983 OPENSSL_free(key);
984 return NULL;
985 }
986 for (i = 0; i < XOR_KEY_SIZE; i++)
987 key->pubkey[i] = key->privkey[i] ^ private_constant[i];
988 key->hasprivkey = 1;
989 key->haspubkey = 1;
990 }
991
992 return key;
993 }
994
995 /* IMPORT + EXPORT */
996
997 static int xor_import(void *vkey, int select, const OSSL_PARAM params[])
998 {
999 XORKEY *key = vkey;
1000 const OSSL_PARAM *param_priv_key, *param_pub_key;
1001 unsigned char privkey[XOR_KEY_SIZE];
1002 unsigned char pubkey[XOR_KEY_SIZE];
1003 void *pprivkey = privkey, *ppubkey = pubkey;
1004 size_t priv_len = 0, pub_len = 0;
1005 int res = 0;
1006
1007 if (key == NULL || (select & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
1008 return 0;
1009
1010 memset(privkey, 0, sizeof(privkey));
1011 memset(pubkey, 0, sizeof(pubkey));
1012 param_priv_key = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY);
1013 param_pub_key = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY);
1014
1015 if ((param_priv_key != NULL
1016 && !OSSL_PARAM_get_octet_string(param_priv_key, &pprivkey,
1017 sizeof(privkey), &priv_len))
1018 || (param_pub_key != NULL
1019 && !OSSL_PARAM_get_octet_string(param_pub_key, &ppubkey,
1020 sizeof(pubkey), &pub_len)))
1021 goto err;
1022
1023 if (priv_len > 0) {
1024 memcpy(key->privkey, privkey, priv_len);
1025 key->hasprivkey = 1;
1026 }
1027 if (pub_len > 0) {
1028 memcpy(key->pubkey, pubkey, pub_len);
1029 key->haspubkey = 1;
1030 }
1031 res = 1;
1032 err:
1033 return res;
1034 }
1035
1036 static int xor_export(void *vkey, int select, OSSL_CALLBACK *param_cb,
1037 void *cbarg)
1038 {
1039 XORKEY *key = vkey;
1040 OSSL_PARAM params[3], *p = params;
1041
1042 if (key == NULL || (select & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
1043 return 0;
1044
1045 *p++ = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
1046 key->privkey,
1047 sizeof(key->privkey));
1048 *p++ = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
1049 key->pubkey, sizeof(key->pubkey));
1050 *p++ = OSSL_PARAM_construct_end();
1051
1052 return param_cb(params, cbarg);
1053 }
1054
1055 static const OSSL_PARAM xor_key_types[] = {
1056 OSSL_PARAM_BN(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
1057 OSSL_PARAM_BN(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
1058 OSSL_PARAM_END
1059 };
1060
1061 static const OSSL_PARAM *xor_import_types(int select)
1062 {
1063 return (select & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0 ? xor_key_types : NULL;
1064 }
1065
1066 static const OSSL_PARAM *xor_import_types_ex(void *provctx, int select)
1067 {
1068 if (provctx == NULL)
1069 return NULL;
1070
1071 return xor_import_types(select);
1072 }
1073
1074 static const OSSL_PARAM *xor_export_types(int select)
1075 {
1076 return (select & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0 ? xor_key_types : NULL;
1077 }
1078
1079 static const OSSL_PARAM *xor_export_types_ex(void *provctx, int select)
1080 {
1081 if (provctx == NULL)
1082 return NULL;
1083
1084 return xor_export_types(select);
1085 }
1086
1087 static void xor_gen_cleanup(void *genctx)
1088 {
1089 OPENSSL_free(genctx);
1090 }
1091
1092 static const OSSL_DISPATCH xor_keymgmt_functions[] = {
1093 { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))xor_newkey },
1094 { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))xor_gen_init },
1095 { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS, (void (*)(void))xor_gen_set_params },
1096 { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS,
1097 (void (*)(void))xor_gen_settable_params },
1098 { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))xor_gen },
1099 { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))xor_gen_cleanup },
1100 { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))xor_get_params },
1101 { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))xor_gettable_params },
1102 { OSSL_FUNC_KEYMGMT_SET_PARAMS, (void (*) (void))xor_set_params },
1103 { OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS, (void (*) (void))xor_settable_params },
1104 { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))xor_has },
1105 { OSSL_FUNC_KEYMGMT_DUP, (void (*)(void))xor_dup },
1106 { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))xor_freekey },
1107 { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))xor_import },
1108 { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))xor_import_types },
1109 { OSSL_FUNC_KEYMGMT_IMPORT_TYPES_EX, (void (*)(void))xor_import_types_ex },
1110 { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))xor_export },
1111 { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))xor_export_types },
1112 { OSSL_FUNC_KEYMGMT_EXPORT_TYPES_EX, (void (*)(void))xor_export_types_ex },
1113 { 0, NULL }
1114 };
1115
1116 /* We're re-using most XOR keymgmt functions also for signature operations: */
1117 static void *xor_xorhmacsig_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
1118 {
1119 XORKEY *k = xor_gen(genctx, osslcb, cbarg);
1120
1121 if (k == NULL)
1122 return NULL;
1123 k->tls_name = OPENSSL_strdup(XORSIGALG_NAME);
1124 if (k->tls_name == NULL) {
1125 xor_freekey(k);
1126 return NULL;
1127 }
1128 return k;
1129 }
1130
1131 static void *xor_xorhmacsha2sig_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
1132 {
1133 XORKEY* k = xor_gen(genctx, osslcb, cbarg);
1134
1135 if (k == NULL)
1136 return NULL;
1137 k->tls_name = OPENSSL_strdup(XORSIGALG_HASH_NAME);
1138 if (k->tls_name == NULL) {
1139 xor_freekey(k);
1140 return NULL;
1141 }
1142 return k;
1143 }
1144
1145
1146 static const OSSL_DISPATCH xor_xorhmacsig_keymgmt_functions[] = {
1147 { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))xor_newkey },
1148 { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))xor_gen_init },
1149 { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS, (void (*)(void))xor_gen_set_params },
1150 { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS,
1151 (void (*)(void))xor_gen_settable_params },
1152 { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))xor_xorhmacsig_gen },
1153 { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))xor_gen_cleanup },
1154 { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))xor_get_params },
1155 { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))xor_gettable_params },
1156 { OSSL_FUNC_KEYMGMT_SET_PARAMS, (void (*) (void))xor_set_params },
1157 { OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS, (void (*) (void))xor_settable_params },
1158 { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))xor_has },
1159 { OSSL_FUNC_KEYMGMT_DUP, (void (*)(void))xor_dup },
1160 { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))xor_freekey },
1161 { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))xor_import },
1162 { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))xor_import_types },
1163 { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))xor_export },
1164 { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))xor_export_types },
1165 { OSSL_FUNC_KEYMGMT_LOAD, (void (*)(void))xor_load },
1166 { OSSL_FUNC_KEYMGMT_MATCH, (void (*)(void))xor_match },
1167 { 0, NULL }
1168 };
1169
1170 static const OSSL_DISPATCH xor_xorhmacsha2sig_keymgmt_functions[] = {
1171 { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))xor_newkey },
1172 { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))xor_gen_init },
1173 { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS, (void (*)(void))xor_gen_set_params },
1174 { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS,
1175 (void (*)(void))xor_gen_settable_params },
1176 { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))xor_xorhmacsha2sig_gen },
1177 { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))xor_gen_cleanup },
1178 { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))xor_get_params },
1179 { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))xor_gettable_params },
1180 { OSSL_FUNC_KEYMGMT_SET_PARAMS, (void (*) (void))xor_set_params },
1181 { OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS, (void (*) (void))xor_settable_params },
1182 { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))xor_has },
1183 { OSSL_FUNC_KEYMGMT_DUP, (void (*)(void))xor_dup },
1184 { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))xor_freekey },
1185 { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))xor_import },
1186 { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))xor_import_types },
1187 { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))xor_export },
1188 { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))xor_export_types },
1189 { OSSL_FUNC_KEYMGMT_LOAD, (void (*)(void))xor_load },
1190 { OSSL_FUNC_KEYMGMT_MATCH, (void (*)(void))xor_match },
1191 { 0, NULL }
1192 };
1193
1194 typedef enum {
1195 KEY_OP_PUBLIC,
1196 KEY_OP_PRIVATE,
1197 KEY_OP_KEYGEN
1198 } xor_key_op_t;
1199
1200 /* Re-create XORKEY from encoding(s): Same end-state as after key-gen */
1201 static XORKEY *xor_key_op(const X509_ALGOR *palg,
1202 const unsigned char *p, int plen,
1203 xor_key_op_t op,
1204 OSSL_LIB_CTX *libctx, const char *propq)
1205 {
1206 XORKEY *key = NULL;
1207 int nid = NID_undef;
1208
1209 if (palg != NULL) {
1210 int ptype;
1211
1212 /* Algorithm parameters must be absent */
1213 X509_ALGOR_get0(NULL, &ptype, NULL, palg);
1214 if (ptype != V_ASN1_UNDEF || palg->algorithm == NULL) {
1215 ERR_raise(ERR_LIB_USER, XORPROV_R_INVALID_ENCODING);
1216 return 0;
1217 }
1218 nid = OBJ_obj2nid(palg->algorithm);
1219 }
1220
1221 if (p == NULL || nid == EVP_PKEY_NONE || nid == NID_undef) {
1222 ERR_raise(ERR_LIB_USER, XORPROV_R_INVALID_ENCODING);
1223 return 0;
1224 }
1225
1226 key = xor_newkey(NULL);
1227 if (key == NULL) {
1228 ERR_raise(ERR_LIB_USER, ERR_R_MALLOC_FAILURE);
1229 return 0;
1230 }
1231
1232 if (XOR_KEY_SIZE != plen) {
1233 ERR_raise(ERR_LIB_USER, XORPROV_R_INVALID_ENCODING);
1234 goto err;
1235 }
1236
1237 if (op == KEY_OP_PUBLIC) {
1238 memcpy(key->pubkey, p, plen);
1239 key->haspubkey = 1;
1240 } else {
1241 memcpy(key->privkey, p, plen);
1242 key->hasprivkey = 1;
1243 }
1244
1245 key->tls_name = OPENSSL_strdup(OBJ_nid2sn(nid));
1246 if (key->tls_name == NULL)
1247 goto err;
1248 return key;
1249
1250 err:
1251 xor_freekey(key);
1252 return NULL;
1253 }
1254
1255 static XORKEY *xor_key_from_x509pubkey(const X509_PUBKEY *xpk,
1256 OSSL_LIB_CTX *libctx, const char *propq)
1257 {
1258 const unsigned char *p;
1259 int plen;
1260 X509_ALGOR *palg;
1261
1262 if (!xpk || (!X509_PUBKEY_get0_param(NULL, &p, &plen, &palg, xpk))) {
1263 return NULL;
1264 }
1265 return xor_key_op(palg, p, plen, KEY_OP_PUBLIC, libctx, propq);
1266 }
1267
1268 static XORKEY *xor_key_from_pkcs8(const PKCS8_PRIV_KEY_INFO *p8inf,
1269 OSSL_LIB_CTX *libctx, const char *propq)
1270 {
1271 XORKEY *xork = NULL;
1272 const unsigned char *p;
1273 int plen;
1274 ASN1_OCTET_STRING *oct = NULL;
1275 const X509_ALGOR *palg;
1276
1277 if (!PKCS8_pkey_get0(NULL, &p, &plen, &palg, p8inf))
1278 return 0;
1279
1280 oct = d2i_ASN1_OCTET_STRING(NULL, &p, plen);
1281 if (oct == NULL) {
1282 p = NULL;
1283 plen = 0;
1284 } else {
1285 p = ASN1_STRING_get0_data(oct);
1286 plen = ASN1_STRING_length(oct);
1287 }
1288
1289 xork = xor_key_op(palg, p, plen, KEY_OP_PRIVATE,
1290 libctx, propq);
1291 ASN1_OCTET_STRING_free(oct);
1292 return xork;
1293 }
1294
1295 static const OSSL_ALGORITHM tls_prov_keymgmt[] = {
1296 /*
1297 * Obviously this is not FIPS approved, but in order to test in conjunction
1298 * with the FIPS provider we pretend that it is.
1299 */
1300 { "XOR", "provider=tls-provider,fips=yes",
1301 xor_keymgmt_functions },
1302 { XORSIGALG_NAME, "provider=tls-provider,fips=yes",
1303 xor_xorhmacsig_keymgmt_functions },
1304 { XORSIGALG_HASH_NAME,
1305 "provider=tls-provider,fips=yes",
1306 xor_xorhmacsha2sig_keymgmt_functions },
1307 { NULL, NULL, NULL }
1308 };
1309
1310 struct key2any_ctx_st {
1311 PROV_XOR_CTX *provctx;
1312
1313 /* Set to 0 if parameters should not be saved (dsa only) */
1314 int save_parameters;
1315
1316 /* Set to 1 if intending to encrypt/decrypt, otherwise 0 */
1317 int cipher_intent;
1318
1319 EVP_CIPHER *cipher;
1320
1321 OSSL_PASSPHRASE_CALLBACK *pwcb;
1322 void *pwcbarg;
1323 };
1324
1325 typedef int check_key_type_fn(const void *key, int nid);
1326 typedef int key_to_paramstring_fn(const void *key, int nid, int save,
1327 void **str, int *strtype);
1328 typedef int key_to_der_fn(BIO *out, const void *key,
1329 int key_nid, const char *pemname,
1330 key_to_paramstring_fn *p2s, i2d_of_void *k2d,
1331 struct key2any_ctx_st *ctx);
1332 typedef int write_bio_of_void_fn(BIO *bp, const void *x);
1333
1334
1335 /* Free the blob allocated during key_to_paramstring_fn */
1336 static void free_asn1_data(int type, void *data)
1337 {
1338 switch(type) {
1339 case V_ASN1_OBJECT:
1340 ASN1_OBJECT_free(data);
1341 break;
1342 case V_ASN1_SEQUENCE:
1343 ASN1_STRING_free(data);
1344 break;
1345 }
1346 }
1347
1348 static PKCS8_PRIV_KEY_INFO *key_to_p8info(const void *key, int key_nid,
1349 void *params, int params_type,
1350 i2d_of_void *k2d)
1351 {
1352 /* der, derlen store the key DER output and its length */
1353 unsigned char *der = NULL;
1354 int derlen;
1355 /* The final PKCS#8 info */
1356 PKCS8_PRIV_KEY_INFO *p8info = NULL;
1357
1358 if ((p8info = PKCS8_PRIV_KEY_INFO_new()) == NULL
1359 || (derlen = k2d(key, &der)) <= 0
1360 || !PKCS8_pkey_set0(p8info, OBJ_nid2obj(key_nid), 0,
1361 V_ASN1_UNDEF, NULL,
1362 der, derlen)) {
1363 ERR_raise(ERR_LIB_USER, ERR_R_MALLOC_FAILURE);
1364 PKCS8_PRIV_KEY_INFO_free(p8info);
1365 OPENSSL_free(der);
1366 p8info = NULL;
1367 }
1368
1369 return p8info;
1370 }
1371
1372 static X509_SIG *p8info_to_encp8(PKCS8_PRIV_KEY_INFO *p8info,
1373 struct key2any_ctx_st *ctx)
1374 {
1375 X509_SIG *p8 = NULL;
1376 char kstr[PEM_BUFSIZE];
1377 size_t klen = 0;
1378 OSSL_LIB_CTX *libctx = PROV_XOR_LIBCTX_OF(ctx->provctx);
1379
1380 if (ctx->cipher == NULL || ctx->pwcb == NULL)
1381 return NULL;
1382
1383 if (!ctx->pwcb(kstr, PEM_BUFSIZE, &klen, NULL, ctx->pwcbarg)) {
1384 ERR_raise(ERR_LIB_USER, PROV_R_UNABLE_TO_GET_PASSPHRASE);
1385 return NULL;
1386 }
1387 /* First argument == -1 means "standard" */
1388 p8 = PKCS8_encrypt_ex(-1, ctx->cipher, kstr, klen, NULL, 0, 0, p8info, libctx, NULL);
1389 OPENSSL_cleanse(kstr, klen);
1390 return p8;
1391 }
1392
1393 static X509_SIG *key_to_encp8(const void *key, int key_nid,
1394 void *params, int params_type,
1395 i2d_of_void *k2d, struct key2any_ctx_st *ctx)
1396 {
1397 PKCS8_PRIV_KEY_INFO *p8info =
1398 key_to_p8info(key, key_nid, params, params_type, k2d);
1399 X509_SIG *p8 = NULL;
1400
1401 if (p8info == NULL) {
1402 free_asn1_data(params_type, params);
1403 } else {
1404 p8 = p8info_to_encp8(p8info, ctx);
1405 PKCS8_PRIV_KEY_INFO_free(p8info);
1406 }
1407 return p8;
1408 }
1409
1410 static X509_PUBKEY *xorx_key_to_pubkey(const void *key, int key_nid,
1411 void *params, int params_type,
1412 i2d_of_void k2d)
1413 {
1414 /* der, derlen store the key DER output and its length */
1415 unsigned char *der = NULL;
1416 int derlen;
1417 /* The final X509_PUBKEY */
1418 X509_PUBKEY *xpk = NULL;
1419
1420 if ((xpk = X509_PUBKEY_new()) == NULL
1421 || (derlen = k2d(key, &der)) <= 0
1422 || !X509_PUBKEY_set0_param(xpk, OBJ_nid2obj(key_nid),
1423 V_ASN1_UNDEF, NULL,
1424 der, derlen)) {
1425 ERR_raise(ERR_LIB_USER, ERR_R_MALLOC_FAILURE);
1426 X509_PUBKEY_free(xpk);
1427 OPENSSL_free(der);
1428 xpk = NULL;
1429 }
1430
1431 return xpk;
1432 }
1433
1434 /*
1435 * key_to_epki_* produce encoded output with the private key data in a
1436 * EncryptedPrivateKeyInfo structure (defined by PKCS#8). They require
1437 * that there's an intent to encrypt, anything else is an error.
1438 *
1439 * key_to_pki_* primarly produce encoded output with the private key data
1440 * in a PrivateKeyInfo structure (also defined by PKCS#8). However, if
1441 * there is an intent to encrypt the data, the corresponding key_to_epki_*
1442 * function is used instead.
1443 *
1444 * key_to_spki_* produce encoded output with the public key data in an
1445 * X.509 SubjectPublicKeyInfo.
1446 *
1447 * Key parameters don't have any defined envelopment of this kind, but are
1448 * included in some manner in the output from the functions described above,
1449 * either in the AlgorithmIdentifier's parameter field, or as part of the
1450 * key data itself.
1451 */
1452
1453 static int key_to_epki_der_priv_bio(BIO *out, const void *key,
1454 int key_nid,
1455 ossl_unused const char *pemname,
1456 key_to_paramstring_fn *p2s,
1457 i2d_of_void *k2d,
1458 struct key2any_ctx_st *ctx)
1459 {
1460 int ret = 0;
1461 void *str = NULL;
1462 int strtype = V_ASN1_UNDEF;
1463 X509_SIG *p8;
1464
1465 if (!ctx->cipher_intent)
1466 return 0;
1467
1468 if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
1469 &str, &strtype))
1470 return 0;
1471
1472 p8 = key_to_encp8(key, key_nid, str, strtype, k2d, ctx);
1473 if (p8 != NULL)
1474 ret = i2d_PKCS8_bio(out, p8);
1475
1476 X509_SIG_free(p8);
1477
1478 return ret;
1479 }
1480
1481 static int key_to_epki_pem_priv_bio(BIO *out, const void *key,
1482 int key_nid,
1483 ossl_unused const char *pemname,
1484 key_to_paramstring_fn *p2s,
1485 i2d_of_void *k2d,
1486 struct key2any_ctx_st *ctx)
1487 {
1488 int ret = 0;
1489 void *str = NULL;
1490 int strtype = V_ASN1_UNDEF;
1491 X509_SIG *p8;
1492
1493 if (!ctx->cipher_intent)
1494 return 0;
1495
1496 if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
1497 &str, &strtype))
1498 return 0;
1499
1500 p8 = key_to_encp8(key, key_nid, str, strtype, k2d, ctx);
1501 if (p8 != NULL)
1502 ret = PEM_write_bio_PKCS8(out, p8);
1503
1504 X509_SIG_free(p8);
1505
1506 return ret;
1507 }
1508
1509 static int key_to_pki_der_priv_bio(BIO *out, const void *key,
1510 int key_nid,
1511 ossl_unused const char *pemname,
1512 key_to_paramstring_fn *p2s,
1513 i2d_of_void *k2d,
1514 struct key2any_ctx_st *ctx)
1515 {
1516 int ret = 0;
1517 void *str = NULL;
1518 int strtype = V_ASN1_UNDEF;
1519 PKCS8_PRIV_KEY_INFO *p8info;
1520
1521 if (ctx->cipher_intent)
1522 return key_to_epki_der_priv_bio(out, key, key_nid, pemname,
1523 p2s, k2d, ctx);
1524
1525 if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
1526 &str, &strtype))
1527 return 0;
1528
1529 p8info = key_to_p8info(key, key_nid, str, strtype, k2d);
1530
1531 if (p8info != NULL)
1532 ret = i2d_PKCS8_PRIV_KEY_INFO_bio(out, p8info);
1533 else
1534 free_asn1_data(strtype, str);
1535
1536 PKCS8_PRIV_KEY_INFO_free(p8info);
1537
1538 return ret;
1539 }
1540
1541 static int key_to_pki_pem_priv_bio(BIO *out, const void *key,
1542 int key_nid,
1543 ossl_unused const char *pemname,
1544 key_to_paramstring_fn *p2s,
1545 i2d_of_void *k2d,
1546 struct key2any_ctx_st *ctx)
1547 {
1548 int ret = 0;
1549 void *str = NULL;
1550 int strtype = V_ASN1_UNDEF;
1551 PKCS8_PRIV_KEY_INFO *p8info;
1552
1553 if (ctx->cipher_intent)
1554 return key_to_epki_pem_priv_bio(out, key, key_nid, pemname,
1555 p2s, k2d, ctx);
1556
1557 if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
1558 &str, &strtype))
1559 return 0;
1560
1561 p8info = key_to_p8info(key, key_nid, str, strtype, k2d);
1562
1563 if (p8info != NULL)
1564 ret = PEM_write_bio_PKCS8_PRIV_KEY_INFO(out, p8info);
1565 else
1566 free_asn1_data(strtype, str);
1567
1568 PKCS8_PRIV_KEY_INFO_free(p8info);
1569
1570 return ret;
1571 }
1572
1573 static int key_to_spki_der_pub_bio(BIO *out, const void *key,
1574 int key_nid,
1575 ossl_unused const char *pemname,
1576 key_to_paramstring_fn *p2s,
1577 i2d_of_void *k2d,
1578 struct key2any_ctx_st *ctx)
1579 {
1580 int ret = 0;
1581 X509_PUBKEY *xpk = NULL;
1582 void *str = NULL;
1583 int strtype = V_ASN1_UNDEF;
1584
1585 if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
1586 &str, &strtype))
1587 return 0;
1588
1589 xpk = xorx_key_to_pubkey(key, key_nid, str, strtype, k2d);
1590
1591 if (xpk != NULL)
1592 ret = i2d_X509_PUBKEY_bio(out, xpk);
1593
1594 X509_PUBKEY_free(xpk);
1595 return ret;
1596 }
1597
1598 static int key_to_spki_pem_pub_bio(BIO *out, const void *key,
1599 int key_nid,
1600 ossl_unused const char *pemname,
1601 key_to_paramstring_fn *p2s,
1602 i2d_of_void *k2d,
1603 struct key2any_ctx_st *ctx)
1604 {
1605 int ret = 0;
1606 X509_PUBKEY *xpk = NULL;
1607 void *str = NULL;
1608 int strtype = V_ASN1_UNDEF;
1609
1610 if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
1611 &str, &strtype))
1612 return 0;
1613
1614 xpk = xorx_key_to_pubkey(key, key_nid, str, strtype, k2d);
1615
1616 if (xpk != NULL)
1617 ret = PEM_write_bio_X509_PUBKEY(out, xpk);
1618 else
1619 free_asn1_data(strtype, str);
1620
1621 /* Also frees |str| */
1622 X509_PUBKEY_free(xpk);
1623 return ret;
1624 }
1625
1626 /* ---------------------------------------------------------------------- */
1627
1628 static int prepare_xorx_params(const void *xorxkey, int nid, int save,
1629 void **pstr, int *pstrtype)
1630 {
1631 ASN1_OBJECT *params = NULL;
1632 XORKEY *k = (XORKEY*)xorxkey;
1633
1634 if (k->tls_name && OBJ_sn2nid(k->tls_name) != nid) {
1635 ERR_raise(ERR_LIB_USER, XORPROV_R_INVALID_KEY);
1636 return 0;
1637 }
1638
1639 if (nid == NID_undef) {
1640 ERR_raise(ERR_LIB_USER, XORPROV_R_MISSING_OID);
1641 return 0;
1642 }
1643
1644 params = OBJ_nid2obj(nid);
1645
1646 if (params == NULL || OBJ_length(params) == 0) {
1647 /* unexpected error */
1648 ERR_raise(ERR_LIB_USER, XORPROV_R_MISSING_OID);
1649 ASN1_OBJECT_free(params);
1650 return 0;
1651 }
1652 *pstr = params;
1653 *pstrtype = V_ASN1_OBJECT;
1654 return 1;
1655 }
1656
1657 static int xorx_spki_pub_to_der(const void *vecxkey, unsigned char **pder)
1658 {
1659 const XORKEY *xorxkey = vecxkey;
1660 unsigned char *keyblob;
1661 int retlen;
1662
1663 if (xorxkey == NULL) {
1664 ERR_raise(ERR_LIB_USER, ERR_R_PASSED_NULL_PARAMETER);
1665 return 0;
1666 }
1667
1668 keyblob = OPENSSL_memdup(xorxkey->pubkey, retlen = XOR_KEY_SIZE);
1669 if (keyblob == NULL) {
1670 ERR_raise(ERR_LIB_USER, ERR_R_MALLOC_FAILURE);
1671 return 0;
1672 }
1673
1674 *pder = keyblob;
1675 return retlen;
1676 }
1677
1678 static int xorx_pki_priv_to_der(const void *vecxkey, unsigned char **pder)
1679 {
1680 XORKEY *xorxkey = (XORKEY *)vecxkey;
1681 unsigned char* buf = NULL;
1682 ASN1_OCTET_STRING oct;
1683 int keybloblen;
1684
1685 if (xorxkey == NULL) {
1686 ERR_raise(ERR_LIB_USER, ERR_R_PASSED_NULL_PARAMETER);
1687 return 0;
1688 }
1689
1690 buf = OPENSSL_secure_malloc(XOR_KEY_SIZE);
1691 memcpy(buf, xorxkey->privkey, XOR_KEY_SIZE);
1692
1693 oct.data = buf;
1694 oct.length = XOR_KEY_SIZE;
1695 oct.flags = 0;
1696
1697 keybloblen = i2d_ASN1_OCTET_STRING(&oct, pder);
1698 if (keybloblen < 0) {
1699 ERR_raise(ERR_LIB_USER, ERR_R_MALLOC_FAILURE);
1700 keybloblen = 0;
1701 }
1702
1703 OPENSSL_secure_clear_free(buf, XOR_KEY_SIZE);
1704 return keybloblen;
1705 }
1706
1707 # define xorx_epki_priv_to_der xorx_pki_priv_to_der
1708
1709 /*
1710 * XORX only has PKCS#8 / SubjectPublicKeyInfo
1711 * representation, so we don't define xorx_type_specific_[priv,pub,params]_to_der.
1712 */
1713
1714 # define xorx_check_key_type NULL
1715
1716 # define xorhmacsig_evp_type 0
1717 # define xorhmacsig_input_type XORSIGALG_NAME
1718 # define xorhmacsig_pem_type XORSIGALG_NAME
1719 # define xorhmacsha2sig_evp_type 0
1720 # define xorhmacsha2sig_input_type XORSIGALG_HASH_NAME
1721 # define xorhmacsha2sig_pem_type XORSIGALG_HASH_NAME
1722
1723 /* ---------------------------------------------------------------------- */
1724
1725 static OSSL_FUNC_decoder_newctx_fn key2any_newctx;
1726 static OSSL_FUNC_decoder_freectx_fn key2any_freectx;
1727
1728 static void *key2any_newctx(void *provctx)
1729 {
1730 struct key2any_ctx_st *ctx = OPENSSL_zalloc(sizeof(*ctx));
1731
1732 if (ctx != NULL) {
1733 ctx->provctx = provctx;
1734 ctx->save_parameters = 1;
1735 }
1736
1737 return ctx;
1738 }
1739
1740 static void key2any_freectx(void *vctx)
1741 {
1742 struct key2any_ctx_st *ctx = vctx;
1743
1744 EVP_CIPHER_free(ctx->cipher);
1745 OPENSSL_free(ctx);
1746 }
1747
1748 static const OSSL_PARAM *key2any_settable_ctx_params(ossl_unused void *provctx)
1749 {
1750 static const OSSL_PARAM settables[] = {
1751 OSSL_PARAM_utf8_string(OSSL_ENCODER_PARAM_CIPHER, NULL, 0),
1752 OSSL_PARAM_utf8_string(OSSL_ENCODER_PARAM_PROPERTIES, NULL, 0),
1753 OSSL_PARAM_END,
1754 };
1755
1756 return settables;
1757 }
1758
1759 static int key2any_set_ctx_params(void *vctx, const OSSL_PARAM params[])
1760 {
1761 struct key2any_ctx_st *ctx = vctx;
1762 OSSL_LIB_CTX *libctx = PROV_XOR_LIBCTX_OF(ctx->provctx);
1763 const OSSL_PARAM *cipherp =
1764 OSSL_PARAM_locate_const(params, OSSL_ENCODER_PARAM_CIPHER);
1765 const OSSL_PARAM *propsp =
1766 OSSL_PARAM_locate_const(params, OSSL_ENCODER_PARAM_PROPERTIES);
1767 const OSSL_PARAM *save_paramsp =
1768 OSSL_PARAM_locate_const(params, OSSL_ENCODER_PARAM_SAVE_PARAMETERS);
1769
1770 if (cipherp != NULL) {
1771 const char *ciphername = NULL;
1772 const char *props = NULL;
1773
1774 if (!OSSL_PARAM_get_utf8_string_ptr(cipherp, &ciphername))
1775 return 0;
1776 if (propsp != NULL && !OSSL_PARAM_get_utf8_string_ptr(propsp, &props))
1777 return 0;
1778
1779 EVP_CIPHER_free(ctx->cipher);
1780 ctx->cipher = NULL;
1781 ctx->cipher_intent = ciphername != NULL;
1782 if (ciphername != NULL
1783 && ((ctx->cipher =
1784 EVP_CIPHER_fetch(libctx, ciphername, props)) == NULL)) {
1785 return 0;
1786 }
1787 }
1788
1789 if (save_paramsp != NULL) {
1790 if (!OSSL_PARAM_get_int(save_paramsp, &ctx->save_parameters)) {
1791 return 0;
1792 }
1793 }
1794 return 1;
1795 }
1796
1797 static int key2any_check_selection(int selection, int selection_mask)
1798 {
1799 /*
1800 * The selections are kinda sorta "levels", i.e. each selection given
1801 * here is assumed to include those following.
1802 */
1803 int checks[] = {
1804 OSSL_KEYMGMT_SELECT_PRIVATE_KEY,
1805 OSSL_KEYMGMT_SELECT_PUBLIC_KEY,
1806 OSSL_KEYMGMT_SELECT_ALL_PARAMETERS
1807 };
1808 size_t i;
1809
1810 /* The decoder implementations made here support guessing */
1811 if (selection == 0)
1812 return 1;
1813
1814 for (i = 0; i < OSSL_NELEM(checks); i++) {
1815 int check1 = (selection & checks[i]) != 0;
1816 int check2 = (selection_mask & checks[i]) != 0;
1817
1818 /*
1819 * If the caller asked for the currently checked bit(s), return
1820 * whether the decoder description says it's supported.
1821 */
1822 if (check1)
1823 return check2;
1824 }
1825
1826 /* This should be dead code, but just to be safe... */
1827 return 0;
1828 }
1829
1830 static int key2any_encode(struct key2any_ctx_st *ctx, OSSL_CORE_BIO *cout,
1831 const void *key, const char* typestr, const char *pemname,
1832 key_to_der_fn *writer,
1833 OSSL_PASSPHRASE_CALLBACK *pwcb, void *pwcbarg,
1834 key_to_paramstring_fn *key2paramstring,
1835 i2d_of_void *key2der)
1836 {
1837 int ret = 0;
1838 int type = OBJ_sn2nid(typestr);
1839
1840 if (key == NULL || type <= 0) {
1841 ERR_raise(ERR_LIB_USER, ERR_R_PASSED_NULL_PARAMETER);
1842 } else if (writer != NULL) {
1843 BIO *out = BIO_new_from_core_bio(ctx->provctx->libctx, cout);
1844
1845 if (out != NULL) {
1846 ctx->pwcb = pwcb;
1847 ctx->pwcbarg = pwcbarg;
1848
1849 ret = writer(out, key, type, pemname, key2paramstring, key2der, ctx);
1850 }
1851
1852 BIO_free(out);
1853 } else {
1854 ERR_raise(ERR_LIB_USER, ERR_R_PASSED_INVALID_ARGUMENT);
1855 }
1856 return ret;
1857 }
1858
1859 #define DO_ENC_PRIVATE_KEY_selection_mask OSSL_KEYMGMT_SELECT_PRIVATE_KEY
1860 #define DO_ENC_PRIVATE_KEY(impl, type, kind, output) \
1861 if ((selection & DO_ENC_PRIVATE_KEY_selection_mask) != 0) \
1862 return key2any_encode(ctx, cout, key, impl##_pem_type, \
1863 impl##_pem_type " PRIVATE KEY", \
1864 key_to_##kind##_##output##_priv_bio, \
1865 cb, cbarg, prepare_##type##_params, \
1866 type##_##kind##_priv_to_der);
1867
1868 #define DO_ENC_PUBLIC_KEY_selection_mask OSSL_KEYMGMT_SELECT_PUBLIC_KEY
1869 #define DO_ENC_PUBLIC_KEY(impl, type, kind, output) \
1870 if ((selection & DO_ENC_PUBLIC_KEY_selection_mask) != 0) \
1871 return key2any_encode(ctx, cout, key, impl##_pem_type, \
1872 impl##_pem_type " PUBLIC KEY", \
1873 key_to_##kind##_##output##_pub_bio, \
1874 cb, cbarg, prepare_##type##_params, \
1875 type##_##kind##_pub_to_der);
1876
1877 #define DO_ENC_PARAMETERS_selection_mask OSSL_KEYMGMT_SELECT_ALL_PARAMETERS
1878 #define DO_ENC_PARAMETERS(impl, type, kind, output) \
1879 if ((selection & DO_ENC_PARAMETERS_selection_mask) != 0) \
1880 return key2any_encode(ctx, cout, key, impl##_pem_type, \
1881 impl##_pem_type " PARAMETERS", \
1882 key_to_##kind##_##output##_param_bio, \
1883 NULL, NULL, NULL, \
1884 type##_##kind##_params_to_der);
1885
1886 /*-
1887 * Implement the kinds of output structure that can be produced. They are
1888 * referred to by name, and for each name, the following macros are defined
1889 * (braces not included):
1890 *
1891 * DO_{kind}_selection_mask
1892 *
1893 * A mask of selection bits that must not be zero. This is used as a
1894 * selection criterion for each implementation.
1895 * This mask must never be zero.
1896 *
1897 * DO_{kind}
1898 *
1899 * The performing macro. It must use the DO_ macros defined above,
1900 * always in this order:
1901 *
1902 * - DO_PRIVATE_KEY
1903 * - DO_PUBLIC_KEY
1904 * - DO_PARAMETERS
1905 *
1906 * Any of those may be omitted, but the relative order must still be
1907 * the same.
1908 */
1909
1910 /*
1911 * PKCS#8 defines two structures for private keys only:
1912 * - PrivateKeyInfo (raw unencrypted form)
1913 * - EncryptedPrivateKeyInfo (encrypted wrapping)
1914 *
1915 * To allow a certain amount of flexibility, we allow the routines
1916 * for PrivateKeyInfo to also produce EncryptedPrivateKeyInfo if a
1917 * passphrase callback has been passed to them.
1918 */
1919 #define DO_ENC_PrivateKeyInfo_selection_mask DO_ENC_PRIVATE_KEY_selection_mask
1920 #define DO_ENC_PrivateKeyInfo(impl, type, output) \
1921 DO_ENC_PRIVATE_KEY(impl, type, pki, output)
1922
1923 #define DO_ENC_EncryptedPrivateKeyInfo_selection_mask DO_ENC_PRIVATE_KEY_selection_mask
1924 #define DO_ENC_EncryptedPrivateKeyInfo(impl, type, output) \
1925 DO_ENC_PRIVATE_KEY(impl, type, epki, output)
1926
1927 /* SubjectPublicKeyInfo is a structure for public keys only */
1928 #define DO_ENC_SubjectPublicKeyInfo_selection_mask DO_ENC_PUBLIC_KEY_selection_mask
1929 #define DO_ENC_SubjectPublicKeyInfo(impl, type, output) \
1930 DO_ENC_PUBLIC_KEY(impl, type, spki, output)
1931
1932 /*
1933 * MAKE_ENCODER is the single driver for creating OSSL_DISPATCH tables.
1934 * It takes the following arguments:
1935 *
1936 * impl This is the key type name that's being implemented.
1937 * type This is the type name for the set of functions that implement
1938 * the key type. For example, ed25519, ed448, x25519 and x448
1939 * are all implemented with the exact same set of functions.
1940 * kind What kind of support to implement. These translate into
1941 * the DO_##kind macros above.
1942 * output The output type to implement. may be der or pem.
1943 *
1944 * The resulting OSSL_DISPATCH array gets the following name (expressed in
1945 * C preprocessor terms) from those arguments:
1946 *
1947 * xor_##impl##_to_##kind##_##output##_encoder_functions
1948 */
1949 #define MAKE_ENCODER(impl, type, kind, output) \
1950 static OSSL_FUNC_encoder_import_object_fn \
1951 impl##_to_##kind##_##output##_import_object; \
1952 static OSSL_FUNC_encoder_free_object_fn \
1953 impl##_to_##kind##_##output##_free_object; \
1954 static OSSL_FUNC_encoder_encode_fn \
1955 impl##_to_##kind##_##output##_encode; \
1956 \
1957 static void * \
1958 impl##_to_##kind##_##output##_import_object(void *vctx, int selection, \
1959 const OSSL_PARAM params[]) \
1960 { \
1961 struct key2any_ctx_st *ctx = vctx; \
1962 \
1963 return xor_prov_import_key(xor_##impl##_keymgmt_functions, \
1964 ctx->provctx, selection, params); \
1965 } \
1966 static void impl##_to_##kind##_##output##_free_object(void *key) \
1967 { \
1968 xor_prov_free_key(xor_##impl##_keymgmt_functions, key); \
1969 } \
1970 static int impl##_to_##kind##_##output##_does_selection(void *ctx, \
1971 int selection) \
1972 { \
1973 return key2any_check_selection(selection, \
1974 DO_ENC_##kind##_selection_mask); \
1975 } \
1976 static int \
1977 impl##_to_##kind##_##output##_encode(void *ctx, OSSL_CORE_BIO *cout, \
1978 const void *key, \
1979 const OSSL_PARAM key_abstract[], \
1980 int selection, \
1981 OSSL_PASSPHRASE_CALLBACK *cb, \
1982 void *cbarg) \
1983 { \
1984 /* We don't deal with abstract objects */ \
1985 if (key_abstract != NULL) { \
1986 ERR_raise(ERR_LIB_USER, ERR_R_PASSED_INVALID_ARGUMENT); \
1987 return 0; \
1988 } \
1989 DO_ENC_##kind(impl, type, output) \
1990 \
1991 ERR_raise(ERR_LIB_USER, ERR_R_PASSED_INVALID_ARGUMENT); \
1992 return 0; \
1993 } \
1994 static const OSSL_DISPATCH \
1995 xor_##impl##_to_##kind##_##output##_encoder_functions[] = { \
1996 { OSSL_FUNC_ENCODER_NEWCTX, \
1997 (void (*)(void))key2any_newctx }, \
1998 { OSSL_FUNC_ENCODER_FREECTX, \
1999 (void (*)(void))key2any_freectx }, \
2000 { OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS, \
2001 (void (*)(void))key2any_settable_ctx_params }, \
2002 { OSSL_FUNC_ENCODER_SET_CTX_PARAMS, \
2003 (void (*)(void))key2any_set_ctx_params }, \
2004 { OSSL_FUNC_ENCODER_DOES_SELECTION, \
2005 (void (*)(void))impl##_to_##kind##_##output##_does_selection }, \
2006 { OSSL_FUNC_ENCODER_IMPORT_OBJECT, \
2007 (void (*)(void))impl##_to_##kind##_##output##_import_object }, \
2008 { OSSL_FUNC_ENCODER_FREE_OBJECT, \
2009 (void (*)(void))impl##_to_##kind##_##output##_free_object }, \
2010 { OSSL_FUNC_ENCODER_ENCODE, \
2011 (void (*)(void))impl##_to_##kind##_##output##_encode }, \
2012 { 0, NULL } \
2013 }
2014
2015 /*
2016 * Replacements for i2d_{TYPE}PrivateKey, i2d_{TYPE}PublicKey,
2017 * i2d_{TYPE}params, as they exist.
2018 */
2019
2020 /*
2021 * PKCS#8 and SubjectPublicKeyInfo support. This may duplicate some of the
2022 * implementations specified above, but are more specific.
2023 * The SubjectPublicKeyInfo implementations also replace the
2024 * PEM_write_bio_{TYPE}_PUBKEY functions.
2025 * For PEM, these are expected to be used by PEM_write_bio_PrivateKey(),
2026 * PEM_write_bio_PUBKEY() and PEM_write_bio_Parameters().
2027 */
2028
2029 MAKE_ENCODER(xorhmacsig, xorx, EncryptedPrivateKeyInfo, der);
2030 MAKE_ENCODER(xorhmacsig, xorx, EncryptedPrivateKeyInfo, pem);
2031 MAKE_ENCODER(xorhmacsig, xorx, PrivateKeyInfo, der);
2032 MAKE_ENCODER(xorhmacsig, xorx, PrivateKeyInfo, pem);
2033 MAKE_ENCODER(xorhmacsig, xorx, SubjectPublicKeyInfo, der);
2034 MAKE_ENCODER(xorhmacsig, xorx, SubjectPublicKeyInfo, pem);
2035 MAKE_ENCODER(xorhmacsha2sig, xorx, EncryptedPrivateKeyInfo, der);
2036 MAKE_ENCODER(xorhmacsha2sig, xorx, EncryptedPrivateKeyInfo, pem);
2037 MAKE_ENCODER(xorhmacsha2sig, xorx, PrivateKeyInfo, der);
2038 MAKE_ENCODER(xorhmacsha2sig, xorx, PrivateKeyInfo, pem);
2039 MAKE_ENCODER(xorhmacsha2sig, xorx, SubjectPublicKeyInfo, der);
2040 MAKE_ENCODER(xorhmacsha2sig, xorx, SubjectPublicKeyInfo, pem);
2041
2042 static const OSSL_ALGORITHM tls_prov_encoder[] = {
2043 #define ENCODER_PROVIDER "tls-provider"
2044 #ifndef ENCODER_PROVIDER
2045 # error Macro ENCODER_PROVIDER undefined
2046 #endif
2047
2048 #define ENCODER_STRUCTURE_PKCS8 "pkcs8"
2049 #define ENCODER_STRUCTURE_SubjectPublicKeyInfo "SubjectPublicKeyInfo"
2050 #define ENCODER_STRUCTURE_PrivateKeyInfo "PrivateKeyInfo"
2051 #define ENCODER_STRUCTURE_EncryptedPrivateKeyInfo "EncryptedPrivateKeyInfo"
2052 #define ENCODER_STRUCTURE_PKCS1 "pkcs1"
2053 #define ENCODER_STRUCTURE_PKCS3 "pkcs3"
2054
2055 /* Arguments are prefixed with '_' to avoid build breaks on certain platforms */
2056 /*
2057 * Obviously this is not FIPS approved, but in order to test in conjunction
2058 * with the FIPS provider we pretend that it is.
2059 */
2060 #define ENCODER_TEXT(_name, _sym) \
2061 { _name, \
2062 "provider=" ENCODER_PROVIDER ",fips=yes,output=text", \
2063 (xor_##_sym##_to_text_encoder_functions) }
2064 #define ENCODER(_name, _sym, _fips, _output) \
2065 { _name, \
2066 "provider=" ENCODER_PROVIDER ",fips=yes,output=" #_output, \
2067 (xor_##_sym##_to_##_output##_encoder_functions) }
2068
2069 #define ENCODER_w_structure(_name, _sym, _output, _structure) \
2070 { _name, \
2071 "provider=" ENCODER_PROVIDER ",fips=yes,output=" #_output \
2072 ",structure=" ENCODER_STRUCTURE_##_structure, \
2073 (xor_##_sym##_to_##_structure##_##_output##_encoder_functions) }
2074
2075 /*
2076 * Entries for human text "encoders"
2077 */
2078
2079 /*
2080 * Entries for PKCS#8 and SubjectPublicKeyInfo.
2081 * The "der" ones are added convenience for any user that wants to use
2082 * OSSL_ENCODER directly.
2083 * The "pem" ones also support PEM_write_bio_PrivateKey() and
2084 * PEM_write_bio_PUBKEY().
2085 */
2086
2087 ENCODER_w_structure(XORSIGALG_NAME, xorhmacsig, der, PrivateKeyInfo),
2088 ENCODER_w_structure(XORSIGALG_NAME, xorhmacsig, pem, PrivateKeyInfo),
2089 ENCODER_w_structure(XORSIGALG_NAME, xorhmacsig, der, EncryptedPrivateKeyInfo),
2090 ENCODER_w_structure(XORSIGALG_NAME, xorhmacsig, pem, EncryptedPrivateKeyInfo),
2091 ENCODER_w_structure(XORSIGALG_NAME, xorhmacsig, der, SubjectPublicKeyInfo),
2092 ENCODER_w_structure(XORSIGALG_NAME, xorhmacsig, pem, SubjectPublicKeyInfo),
2093 ENCODER_w_structure(XORSIGALG_HASH_NAME, xorhmacsha2sig,
2094 der, PrivateKeyInfo),
2095 ENCODER_w_structure(XORSIGALG_HASH_NAME, xorhmacsha2sig,
2096 pem, PrivateKeyInfo),
2097 ENCODER_w_structure(XORSIGALG_HASH_NAME, xorhmacsha2sig,
2098 der, EncryptedPrivateKeyInfo),
2099 ENCODER_w_structure(XORSIGALG_HASH_NAME, xorhmacsha2sig,
2100 pem, EncryptedPrivateKeyInfo),
2101 ENCODER_w_structure(XORSIGALG_HASH_NAME, xorhmacsha2sig,
2102 der, SubjectPublicKeyInfo),
2103 ENCODER_w_structure(XORSIGALG_HASH_NAME, xorhmacsha2sig,
2104 pem, SubjectPublicKeyInfo),
2105 #undef ENCODER_PROVIDER
2106 { NULL, NULL, NULL }
2107 };
2108
2109 struct der2key_ctx_st; /* Forward declaration */
2110 typedef int check_key_fn(void *, struct der2key_ctx_st *ctx);
2111 typedef void adjust_key_fn(void *, struct der2key_ctx_st *ctx);
2112 typedef void free_key_fn(void *);
2113 typedef void *d2i_PKCS8_fn(void **, const unsigned char **, long,
2114 struct der2key_ctx_st *);
2115 struct keytype_desc_st {
2116 const char *keytype_name;
2117 const OSSL_DISPATCH *fns; /* Keymgmt (to pilfer functions from) */
2118
2119 /* The input structure name */
2120 const char *structure_name;
2121
2122 /*
2123 * The EVP_PKEY_xxx type macro. Should be zero for type specific
2124 * structures, non-zero when the outermost structure is PKCS#8 or
2125 * SubjectPublicKeyInfo. This determines which of the function
2126 * pointers below will be used.
2127 */
2128 int evp_type;
2129
2130 /* The selection mask for OSSL_FUNC_decoder_does_selection() */
2131 int selection_mask;
2132
2133 /* For type specific decoders, we use the corresponding d2i */
2134 d2i_of_void *d2i_private_key; /* From type-specific DER */
2135 d2i_of_void *d2i_public_key; /* From type-specific DER */
2136 d2i_of_void *d2i_key_params; /* From type-specific DER */
2137 d2i_PKCS8_fn *d2i_PKCS8; /* Wrapped in a PrivateKeyInfo */
2138 d2i_of_void *d2i_PUBKEY; /* Wrapped in a SubjectPublicKeyInfo */
2139
2140 /*
2141 * For any key, we may need to check that the key meets expectations.
2142 * This is useful when the same functions can decode several variants
2143 * of a key.
2144 */
2145 check_key_fn *check_key;
2146
2147 /*
2148 * For any key, we may need to make provider specific adjustments, such
2149 * as ensure the key carries the correct library context.
2150 */
2151 adjust_key_fn *adjust_key;
2152 /* {type}_free() */
2153 free_key_fn *free_key;
2154 };
2155
2156 /*
2157 * Start blatant code steal. Alternative: Open up d2i_X509_PUBKEY_INTERNAL
2158 * as per https://github.com/openssl/openssl/issues/16697 (TBD)
2159 * Code from from openssl/crypto/x509/x_pubkey.c as
2160 * ossl_d2i_X509_PUBKEY_INTERNAL is presently not public
2161 */
2162 struct X509_pubkey_st {
2163 X509_ALGOR *algor;
2164 ASN1_BIT_STRING *public_key;
2165
2166 EVP_PKEY *pkey;
2167
2168 /* extra data for the callback, used by d2i_PUBKEY_ex */
2169 OSSL_LIB_CTX *libctx;
2170 char *propq;
2171 };
2172
2173 ASN1_SEQUENCE(X509_PUBKEY_INTERNAL) = {
2174 ASN1_SIMPLE(X509_PUBKEY, algor, X509_ALGOR),
2175 ASN1_SIMPLE(X509_PUBKEY, public_key, ASN1_BIT_STRING)
2176 } static_ASN1_SEQUENCE_END_name(X509_PUBKEY, X509_PUBKEY_INTERNAL)
2177
2178 static X509_PUBKEY *xorx_d2i_X509_PUBKEY_INTERNAL(const unsigned char **pp,
2179 long len, OSSL_LIB_CTX *libctx)
2180 {
2181 X509_PUBKEY *xpub = OPENSSL_zalloc(sizeof(*xpub));
2182
2183 if (xpub == NULL)
2184 return NULL;
2185 return (X509_PUBKEY *)ASN1_item_d2i_ex((ASN1_VALUE **)&xpub, pp, len,
2186 ASN1_ITEM_rptr(X509_PUBKEY_INTERNAL),
2187 libctx, NULL);
2188 }
2189 /* end steal https://github.com/openssl/openssl/issues/16697 */
2190
2191 /*
2192 * Context used for DER to key decoding.
2193 */
2194 struct der2key_ctx_st {
2195 PROV_XOR_CTX *provctx;
2196 struct keytype_desc_st *desc;
2197 /* The selection that is passed to xor_der2key_decode() */
2198 int selection;
2199 /* Flag used to signal that a failure is fatal */
2200 unsigned int flag_fatal : 1;
2201 };
2202
2203 static int xor_read_der(PROV_XOR_CTX *provctx, OSSL_CORE_BIO *cin,
2204 unsigned char **data, long *len)
2205 {
2206 BUF_MEM *mem = NULL;
2207 BIO *in = BIO_new_from_core_bio(provctx->libctx, cin);
2208 int ok = (asn1_d2i_read_bio(in, &mem) >= 0);
2209
2210 if (ok) {
2211 *data = (unsigned char *)mem->data;
2212 *len = (long)mem->length;
2213 OPENSSL_free(mem);
2214 }
2215 BIO_free(in);
2216 return ok;
2217 }
2218
2219 typedef void *key_from_pkcs8_t(const PKCS8_PRIV_KEY_INFO *p8inf,
2220 OSSL_LIB_CTX *libctx, const char *propq);
2221 static void *xor_der2key_decode_p8(const unsigned char **input_der,
2222 long input_der_len, struct der2key_ctx_st *ctx,
2223 key_from_pkcs8_t *key_from_pkcs8)
2224 {
2225 PKCS8_PRIV_KEY_INFO *p8inf = NULL;
2226 const X509_ALGOR *alg = NULL;
2227 void *key = NULL;
2228
2229 if ((p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, input_der, input_der_len)) != NULL
2230 && PKCS8_pkey_get0(NULL, NULL, NULL, &alg, p8inf)
2231 && OBJ_obj2nid(alg->algorithm) == ctx->desc->evp_type)
2232 key = key_from_pkcs8(p8inf, PROV_XOR_LIBCTX_OF(ctx->provctx), NULL);
2233 PKCS8_PRIV_KEY_INFO_free(p8inf);
2234
2235 return key;
2236 }
2237
2238 static XORKEY *xor_d2i_PUBKEY(XORKEY **a,
2239 const unsigned char **pp, long length)
2240 {
2241 XORKEY *key = NULL;
2242 X509_PUBKEY *xpk;
2243
2244 xpk = xorx_d2i_X509_PUBKEY_INTERNAL(pp, length, NULL);
2245
2246 key = xor_key_from_x509pubkey(xpk, NULL, NULL);
2247
2248 if (key == NULL)
2249 goto err_exit;
2250
2251 if (a != NULL) {
2252 xor_freekey(*a);
2253 *a = key;
2254 }
2255
2256 err_exit:
2257 X509_PUBKEY_free(xpk);
2258 return key;
2259 }
2260
2261
2262 /* ---------------------------------------------------------------------- */
2263
2264 static OSSL_FUNC_decoder_freectx_fn der2key_freectx;
2265 static OSSL_FUNC_decoder_decode_fn xor_der2key_decode;
2266 static OSSL_FUNC_decoder_export_object_fn der2key_export_object;
2267
2268 static struct der2key_ctx_st *
2269 der2key_newctx(void *provctx, struct keytype_desc_st *desc, const char* tls_name)
2270 {
2271 struct der2key_ctx_st *ctx = OPENSSL_zalloc(sizeof(*ctx));
2272
2273 if (ctx != NULL) {
2274 ctx->provctx = provctx;
2275 ctx->desc = desc;
2276 if (desc->evp_type == 0) {
2277 ctx->desc->evp_type = OBJ_sn2nid(tls_name);
2278 }
2279 }
2280 return ctx;
2281 }
2282
2283 static void der2key_freectx(void *vctx)
2284 {
2285 struct der2key_ctx_st *ctx = vctx;
2286
2287 OPENSSL_free(ctx);
2288 }
2289
2290 static int der2key_check_selection(int selection,
2291 const struct keytype_desc_st *desc)
2292 {
2293 /*
2294 * The selections are kinda sorta "levels", i.e. each selection given
2295 * here is assumed to include those following.
2296 */
2297 int checks[] = {
2298 OSSL_KEYMGMT_SELECT_PRIVATE_KEY,
2299 OSSL_KEYMGMT_SELECT_PUBLIC_KEY,
2300 OSSL_KEYMGMT_SELECT_ALL_PARAMETERS
2301 };
2302 size_t i;
2303
2304 /* The decoder implementations made here support guessing */
2305 if (selection == 0)
2306 return 1;
2307
2308 for (i = 0; i < OSSL_NELEM(checks); i++) {
2309 int check1 = (selection & checks[i]) != 0;
2310 int check2 = (desc->selection_mask & checks[i]) != 0;
2311
2312 /*
2313 * If the caller asked for the currently checked bit(s), return
2314 * whether the decoder description says it's supported.
2315 */
2316 if (check1)
2317 return check2;
2318 }
2319
2320 /* This should be dead code, but just to be safe... */
2321 return 0;
2322 }
2323
2324 static int xor_der2key_decode(void *vctx, OSSL_CORE_BIO *cin, int selection,
2325 OSSL_CALLBACK *data_cb, void *data_cbarg,
2326 OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
2327 {
2328 struct der2key_ctx_st *ctx = vctx;
2329 unsigned char *der = NULL;
2330 const unsigned char *derp;
2331 long der_len = 0;
2332 void *key = NULL;
2333 int ok = 0;
2334
2335 ctx->selection = selection;
2336 /*
2337 * The caller is allowed to specify 0 as a selection mark, to have the
2338 * structure and key type guessed. For type-specific structures, this
2339 * is not recommended, as some structures are very similar.
2340 * Note that 0 isn't the same as OSSL_KEYMGMT_SELECT_ALL, as the latter
2341 * signifies a private key structure, where everything else is assumed
2342 * to be present as well.
2343 */
2344 if (selection == 0)
2345 selection = ctx->desc->selection_mask;
2346 if ((selection & ctx->desc->selection_mask) == 0) {
2347 ERR_raise(ERR_LIB_PROV, ERR_R_PASSED_INVALID_ARGUMENT);
2348 return 0;
2349 }
2350
2351 ok = xor_read_der(ctx->provctx, cin, &der, &der_len);
2352 if (!ok)
2353 goto next;
2354
2355 ok = 0; /* Assume that we fail */
2356
2357 if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) {
2358 derp = der;
2359 if (ctx->desc->d2i_PKCS8 != NULL) {
2360 key = ctx->desc->d2i_PKCS8(NULL, &derp, der_len, ctx);
2361 if (ctx->flag_fatal)
2362 goto end;
2363 } else if (ctx->desc->d2i_private_key != NULL) {
2364 key = ctx->desc->d2i_private_key(NULL, &derp, der_len);
2365 }
2366 if (key == NULL && ctx->selection != 0)
2367 goto next;
2368 }
2369 if (key == NULL && (selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0) {
2370 derp = der;
2371 if (ctx->desc->d2i_PUBKEY != NULL)
2372 key = ctx->desc->d2i_PUBKEY(NULL, &derp, der_len);
2373 else
2374 key = ctx->desc->d2i_public_key(NULL, &derp, der_len);
2375 if (key == NULL && ctx->selection != 0)
2376 goto next;
2377 }
2378 if (key == NULL && (selection & OSSL_KEYMGMT_SELECT_ALL_PARAMETERS) != 0) {
2379 derp = der;
2380 if (ctx->desc->d2i_key_params != NULL)
2381 key = ctx->desc->d2i_key_params(NULL, &derp, der_len);
2382 if (key == NULL && ctx->selection != 0)
2383 goto next;
2384 }
2385
2386 /*
2387 * Last minute check to see if this was the correct type of key. This
2388 * should never lead to a fatal error, i.e. the decoding itself was
2389 * correct, it was just an unexpected key type. This is generally for
2390 * classes of key types that have subtle variants, like RSA-PSS keys as
2391 * opposed to plain RSA keys.
2392 */
2393 if (key != NULL
2394 && ctx->desc->check_key != NULL
2395 && !ctx->desc->check_key(key, ctx)) {
2396 ctx->desc->free_key(key);
2397 key = NULL;
2398 }
2399
2400 if (key != NULL && ctx->desc->adjust_key != NULL)
2401 ctx->desc->adjust_key(key, ctx);
2402
2403 next:
2404 /*
2405 * Indicated that we successfully decoded something, or not at all.
2406 * Ending up "empty handed" is not an error.
2407 */
2408 ok = 1;
2409
2410 /*
2411 * We free memory here so it's not held up during the callback, because
2412 * we know the process is recursive and the allocated chunks of memory
2413 * add up.
2414 */
2415 OPENSSL_free(der);
2416 der = NULL;
2417
2418 if (key != NULL) {
2419 OSSL_PARAM params[4];
2420 int object_type = OSSL_OBJECT_PKEY;
2421
2422 params[0] =
2423 OSSL_PARAM_construct_int(OSSL_OBJECT_PARAM_TYPE, &object_type);
2424 params[1] =
2425 OSSL_PARAM_construct_utf8_string(OSSL_OBJECT_PARAM_DATA_TYPE,
2426 (char *)ctx->desc->keytype_name,
2427 0);
2428 /* The address of the key becomes the octet string */
2429 params[2] =
2430 OSSL_PARAM_construct_octet_string(OSSL_OBJECT_PARAM_REFERENCE,
2431 &key, sizeof(key));
2432 params[3] = OSSL_PARAM_construct_end();
2433
2434 ok = data_cb(params, data_cbarg);
2435 }
2436
2437 end:
2438 ctx->desc->free_key(key);
2439 OPENSSL_free(der);
2440
2441 return ok;
2442 }
2443
2444 static int der2key_export_object(void *vctx,
2445 const void *reference, size_t reference_sz,
2446 OSSL_CALLBACK *export_cb, void *export_cbarg)
2447 {
2448 struct der2key_ctx_st *ctx = vctx;
2449 OSSL_FUNC_keymgmt_export_fn *export =
2450 xor_prov_get_keymgmt_export(ctx->desc->fns);
2451 void *keydata;
2452
2453 if (reference_sz == sizeof(keydata) && export != NULL) {
2454 /* The contents of the reference is the address to our object */
2455 keydata = *(void **)reference;
2456
2457 return export(keydata, ctx->selection, export_cb, export_cbarg);
2458 }
2459 return 0;
2460 }
2461
2462 /* ---------------------------------------------------------------------- */
2463
2464 static void *xorx_d2i_PKCS8(void **key, const unsigned char **der, long der_len,
2465 struct der2key_ctx_st *ctx)
2466 {
2467 return xor_der2key_decode_p8(der, der_len, ctx,
2468 (key_from_pkcs8_t *)xor_key_from_pkcs8);
2469 }
2470
2471 static void xorx_key_adjust(void *key, struct der2key_ctx_st *ctx)
2472 {
2473 }
2474
2475 /* ---------------------------------------------------------------------- */
2476
2477 #define DO_PrivateKeyInfo(keytype) \
2478 "PrivateKeyInfo", 0, \
2479 ( OSSL_KEYMGMT_SELECT_PRIVATE_KEY ), \
2480 NULL, \
2481 NULL, \
2482 NULL, \
2483 xorx_d2i_PKCS8, \
2484 NULL, \
2485 NULL, \
2486 xorx_key_adjust, \
2487 (free_key_fn *)xor_freekey
2488
2489 #define DO_SubjectPublicKeyInfo(keytype) \
2490 "SubjectPublicKeyInfo", 0, \
2491 ( OSSL_KEYMGMT_SELECT_PUBLIC_KEY ), \
2492 NULL, \
2493 NULL, \
2494 NULL, \
2495 NULL, \
2496 (d2i_of_void *)xor_d2i_PUBKEY, \
2497 NULL, \
2498 xorx_key_adjust, \
2499 (free_key_fn *)xor_freekey
2500
2501 /*
2502 * MAKE_DECODER is the single driver for creating OSSL_DISPATCH tables.
2503 * It takes the following arguments:
2504 *
2505 * keytype_name The implementation key type as a string.
2506 * keytype The implementation key type. This must correspond exactly
2507 * to our existing keymgmt keytype names... in other words,
2508 * there must exist an ossl_##keytype##_keymgmt_functions.
2509 * type The type name for the set of functions that implement the
2510 * decoder for the key type. This isn't necessarily the same
2511 * as keytype. For example, the key types ed25519, ed448,
2512 * x25519 and x448 are all handled by the same functions with
2513 * the common type name ecx.
2514 * kind The kind of support to implement. This translates into
2515 * the DO_##kind macros above, to populate the keytype_desc_st
2516 * structure.
2517 */
2518 #define MAKE_DECODER(keytype_name, keytype, type, kind) \
2519 static struct keytype_desc_st kind##_##keytype##_desc = \
2520 { keytype_name, xor_##keytype##_keymgmt_functions, \
2521 DO_##kind(keytype) }; \
2522 \
2523 static OSSL_FUNC_decoder_newctx_fn kind##_der2##keytype##_newctx; \
2524 \
2525 static void *kind##_der2##keytype##_newctx(void *provctx) \
2526 { \
2527 return der2key_newctx(provctx, &kind##_##keytype##_desc, keytype_name );\
2528 } \
2529 static int kind##_der2##keytype##_does_selection(void *provctx, \
2530 int selection) \
2531 { \
2532 return der2key_check_selection(selection, \
2533 &kind##_##keytype##_desc); \
2534 } \
2535 static const OSSL_DISPATCH \
2536 xor_##kind##_der_to_##keytype##_decoder_functions[] = { \
2537 { OSSL_FUNC_DECODER_NEWCTX, \
2538 (void (*)(void))kind##_der2##keytype##_newctx }, \
2539 { OSSL_FUNC_DECODER_FREECTX, \
2540 (void (*)(void))der2key_freectx }, \
2541 { OSSL_FUNC_DECODER_DOES_SELECTION, \
2542 (void (*)(void))kind##_der2##keytype##_does_selection }, \
2543 { OSSL_FUNC_DECODER_DECODE, \
2544 (void (*)(void))xor_der2key_decode }, \
2545 { OSSL_FUNC_DECODER_EXPORT_OBJECT, \
2546 (void (*)(void))der2key_export_object }, \
2547 { 0, NULL } \
2548 }
2549
2550 MAKE_DECODER(XORSIGALG_NAME, xorhmacsig, xor, PrivateKeyInfo);
2551 MAKE_DECODER(XORSIGALG_NAME, xorhmacsig, xor, SubjectPublicKeyInfo);
2552 MAKE_DECODER(XORSIGALG_HASH_NAME, xorhmacsha2sig, xor, PrivateKeyInfo);
2553 MAKE_DECODER(XORSIGALG_HASH_NAME, xorhmacsha2sig, xor, SubjectPublicKeyInfo);
2554
2555 static const OSSL_ALGORITHM tls_prov_decoder[] = {
2556 #define DECODER_PROVIDER "tls-provider"
2557 #define DECODER_STRUCTURE_SubjectPublicKeyInfo "SubjectPublicKeyInfo"
2558 #define DECODER_STRUCTURE_PrivateKeyInfo "PrivateKeyInfo"
2559
2560 /* Arguments are prefixed with '_' to avoid build breaks on certain platforms */
2561 /*
2562 * Obviously this is not FIPS approved, but in order to test in conjunction
2563 * with the FIPS provider we pretend that it is.
2564 */
2565
2566 #define DECODER(_name, _input, _output) \
2567 { _name, \
2568 "provider=" DECODER_PROVIDER ",fips=yes,input=" #_input, \
2569 (xor_##_input##_to_##_output##_decoder_functions) }
2570 #define DECODER_w_structure(_name, _input, _structure, _output) \
2571 { _name, \
2572 "provider=" DECODER_PROVIDER ",fips=yes,input=" #_input \
2573 ",structure=" DECODER_STRUCTURE_##_structure, \
2574 (xor_##_structure##_##_input##_to_##_output##_decoder_functions) }
2575
2576 DECODER_w_structure(XORSIGALG_NAME, der, PrivateKeyInfo, xorhmacsig),
2577 DECODER_w_structure(XORSIGALG_NAME, der, SubjectPublicKeyInfo, xorhmacsig),
2578 DECODER_w_structure(XORSIGALG_HASH_NAME, der, PrivateKeyInfo, xorhmacsha2sig),
2579 DECODER_w_structure(XORSIGALG_HASH_NAME, der, SubjectPublicKeyInfo, xorhmacsha2sig),
2580 #undef DECODER_PROVIDER
2581 { NULL, NULL, NULL }
2582 };
2583
2584 #define OSSL_MAX_NAME_SIZE 50
2585 #define OSSL_MAX_PROPQUERY_SIZE 256 /* Property query strings */
2586
2587 static OSSL_FUNC_signature_newctx_fn xor_sig_newctx;
2588 static OSSL_FUNC_signature_sign_init_fn xor_sig_sign_init;
2589 static OSSL_FUNC_signature_verify_init_fn xor_sig_verify_init;
2590 static OSSL_FUNC_signature_sign_fn xor_sig_sign;
2591 static OSSL_FUNC_signature_verify_fn xor_sig_verify;
2592 static OSSL_FUNC_signature_digest_sign_init_fn xor_sig_digest_sign_init;
2593 static OSSL_FUNC_signature_digest_sign_update_fn xor_sig_digest_signverify_update;
2594 static OSSL_FUNC_signature_digest_sign_final_fn xor_sig_digest_sign_final;
2595 static OSSL_FUNC_signature_digest_verify_init_fn xor_sig_digest_verify_init;
2596 static OSSL_FUNC_signature_digest_verify_update_fn xor_sig_digest_signverify_update;
2597 static OSSL_FUNC_signature_digest_verify_final_fn xor_sig_digest_verify_final;
2598 static OSSL_FUNC_signature_freectx_fn xor_sig_freectx;
2599 static OSSL_FUNC_signature_dupctx_fn xor_sig_dupctx;
2600 static OSSL_FUNC_signature_get_ctx_params_fn xor_sig_get_ctx_params;
2601 static OSSL_FUNC_signature_gettable_ctx_params_fn xor_sig_gettable_ctx_params;
2602 static OSSL_FUNC_signature_set_ctx_params_fn xor_sig_set_ctx_params;
2603 static OSSL_FUNC_signature_settable_ctx_params_fn xor_sig_settable_ctx_params;
2604 static OSSL_FUNC_signature_get_ctx_md_params_fn xor_sig_get_ctx_md_params;
2605 static OSSL_FUNC_signature_gettable_ctx_md_params_fn xor_sig_gettable_ctx_md_params;
2606 static OSSL_FUNC_signature_set_ctx_md_params_fn xor_sig_set_ctx_md_params;
2607 static OSSL_FUNC_signature_settable_ctx_md_params_fn xor_sig_settable_ctx_md_params;
2608
2609 static int xor_get_aid(unsigned char** oidbuf, const char *tls_name) {
2610 X509_ALGOR *algor = X509_ALGOR_new();
2611 int aidlen = 0;
2612
2613 X509_ALGOR_set0(algor, OBJ_txt2obj(tls_name, 0), V_ASN1_UNDEF, NULL);
2614
2615 aidlen = i2d_X509_ALGOR(algor, oidbuf);
2616 X509_ALGOR_free(algor);
2617 return(aidlen);
2618 }
2619
2620 /*
2621 * What's passed as an actual key is defined by the KEYMGMT interface.
2622 */
2623 typedef struct {
2624 OSSL_LIB_CTX *libctx;
2625 char *propq;
2626 XORKEY *sig;
2627
2628 /*
2629 * Flag to determine if the hash function can be changed (1) or not (0)
2630 * Because it's dangerous to change during a DigestSign or DigestVerify
2631 * operation, this flag is cleared by their Init function, and set again
2632 * by their Final function.
2633 */
2634 unsigned int flag_allow_md : 1;
2635
2636 char mdname[OSSL_MAX_NAME_SIZE];
2637
2638 /* The Algorithm Identifier of the combined signature algorithm */
2639 unsigned char *aid;
2640 size_t aid_len;
2641
2642 /* main digest */
2643 EVP_MD *md;
2644 EVP_MD_CTX *mdctx;
2645 int operation;
2646 } PROV_XORSIG_CTX;
2647
2648 static void *xor_sig_newctx(void *provctx, const char *propq)
2649 {
2650 PROV_XORSIG_CTX *pxor_sigctx;
2651
2652 pxor_sigctx = OPENSSL_zalloc(sizeof(PROV_XORSIG_CTX));
2653 if (pxor_sigctx == NULL)
2654 return NULL;
2655
2656 pxor_sigctx->libctx = ((PROV_XOR_CTX*)provctx)->libctx;
2657 pxor_sigctx->flag_allow_md = 0;
2658 if (propq != NULL && (pxor_sigctx->propq = OPENSSL_strdup(propq)) == NULL) {
2659 OPENSSL_free(pxor_sigctx);
2660 pxor_sigctx = NULL;
2661 ERR_raise(ERR_LIB_USER, ERR_R_MALLOC_FAILURE);
2662 }
2663 return pxor_sigctx;
2664 }
2665
2666 static int xor_sig_setup_md(PROV_XORSIG_CTX *ctx,
2667 const char *mdname, const char *mdprops)
2668 {
2669 EVP_MD *md;
2670
2671 if (mdprops == NULL)
2672 mdprops = ctx->propq;
2673
2674 md = EVP_MD_fetch(ctx->libctx, mdname, mdprops);
2675
2676 if ((md == NULL) || (EVP_MD_nid(md)==NID_undef)) {
2677 if (md == NULL)
2678 ERR_raise_data(ERR_LIB_USER, XORPROV_R_INVALID_DIGEST,
2679 "%s could not be fetched", mdname);
2680 EVP_MD_free(md);
2681 return 0;
2682 }
2683
2684 EVP_MD_CTX_free(ctx->mdctx);
2685 ctx->mdctx = NULL;
2686 EVP_MD_free(ctx->md);
2687 ctx->md = NULL;
2688
2689 OPENSSL_free(ctx->aid);
2690 ctx->aid = NULL;
2691 ctx->aid_len = xor_get_aid(&(ctx->aid), ctx->sig->tls_name);
2692
2693 ctx->mdctx = NULL;
2694 ctx->md = md;
2695 OPENSSL_strlcpy(ctx->mdname, mdname, sizeof(ctx->mdname));
2696 return 1;
2697 }
2698
2699 static int xor_sig_signverify_init(void *vpxor_sigctx, void *vxorsig,
2700 int operation)
2701 {
2702 PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2703
2704 if (pxor_sigctx == NULL || vxorsig == NULL)
2705 return 0;
2706 xor_freekey(pxor_sigctx->sig);
2707 if (!xor_key_up_ref(vxorsig))
2708 return 0;
2709 pxor_sigctx->sig = vxorsig;
2710 pxor_sigctx->operation = operation;
2711 if ((operation==EVP_PKEY_OP_SIGN && pxor_sigctx->sig == NULL)
2712 || (operation==EVP_PKEY_OP_VERIFY && pxor_sigctx->sig == NULL)) {
2713 ERR_raise(ERR_LIB_USER, XORPROV_R_INVALID_KEY);
2714 return 0;
2715 }
2716 return 1;
2717 }
2718
2719 static int xor_sig_sign_init(void *vpxor_sigctx, void *vxorsig,
2720 const OSSL_PARAM params[])
2721 {
2722 return xor_sig_signverify_init(vpxor_sigctx, vxorsig, EVP_PKEY_OP_SIGN);
2723 }
2724
2725 static int xor_sig_verify_init(void *vpxor_sigctx, void *vxorsig,
2726 const OSSL_PARAM params[])
2727 {
2728 return xor_sig_signverify_init(vpxor_sigctx, vxorsig, EVP_PKEY_OP_VERIFY);
2729 }
2730
2731 static int xor_sig_sign(void *vpxor_sigctx, unsigned char *sig, size_t *siglen,
2732 size_t sigsize, const unsigned char *tbs, size_t tbslen)
2733 {
2734 PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2735 XORKEY *xorkey = pxor_sigctx->sig;
2736
2737 size_t max_sig_len = EVP_MAX_MD_SIZE;
2738 size_t xor_sig_len = 0;
2739 int rv = 0;
2740
2741 if (xorkey == NULL || !xorkey->hasprivkey) {
2742 ERR_raise(ERR_LIB_USER, XORPROV_R_NO_PRIVATE_KEY);
2743 return rv;
2744 }
2745
2746 if (sig == NULL) {
2747 *siglen = max_sig_len;
2748 return 1;
2749 }
2750 if (*siglen < max_sig_len) {
2751 ERR_raise(ERR_LIB_USER, XORPROV_R_BUFFER_LENGTH_WRONG);
2752 return rv;
2753 }
2754
2755 /*
2756 * create HMAC using XORKEY as key and hash as data:
2757 * No real crypto, just for test, don't do this at home!
2758 */
2759 if (!EVP_Q_mac(pxor_sigctx->libctx, "HMAC", NULL, "sha1", NULL,
2760 xorkey->privkey, XOR_KEY_SIZE, tbs, tbslen,
2761 &sig[0], EVP_MAX_MD_SIZE, &xor_sig_len)) {
2762 ERR_raise(ERR_LIB_USER, XORPROV_R_SIGNING_FAILED);
2763 goto endsign;
2764 }
2765
2766 *siglen = xor_sig_len;
2767 rv = 1; /* success */
2768
2769 endsign:
2770 return rv;
2771 }
2772
2773 static int xor_sig_verify(void *vpxor_sigctx,
2774 const unsigned char *sig, size_t siglen,
2775 const unsigned char *tbs, size_t tbslen)
2776 {
2777 PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2778 XORKEY *xorkey = pxor_sigctx->sig;
2779 unsigned char resignature[EVP_MAX_MD_SIZE];
2780 size_t resiglen;
2781 int i;
2782
2783 if (xorkey == NULL || sig == NULL || tbs == NULL) {
2784 ERR_raise(ERR_LIB_USER, XORPROV_R_WRONG_PARAMETERS);
2785 return 0;
2786 }
2787
2788 /*
2789 * This is no real verify: just re-sign and compare:
2790 * Don't do this at home! Not fit for real use!
2791 */
2792 /* First re-create private key from public key: */
2793 for (i = 0; i < XOR_KEY_SIZE; i++)
2794 xorkey->privkey[i] = xorkey->pubkey[i] ^ private_constant[i];
2795
2796 /* Now re-create signature */
2797 if (!EVP_Q_mac(pxor_sigctx->libctx, "HMAC", NULL, "sha1", NULL,
2798 xorkey->privkey, XOR_KEY_SIZE, tbs, tbslen,
2799 &resignature[0], EVP_MAX_MD_SIZE, &resiglen)) {
2800 ERR_raise(ERR_LIB_USER, XORPROV_R_VERIFY_ERROR);
2801 return 0;
2802 }
2803
2804 /* Now compare with signature passed */
2805 if (siglen != resiglen || memcmp(resignature, sig, siglen) != 0) {
2806 ERR_raise(ERR_LIB_USER, XORPROV_R_VERIFY_ERROR);
2807 return 0;
2808 }
2809 return 1;
2810 }
2811
2812 static int xor_sig_digest_signverify_init(void *vpxor_sigctx, const char *mdname,
2813 void *vxorsig, int operation)
2814 {
2815 PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2816 char *rmdname = (char *)mdname;
2817
2818 if (rmdname == NULL)
2819 rmdname = "sha256";
2820
2821 pxor_sigctx->flag_allow_md = 0;
2822 if (!xor_sig_signverify_init(vpxor_sigctx, vxorsig, operation))
2823 return 0;
2824
2825 if (!xor_sig_setup_md(pxor_sigctx, rmdname, NULL))
2826 return 0;
2827
2828 pxor_sigctx->mdctx = EVP_MD_CTX_new();
2829 if (pxor_sigctx->mdctx == NULL)
2830 goto error;
2831
2832 if (!EVP_DigestInit_ex(pxor_sigctx->mdctx, pxor_sigctx->md, NULL))
2833 goto error;
2834
2835 return 1;
2836
2837 error:
2838 EVP_MD_CTX_free(pxor_sigctx->mdctx);
2839 EVP_MD_free(pxor_sigctx->md);
2840 pxor_sigctx->mdctx = NULL;
2841 pxor_sigctx->md = NULL;
2842 return 0;
2843 }
2844
2845 static int xor_sig_digest_sign_init(void *vpxor_sigctx, const char *mdname,
2846 void *vxorsig, const OSSL_PARAM params[])
2847 {
2848 return xor_sig_digest_signverify_init(vpxor_sigctx, mdname, vxorsig,
2849 EVP_PKEY_OP_SIGN);
2850 }
2851
2852 static int xor_sig_digest_verify_init(void *vpxor_sigctx, const char *mdname, void *vxorsig, const OSSL_PARAM params[])
2853 {
2854 return xor_sig_digest_signverify_init(vpxor_sigctx, mdname,
2855 vxorsig, EVP_PKEY_OP_VERIFY);
2856 }
2857
2858 int xor_sig_digest_signverify_update(void *vpxor_sigctx,
2859 const unsigned char *data,
2860 size_t datalen)
2861 {
2862 PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2863
2864 if (pxor_sigctx == NULL || pxor_sigctx->mdctx == NULL)
2865 return 0;
2866
2867 return EVP_DigestUpdate(pxor_sigctx->mdctx, data, datalen);
2868 }
2869
2870 int xor_sig_digest_sign_final(void *vpxor_sigctx,
2871 unsigned char *sig, size_t *siglen,
2872 size_t sigsize)
2873 {
2874 PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2875 unsigned char digest[EVP_MAX_MD_SIZE];
2876 unsigned int dlen = 0;
2877
2878 if (sig != NULL) {
2879 if (pxor_sigctx == NULL || pxor_sigctx->mdctx == NULL)
2880 return 0;
2881
2882 if (!EVP_DigestFinal_ex(pxor_sigctx->mdctx, digest, &dlen))
2883 return 0;
2884
2885 pxor_sigctx->flag_allow_md = 1;
2886 }
2887
2888 return xor_sig_sign(vpxor_sigctx, sig, siglen, sigsize, digest, (size_t)dlen);
2889
2890 }
2891
2892 int xor_sig_digest_verify_final(void *vpxor_sigctx, const unsigned char *sig,
2893 size_t siglen)
2894 {
2895 PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2896 unsigned char digest[EVP_MAX_MD_SIZE];
2897 unsigned int dlen = 0;
2898
2899 if (pxor_sigctx == NULL || pxor_sigctx->mdctx == NULL)
2900 return 0;
2901
2902 if (!EVP_DigestFinal_ex(pxor_sigctx->mdctx, digest, &dlen))
2903 return 0;
2904
2905 pxor_sigctx->flag_allow_md = 1;
2906
2907 return xor_sig_verify(vpxor_sigctx, sig, siglen, digest, (size_t)dlen);
2908 }
2909
2910 static void xor_sig_freectx(void *vpxor_sigctx)
2911 {
2912 PROV_XORSIG_CTX *ctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2913
2914 OPENSSL_free(ctx->propq);
2915 EVP_MD_CTX_free(ctx->mdctx);
2916 EVP_MD_free(ctx->md);
2917 ctx->propq = NULL;
2918 ctx->mdctx = NULL;
2919 ctx->md = NULL;
2920 xor_freekey(ctx->sig);
2921 ctx->sig = NULL;
2922 OPENSSL_free(ctx->aid);
2923 OPENSSL_free(ctx);
2924 }
2925
2926 static void *xor_sig_dupctx(void *vpxor_sigctx)
2927 {
2928 PROV_XORSIG_CTX *srcctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2929 PROV_XORSIG_CTX *dstctx;
2930
2931 dstctx = OPENSSL_zalloc(sizeof(*srcctx));
2932 if (dstctx == NULL)
2933 return NULL;
2934
2935 *dstctx = *srcctx;
2936 dstctx->sig = NULL;
2937 dstctx->md = NULL;
2938 dstctx->mdctx = NULL;
2939 dstctx->aid = NULL;
2940
2941 if ((srcctx->sig != NULL) && !xor_key_up_ref(srcctx->sig))
2942 goto err;
2943 dstctx->sig = srcctx->sig;
2944
2945 if (srcctx->md != NULL && !EVP_MD_up_ref(srcctx->md))
2946 goto err;
2947 dstctx->md = srcctx->md;
2948
2949 if (srcctx->mdctx != NULL) {
2950 dstctx->mdctx = EVP_MD_CTX_new();
2951 if (dstctx->mdctx == NULL
2952 || !EVP_MD_CTX_copy_ex(dstctx->mdctx, srcctx->mdctx))
2953 goto err;
2954 }
2955
2956 return dstctx;
2957 err:
2958 xor_sig_freectx(dstctx);
2959 return NULL;
2960 }
2961
2962 static int xor_sig_get_ctx_params(void *vpxor_sigctx, OSSL_PARAM *params)
2963 {
2964 PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2965 OSSL_PARAM *p;
2966
2967 if (pxor_sigctx == NULL || params == NULL)
2968 return 0;
2969
2970 p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_ALGORITHM_ID);
2971
2972 if (pxor_sigctx->aid == NULL)
2973 pxor_sigctx->aid_len = xor_get_aid(&(pxor_sigctx->aid), pxor_sigctx->sig->tls_name);
2974
2975 if (p != NULL
2976 && !OSSL_PARAM_set_octet_string(p, pxor_sigctx->aid, pxor_sigctx->aid_len))
2977 return 0;
2978
2979 p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_DIGEST);
2980 if (p != NULL && !OSSL_PARAM_set_utf8_string(p, pxor_sigctx->mdname))
2981 return 0;
2982
2983 return 1;
2984 }
2985
2986 static const OSSL_PARAM known_gettable_ctx_params[] = {
2987 OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0),
2988 OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
2989 OSSL_PARAM_END
2990 };
2991
2992 static const OSSL_PARAM *xor_sig_gettable_ctx_params(ossl_unused void *vpxor_sigctx, ossl_unused void *vctx)
2993 {
2994 return known_gettable_ctx_params;
2995 }
2996
2997 static int xor_sig_set_ctx_params(void *vpxor_sigctx, const OSSL_PARAM params[])
2998 {
2999 PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
3000 const OSSL_PARAM *p;
3001
3002 if (pxor_sigctx == NULL || params == NULL)
3003 return 0;
3004
3005 p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST);
3006 /* Not allowed during certain operations */
3007 if (p != NULL && !pxor_sigctx->flag_allow_md)
3008 return 0;
3009 if (p != NULL) {
3010 char mdname[OSSL_MAX_NAME_SIZE] = "", *pmdname = mdname;
3011 char mdprops[OSSL_MAX_PROPQUERY_SIZE] = "", *pmdprops = mdprops;
3012 const OSSL_PARAM *propsp =
3013 OSSL_PARAM_locate_const(params,
3014 OSSL_SIGNATURE_PARAM_PROPERTIES);
3015
3016 if (!OSSL_PARAM_get_utf8_string(p, &pmdname, sizeof(mdname)))
3017 return 0;
3018 if (propsp != NULL
3019 && !OSSL_PARAM_get_utf8_string(propsp, &pmdprops, sizeof(mdprops)))
3020 return 0;
3021 if (!xor_sig_setup_md(pxor_sigctx, mdname, mdprops))
3022 return 0;
3023 }
3024
3025 return 1;
3026 }
3027
3028 static const OSSL_PARAM known_settable_ctx_params[] = {
3029 OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
3030 OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PROPERTIES, NULL, 0),
3031 OSSL_PARAM_END
3032 };
3033
3034 static const OSSL_PARAM *xor_sig_settable_ctx_params(ossl_unused void *vpsm2ctx,
3035 ossl_unused void *provctx)
3036 {
3037 return known_settable_ctx_params;
3038 }
3039
3040 static int xor_sig_get_ctx_md_params(void *vpxor_sigctx, OSSL_PARAM *params)
3041 {
3042 PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
3043
3044 if (pxor_sigctx->mdctx == NULL)
3045 return 0;
3046
3047 return EVP_MD_CTX_get_params(pxor_sigctx->mdctx, params);
3048 }
3049
3050 static const OSSL_PARAM *xor_sig_gettable_ctx_md_params(void *vpxor_sigctx)
3051 {
3052 PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
3053
3054 if (pxor_sigctx->md == NULL)
3055 return 0;
3056
3057 return EVP_MD_gettable_ctx_params(pxor_sigctx->md);
3058 }
3059
3060 static int xor_sig_set_ctx_md_params(void *vpxor_sigctx, const OSSL_PARAM params[])
3061 {
3062 PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
3063
3064 if (pxor_sigctx->mdctx == NULL)
3065 return 0;
3066
3067 return EVP_MD_CTX_set_params(pxor_sigctx->mdctx, params);
3068 }
3069
3070 static const OSSL_PARAM *xor_sig_settable_ctx_md_params(void *vpxor_sigctx)
3071 {
3072 PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
3073
3074 if (pxor_sigctx->md == NULL)
3075 return 0;
3076
3077 return EVP_MD_settable_ctx_params(pxor_sigctx->md);
3078 }
3079
3080 static const OSSL_DISPATCH xor_signature_functions[] = {
3081 { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))xor_sig_newctx },
3082 { OSSL_FUNC_SIGNATURE_SIGN_INIT, (void (*)(void))xor_sig_sign_init },
3083 { OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))xor_sig_sign },
3084 { OSSL_FUNC_SIGNATURE_VERIFY_INIT, (void (*)(void))xor_sig_verify_init },
3085 { OSSL_FUNC_SIGNATURE_VERIFY, (void (*)(void))xor_sig_verify },
3086 { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT,
3087 (void (*)(void))xor_sig_digest_sign_init },
3088 { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE,
3089 (void (*)(void))xor_sig_digest_signverify_update },
3090 { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL,
3091 (void (*)(void))xor_sig_digest_sign_final },
3092 { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT,
3093 (void (*)(void))xor_sig_digest_verify_init },
3094 { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE,
3095 (void (*)(void))xor_sig_digest_signverify_update },
3096 { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL,
3097 (void (*)(void))xor_sig_digest_verify_final },
3098 { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))xor_sig_freectx },
3099 { OSSL_FUNC_SIGNATURE_DUPCTX, (void (*)(void))xor_sig_dupctx },
3100 { OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS, (void (*)(void))xor_sig_get_ctx_params },
3101 { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS,
3102 (void (*)(void))xor_sig_gettable_ctx_params },
3103 { OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS, (void (*)(void))xor_sig_set_ctx_params },
3104 { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS,
3105 (void (*)(void))xor_sig_settable_ctx_params },
3106 { OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS,
3107 (void (*)(void))xor_sig_get_ctx_md_params },
3108 { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS,
3109 (void (*)(void))xor_sig_gettable_ctx_md_params },
3110 { OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS,
3111 (void (*)(void))xor_sig_set_ctx_md_params },
3112 { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS,
3113 (void (*)(void))xor_sig_settable_ctx_md_params },
3114 { 0, NULL }
3115 };
3116
3117 static const OSSL_ALGORITHM tls_prov_signature[] = {
3118 /*
3119 * Obviously this is not FIPS approved, but in order to test in conjunction
3120 * with the FIPS provider we pretend that it is.
3121 */
3122 { XORSIGALG_NAME, "provider=tls-provider,fips=yes",
3123 xor_signature_functions },
3124 { XORSIGALG_HASH_NAME, "provider=tls-provider,fips=yes",
3125 xor_signature_functions },
3126 { XORSIGALG12_NAME, "provider=tls-provider,fips=yes",
3127 xor_signature_functions },
3128 { NULL, NULL, NULL }
3129 };
3130
3131
3132 static const OSSL_ALGORITHM *tls_prov_query(void *provctx, int operation_id,
3133 int *no_cache)
3134 {
3135 *no_cache = 0;
3136 switch (operation_id) {
3137 case OSSL_OP_KEYMGMT:
3138 return tls_prov_keymgmt;
3139 case OSSL_OP_KEYEXCH:
3140 return tls_prov_keyexch;
3141 case OSSL_OP_KEM:
3142 return tls_prov_kem;
3143 case OSSL_OP_ENCODER:
3144 return tls_prov_encoder;
3145 case OSSL_OP_DECODER:
3146 return tls_prov_decoder;
3147 case OSSL_OP_SIGNATURE:
3148 return tls_prov_signature;
3149 }
3150 return NULL;
3151 }
3152
3153 static void tls_prov_teardown(void *provctx)
3154 {
3155 int i;
3156 PROV_XOR_CTX *pctx = (PROV_XOR_CTX*)provctx;
3157
3158 OSSL_LIB_CTX_free(pctx->libctx);
3159
3160 for (i = 0; i < NUM_DUMMY_GROUPS; i++) {
3161 OPENSSL_free(dummy_group_names[i]);
3162 dummy_group_names[i] = NULL;
3163 }
3164 OPENSSL_free(pctx);
3165 }
3166
3167 /* Functions we provide to the core */
3168 static const OSSL_DISPATCH tls_prov_dispatch_table[] = {
3169 { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))tls_prov_teardown },
3170 { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))tls_prov_query },
3171 { OSSL_FUNC_PROVIDER_GET_CAPABILITIES, (void (*)(void))tls_prov_get_capabilities },
3172 { 0, NULL }
3173 };
3174
3175 static
3176 unsigned int randomize_tls_alg_id(OSSL_LIB_CTX *libctx)
3177 {
3178 /*
3179 * Randomise the id we're going to use to ensure we don't interoperate
3180 * with anything but ourselves.
3181 */
3182 unsigned int id;
3183 static unsigned int mem[10] = { 0 };
3184 static int in_mem = 0;
3185 int i;
3186
3187 retry:
3188 if (RAND_bytes_ex(libctx, (unsigned char *)&id, sizeof(id), 0) <= 0)
3189 return 0;
3190 /*
3191 * Ensure id is within the IANA Reserved for private use range
3192 * (65024-65279)
3193 */
3194 id %= 65279 - 65024;
3195 id += 65024;
3196
3197 /* Ensure we did not already issue this id */
3198 for (i = 0; i < in_mem; i++)
3199 if (mem[i] == id)
3200 goto retry;
3201
3202 /* Add this id to the list of ids issued by this function */
3203 mem[in_mem++] = id;
3204
3205 return id;
3206 }
3207
3208 int tls_provider_init(const OSSL_CORE_HANDLE *handle,
3209 const OSSL_DISPATCH *in,
3210 const OSSL_DISPATCH **out,
3211 void **provctx)
3212 {
3213 OSSL_LIB_CTX *libctx = OSSL_LIB_CTX_new_from_dispatch(handle, in);
3214 OSSL_FUNC_core_obj_create_fn *c_obj_create= NULL;
3215 OSSL_FUNC_core_obj_add_sigid_fn *c_obj_add_sigid= NULL;
3216 PROV_XOR_CTX *prov_ctx = xor_newprovctx(libctx);
3217
3218 if (libctx == NULL || prov_ctx == NULL)
3219 return 0;
3220
3221 *provctx = prov_ctx;
3222
3223 /*
3224 * Randomise the group_id and code_points we're going to use to ensure we
3225 * don't interoperate with anything but ourselves.
3226 */
3227 xor_group.group_id = randomize_tls_alg_id(libctx);
3228 xor_kemgroup.group_id = randomize_tls_alg_id(libctx);
3229 xor_sigalg.code_point = randomize_tls_alg_id(libctx);
3230 xor_sigalg_hash.code_point = randomize_tls_alg_id(libctx);
3231
3232 /* Retrieve registration functions */
3233 for (; in->function_id != 0; in++) {
3234 switch (in->function_id) {
3235 case OSSL_FUNC_CORE_OBJ_CREATE:
3236 c_obj_create = OSSL_FUNC_core_obj_create(in);
3237 break;
3238 case OSSL_FUNC_CORE_OBJ_ADD_SIGID:
3239 c_obj_add_sigid = OSSL_FUNC_core_obj_add_sigid(in);
3240 break;
3241 /* Just ignore anything we don't understand */
3242 default:
3243 break;
3244 }
3245 }
3246
3247 /*
3248 * Register algorithms manually as add_provider_sigalgs is
3249 * only called during session establishment -- too late for
3250 * key & cert generation...
3251 */
3252 if (!c_obj_create(handle, XORSIGALG_OID, XORSIGALG_NAME, XORSIGALG_NAME)) {
3253 ERR_raise(ERR_LIB_USER, XORPROV_R_OBJ_CREATE_ERR);
3254 return 0;
3255 }
3256
3257 if (!c_obj_add_sigid(handle, XORSIGALG_OID, "", XORSIGALG_OID)) {
3258 ERR_raise(ERR_LIB_USER, XORPROV_R_OBJ_CREATE_ERR);
3259 return 0;
3260 }
3261 if (!c_obj_create(handle, XORSIGALG_HASH_OID, XORSIGALG_HASH_NAME, NULL)) {
3262 ERR_raise(ERR_LIB_USER, XORPROV_R_OBJ_CREATE_ERR);
3263 return 0;
3264 }
3265
3266 if (!c_obj_add_sigid(handle, XORSIGALG_HASH_OID, XORSIGALG_HASH, XORSIGALG_HASH_OID)) {
3267 ERR_raise(ERR_LIB_USER, XORPROV_R_OBJ_CREATE_ERR);
3268 return 0;
3269 }
3270
3271 *out = tls_prov_dispatch_table;
3272 return 1;
3273 }
A mirror of the official openssl repository