]> git.ipfire.org Git - thirdparty/openssl.git/blame - crypto/dh/dh_ameth.c
Rename some BUF_xxx to OPENSSL_xxx
[thirdparty/openssl.git] / crypto / dh / dh_ameth.c
CommitLineData
0f113f3e
MC
1/*
2 * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
3 * 2006.
adbc603d
DSH
4 */
5/* ====================================================================
6 * Copyright (c) 2006 The OpenSSL Project. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
0f113f3e 13 * notice, this list of conditions and the following disclaimer.
adbc603d
DSH
14 *
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in
17 * the documentation and/or other materials provided with the
18 * distribution.
19 *
20 * 3. All advertising materials mentioning features or use of this
21 * software must display the following acknowledgment:
22 * "This product includes software developed by the OpenSSL Project
23 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24 *
25 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26 * endorse or promote products derived from this software without
27 * prior written permission. For written permission, please contact
28 * licensing@OpenSSL.org.
29 *
30 * 5. Products derived from this software may not be called "OpenSSL"
31 * nor may "OpenSSL" appear in their names without prior written
32 * permission of the OpenSSL Project.
33 *
34 * 6. Redistributions of any form whatsoever must retain the following
35 * acknowledgment:
36 * "This product includes software developed by the OpenSSL Project
37 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38 *
39 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
43 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50 * OF THE POSSIBILITY OF SUCH DAMAGE.
51 * ====================================================================
52 *
53 * This product includes cryptographic software written by Eric Young
54 * (eay@cryptsoft.com). This product includes software written by Tim
55 * Hudson (tjh@cryptsoft.com).
56 *
57 */
58
59#include <stdio.h>
b39fc560 60#include "internal/cryptlib.h"
adbc603d
DSH
61#include <openssl/x509.h>
62#include <openssl/asn1.h>
63#include <openssl/dh.h>
1e26a8ba 64#include <openssl/bn.h>
5fe736e5 65#include "internal/asn1_int.h"
bd59f2b9 66#ifndef OPENSSL_NO_CMS
0f113f3e 67# include <openssl/cms.h>
bd59f2b9 68#endif
adbc603d 69
0f113f3e
MC
70/*
71 * i2d/d2i like DH parameter functions which use the appropriate routine for
72 * PKCS#3 DH or X9.42 DH.
afb14cda
DSH
73 */
74
0f113f3e
MC
75static DH *d2i_dhp(const EVP_PKEY *pkey, const unsigned char **pp,
76 long length)
77{
78 if (pkey->ameth == &dhx_asn1_meth)
79 return d2i_DHxparams(NULL, pp, length);
80 return d2i_DHparams(NULL, pp, length);
81}
afb14cda
DSH
82
83static int i2d_dhp(const EVP_PKEY *pkey, const DH *a, unsigned char **pp)
0f113f3e
MC
84{
85 if (pkey->ameth == &dhx_asn1_meth)
86 return i2d_DHxparams(a, pp);
87 return i2d_DHparams(a, pp);
88}
afb14cda 89
adbc603d 90static void int_dh_free(EVP_PKEY *pkey)
0f113f3e
MC
91{
92 DH_free(pkey->pkey.dh);
93}
adbc603d 94
ceb46789 95static int dh_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)
0f113f3e
MC
96{
97 const unsigned char *p, *pm;
98 int pklen, pmlen;
99 int ptype;
100 void *pval;
101 ASN1_STRING *pstr;
102 X509_ALGOR *palg;
103 ASN1_INTEGER *public_key = NULL;
104
105 DH *dh = NULL;
106
107 if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, &palg, pubkey))
108 return 0;
109 X509_ALGOR_get0(NULL, &ptype, &pval, palg);
110
111 if (ptype != V_ASN1_SEQUENCE) {
112 DHerr(DH_F_DH_PUB_DECODE, DH_R_PARAMETER_ENCODING_ERROR);
113 goto err;
114 }
115
116 pstr = pval;
117 pm = pstr->data;
118 pmlen = pstr->length;
119
75ebbd9a 120 if ((dh = d2i_dhp(pkey, &pm, pmlen)) == NULL) {
0f113f3e
MC
121 DHerr(DH_F_DH_PUB_DECODE, DH_R_DECODE_ERROR);
122 goto err;
123 }
124
75ebbd9a 125 if ((public_key = d2i_ASN1_INTEGER(NULL, &p, pklen)) == NULL) {
0f113f3e
MC
126 DHerr(DH_F_DH_PUB_DECODE, DH_R_DECODE_ERROR);
127 goto err;
128 }
129
130 /* We have parameters now set public key */
75ebbd9a 131 if ((dh->pub_key = ASN1_INTEGER_to_BN(public_key, NULL)) == NULL) {
0f113f3e
MC
132 DHerr(DH_F_DH_PUB_DECODE, DH_R_BN_DECODE_ERROR);
133 goto err;
134 }
135
136 ASN1_INTEGER_free(public_key);
137 EVP_PKEY_assign(pkey, pkey->ameth->pkey_id, dh);
138 return 1;
139
140 err:
2ace7450 141 ASN1_INTEGER_free(public_key);
d6407083 142 DH_free(dh);
0f113f3e 143 return 0;
4c97a04e 144
0f113f3e 145}
4c97a04e 146
0f113f3e
MC
147static int dh_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
148{
149 DH *dh;
0f113f3e
MC
150 int ptype;
151 unsigned char *penc = NULL;
152 int penclen;
153 ASN1_STRING *str;
154 ASN1_INTEGER *pub_key = NULL;
155
156 dh = pkey->pkey.dh;
157
158 str = ASN1_STRING_new();
90945fa3 159 if (str == NULL) {
6aa8dab2
MC
160 DHerr(DH_F_DH_PUB_ENCODE, ERR_R_MALLOC_FAILURE);
161 goto err;
162 }
0f113f3e
MC
163 str->length = i2d_dhp(pkey, dh, &str->data);
164 if (str->length <= 0) {
165 DHerr(DH_F_DH_PUB_ENCODE, ERR_R_MALLOC_FAILURE);
166 goto err;
167 }
0f113f3e
MC
168 ptype = V_ASN1_SEQUENCE;
169
170 pub_key = BN_to_ASN1_INTEGER(dh->pub_key, NULL);
171 if (!pub_key)
172 goto err;
173
174 penclen = i2d_ASN1_INTEGER(pub_key, &penc);
175
176 ASN1_INTEGER_free(pub_key);
177
178 if (penclen <= 0) {
179 DHerr(DH_F_DH_PUB_ENCODE, ERR_R_MALLOC_FAILURE);
180 goto err;
181 }
182
183 if (X509_PUBKEY_set0_param(pk, OBJ_nid2obj(pkey->ameth->pkey_id),
6aa8dab2 184 ptype, str, penc, penclen))
0f113f3e
MC
185 return 1;
186
187 err:
b548a1f1 188 OPENSSL_free(penc);
0dfb9398 189 ASN1_STRING_free(str);
0f113f3e
MC
190
191 return 0;
192}
4c97a04e 193
0f113f3e
MC
194/*
195 * PKCS#8 DH is defined in PKCS#11 of all places. It is similar to DH in that
196 * the AlgorithmIdentifier contains the parameters, the private key is
197 * explcitly included and the pubkey must be recalculated.
198 */
4c97a04e 199
0f113f3e
MC
200static int dh_priv_decode(EVP_PKEY *pkey, PKCS8_PRIV_KEY_INFO *p8)
201{
202 const unsigned char *p, *pm;
203 int pklen, pmlen;
204 int ptype;
205 void *pval;
206 ASN1_STRING *pstr;
207 X509_ALGOR *palg;
208 ASN1_INTEGER *privkey = NULL;
209
210 DH *dh = NULL;
211
212 if (!PKCS8_pkey_get0(NULL, &p, &pklen, &palg, p8))
213 return 0;
214
215 X509_ALGOR_get0(NULL, &ptype, &pval, palg);
216
217 if (ptype != V_ASN1_SEQUENCE)
218 goto decerr;
75ebbd9a 219 if ((privkey = d2i_ASN1_INTEGER(NULL, &p, pklen)) == NULL)
0f113f3e
MC
220 goto decerr;
221
222 pstr = pval;
223 pm = pstr->data;
224 pmlen = pstr->length;
75ebbd9a 225 if ((dh = d2i_dhp(pkey, &pm, pmlen)) == NULL)
0f113f3e 226 goto decerr;
75ebbd9a 227
0f113f3e 228 /* We have parameters now set private key */
74924dcb
RS
229 if ((dh->priv_key = BN_secure_new()) == NULL
230 || !ASN1_INTEGER_to_BN(privkey, dh->priv_key)) {
0f113f3e
MC
231 DHerr(DH_F_DH_PRIV_DECODE, DH_R_BN_ERROR);
232 goto dherr;
233 }
234 /* Calculate public key */
235 if (!DH_generate_key(dh))
236 goto dherr;
237
238 EVP_PKEY_assign(pkey, pkey->ameth->pkey_id, dh);
239
a8ae0891 240 ASN1_STRING_clear_free(privkey);
0f113f3e
MC
241
242 return 1;
243
244 decerr:
245 DHerr(DH_F_DH_PRIV_DECODE, EVP_R_DECODE_ERROR);
246 dherr:
247 DH_free(dh);
a8ae0891 248 ASN1_STRING_clear_free(privkey);
0f113f3e
MC
249 return 0;
250}
4c97a04e
DSH
251
252static int dh_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
253{
0f113f3e
MC
254 ASN1_STRING *params = NULL;
255 ASN1_INTEGER *prkey = NULL;
256 unsigned char *dp = NULL;
257 int dplen;
258
259 params = ASN1_STRING_new();
260
90945fa3 261 if (params == NULL) {
0f113f3e
MC
262 DHerr(DH_F_DH_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
263 goto err;
264 }
265
266 params->length = i2d_dhp(pkey, pkey->pkey.dh, &params->data);
267 if (params->length <= 0) {
268 DHerr(DH_F_DH_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
269 goto err;
270 }
271 params->type = V_ASN1_SEQUENCE;
272
273 /* Get private key into integer */
274 prkey = BN_to_ASN1_INTEGER(pkey->pkey.dh->priv_key, NULL);
275
276 if (!prkey) {
277 DHerr(DH_F_DH_PRIV_ENCODE, DH_R_BN_ERROR);
278 goto err;
279 }
280
281 dplen = i2d_ASN1_INTEGER(prkey, &dp);
282
a8ae0891 283 ASN1_STRING_clear_free(prkey);
1549a265 284 prkey = NULL;
0f113f3e
MC
285
286 if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(pkey->ameth->pkey_id), 0,
287 V_ASN1_SEQUENCE, params, dp, dplen))
288 goto err;
289
290 return 1;
291
292 err:
b548a1f1 293 OPENSSL_free(dp);
0dfb9398 294 ASN1_STRING_free(params);
2ace7450 295 ASN1_STRING_clear_free(prkey);
0f113f3e 296 return 0;
4c97a04e
DSH
297}
298
ceb46789 299static void update_buflen(const BIGNUM *b, size_t *pbuflen)
0f113f3e
MC
300{
301 size_t i;
302 if (!b)
303 return;
304 if (*pbuflen < (i = (size_t)BN_num_bytes(b)))
305 *pbuflen = i;
306}
ceb46789 307
3e4585c8 308static int dh_param_decode(EVP_PKEY *pkey,
0f113f3e
MC
309 const unsigned char **pder, int derlen)
310{
311 DH *dh;
75ebbd9a
RS
312
313 if ((dh = d2i_dhp(pkey, pder, derlen)) == NULL) {
0f113f3e
MC
314 DHerr(DH_F_DH_PARAM_DECODE, ERR_R_DH_LIB);
315 return 0;
316 }
317 EVP_PKEY_assign(pkey, pkey->ameth->pkey_id, dh);
318 return 1;
319}
3e4585c8
DSH
320
321static int dh_param_encode(const EVP_PKEY *pkey, unsigned char **pder)
0f113f3e
MC
322{
323 return i2d_dhp(pkey, pkey->pkey.dh, pder);
324}
3e4585c8 325
ceb46789 326static int do_dh_print(BIO *bp, const DH *x, int indent,
0f113f3e
MC
327 ASN1_PCTX *ctx, int ptype)
328{
329 unsigned char *m = NULL;
66696478 330 int reason = ERR_R_BUF_LIB;
0f113f3e
MC
331 size_t buf_len = 0;
332
333 const char *ktype = NULL;
334
335 BIGNUM *priv_key, *pub_key;
336
337 if (ptype == 2)
338 priv_key = x->priv_key;
339 else
340 priv_key = NULL;
341
342 if (ptype > 0)
343 pub_key = x->pub_key;
344 else
345 pub_key = NULL;
346
347 update_buflen(x->p, &buf_len);
348
349 if (buf_len == 0) {
350 reason = ERR_R_PASSED_NULL_PARAMETER;
351 goto err;
352 }
353
354 update_buflen(x->g, &buf_len);
355 update_buflen(x->q, &buf_len);
356 update_buflen(x->j, &buf_len);
357 update_buflen(x->counter, &buf_len);
358 update_buflen(pub_key, &buf_len);
359 update_buflen(priv_key, &buf_len);
360
361 if (ptype == 2)
362 ktype = "DH Private-Key";
363 else if (ptype == 1)
364 ktype = "DH Public-Key";
365 else
366 ktype = "DH Parameters";
367
368 m = OPENSSL_malloc(buf_len + 10);
369 if (m == NULL) {
370 reason = ERR_R_MALLOC_FAILURE;
371 goto err;
372 }
373
374 BIO_indent(bp, indent, 128);
375 if (BIO_printf(bp, "%s: (%d bit)\n", ktype, BN_num_bits(x->p)) <= 0)
376 goto err;
377 indent += 4;
378
379 if (!ASN1_bn_print(bp, "private-key:", priv_key, m, indent))
380 goto err;
381 if (!ASN1_bn_print(bp, "public-key:", pub_key, m, indent))
382 goto err;
383
384 if (!ASN1_bn_print(bp, "prime:", x->p, m, indent))
385 goto err;
386 if (!ASN1_bn_print(bp, "generator:", x->g, m, indent))
387 goto err;
388 if (x->q && !ASN1_bn_print(bp, "subgroup order:", x->q, m, indent))
389 goto err;
390 if (x->j && !ASN1_bn_print(bp, "subgroup factor:", x->j, m, indent))
391 goto err;
392 if (x->seed) {
393 int i;
394 BIO_indent(bp, indent, 128);
395 BIO_puts(bp, "seed:");
396 for (i = 0; i < x->seedlen; i++) {
397 if ((i % 15) == 0) {
398 if (BIO_puts(bp, "\n") <= 0
399 || !BIO_indent(bp, indent + 4, 128))
400 goto err;
401 }
402 if (BIO_printf(bp, "%02x%s", x->seed[i],
403 ((i + 1) == x->seedlen) ? "" : ":") <= 0)
404 goto err;
405 }
406 if (BIO_write(bp, "\n", 1) <= 0)
407 return (0);
408 }
409 if (x->counter && !ASN1_bn_print(bp, "counter:", x->counter, m, indent))
410 goto err;
411 if (x->length != 0) {
412 BIO_indent(bp, indent, 128);
413 if (BIO_printf(bp, "recommended-private-length: %d bits\n",
414 (int)x->length) <= 0)
415 goto err;
416 }
417
66696478
RS
418 OPENSSL_free(m);
419 return 1;
420
0f113f3e 421 err:
66696478 422 DHerr(DH_F_DO_DH_PRINT, reason);
b548a1f1 423 OPENSSL_free(m);
66696478 424 return 0;
0f113f3e 425}
3e4585c8 426
ceb46789 427static int int_dh_size(const EVP_PKEY *pkey)
0f113f3e
MC
428{
429 return (DH_size(pkey->pkey.dh));
430}
ceb46789
DSH
431
432static int dh_bits(const EVP_PKEY *pkey)
0f113f3e
MC
433{
434 return BN_num_bits(pkey->pkey.dh->p);
435}
ceb46789 436
2514fa79 437static int dh_security_bits(const EVP_PKEY *pkey)
0f113f3e
MC
438{
439 return DH_security_bits(pkey->pkey.dh);
440}
2514fa79 441
ffb1ac67 442static int dh_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b)
0f113f3e
MC
443{
444 if (BN_cmp(a->pkey.dh->p, b->pkey.dh->p) ||
445 BN_cmp(a->pkey.dh->g, b->pkey.dh->g))
446 return 0;
447 else if (a->ameth == &dhx_asn1_meth) {
448 if (BN_cmp(a->pkey.dh->q, b->pkey.dh->q))
449 return 0;
450 }
451 return 1;
452}
ffb1ac67 453
d3cc91ee 454static int int_dh_bn_cpy(BIGNUM **dst, const BIGNUM *src)
0f113f3e
MC
455{
456 BIGNUM *a;
457 if (src) {
458 a = BN_dup(src);
459 if (!a)
460 return 0;
461 } else
462 a = NULL;
23a1d5e9 463 BN_free(*dst);
0f113f3e
MC
464 *dst = a;
465 return 1;
466}
ceb46789 467
d3cc91ee 468static int int_dh_param_copy(DH *to, const DH *from, int is_x942)
0f113f3e
MC
469{
470 if (is_x942 == -1)
471 is_x942 = ! !from->q;
472 if (!int_dh_bn_cpy(&to->p, from->p))
473 return 0;
474 if (!int_dh_bn_cpy(&to->g, from->g))
475 return 0;
476 if (is_x942) {
477 if (!int_dh_bn_cpy(&to->q, from->q))
478 return 0;
479 if (!int_dh_bn_cpy(&to->j, from->j))
480 return 0;
b548a1f1
RS
481 OPENSSL_free(to->seed);
482 to->seed = NULL;
483 to->seedlen = 0;
0f113f3e 484 if (from->seed) {
7644a9ae 485 to->seed = OPENSSL_memdup(from->seed, from->seedlen);
0f113f3e
MC
486 if (!to->seed)
487 return 0;
488 to->seedlen = from->seedlen;
489 }
490 } else
491 to->length = from->length;
492 return 1;
493}
d3cc91ee
DSH
494
495DH *DHparams_dup(DH *dh)
0f113f3e
MC
496{
497 DH *ret;
498 ret = DH_new();
90945fa3 499 if (ret == NULL)
0f113f3e
MC
500 return NULL;
501 if (!int_dh_param_copy(ret, dh, -1)) {
502 DH_free(ret);
503 return NULL;
504 }
505 return ret;
506}
d3cc91ee
DSH
507
508static int dh_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from)
0f113f3e 509{
2986ecdc
DSH
510 if (to->pkey.dh == NULL) {
511 to->pkey.dh = DH_new();
512 if (to->pkey.dh == NULL)
513 return 0;
514 }
0f113f3e
MC
515 return int_dh_param_copy(to->pkey.dh, from->pkey.dh,
516 from->ameth == &dhx_asn1_meth);
517}
d3cc91ee 518
ffb1ac67 519static int dh_missing_parameters(const EVP_PKEY *a)
0f113f3e
MC
520{
521 if (!a->pkey.dh->p || !a->pkey.dh->g)
522 return 1;
523 return 0;
524}
ceb46789
DSH
525
526static int dh_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
0f113f3e
MC
527{
528 if (dh_cmp_parameters(a, b) == 0)
529 return 0;
530 if (BN_cmp(b->pkey.dh->pub_key, a->pkey.dh->pub_key) != 0)
531 return 0;
532 else
533 return 1;
534}
ceb46789 535
3e4585c8 536static int dh_param_print(BIO *bp, const EVP_PKEY *pkey, int indent,
0f113f3e
MC
537 ASN1_PCTX *ctx)
538{
539 return do_dh_print(bp, pkey->pkey.dh, indent, ctx, 0);
540}
ceb46789
DSH
541
542static int dh_public_print(BIO *bp, const EVP_PKEY *pkey, int indent,
0f113f3e
MC
543 ASN1_PCTX *ctx)
544{
545 return do_dh_print(bp, pkey->pkey.dh, indent, ctx, 1);
546}
ceb46789
DSH
547
548static int dh_private_print(BIO *bp, const EVP_PKEY *pkey, int indent,
0f113f3e
MC
549 ASN1_PCTX *ctx)
550{
551 return do_dh_print(bp, pkey->pkey.dh, indent, ctx, 2);
552}
3e4585c8
DSH
553
554int DHparams_print(BIO *bp, const DH *x)
0f113f3e
MC
555{
556 return do_dh_print(bp, x, 4, NULL, 0);
557}
3e4585c8 558
bd59f2b9
DSH
559#ifndef OPENSSL_NO_CMS
560static int dh_cms_decrypt(CMS_RecipientInfo *ri);
561static int dh_cms_encrypt(CMS_RecipientInfo *ri);
562#endif
563
564static int dh_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
0f113f3e
MC
565{
566 switch (op) {
bd59f2b9
DSH
567#ifndef OPENSSL_NO_CMS
568
0f113f3e
MC
569 case ASN1_PKEY_CTRL_CMS_ENVELOPE:
570 if (arg1 == 1)
571 return dh_cms_decrypt(arg2);
572 else if (arg1 == 0)
573 return dh_cms_encrypt(arg2);
574 return -2;
bd59f2b9 575
0f113f3e
MC
576 case ASN1_PKEY_CTRL_CMS_RI_TYPE:
577 *(int *)arg2 = CMS_RECIPINFO_AGREE;
578 return 1;
bd59f2b9 579#endif
0f113f3e
MC
580 default:
581 return -2;
582 }
583
584}
585
586const EVP_PKEY_ASN1_METHOD dh_asn1_meth = {
587 EVP_PKEY_DH,
588 EVP_PKEY_DH,
589 0,
590
591 "DH",
592 "OpenSSL PKCS#3 DH method",
593
594 dh_pub_decode,
595 dh_pub_encode,
596 dh_pub_cmp,
597 dh_public_print,
598
599 dh_priv_decode,
600 dh_priv_encode,
601 dh_private_print,
602
603 int_dh_size,
604 dh_bits,
605 dh_security_bits,
606
607 dh_param_decode,
608 dh_param_encode,
609 dh_missing_parameters,
610 dh_copy_parameters,
611 dh_cmp_parameters,
612 dh_param_print,
613 0,
614
615 int_dh_free,
616 0
617};
618
619const EVP_PKEY_ASN1_METHOD dhx_asn1_meth = {
620 EVP_PKEY_DHX,
621 EVP_PKEY_DHX,
622 0,
623
624 "X9.42 DH",
625 "OpenSSL X9.42 DH method",
626
627 dh_pub_decode,
628 dh_pub_encode,
629 dh_pub_cmp,
630 dh_public_print,
631
632 dh_priv_decode,
633 dh_priv_encode,
634 dh_private_print,
635
636 int_dh_size,
637 dh_bits,
638 dh_security_bits,
639
640 dh_param_decode,
641 dh_param_encode,
642 dh_missing_parameters,
643 dh_copy_parameters,
644 dh_cmp_parameters,
645 dh_param_print,
646 0,
647
648 int_dh_free,
649 dh_pkey_ctrl
650};
651
bd59f2b9
DSH
652#ifndef OPENSSL_NO_CMS
653
654static int dh_cms_set_peerkey(EVP_PKEY_CTX *pctx,
0f113f3e
MC
655 X509_ALGOR *alg, ASN1_BIT_STRING *pubkey)
656{
657 ASN1_OBJECT *aoid;
658 int atype;
659 void *aval;
660 ASN1_INTEGER *public_key = NULL;
661 int rv = 0;
662 EVP_PKEY *pkpeer = NULL, *pk = NULL;
663 DH *dhpeer = NULL;
664 const unsigned char *p;
665 int plen;
666
667 X509_ALGOR_get0(&aoid, &atype, &aval, alg);
668 if (OBJ_obj2nid(aoid) != NID_dhpublicnumber)
669 goto err;
670 /* Only absent parameters allowed in RFC XXXX */
671 if (atype != V_ASN1_UNDEF && atype == V_ASN1_NULL)
672 goto err;
673
674 pk = EVP_PKEY_CTX_get0_pkey(pctx);
675 if (!pk)
676 goto err;
677 if (pk->type != EVP_PKEY_DHX)
678 goto err;
679 /* Get parameters from parent key */
680 dhpeer = DHparams_dup(pk->pkey.dh);
681 /* We have parameters now set public key */
682 plen = ASN1_STRING_length(pubkey);
683 p = ASN1_STRING_data(pubkey);
684 if (!p || !plen)
685 goto err;
686
75ebbd9a 687 if ((public_key = d2i_ASN1_INTEGER(NULL, &p, plen)) == NULL) {
0f113f3e
MC
688 DHerr(DH_F_DH_CMS_SET_PEERKEY, DH_R_DECODE_ERROR);
689 goto err;
690 }
691
692 /* We have parameters now set public key */
75ebbd9a 693 if ((dhpeer->pub_key = ASN1_INTEGER_to_BN(public_key, NULL)) == NULL) {
0f113f3e
MC
694 DHerr(DH_F_DH_CMS_SET_PEERKEY, DH_R_BN_DECODE_ERROR);
695 goto err;
696 }
697
698 pkpeer = EVP_PKEY_new();
90945fa3 699 if (pkpeer == NULL)
0f113f3e
MC
700 goto err;
701 EVP_PKEY_assign(pkpeer, pk->ameth->pkey_id, dhpeer);
702 dhpeer = NULL;
703 if (EVP_PKEY_derive_set_peer(pctx, pkpeer) > 0)
704 rv = 1;
705 err:
2ace7450 706 ASN1_INTEGER_free(public_key);
c5ba2d99 707 EVP_PKEY_free(pkpeer);
d6407083 708 DH_free(dhpeer);
0f113f3e
MC
709 return rv;
710}
bd59f2b9
DSH
711
712static int dh_cms_set_shared_info(EVP_PKEY_CTX *pctx, CMS_RecipientInfo *ri)
0f113f3e
MC
713{
714 int rv = 0;
715
716 X509_ALGOR *alg, *kekalg = NULL;
717 ASN1_OCTET_STRING *ukm;
718 const unsigned char *p;
719 unsigned char *dukm = NULL;
720 size_t dukmlen = 0;
721 int keylen, plen;
722 const EVP_CIPHER *kekcipher;
723 EVP_CIPHER_CTX *kekctx;
724
725 if (!CMS_RecipientInfo_kari_get0_alg(ri, &alg, &ukm))
726 goto err;
727
728 /*
729 * For DH we only have one OID permissible. If ever any more get defined
730 * we will need something cleverer.
731 */
732 if (OBJ_obj2nid(alg->algorithm) != NID_id_smime_alg_ESDH) {
733 DHerr(DH_F_DH_CMS_SET_SHARED_INFO, DH_R_KDF_PARAMETER_ERROR);
734 goto err;
735 }
736
737 if (EVP_PKEY_CTX_set_dh_kdf_type(pctx, EVP_PKEY_DH_KDF_X9_42) <= 0)
738 goto err;
739
740 if (EVP_PKEY_CTX_set_dh_kdf_md(pctx, EVP_sha1()) <= 0)
741 goto err;
742
743 if (alg->parameter->type != V_ASN1_SEQUENCE)
744 goto err;
745
746 p = alg->parameter->value.sequence->data;
747 plen = alg->parameter->value.sequence->length;
748 kekalg = d2i_X509_ALGOR(NULL, &p, plen);
749 if (!kekalg)
750 goto err;
751 kekctx = CMS_RecipientInfo_kari_get0_ctx(ri);
752 if (!kekctx)
753 goto err;
754 kekcipher = EVP_get_cipherbyobj(kekalg->algorithm);
755 if (!kekcipher || EVP_CIPHER_mode(kekcipher) != EVP_CIPH_WRAP_MODE)
756 goto err;
757 if (!EVP_EncryptInit_ex(kekctx, kekcipher, NULL, NULL, NULL))
758 goto err;
759 if (EVP_CIPHER_asn1_to_param(kekctx, kekalg->parameter) <= 0)
760 goto err;
761
762 keylen = EVP_CIPHER_CTX_key_length(kekctx);
763 if (EVP_PKEY_CTX_set_dh_kdf_outlen(pctx, keylen) <= 0)
764 goto err;
765 /* Use OBJ_nid2obj to ensure we use built in OID that isn't freed */
766 if (EVP_PKEY_CTX_set0_dh_kdf_oid(pctx,
767 OBJ_nid2obj(EVP_CIPHER_type(kekcipher)))
768 <= 0)
769 goto err;
770
771 if (ukm) {
772 dukmlen = ASN1_STRING_length(ukm);
7644a9ae 773 dukm = OPENSSL_memdup(ASN1_STRING_data(ukm), dukmlen);
0f113f3e
MC
774 if (!dukm)
775 goto err;
776 }
777
778 if (EVP_PKEY_CTX_set0_dh_kdf_ukm(pctx, dukm, dukmlen) <= 0)
779 goto err;
780 dukm = NULL;
781
782 rv = 1;
783 err:
222561fe
RS
784 X509_ALGOR_free(kekalg);
785 OPENSSL_free(dukm);
0f113f3e
MC
786 return rv;
787}
bd59f2b9
DSH
788
789static int dh_cms_decrypt(CMS_RecipientInfo *ri)
0f113f3e
MC
790{
791 EVP_PKEY_CTX *pctx;
792 pctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
793 if (!pctx)
794 return 0;
795 /* See if we need to set peer key */
796 if (!EVP_PKEY_CTX_get0_peerkey(pctx)) {
797 X509_ALGOR *alg;
798 ASN1_BIT_STRING *pubkey;
799 if (!CMS_RecipientInfo_kari_get0_orig_id(ri, &alg, &pubkey,
800 NULL, NULL, NULL))
801 return 0;
802 if (!alg || !pubkey)
803 return 0;
804 if (!dh_cms_set_peerkey(pctx, alg, pubkey)) {
805 DHerr(DH_F_DH_CMS_DECRYPT, DH_R_PEER_KEY_ERROR);
806 return 0;
807 }
808 }
809 /* Set DH derivation parameters and initialise unwrap context */
810 if (!dh_cms_set_shared_info(pctx, ri)) {
811 DHerr(DH_F_DH_CMS_DECRYPT, DH_R_SHARED_INFO_ERROR);
812 return 0;
813 }
814 return 1;
815}
bd59f2b9
DSH
816
817static int dh_cms_encrypt(CMS_RecipientInfo *ri)
0f113f3e
MC
818{
819 EVP_PKEY_CTX *pctx;
820 EVP_PKEY *pkey;
821 EVP_CIPHER_CTX *ctx;
822 int keylen;
823 X509_ALGOR *talg, *wrap_alg = NULL;
824 ASN1_OBJECT *aoid;
825 ASN1_BIT_STRING *pubkey;
826 ASN1_STRING *wrap_str;
827 ASN1_OCTET_STRING *ukm;
828 unsigned char *penc = NULL, *dukm = NULL;
829 int penclen;
830 size_t dukmlen = 0;
831 int rv = 0;
832 int kdf_type, wrap_nid;
833 const EVP_MD *kdf_md;
834 pctx = CMS_RecipientInfo_get0_pkey_ctx(ri);
835 if (!pctx)
836 return 0;
837 /* Get ephemeral key */
838 pkey = EVP_PKEY_CTX_get0_pkey(pctx);
839 if (!CMS_RecipientInfo_kari_get0_orig_id(ri, &talg, &pubkey,
840 NULL, NULL, NULL))
841 goto err;
842 X509_ALGOR_get0(&aoid, NULL, NULL, talg);
843 /* Is everything uninitialised? */
844 if (aoid == OBJ_nid2obj(NID_undef)) {
c5ba2d99 845 ASN1_INTEGER *pubk = BN_to_ASN1_INTEGER(pkey->pkey.dh->pub_key, NULL);
0f113f3e
MC
846 if (!pubk)
847 goto err;
848 /* Set the key */
849
850 penclen = i2d_ASN1_INTEGER(pubk, &penc);
851 ASN1_INTEGER_free(pubk);
852 if (penclen <= 0)
853 goto err;
854 ASN1_STRING_set0(pubkey, penc, penclen);
855 pubkey->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);
856 pubkey->flags |= ASN1_STRING_FLAG_BITS_LEFT;
857
858 penc = NULL;
859 X509_ALGOR_set0(talg, OBJ_nid2obj(NID_dhpublicnumber),
860 V_ASN1_UNDEF, NULL);
861 }
862
863 /* See if custom paraneters set */
864 kdf_type = EVP_PKEY_CTX_get_dh_kdf_type(pctx);
865 if (kdf_type <= 0)
866 goto err;
867 if (!EVP_PKEY_CTX_get_dh_kdf_md(pctx, &kdf_md))
868 goto err;
869
870 if (kdf_type == EVP_PKEY_DH_KDF_NONE) {
871 kdf_type = EVP_PKEY_DH_KDF_X9_42;
872 if (EVP_PKEY_CTX_set_dh_kdf_type(pctx, kdf_type) <= 0)
873 goto err;
874 } else if (kdf_type != EVP_PKEY_DH_KDF_X9_42)
875 /* Unknown KDF */
876 goto err;
877 if (kdf_md == NULL) {
878 /* Only SHA1 supported */
879 kdf_md = EVP_sha1();
880 if (EVP_PKEY_CTX_set_dh_kdf_md(pctx, kdf_md) <= 0)
881 goto err;
882 } else if (EVP_MD_type(kdf_md) != NID_sha1)
883 /* Unsupported digest */
884 goto err;
885
886 if (!CMS_RecipientInfo_kari_get0_alg(ri, &talg, &ukm))
887 goto err;
888
889 /* Get wrap NID */
890 ctx = CMS_RecipientInfo_kari_get0_ctx(ri);
891 wrap_nid = EVP_CIPHER_CTX_type(ctx);
892 if (EVP_PKEY_CTX_set0_dh_kdf_oid(pctx, OBJ_nid2obj(wrap_nid)) <= 0)
893 goto err;
894 keylen = EVP_CIPHER_CTX_key_length(ctx);
895
896 /* Package wrap algorithm in an AlgorithmIdentifier */
897
898 wrap_alg = X509_ALGOR_new();
90945fa3 899 if (wrap_alg == NULL)
0f113f3e
MC
900 goto err;
901 wrap_alg->algorithm = OBJ_nid2obj(wrap_nid);
902 wrap_alg->parameter = ASN1_TYPE_new();
90945fa3 903 if (wrap_alg->parameter == NULL)
0f113f3e
MC
904 goto err;
905 if (EVP_CIPHER_param_to_asn1(ctx, wrap_alg->parameter) <= 0)
906 goto err;
907 if (ASN1_TYPE_get(wrap_alg->parameter) == NID_undef) {
908 ASN1_TYPE_free(wrap_alg->parameter);
909 wrap_alg->parameter = NULL;
910 }
911
912 if (EVP_PKEY_CTX_set_dh_kdf_outlen(pctx, keylen) <= 0)
913 goto err;
914
915 if (ukm) {
916 dukmlen = ASN1_STRING_length(ukm);
7644a9ae 917 dukm = OPENSSL_memdup(ASN1_STRING_data(ukm), dukmlen);
0f113f3e
MC
918 if (!dukm)
919 goto err;
920 }
921
922 if (EVP_PKEY_CTX_set0_dh_kdf_ukm(pctx, dukm, dukmlen) <= 0)
923 goto err;
924 dukm = NULL;
925
926 /*
927 * Now need to wrap encoding of wrap AlgorithmIdentifier into parameter
928 * of another AlgorithmIdentifier.
929 */
930 penc = NULL;
931 penclen = i2d_X509_ALGOR(wrap_alg, &penc);
932 if (!penc || !penclen)
933 goto err;
934 wrap_str = ASN1_STRING_new();
90945fa3 935 if (wrap_str == NULL)
0f113f3e
MC
936 goto err;
937 ASN1_STRING_set0(wrap_str, penc, penclen);
938 penc = NULL;
939 X509_ALGOR_set0(talg, OBJ_nid2obj(NID_id_smime_alg_ESDH),
940 V_ASN1_SEQUENCE, wrap_str);
941
942 rv = 1;
943
944 err:
222561fe
RS
945 OPENSSL_free(penc);
946 X509_ALGOR_free(wrap_alg);
0f113f3e
MC
947 return rv;
948}
bd59f2b9
DSH
949
950#endif