Remove "experimental" in code and comments, too.
[openssl.git] / crypto / dsa / dsa_ameth.c
1 /*
2  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
3  * 2006.
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
13  *    notice, this list of conditions and the following disclaimer.
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>
60 #include "internal/cryptlib.h"
61 #include <openssl/x509.h>
62 #include <openssl/asn1.h>
63 #include <openssl/dsa.h>
64 #include <openssl/bn.h>
65 #ifndef OPENSSL_NO_CMS
66 # include <openssl/cms.h>
67 #endif
68 #include "internal/asn1_int.h"
69 #include "internal/evp_int.h"
70
71 static int dsa_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)
72 {
73     const unsigned char *p, *pm;
74     int pklen, pmlen;
75     int ptype;
76     void *pval;
77     ASN1_STRING *pstr;
78     X509_ALGOR *palg;
79     ASN1_INTEGER *public_key = NULL;
80
81     DSA *dsa = NULL;
82
83     if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, &palg, pubkey))
84         return 0;
85     X509_ALGOR_get0(NULL, &ptype, &pval, palg);
86
87     if (ptype == V_ASN1_SEQUENCE) {
88         pstr = pval;
89         pm = pstr->data;
90         pmlen = pstr->length;
91
92         if ((dsa = d2i_DSAparams(NULL, &pm, pmlen)) == NULL) {
93             DSAerr(DSA_F_DSA_PUB_DECODE, DSA_R_DECODE_ERROR);
94             goto err;
95         }
96
97     } else if ((ptype == V_ASN1_NULL) || (ptype == V_ASN1_UNDEF)) {
98         if ((dsa = DSA_new()) == NULL) {
99             DSAerr(DSA_F_DSA_PUB_DECODE, ERR_R_MALLOC_FAILURE);
100             goto err;
101         }
102     } else {
103         DSAerr(DSA_F_DSA_PUB_DECODE, DSA_R_PARAMETER_ENCODING_ERROR);
104         goto err;
105     }
106
107     if ((public_key = d2i_ASN1_INTEGER(NULL, &p, pklen)) == NULL) {
108         DSAerr(DSA_F_DSA_PUB_DECODE, DSA_R_DECODE_ERROR);
109         goto err;
110     }
111
112     if ((dsa->pub_key = ASN1_INTEGER_to_BN(public_key, NULL)) == NULL) {
113         DSAerr(DSA_F_DSA_PUB_DECODE, DSA_R_BN_DECODE_ERROR);
114         goto err;
115     }
116
117     ASN1_INTEGER_free(public_key);
118     EVP_PKEY_assign_DSA(pkey, dsa);
119     return 1;
120
121  err:
122     ASN1_INTEGER_free(public_key);
123     DSA_free(dsa);
124     return 0;
125
126 }
127
128 static int dsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
129 {
130     DSA *dsa;
131     int ptype;
132     unsigned char *penc = NULL;
133     int penclen;
134     ASN1_STRING *str = NULL;
135     ASN1_INTEGER *pubint = NULL;
136
137     dsa = pkey->pkey.dsa;
138     if (pkey->save_parameters && dsa->p && dsa->q && dsa->g) {
139         str = ASN1_STRING_new();
140         if (str == NULL) {
141             DSAerr(DSA_F_DSA_PUB_ENCODE, ERR_R_MALLOC_FAILURE);
142             goto err;
143         }
144         str->length = i2d_DSAparams(dsa, &str->data);
145         if (str->length <= 0) {
146             DSAerr(DSA_F_DSA_PUB_ENCODE, ERR_R_MALLOC_FAILURE);
147             goto err;
148         }
149         ptype = V_ASN1_SEQUENCE;
150     } else
151         ptype = V_ASN1_UNDEF;
152
153     pubint = BN_to_ASN1_INTEGER(dsa->pub_key, NULL);
154
155     if (pubint == NULL) {
156         DSAerr(DSA_F_DSA_PUB_ENCODE, ERR_R_MALLOC_FAILURE);
157         goto err;
158     }
159
160     penclen = i2d_ASN1_INTEGER(pubint, &penc);
161     ASN1_INTEGER_free(pubint);
162
163     if (penclen <= 0) {
164         DSAerr(DSA_F_DSA_PUB_ENCODE, ERR_R_MALLOC_FAILURE);
165         goto err;
166     }
167
168     if (X509_PUBKEY_set0_param(pk, OBJ_nid2obj(EVP_PKEY_DSA),
169                                ptype, str, penc, penclen))
170         return 1;
171
172  err:
173     OPENSSL_free(penc);
174     ASN1_STRING_free(str);
175
176     return 0;
177 }
178
179 /*
180  * In PKCS#8 DSA: you just get a private key integer and parameters in the
181  * AlgorithmIdentifier the pubkey must be recalculated.
182  */
183
184 static int dsa_priv_decode(EVP_PKEY *pkey, PKCS8_PRIV_KEY_INFO *p8)
185 {
186     const unsigned char *p, *pm;
187     int pklen, pmlen;
188     int ptype;
189     void *pval;
190     ASN1_STRING *pstr;
191     X509_ALGOR *palg;
192     ASN1_INTEGER *privkey = NULL;
193     BN_CTX *ctx = NULL;
194
195     STACK_OF(ASN1_TYPE) *ndsa = NULL;
196     DSA *dsa = NULL;
197
198     if (!PKCS8_pkey_get0(NULL, &p, &pklen, &palg, p8))
199         return 0;
200     X509_ALGOR_get0(NULL, &ptype, &pval, palg);
201
202     /* Check for broken DSA PKCS#8, UGH! */
203     if (*p == (V_ASN1_SEQUENCE | V_ASN1_CONSTRUCTED)) {
204         ASN1_TYPE *t1, *t2;
205         if ((ndsa = d2i_ASN1_SEQUENCE_ANY(NULL, &p, pklen)) == NULL)
206             goto decerr;
207         if (sk_ASN1_TYPE_num(ndsa) != 2)
208             goto decerr;
209         /*-
210          * Handle Two broken types:
211          * SEQUENCE {parameters, priv_key}
212          * SEQUENCE {pub_key, priv_key}
213          */
214
215         t1 = sk_ASN1_TYPE_value(ndsa, 0);
216         t2 = sk_ASN1_TYPE_value(ndsa, 1);
217         if (t1->type == V_ASN1_SEQUENCE) {
218             p8->broken = PKCS8_EMBEDDED_PARAM;
219             pval = t1->value.ptr;
220         } else if (ptype == V_ASN1_SEQUENCE)
221             p8->broken = PKCS8_NS_DB;
222         else
223             goto decerr;
224
225         if (t2->type != V_ASN1_INTEGER)
226             goto decerr;
227
228         privkey = t2->value.integer;
229     } else {
230         const unsigned char *q = p;
231         if ((privkey = d2i_ASN1_INTEGER(NULL, &p, pklen)) == NULL)
232             goto decerr;
233         if (privkey->type == V_ASN1_NEG_INTEGER) {
234             p8->broken = PKCS8_NEG_PRIVKEY;
235             ASN1_STRING_clear_free(privkey);
236             if ((privkey = d2i_ASN1_UINTEGER(NULL, &q, pklen)) == NULL)
237                 goto decerr;
238         }
239         if (ptype != V_ASN1_SEQUENCE)
240             goto decerr;
241     }
242
243     pstr = pval;
244     pm = pstr->data;
245     pmlen = pstr->length;
246     if ((dsa = d2i_DSAparams(NULL, &pm, pmlen)) == NULL)
247         goto decerr;
248     /* We have parameters now set private key */
249     if ((dsa->priv_key = BN_secure_new()) == NULL
250         || !ASN1_INTEGER_to_BN(privkey, dsa->priv_key)) {
251         DSAerr(DSA_F_DSA_PRIV_DECODE, DSA_R_BN_ERROR);
252         goto dsaerr;
253     }
254     /* Calculate public key */
255     if ((dsa->pub_key = BN_new()) == NULL) {
256         DSAerr(DSA_F_DSA_PRIV_DECODE, ERR_R_MALLOC_FAILURE);
257         goto dsaerr;
258     }
259     if ((ctx = BN_CTX_new()) == NULL) {
260         DSAerr(DSA_F_DSA_PRIV_DECODE, ERR_R_MALLOC_FAILURE);
261         goto dsaerr;
262     }
263
264     if (!BN_mod_exp(dsa->pub_key, dsa->g, dsa->priv_key, dsa->p, ctx)) {
265         DSAerr(DSA_F_DSA_PRIV_DECODE, DSA_R_BN_ERROR);
266         goto dsaerr;
267     }
268
269     EVP_PKEY_assign_DSA(pkey, dsa);
270     BN_CTX_free(ctx);
271     if (ndsa)
272         sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);
273     else
274         ASN1_STRING_clear_free(privkey);
275
276     return 1;
277
278  decerr:
279     DSAerr(DSA_F_DSA_PRIV_DECODE, EVP_R_DECODE_ERROR);
280  dsaerr:
281     BN_CTX_free(ctx);
282     ASN1_STRING_clear_free(privkey);
283     sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);
284     DSA_free(dsa);
285     return 0;
286 }
287
288 static int dsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
289 {
290     ASN1_STRING *params = NULL;
291     ASN1_INTEGER *prkey = NULL;
292     unsigned char *dp = NULL;
293     int dplen;
294
295     if (!pkey->pkey.dsa || !pkey->pkey.dsa->priv_key) {
296         DSAerr(DSA_F_DSA_PRIV_ENCODE, DSA_R_MISSING_PARAMETERS);
297         goto err;
298     }
299
300     params = ASN1_STRING_new();
301
302     if (params == NULL) {
303         DSAerr(DSA_F_DSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
304         goto err;
305     }
306
307     params->length = i2d_DSAparams(pkey->pkey.dsa, &params->data);
308     if (params->length <= 0) {
309         DSAerr(DSA_F_DSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
310         goto err;
311     }
312     params->type = V_ASN1_SEQUENCE;
313
314     /* Get private key into integer */
315     prkey = BN_to_ASN1_INTEGER(pkey->pkey.dsa->priv_key, NULL);
316
317     if (!prkey) {
318         DSAerr(DSA_F_DSA_PRIV_ENCODE, DSA_R_BN_ERROR);
319         goto err;
320     }
321
322     dplen = i2d_ASN1_INTEGER(prkey, &dp);
323
324     ASN1_STRING_clear_free(prkey);
325     prkey = NULL;
326
327     if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(NID_dsa), 0,
328                          V_ASN1_SEQUENCE, params, dp, dplen))
329         goto err;
330
331     return 1;
332
333  err:
334     OPENSSL_free(dp);
335     ASN1_STRING_free(params);
336     ASN1_STRING_clear_free(prkey);
337     return 0;
338 }
339
340 static int int_dsa_size(const EVP_PKEY *pkey)
341 {
342     return (DSA_size(pkey->pkey.dsa));
343 }
344
345 static int dsa_bits(const EVP_PKEY *pkey)
346 {
347     return BN_num_bits(pkey->pkey.dsa->p);
348 }
349
350 static int dsa_security_bits(const EVP_PKEY *pkey)
351 {
352     return DSA_security_bits(pkey->pkey.dsa);
353 }
354
355 static int dsa_missing_parameters(const EVP_PKEY *pkey)
356 {
357     DSA *dsa;
358     dsa = pkey->pkey.dsa;
359     if ((dsa->p == NULL) || (dsa->q == NULL) || (dsa->g == NULL))
360         return 1;
361     return 0;
362 }
363
364 static int dsa_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from)
365 {
366     BIGNUM *a;
367
368     if (to->pkey.dsa == NULL) {
369         to->pkey.dsa = DSA_new();
370         if (to->pkey.dsa == NULL)
371             return 0;
372     }
373
374     if ((a = BN_dup(from->pkey.dsa->p)) == NULL)
375         return 0;
376     BN_free(to->pkey.dsa->p);
377     to->pkey.dsa->p = a;
378
379     if ((a = BN_dup(from->pkey.dsa->q)) == NULL)
380         return 0;
381     BN_free(to->pkey.dsa->q);
382     to->pkey.dsa->q = a;
383
384     if ((a = BN_dup(from->pkey.dsa->g)) == NULL)
385         return 0;
386     BN_free(to->pkey.dsa->g);
387     to->pkey.dsa->g = a;
388     return 1;
389 }
390
391 static int dsa_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b)
392 {
393     if (BN_cmp(a->pkey.dsa->p, b->pkey.dsa->p) ||
394         BN_cmp(a->pkey.dsa->q, b->pkey.dsa->q) ||
395         BN_cmp(a->pkey.dsa->g, b->pkey.dsa->g))
396         return 0;
397     else
398         return 1;
399 }
400
401 static int dsa_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
402 {
403     if (BN_cmp(b->pkey.dsa->pub_key, a->pkey.dsa->pub_key) != 0)
404         return 0;
405     else
406         return 1;
407 }
408
409 static void int_dsa_free(EVP_PKEY *pkey)
410 {
411     DSA_free(pkey->pkey.dsa);
412 }
413
414 static void update_buflen(const BIGNUM *b, size_t *pbuflen)
415 {
416     size_t i;
417     if (!b)
418         return;
419     if (*pbuflen < (i = (size_t)BN_num_bytes(b)))
420         *pbuflen = i;
421 }
422
423 static int do_dsa_print(BIO *bp, const DSA *x, int off, int ptype)
424 {
425     unsigned char *m = NULL;
426     int ret = 0;
427     size_t buf_len = 0;
428     const char *ktype = NULL;
429
430     const BIGNUM *priv_key, *pub_key;
431
432     if (ptype == 2)
433         priv_key = x->priv_key;
434     else
435         priv_key = NULL;
436
437     if (ptype > 0)
438         pub_key = x->pub_key;
439     else
440         pub_key = NULL;
441
442     if (ptype == 2)
443         ktype = "Private-Key";
444     else if (ptype == 1)
445         ktype = "Public-Key";
446     else
447         ktype = "DSA-Parameters";
448
449     update_buflen(x->p, &buf_len);
450     update_buflen(x->q, &buf_len);
451     update_buflen(x->g, &buf_len);
452     update_buflen(priv_key, &buf_len);
453     update_buflen(pub_key, &buf_len);
454
455     m = OPENSSL_malloc(buf_len + 10);
456     if (m == NULL) {
457         DSAerr(DSA_F_DO_DSA_PRINT, ERR_R_MALLOC_FAILURE);
458         goto err;
459     }
460
461     if (priv_key) {
462         if (!BIO_indent(bp, off, 128))
463             goto err;
464         if (BIO_printf(bp, "%s: (%d bit)\n", ktype, BN_num_bits(x->p))
465             <= 0)
466             goto err;
467     }
468
469     if (!ASN1_bn_print(bp, "priv:", priv_key, m, off))
470         goto err;
471     if (!ASN1_bn_print(bp, "pub: ", pub_key, m, off))
472         goto err;
473     if (!ASN1_bn_print(bp, "P:   ", x->p, m, off))
474         goto err;
475     if (!ASN1_bn_print(bp, "Q:   ", x->q, m, off))
476         goto err;
477     if (!ASN1_bn_print(bp, "G:   ", x->g, m, off))
478         goto err;
479     ret = 1;
480  err:
481     OPENSSL_free(m);
482     return (ret);
483 }
484
485 static int dsa_param_decode(EVP_PKEY *pkey,
486                             const unsigned char **pder, int derlen)
487 {
488     DSA *dsa;
489
490     if ((dsa = d2i_DSAparams(NULL, pder, derlen)) == NULL) {
491         DSAerr(DSA_F_DSA_PARAM_DECODE, ERR_R_DSA_LIB);
492         return 0;
493     }
494     EVP_PKEY_assign_DSA(pkey, dsa);
495     return 1;
496 }
497
498 static int dsa_param_encode(const EVP_PKEY *pkey, unsigned char **pder)
499 {
500     return i2d_DSAparams(pkey->pkey.dsa, pder);
501 }
502
503 static int dsa_param_print(BIO *bp, const EVP_PKEY *pkey, int indent,
504                            ASN1_PCTX *ctx)
505 {
506     return do_dsa_print(bp, pkey->pkey.dsa, indent, 0);
507 }
508
509 static int dsa_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
510                          ASN1_PCTX *ctx)
511 {
512     return do_dsa_print(bp, pkey->pkey.dsa, indent, 1);
513 }
514
515 static int dsa_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
516                           ASN1_PCTX *ctx)
517 {
518     return do_dsa_print(bp, pkey->pkey.dsa, indent, 2);
519 }
520
521 static int old_dsa_priv_decode(EVP_PKEY *pkey,
522                                const unsigned char **pder, int derlen)
523 {
524     DSA *dsa;
525
526     if ((dsa = d2i_DSAPrivateKey(NULL, pder, derlen)) == NULL) {
527         DSAerr(DSA_F_OLD_DSA_PRIV_DECODE, ERR_R_DSA_LIB);
528         return 0;
529     }
530     EVP_PKEY_assign_DSA(pkey, dsa);
531     return 1;
532 }
533
534 static int old_dsa_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
535 {
536     return i2d_DSAPrivateKey(pkey->pkey.dsa, pder);
537 }
538
539 static int dsa_sig_print(BIO *bp, const X509_ALGOR *sigalg,
540                          const ASN1_STRING *sig, int indent, ASN1_PCTX *pctx)
541 {
542     DSA_SIG *dsa_sig;
543     const unsigned char *p;
544     if (!sig) {
545         if (BIO_puts(bp, "\n") <= 0)
546             return 0;
547         else
548             return 1;
549     }
550     p = sig->data;
551     dsa_sig = d2i_DSA_SIG(NULL, &p, sig->length);
552     if (dsa_sig) {
553         int rv = 0;
554         size_t buf_len = 0;
555         unsigned char *m = NULL;
556         update_buflen(dsa_sig->r, &buf_len);
557         update_buflen(dsa_sig->s, &buf_len);
558         m = OPENSSL_malloc(buf_len + 10);
559         if (m == NULL) {
560             DSAerr(DSA_F_DSA_SIG_PRINT, ERR_R_MALLOC_FAILURE);
561             goto err;
562         }
563
564         if (BIO_write(bp, "\n", 1) != 1)
565             goto err;
566
567         if (!ASN1_bn_print(bp, "r:   ", dsa_sig->r, m, indent))
568             goto err;
569         if (!ASN1_bn_print(bp, "s:   ", dsa_sig->s, m, indent))
570             goto err;
571         rv = 1;
572  err:
573         OPENSSL_free(m);
574         DSA_SIG_free(dsa_sig);
575         return rv;
576     }
577     return X509_signature_dump(bp, sig, indent);
578 }
579
580 static int dsa_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
581 {
582     switch (op) {
583     case ASN1_PKEY_CTRL_PKCS7_SIGN:
584         if (arg1 == 0) {
585             int snid, hnid;
586             X509_ALGOR *alg1, *alg2;
587             PKCS7_SIGNER_INFO_get0_algs(arg2, NULL, &alg1, &alg2);
588             if (alg1 == NULL || alg1->algorithm == NULL)
589                 return -1;
590             hnid = OBJ_obj2nid(alg1->algorithm);
591             if (hnid == NID_undef)
592                 return -1;
593             if (!OBJ_find_sigid_by_algs(&snid, hnid, EVP_PKEY_id(pkey)))
594                 return -1;
595             X509_ALGOR_set0(alg2, OBJ_nid2obj(snid), V_ASN1_UNDEF, 0);
596         }
597         return 1;
598 #ifndef OPENSSL_NO_CMS
599     case ASN1_PKEY_CTRL_CMS_SIGN:
600         if (arg1 == 0) {
601             int snid, hnid;
602             X509_ALGOR *alg1, *alg2;
603             CMS_SignerInfo_get0_algs(arg2, NULL, NULL, &alg1, &alg2);
604             if (alg1 == NULL || alg1->algorithm == NULL)
605                 return -1;
606             hnid = OBJ_obj2nid(alg1->algorithm);
607             if (hnid == NID_undef)
608                 return -1;
609             if (!OBJ_find_sigid_by_algs(&snid, hnid, EVP_PKEY_id(pkey)))
610                 return -1;
611             X509_ALGOR_set0(alg2, OBJ_nid2obj(snid), V_ASN1_UNDEF, 0);
612         }
613         return 1;
614
615     case ASN1_PKEY_CTRL_CMS_RI_TYPE:
616         *(int *)arg2 = CMS_RECIPINFO_NONE;
617         return 1;
618 #endif
619
620     case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
621         *(int *)arg2 = NID_sha256;
622         return 2;
623
624     default:
625         return -2;
626
627     }
628
629 }
630
631 /* NB these are sorted in pkey_id order, lowest first */
632
633 const EVP_PKEY_ASN1_METHOD dsa_asn1_meths[] = {
634
635     {
636      EVP_PKEY_DSA2,
637      EVP_PKEY_DSA,
638      ASN1_PKEY_ALIAS},
639
640     {
641      EVP_PKEY_DSA1,
642      EVP_PKEY_DSA,
643      ASN1_PKEY_ALIAS},
644
645     {
646      EVP_PKEY_DSA4,
647      EVP_PKEY_DSA,
648      ASN1_PKEY_ALIAS},
649
650     {
651      EVP_PKEY_DSA3,
652      EVP_PKEY_DSA,
653      ASN1_PKEY_ALIAS},
654
655     {
656      EVP_PKEY_DSA,
657      EVP_PKEY_DSA,
658      0,
659
660      "DSA",
661      "OpenSSL DSA method",
662
663      dsa_pub_decode,
664      dsa_pub_encode,
665      dsa_pub_cmp,
666      dsa_pub_print,
667
668      dsa_priv_decode,
669      dsa_priv_encode,
670      dsa_priv_print,
671
672      int_dsa_size,
673      dsa_bits,
674      dsa_security_bits,
675
676      dsa_param_decode,
677      dsa_param_encode,
678      dsa_missing_parameters,
679      dsa_copy_parameters,
680      dsa_cmp_parameters,
681      dsa_param_print,
682      dsa_sig_print,
683
684      int_dsa_free,
685      dsa_pkey_ctrl,
686      old_dsa_priv_decode,
687      old_dsa_priv_encode}
688 };