VirtualBox

source: vbox/trunk/src/libs/openssl-3.0.3/crypto/cms/cms_ec.c@ 96159

最後變更 在這個檔案從96159是 94320,由 vboxsync 提交於 3 年 前

libs/openssl-3.0.1: Export to OSE and fix copyright headers in Makefiles, bugref:10128
檔案大小: 11.8 KB
行 
1/*
2 * Copyright 2006-2021 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10#include <assert.h>
11#include <openssl/cms.h>
12#include <openssl/err.h>
13#include <openssl/decoder.h>
14#include "internal/sizes.h"
15#include "crypto/evp.h"
16#include "cms_local.h"
17
18static EVP_PKEY *pkey_type2param(int ptype, const void *pval,
19 OSSL_LIB_CTX *libctx, const char *propq)
20{
21 EVP_PKEY *pkey = NULL;
22 EVP_PKEY_CTX *pctx = NULL;
23 OSSL_DECODER_CTX *ctx = NULL;
24
25 if (ptype == V_ASN1_SEQUENCE) {
26 const ASN1_STRING *pstr = pval;
27 const unsigned char *pm = pstr->data;
28 size_t pmlen = (size_t)pstr->length;
29 int selection = OSSL_KEYMGMT_SELECT_ALL_PARAMETERS;
30
31 ctx = OSSL_DECODER_CTX_new_for_pkey(&pkey, "DER", NULL, "EC",
32 selection, libctx, propq);
33 if (ctx == NULL)
34 goto err;
35
36 if (!OSSL_DECODER_from_data(ctx, &pm, &pmlen)) {
37 ERR_raise(ERR_LIB_CMS, CMS_R_DECODE_ERROR);
38 goto err;
39 }
40 OSSL_DECODER_CTX_free(ctx);
41 return pkey;
42 } else if (ptype == V_ASN1_OBJECT) {
43 const ASN1_OBJECT *poid = pval;
44 char groupname[OSSL_MAX_NAME_SIZE];
45
46 /* type == V_ASN1_OBJECT => the parameters are given by an asn1 OID */
47 pctx = EVP_PKEY_CTX_new_from_name(libctx, "EC", propq);
48 if (pctx == NULL || EVP_PKEY_paramgen_init(pctx) <= 0)
49 goto err;
50 if (OBJ_obj2txt(groupname, sizeof(groupname), poid, 0) <= 0
51 || !EVP_PKEY_CTX_set_group_name(pctx, groupname)) {
52 ERR_raise(ERR_LIB_CMS, CMS_R_DECODE_ERROR);
53 goto err;
54 }
55 if (EVP_PKEY_paramgen(pctx, &pkey) <= 0)
56 goto err;
57 EVP_PKEY_CTX_free(pctx);
58 return pkey;
59 }
60
61 ERR_raise(ERR_LIB_CMS, CMS_R_DECODE_ERROR);
62 return NULL;
63
64 err:
65 EVP_PKEY_free(pkey);
66 EVP_PKEY_CTX_free(pctx);
67 OSSL_DECODER_CTX_free(ctx);
68 return NULL;
69}
70
71static int ecdh_cms_set_peerkey(EVP_PKEY_CTX *pctx,
72 X509_ALGOR *alg, ASN1_BIT_STRING *pubkey)
73{
74 const ASN1_OBJECT *aoid;
75 int atype;
76 const void *aval;
77 int rv = 0;
78 EVP_PKEY *pkpeer = NULL;
79 const unsigned char *p;
80 int plen;
81
82 X509_ALGOR_get0(&aoid, &atype, &aval, alg);
83 if (OBJ_obj2nid(aoid) != NID_X9_62_id_ecPublicKey)
84 goto err;
85
86 /* If absent parameters get group from main key */
87 if (atype == V_ASN1_UNDEF || atype == V_ASN1_NULL) {
88 EVP_PKEY *pk;
89
90 pk = EVP_PKEY_CTX_get0_pkey(pctx);
91 if (pk == NULL)
92 goto err;
93
94 pkpeer = EVP_PKEY_new();
95 if (pkpeer == NULL)
96 goto err;
97 if (!EVP_PKEY_copy_parameters(pkpeer, pk))
98 goto err;
99 } else {
100 pkpeer = pkey_type2param(atype, aval,
101 EVP_PKEY_CTX_get0_libctx(pctx),
102 EVP_PKEY_CTX_get0_propq(pctx));
103 if (pkpeer == NULL)
104 goto err;
105 }
106 /* We have parameters now set public key */
107 plen = ASN1_STRING_length(pubkey);
108 p = ASN1_STRING_get0_data(pubkey);
109 if (p == NULL || plen == 0)
110 goto err;
111
112 if (!EVP_PKEY_set1_encoded_public_key(pkpeer, p, plen))
113 goto err;
114
115 if (EVP_PKEY_derive_set_peer(pctx, pkpeer) > 0)
116 rv = 1;
117 err:
118 EVP_PKEY_free(pkpeer);
119 return rv;
120}
121
122/* Set KDF parameters based on KDF NID */
123static int ecdh_cms_set_kdf_param(EVP_PKEY_CTX *pctx, int eckdf_nid)
124{
125 int kdf_nid, kdfmd_nid, cofactor;
126 const EVP_MD *kdf_md;
127
128 if (eckdf_nid == NID_undef)
129 return 0;
130
131 /* Lookup KDF type, cofactor mode and digest */
132 if (!OBJ_find_sigid_algs(eckdf_nid, &kdfmd_nid, &kdf_nid))
133 return 0;
134
135 if (kdf_nid == NID_dh_std_kdf)
136 cofactor = 0;
137 else if (kdf_nid == NID_dh_cofactor_kdf)
138 cofactor = 1;
139 else
140 return 0;
141
142 if (EVP_PKEY_CTX_set_ecdh_cofactor_mode(pctx, cofactor) <= 0)
143 return 0;
144
145 if (EVP_PKEY_CTX_set_ecdh_kdf_type(pctx, EVP_PKEY_ECDH_KDF_X9_63) <= 0)
146 return 0;
147
148 kdf_md = EVP_get_digestbynid(kdfmd_nid);
149 if (!kdf_md)
150 return 0;
151
152 if (EVP_PKEY_CTX_set_ecdh_kdf_md(pctx, kdf_md) <= 0)
153 return 0;
154 return 1;
155}
156
157static int ecdh_cms_set_shared_info(EVP_PKEY_CTX *pctx, CMS_RecipientInfo *ri)
158{
159 int rv = 0;
160 X509_ALGOR *alg, *kekalg = NULL;
161 ASN1_OCTET_STRING *ukm;
162 const unsigned char *p;
163 unsigned char *der = NULL;
164 int plen, keylen;
165 EVP_CIPHER *kekcipher = NULL;
166 EVP_CIPHER_CTX *kekctx;
167 char name[OSSL_MAX_NAME_SIZE];
168
169 if (!CMS_RecipientInfo_kari_get0_alg(ri, &alg, &ukm))
170 return 0;
171
172 if (!ecdh_cms_set_kdf_param(pctx, OBJ_obj2nid(alg->algorithm))) {
173 ERR_raise(ERR_LIB_CMS, CMS_R_KDF_PARAMETER_ERROR);
174 return 0;
175 }
176
177 if (alg->parameter->type != V_ASN1_SEQUENCE)
178 return 0;
179
180 p = alg->parameter->value.sequence->data;
181 plen = alg->parameter->value.sequence->length;
182 kekalg = d2i_X509_ALGOR(NULL, &p, plen);
183 if (kekalg == NULL)
184 goto err;
185 kekctx = CMS_RecipientInfo_kari_get0_ctx(ri);
186 if (kekctx == NULL)
187 goto err;
188 OBJ_obj2txt(name, sizeof(name), kekalg->algorithm, 0);
189 kekcipher = EVP_CIPHER_fetch(pctx->libctx, name, pctx->propquery);
190 if (kekcipher == NULL || EVP_CIPHER_get_mode(kekcipher) != EVP_CIPH_WRAP_MODE)
191 goto err;
192 if (!EVP_EncryptInit_ex(kekctx, kekcipher, NULL, NULL, NULL))
193 goto err;
194 if (EVP_CIPHER_asn1_to_param(kekctx, kekalg->parameter) <= 0)
195 goto err;
196
197 keylen = EVP_CIPHER_CTX_get_key_length(kekctx);
198 if (EVP_PKEY_CTX_set_ecdh_kdf_outlen(pctx, keylen) <= 0)
199 goto err;
200
201 plen = CMS_SharedInfo_encode(&der, kekalg, ukm, keylen);
202
203 if (plen <= 0)
204 goto err;
205
206 if (EVP_PKEY_CTX_set0_ecdh_kdf_ukm(pctx, der, plen) <= 0)
207 goto err;
208 der = NULL;
209
210 rv = 1;
211 err:
212 EVP_CIPHER_free(kekcipher);
213 X509_ALGOR_free(kekalg);
214 OPENSSL_free(der);
215 return rv;
216}
217
218static int ecdh_cms_decrypt(CMS_RecipientInfo *ri)
219{
220 EVP_PKEY_CTX *pctx;
221
222 pctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
223 if (pctx == NULL)
224 return 0;
225 /* See if we need to set peer key */
226 if (!EVP_PKEY_CTX_get0_peerkey(pctx)) {
227 X509_ALGOR *alg;
228 ASN1_BIT_STRING *pubkey;
229
230 if (!CMS_RecipientInfo_kari_get0_orig_id(ri, &alg, &pubkey,
231 NULL, NULL, NULL))
232 return 0;
233 if (alg == NULL || pubkey == NULL)
234 return 0;
235 if (!ecdh_cms_set_peerkey(pctx, alg, pubkey)) {
236 ERR_raise(ERR_LIB_CMS, CMS_R_PEER_KEY_ERROR);
237 return 0;
238 }
239 }
240 /* Set ECDH derivation parameters and initialise unwrap context */
241 if (!ecdh_cms_set_shared_info(pctx, ri)) {
242 ERR_raise(ERR_LIB_CMS, CMS_R_SHARED_INFO_ERROR);
243 return 0;
244 }
245 return 1;
246}
247
248static int ecdh_cms_encrypt(CMS_RecipientInfo *ri)
249{
250 EVP_PKEY_CTX *pctx;
251 EVP_PKEY *pkey;
252 EVP_CIPHER_CTX *ctx;
253 int keylen;
254 X509_ALGOR *talg, *wrap_alg = NULL;
255 const ASN1_OBJECT *aoid;
256 ASN1_BIT_STRING *pubkey;
257 ASN1_STRING *wrap_str;
258 ASN1_OCTET_STRING *ukm;
259 unsigned char *penc = NULL;
260 size_t penclen;
261 int rv = 0;
262 int ecdh_nid, kdf_type, kdf_nid, wrap_nid;
263 const EVP_MD *kdf_md;
264
265 pctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
266 if (pctx == NULL)
267 return 0;
268 /* Get ephemeral key */
269 pkey = EVP_PKEY_CTX_get0_pkey(pctx);
270 if (!CMS_RecipientInfo_kari_get0_orig_id(ri, &talg, &pubkey,
271 NULL, NULL, NULL))
272 goto err;
273 X509_ALGOR_get0(&aoid, NULL, NULL, talg);
274 /* Is everything uninitialised? */
275 if (aoid == OBJ_nid2obj(NID_undef)) {
276 /* Set the key */
277
278 penclen = EVP_PKEY_get1_encoded_public_key(pkey, &penc);
279 ASN1_STRING_set0(pubkey, penc, penclen);
280 pubkey->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);
281 pubkey->flags |= ASN1_STRING_FLAG_BITS_LEFT;
282
283 penc = NULL;
284 X509_ALGOR_set0(talg, OBJ_nid2obj(NID_X9_62_id_ecPublicKey),
285 V_ASN1_UNDEF, NULL);
286 }
287
288 /* See if custom parameters set */
289 kdf_type = EVP_PKEY_CTX_get_ecdh_kdf_type(pctx);
290 if (kdf_type <= 0)
291 goto err;
292 if (!EVP_PKEY_CTX_get_ecdh_kdf_md(pctx, &kdf_md))
293 goto err;
294 ecdh_nid = EVP_PKEY_CTX_get_ecdh_cofactor_mode(pctx);
295 if (ecdh_nid < 0)
296 goto err;
297 else if (ecdh_nid == 0)
298 ecdh_nid = NID_dh_std_kdf;
299 else if (ecdh_nid == 1)
300 ecdh_nid = NID_dh_cofactor_kdf;
301
302 if (kdf_type == EVP_PKEY_ECDH_KDF_NONE) {
303 kdf_type = EVP_PKEY_ECDH_KDF_X9_63;
304 if (EVP_PKEY_CTX_set_ecdh_kdf_type(pctx, kdf_type) <= 0)
305 goto err;
306 } else
307 /* Unknown KDF */
308 goto err;
309 if (kdf_md == NULL) {
310 /* Fixme later for better MD */
311 kdf_md = EVP_sha1();
312 if (EVP_PKEY_CTX_set_ecdh_kdf_md(pctx, kdf_md) <= 0)
313 goto err;
314 }
315
316 if (!CMS_RecipientInfo_kari_get0_alg(ri, &talg, &ukm))
317 goto err;
318
319 /* Lookup NID for KDF+cofactor+digest */
320
321 if (!OBJ_find_sigid_by_algs(&kdf_nid, EVP_MD_get_type(kdf_md), ecdh_nid))
322 goto err;
323 /* Get wrap NID */
324 ctx = CMS_RecipientInfo_kari_get0_ctx(ri);
325 wrap_nid = EVP_CIPHER_CTX_get_type(ctx);
326 keylen = EVP_CIPHER_CTX_get_key_length(ctx);
327
328 /* Package wrap algorithm in an AlgorithmIdentifier */
329
330 wrap_alg = X509_ALGOR_new();
331 if (wrap_alg == NULL)
332 goto err;
333 wrap_alg->algorithm = OBJ_nid2obj(wrap_nid);
334 wrap_alg->parameter = ASN1_TYPE_new();
335 if (wrap_alg->parameter == NULL)
336 goto err;
337 if (EVP_CIPHER_param_to_asn1(ctx, wrap_alg->parameter) <= 0)
338 goto err;
339 if (ASN1_TYPE_get(wrap_alg->parameter) == NID_undef) {
340 ASN1_TYPE_free(wrap_alg->parameter);
341 wrap_alg->parameter = NULL;
342 }
343
344 if (EVP_PKEY_CTX_set_ecdh_kdf_outlen(pctx, keylen) <= 0)
345 goto err;
346
347 penclen = CMS_SharedInfo_encode(&penc, wrap_alg, ukm, keylen);
348
349 if (penclen == 0)
350 goto err;
351
352 if (EVP_PKEY_CTX_set0_ecdh_kdf_ukm(pctx, penc, penclen) <= 0)
353 goto err;
354 penc = NULL;
355
356 /*
357 * Now need to wrap encoding of wrap AlgorithmIdentifier into parameter
358 * of another AlgorithmIdentifier.
359 */
360 penclen = i2d_X509_ALGOR(wrap_alg, &penc);
361 if (penc == NULL || penclen == 0)
362 goto err;
363 wrap_str = ASN1_STRING_new();
364 if (wrap_str == NULL)
365 goto err;
366 ASN1_STRING_set0(wrap_str, penc, penclen);
367 penc = NULL;
368 X509_ALGOR_set0(talg, OBJ_nid2obj(kdf_nid), V_ASN1_SEQUENCE, wrap_str);
369
370 rv = 1;
371
372 err:
373 OPENSSL_free(penc);
374 X509_ALGOR_free(wrap_alg);
375 return rv;
376}
377
378int ossl_cms_ecdh_envelope(CMS_RecipientInfo *ri, int decrypt)
379{
380 assert(decrypt == 0 || decrypt == 1);
381
382 if (decrypt == 1)
383 return ecdh_cms_decrypt(ri);
384
385 if (decrypt == 0)
386 return ecdh_cms_encrypt(ri);
387
388 ERR_raise(ERR_LIB_CMS, CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
389 return 0;
390}
391
392/* ECDSA and DSA implementation is the same */
393int ossl_cms_ecdsa_dsa_sign(CMS_SignerInfo *si, int verify)
394{
395 assert(verify == 0 || verify == 1);
396
397 if (verify == 0) {
398 int snid, hnid;
399 X509_ALGOR *alg1, *alg2;
400 EVP_PKEY *pkey = si->pkey;
401
402 CMS_SignerInfo_get0_algs(si, NULL, NULL, &alg1, &alg2);
403 if (alg1 == NULL || alg1->algorithm == NULL)
404 return -1;
405 hnid = OBJ_obj2nid(alg1->algorithm);
406 if (hnid == NID_undef)
407 return -1;
408 if (!OBJ_find_sigid_by_algs(&snid, hnid, EVP_PKEY_get_id(pkey)))
409 return -1;
410 X509_ALGOR_set0(alg2, OBJ_nid2obj(snid), V_ASN1_UNDEF, 0);
411 }
412 return 1;
413}
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette