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