9c5b8aa02e9dbd90cb3542836a258094b872e680
[openssl.git] / crypto / dsa / dsa_ameth.c
1 /*
2  * Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (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 <stdio.h>
11 #include "internal/cryptlib.h"
12 #include <openssl/x509.h>
13 #include <openssl/asn1.h>
14 #include "dsa_locl.h"
15 #include <openssl/bn.h>
16 #include <openssl/cms.h>
17 #include "internal/asn1_int.h"
18 #include "internal/evp_int.h"
19
20 static int dsa_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)
21 {
22     const unsigned char *p, *pm;
23     int pklen, pmlen;
24     int ptype;
25     const void *pval;
26     const ASN1_STRING *pstr;
27     X509_ALGOR *palg;
28     ASN1_INTEGER *public_key = NULL;
29
30     DSA *dsa = NULL;
31
32     if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, &palg, pubkey))
33         return 0;
34     X509_ALGOR_get0(NULL, &ptype, &pval, palg);
35
36     if (ptype == V_ASN1_SEQUENCE) {
37         pstr = pval;
38         pm = pstr->data;
39         pmlen = pstr->length;
40
41         if ((dsa = d2i_DSAparams(NULL, &pm, pmlen)) == NULL) {
42             DSAerr(DSA_F_DSA_PUB_DECODE, DSA_R_DECODE_ERROR);
43             goto err;
44         }
45
46     } else if ((ptype == V_ASN1_NULL) || (ptype == V_ASN1_UNDEF)) {
47         if ((dsa = DSA_new()) == NULL) {
48             DSAerr(DSA_F_DSA_PUB_DECODE, ERR_R_MALLOC_FAILURE);
49             goto err;
50         }
51     } else {
52         DSAerr(DSA_F_DSA_PUB_DECODE, DSA_R_PARAMETER_ENCODING_ERROR);
53         goto err;
54     }
55
56     if ((public_key = d2i_ASN1_INTEGER(NULL, &p, pklen)) == NULL) {
57         DSAerr(DSA_F_DSA_PUB_DECODE, DSA_R_DECODE_ERROR);
58         goto err;
59     }
60
61     if ((dsa->pub_key = ASN1_INTEGER_to_BN(public_key, NULL)) == NULL) {
62         DSAerr(DSA_F_DSA_PUB_DECODE, DSA_R_BN_DECODE_ERROR);
63         goto err;
64     }
65
66     ASN1_INTEGER_free(public_key);
67     EVP_PKEY_assign_DSA(pkey, dsa);
68     return 1;
69
70  err:
71     ASN1_INTEGER_free(public_key);
72     DSA_free(dsa);
73     return 0;
74
75 }
76
77 static int dsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
78 {
79     DSA *dsa;
80     int ptype;
81     unsigned char *penc = NULL;
82     int penclen;
83     ASN1_STRING *str = NULL;
84     ASN1_INTEGER *pubint = NULL;
85     ASN1_OBJECT *aobj;
86
87     dsa = pkey->pkey.dsa;
88     if (pkey->save_parameters && dsa->p && dsa->q && dsa->g) {
89         str = ASN1_STRING_new();
90         if (str == NULL) {
91             DSAerr(DSA_F_DSA_PUB_ENCODE, ERR_R_MALLOC_FAILURE);
92             goto err;
93         }
94         str->length = i2d_DSAparams(dsa, &str->data);
95         if (str->length <= 0) {
96             DSAerr(DSA_F_DSA_PUB_ENCODE, ERR_R_MALLOC_FAILURE);
97             goto err;
98         }
99         ptype = V_ASN1_SEQUENCE;
100     } else
101         ptype = V_ASN1_UNDEF;
102
103     pubint = BN_to_ASN1_INTEGER(dsa->pub_key, NULL);
104
105     if (pubint == NULL) {
106         DSAerr(DSA_F_DSA_PUB_ENCODE, ERR_R_MALLOC_FAILURE);
107         goto err;
108     }
109
110     penclen = i2d_ASN1_INTEGER(pubint, &penc);
111     ASN1_INTEGER_free(pubint);
112
113     if (penclen <= 0) {
114         DSAerr(DSA_F_DSA_PUB_ENCODE, ERR_R_MALLOC_FAILURE);
115         goto err;
116     }
117
118     aobj = OBJ_nid2obj(EVP_PKEY_DSA);
119     if (aobj == NULL)
120         goto err;
121
122     if (X509_PUBKEY_set0_param(pk, aobj, ptype, str, penc, penclen))
123         return 1;
124
125  err:
126     OPENSSL_free(penc);
127     ASN1_STRING_free(str);
128
129     return 0;
130 }
131
132 /*
133  * In PKCS#8 DSA: you just get a private key integer and parameters in the
134  * AlgorithmIdentifier the pubkey must be recalculated.
135  */
136
137 static int dsa_priv_decode(EVP_PKEY *pkey, const PKCS8_PRIV_KEY_INFO *p8)
138 {
139     const unsigned char *p, *pm;
140     int pklen, pmlen;
141     int ptype;
142     const void *pval;
143     const ASN1_STRING *pstr;
144     const X509_ALGOR *palg;
145     ASN1_INTEGER *privkey = NULL;
146     BN_CTX *ctx = NULL;
147
148     DSA *dsa = NULL;
149
150     int ret = 0;
151
152     if (!PKCS8_pkey_get0(NULL, &p, &pklen, &palg, p8))
153         return 0;
154     X509_ALGOR_get0(NULL, &ptype, &pval, palg);
155
156     if ((privkey = d2i_ASN1_INTEGER(NULL, &p, pklen)) == NULL)
157         goto decerr;
158     if (privkey->type == V_ASN1_NEG_INTEGER || ptype != V_ASN1_SEQUENCE)
159         goto decerr;
160
161     pstr = pval;
162     pm = pstr->data;
163     pmlen = pstr->length;
164     if ((dsa = d2i_DSAparams(NULL, &pm, pmlen)) == NULL)
165         goto decerr;
166     /* We have parameters now set private key */
167     if ((dsa->priv_key = BN_secure_new()) == NULL
168         || !ASN1_INTEGER_to_BN(privkey, dsa->priv_key)) {
169         DSAerr(DSA_F_DSA_PRIV_DECODE, DSA_R_BN_ERROR);
170         goto dsaerr;
171     }
172     /* Calculate public key */
173     if ((dsa->pub_key = BN_new()) == NULL) {
174         DSAerr(DSA_F_DSA_PRIV_DECODE, ERR_R_MALLOC_FAILURE);
175         goto dsaerr;
176     }
177     if ((ctx = BN_CTX_new()) == NULL) {
178         DSAerr(DSA_F_DSA_PRIV_DECODE, ERR_R_MALLOC_FAILURE);
179         goto dsaerr;
180     }
181
182     BN_set_flags(dsa->priv_key, BN_FLG_CONSTTIME);
183     if (!BN_mod_exp(dsa->pub_key, dsa->g, dsa->priv_key, dsa->p, ctx)) {
184         DSAerr(DSA_F_DSA_PRIV_DECODE, DSA_R_BN_ERROR);
185         goto dsaerr;
186     }
187
188     EVP_PKEY_assign_DSA(pkey, dsa);
189
190     ret = 1;
191     goto done;
192
193  decerr:
194     DSAerr(DSA_F_DSA_PRIV_DECODE, DSA_R_DECODE_ERROR);
195  dsaerr:
196     DSA_free(dsa);
197  done:
198     BN_CTX_free(ctx);
199     ASN1_STRING_clear_free(privkey);
200     return ret;
201 }
202
203 static int dsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
204 {
205     ASN1_STRING *params = NULL;
206     ASN1_INTEGER *prkey = NULL;
207     unsigned char *dp = NULL;
208     int dplen;
209
210     if (!pkey->pkey.dsa || !pkey->pkey.dsa->priv_key) {
211         DSAerr(DSA_F_DSA_PRIV_ENCODE, DSA_R_MISSING_PARAMETERS);
212         goto err;
213     }
214
215     params = ASN1_STRING_new();
216
217     if (params == NULL) {
218         DSAerr(DSA_F_DSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
219         goto err;
220     }
221
222     params->length = i2d_DSAparams(pkey->pkey.dsa, &params->data);
223     if (params->length <= 0) {
224         DSAerr(DSA_F_DSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
225         goto err;
226     }
227     params->type = V_ASN1_SEQUENCE;
228
229     /* Get private key into integer */
230     prkey = BN_to_ASN1_INTEGER(pkey->pkey.dsa->priv_key, NULL);
231
232     if (!prkey) {
233         DSAerr(DSA_F_DSA_PRIV_ENCODE, DSA_R_BN_ERROR);
234         goto err;
235     }
236
237     dplen = i2d_ASN1_INTEGER(prkey, &dp);
238
239     ASN1_STRING_clear_free(prkey);
240     prkey = NULL;
241
242     if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(NID_dsa), 0,
243                          V_ASN1_SEQUENCE, params, dp, dplen))
244         goto err;
245
246     return 1;
247
248  err:
249     OPENSSL_free(dp);
250     ASN1_STRING_free(params);
251     ASN1_STRING_clear_free(prkey);
252     return 0;
253 }
254
255 static int int_dsa_size(const EVP_PKEY *pkey)
256 {
257     return DSA_size(pkey->pkey.dsa);
258 }
259
260 static int dsa_bits(const EVP_PKEY *pkey)
261 {
262     return DSA_bits(pkey->pkey.dsa);
263 }
264
265 static int dsa_security_bits(const EVP_PKEY *pkey)
266 {
267     return DSA_security_bits(pkey->pkey.dsa);
268 }
269
270 static int dsa_missing_parameters(const EVP_PKEY *pkey)
271 {
272     DSA *dsa;
273     dsa = pkey->pkey.dsa;
274     if (dsa == NULL || dsa->p == NULL || dsa->q == NULL || dsa->g == NULL)
275         return 1;
276     return 0;
277 }
278
279 static int dsa_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from)
280 {
281     BIGNUM *a;
282
283     if (to->pkey.dsa == NULL) {
284         to->pkey.dsa = DSA_new();
285         if (to->pkey.dsa == NULL)
286             return 0;
287     }
288
289     if ((a = BN_dup(from->pkey.dsa->p)) == NULL)
290         return 0;
291     BN_free(to->pkey.dsa->p);
292     to->pkey.dsa->p = a;
293
294     if ((a = BN_dup(from->pkey.dsa->q)) == NULL)
295         return 0;
296     BN_free(to->pkey.dsa->q);
297     to->pkey.dsa->q = a;
298
299     if ((a = BN_dup(from->pkey.dsa->g)) == NULL)
300         return 0;
301     BN_free(to->pkey.dsa->g);
302     to->pkey.dsa->g = a;
303     return 1;
304 }
305
306 static int dsa_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b)
307 {
308     if (BN_cmp(a->pkey.dsa->p, b->pkey.dsa->p) ||
309         BN_cmp(a->pkey.dsa->q, b->pkey.dsa->q) ||
310         BN_cmp(a->pkey.dsa->g, b->pkey.dsa->g))
311         return 0;
312     else
313         return 1;
314 }
315
316 static int dsa_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
317 {
318     if (BN_cmp(b->pkey.dsa->pub_key, a->pkey.dsa->pub_key) != 0)
319         return 0;
320     else
321         return 1;
322 }
323
324 static void int_dsa_free(EVP_PKEY *pkey)
325 {
326     DSA_free(pkey->pkey.dsa);
327 }
328
329 static int do_dsa_print(BIO *bp, const DSA *x, int off, int ptype)
330 {
331     int ret = 0;
332     const char *ktype = NULL;
333     const BIGNUM *priv_key, *pub_key;
334
335     if (ptype == 2)
336         priv_key = x->priv_key;
337     else
338         priv_key = NULL;
339
340     if (ptype > 0)
341         pub_key = x->pub_key;
342     else
343         pub_key = NULL;
344
345     if (ptype == 2)
346         ktype = "Private-Key";
347     else if (ptype == 1)
348         ktype = "Public-Key";
349     else
350         ktype = "DSA-Parameters";
351
352     if (priv_key) {
353         if (!BIO_indent(bp, off, 128))
354             goto err;
355         if (BIO_printf(bp, "%s: (%d bit)\n", ktype, BN_num_bits(x->p))
356             <= 0)
357             goto err;
358     }
359
360     if (!ASN1_bn_print(bp, "priv:", priv_key, NULL, off))
361         goto err;
362     if (!ASN1_bn_print(bp, "pub: ", pub_key, NULL, off))
363         goto err;
364     if (!ASN1_bn_print(bp, "P:   ", x->p, NULL, off))
365         goto err;
366     if (!ASN1_bn_print(bp, "Q:   ", x->q, NULL, off))
367         goto err;
368     if (!ASN1_bn_print(bp, "G:   ", x->g, NULL, off))
369         goto err;
370     ret = 1;
371  err:
372     return ret;
373 }
374
375 static int dsa_param_decode(EVP_PKEY *pkey,
376                             const unsigned char **pder, int derlen)
377 {
378     DSA *dsa;
379
380     if ((dsa = d2i_DSAparams(NULL, pder, derlen)) == NULL) {
381         DSAerr(DSA_F_DSA_PARAM_DECODE, ERR_R_DSA_LIB);
382         return 0;
383     }
384     EVP_PKEY_assign_DSA(pkey, dsa);
385     return 1;
386 }
387
388 static int dsa_param_encode(const EVP_PKEY *pkey, unsigned char **pder)
389 {
390     return i2d_DSAparams(pkey->pkey.dsa, pder);
391 }
392
393 static int dsa_param_print(BIO *bp, const EVP_PKEY *pkey, int indent,
394                            ASN1_PCTX *ctx)
395 {
396     return do_dsa_print(bp, pkey->pkey.dsa, indent, 0);
397 }
398
399 static int dsa_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
400                          ASN1_PCTX *ctx)
401 {
402     return do_dsa_print(bp, pkey->pkey.dsa, indent, 1);
403 }
404
405 static int dsa_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
406                           ASN1_PCTX *ctx)
407 {
408     return do_dsa_print(bp, pkey->pkey.dsa, indent, 2);
409 }
410
411 static int old_dsa_priv_decode(EVP_PKEY *pkey,
412                                const unsigned char **pder, int derlen)
413 {
414     DSA *dsa;
415
416     if ((dsa = d2i_DSAPrivateKey(NULL, pder, derlen)) == NULL) {
417         DSAerr(DSA_F_OLD_DSA_PRIV_DECODE, ERR_R_DSA_LIB);
418         return 0;
419     }
420     EVP_PKEY_assign_DSA(pkey, dsa);
421     return 1;
422 }
423
424 static int old_dsa_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
425 {
426     return i2d_DSAPrivateKey(pkey->pkey.dsa, pder);
427 }
428
429 static int dsa_sig_print(BIO *bp, const X509_ALGOR *sigalg,
430                          const ASN1_STRING *sig, int indent, ASN1_PCTX *pctx)
431 {
432     DSA_SIG *dsa_sig;
433     const unsigned char *p;
434
435     if (!sig) {
436         if (BIO_puts(bp, "\n") <= 0)
437             return 0;
438         else
439             return 1;
440     }
441     p = sig->data;
442     dsa_sig = d2i_DSA_SIG(NULL, &p, sig->length);
443     if (dsa_sig) {
444         int rv = 0;
445         const BIGNUM *r, *s;
446
447         DSA_SIG_get0(dsa_sig, &r, &s);
448
449         if (BIO_write(bp, "\n", 1) != 1)
450             goto err;
451
452         if (!ASN1_bn_print(bp, "r:   ", r, NULL, indent))
453             goto err;
454         if (!ASN1_bn_print(bp, "s:   ", s, NULL, indent))
455             goto err;
456         rv = 1;
457  err:
458         DSA_SIG_free(dsa_sig);
459         return rv;
460     }
461     return X509_signature_dump(bp, sig, indent);
462 }
463
464 static int dsa_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
465 {
466     switch (op) {
467     case ASN1_PKEY_CTRL_PKCS7_SIGN:
468         if (arg1 == 0) {
469             int snid, hnid;
470             X509_ALGOR *alg1, *alg2;
471             PKCS7_SIGNER_INFO_get0_algs(arg2, NULL, &alg1, &alg2);
472             if (alg1 == NULL || alg1->algorithm == NULL)
473                 return -1;
474             hnid = OBJ_obj2nid(alg1->algorithm);
475             if (hnid == NID_undef)
476                 return -1;
477             if (!OBJ_find_sigid_by_algs(&snid, hnid, EVP_PKEY_id(pkey)))
478                 return -1;
479             X509_ALGOR_set0(alg2, OBJ_nid2obj(snid), V_ASN1_UNDEF, 0);
480         }
481         return 1;
482 #ifndef OPENSSL_NO_CMS
483     case ASN1_PKEY_CTRL_CMS_SIGN:
484         if (arg1 == 0) {
485             int snid, hnid;
486             X509_ALGOR *alg1, *alg2;
487             CMS_SignerInfo_get0_algs(arg2, NULL, NULL, &alg1, &alg2);
488             if (alg1 == NULL || alg1->algorithm == NULL)
489                 return -1;
490             hnid = OBJ_obj2nid(alg1->algorithm);
491             if (hnid == NID_undef)
492                 return -1;
493             if (!OBJ_find_sigid_by_algs(&snid, hnid, EVP_PKEY_id(pkey)))
494                 return -1;
495             X509_ALGOR_set0(alg2, OBJ_nid2obj(snid), V_ASN1_UNDEF, 0);
496         }
497         return 1;
498
499     case ASN1_PKEY_CTRL_CMS_RI_TYPE:
500         *(int *)arg2 = CMS_RECIPINFO_NONE;
501         return 1;
502 #endif
503
504     case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
505         *(int *)arg2 = NID_sha256;
506         return 2;
507
508     default:
509         return -2;
510
511     }
512
513 }
514
515 /* NB these are sorted in pkey_id order, lowest first */
516
517 const EVP_PKEY_ASN1_METHOD dsa_asn1_meths[5] = {
518
519     {
520      EVP_PKEY_DSA2,
521      EVP_PKEY_DSA,
522      ASN1_PKEY_ALIAS},
523
524     {
525      EVP_PKEY_DSA1,
526      EVP_PKEY_DSA,
527      ASN1_PKEY_ALIAS},
528
529     {
530      EVP_PKEY_DSA4,
531      EVP_PKEY_DSA,
532      ASN1_PKEY_ALIAS},
533
534     {
535      EVP_PKEY_DSA3,
536      EVP_PKEY_DSA,
537      ASN1_PKEY_ALIAS},
538
539     {
540      EVP_PKEY_DSA,
541      EVP_PKEY_DSA,
542      0,
543
544      "DSA",
545      "OpenSSL DSA method",
546
547      dsa_pub_decode,
548      dsa_pub_encode,
549      dsa_pub_cmp,
550      dsa_pub_print,
551
552      dsa_priv_decode,
553      dsa_priv_encode,
554      dsa_priv_print,
555
556      int_dsa_size,
557      dsa_bits,
558      dsa_security_bits,
559
560      dsa_param_decode,
561      dsa_param_encode,
562      dsa_missing_parameters,
563      dsa_copy_parameters,
564      dsa_cmp_parameters,
565      dsa_param_print,
566      dsa_sig_print,
567
568      int_dsa_free,
569      dsa_pkey_ctrl,
570      old_dsa_priv_decode,
571      old_dsa_priv_encode}
572 };