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.c698
1 files changed, 0 insertions, 698 deletions
diff --git a/src/lib/libcrypto/dsa/dsa_ameth.c b/src/lib/libcrypto/dsa/dsa_ameth.c
deleted file mode 100644
index a6e21a688e..0000000000
--- a/src/lib/libcrypto/dsa/dsa_ameth.c
+++ /dev/null
@@ -1,698 +0,0 @@
1/* $OpenBSD: dsa_ameth.c,v 1.19 2016/03/01 07:04:41 doug 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 */
184static int
185dsa_priv_decode(EVP_PKEY *pkey, PKCS8_PRIV_KEY_INFO *p8)
186{
187 const unsigned char *p, *pm;
188 int pklen, pmlen;
189 int ptype;
190 void *pval;
191 ASN1_STRING *pstr;
192 X509_ALGOR *palg;
193 ASN1_INTEGER *privkey = NULL;
194 BN_CTX *ctx = NULL;
195 DSA *dsa = NULL;
196
197 int ret = 0;
198
199 if (!PKCS8_pkey_get0(NULL, &p, &pklen, &palg, p8))
200 return 0;
201 X509_ALGOR_get0(NULL, &ptype, &pval, palg);
202 if (ptype != V_ASN1_SEQUENCE)
203 goto decerr;
204
205 if ((privkey = d2i_ASN1_INTEGER(NULL, &p, pklen)) == NULL)
206 goto decerr;
207 if (privkey->type == V_ASN1_NEG_INTEGER)
208 goto decerr;
209
210 pstr = pval;
211 pm = pstr->data;
212 pmlen = pstr->length;
213 if (!(dsa = d2i_DSAparams(NULL, &pm, pmlen)))
214 goto decerr;
215 /* We have parameters now set private key */
216 if (!(dsa->priv_key = ASN1_INTEGER_to_BN(privkey, NULL))) {
217 DSAerr(DSA_F_DSA_PRIV_DECODE,DSA_R_BN_ERROR);
218 goto dsaerr;
219 }
220 /* Calculate public key */
221 if (!(dsa->pub_key = BN_new())) {
222 DSAerr(DSA_F_DSA_PRIV_DECODE, ERR_R_MALLOC_FAILURE);
223 goto dsaerr;
224 }
225 if (!(ctx = BN_CTX_new())) {
226 DSAerr(DSA_F_DSA_PRIV_DECODE, ERR_R_MALLOC_FAILURE);
227 goto dsaerr;
228 }
229
230 if (!BN_mod_exp(dsa->pub_key, dsa->g, dsa->priv_key, dsa->p, ctx)) {
231 DSAerr(DSA_F_DSA_PRIV_DECODE,DSA_R_BN_ERROR);
232 goto dsaerr;
233 }
234
235 if (!EVP_PKEY_assign_DSA(pkey, dsa))
236 goto decerr;
237
238 ret = 1;
239 goto done;
240
241decerr:
242 DSAerr(DSA_F_DSA_PRIV_DECODE, DSA_R_DECODE_ERROR);
243dsaerr:
244 DSA_free(dsa);
245done:
246 BN_CTX_free(ctx);
247 ASN1_INTEGER_free(privkey);
248 return ret;
249}
250
251static int
252dsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
253{
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 if (!params) {
261 DSAerr(DSA_F_DSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
262 goto err;
263 }
264
265 params->length = i2d_DSAparams(pkey->pkey.dsa, &params->data);
266 if (params->length <= 0) {
267 DSAerr(DSA_F_DSA_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
268 goto err;
269 }
270 params->type = V_ASN1_SEQUENCE;
271
272 /* Get private key into integer */
273 prkey = BN_to_ASN1_INTEGER(pkey->pkey.dsa->priv_key, NULL);
274 if (!prkey) {
275 DSAerr(DSA_F_DSA_PRIV_ENCODE, DSA_R_BN_ERROR);
276 goto err;
277 }
278
279 dplen = i2d_ASN1_INTEGER(prkey, &dp);
280
281 ASN1_INTEGER_free(prkey);
282 prkey = NULL;
283
284 if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(NID_dsa), 0, V_ASN1_SEQUENCE,
285 params, dp, dplen))
286 goto err;
287
288 return 1;
289
290err:
291 free(dp);
292 ASN1_STRING_free(params);
293 ASN1_INTEGER_free(prkey);
294 return 0;
295}
296
297static int
298int_dsa_size(const EVP_PKEY *pkey)
299{
300 return DSA_size(pkey->pkey.dsa);
301}
302
303static int
304dsa_bits(const EVP_PKEY *pkey)
305{
306 return BN_num_bits(pkey->pkey.dsa->p);
307}
308
309static int
310dsa_missing_parameters(const EVP_PKEY *pkey)
311{
312 DSA *dsa;
313
314 dsa = pkey->pkey.dsa;
315 if (dsa->p == NULL || dsa->q == NULL || dsa->g == NULL)
316 return 1;
317 return 0;
318}
319
320static int
321dsa_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from)
322{
323 BIGNUM *a;
324
325 if ((a = BN_dup(from->pkey.dsa->p)) == NULL)
326 return 0;
327 BN_free(to->pkey.dsa->p);
328 to->pkey.dsa->p = a;
329
330 if ((a = BN_dup(from->pkey.dsa->q)) == NULL)
331 return 0;
332 BN_free(to->pkey.dsa->q);
333 to->pkey.dsa->q = a;
334
335 if ((a = BN_dup(from->pkey.dsa->g)) == NULL)
336 return 0;
337 BN_free(to->pkey.dsa->g);
338 to->pkey.dsa->g = a;
339 return 1;
340}
341
342static int
343dsa_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b)
344{
345 if (BN_cmp(a->pkey.dsa->p, b->pkey.dsa->p) ||
346 BN_cmp(a->pkey.dsa->q, b->pkey.dsa->q) ||
347 BN_cmp(a->pkey.dsa->g, b->pkey.dsa->g))
348 return 0;
349 else
350 return 1;
351}
352
353static int
354dsa_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
355{
356 if (BN_cmp(b->pkey.dsa->pub_key, a->pkey.dsa->pub_key) != 0)
357 return 0;
358 else
359 return 1;
360}
361
362static void
363int_dsa_free(EVP_PKEY *pkey)
364{
365 DSA_free(pkey->pkey.dsa);
366}
367
368static void
369update_buflen(const BIGNUM *b, size_t *pbuflen)
370{
371 size_t i;
372
373 if (!b)
374 return;
375 if (*pbuflen < (i = (size_t)BN_num_bytes(b)))
376 *pbuflen = i;
377}
378
379static int
380do_dsa_print(BIO *bp, const DSA *x, int off, int ptype)
381{
382 unsigned char *m = NULL;
383 int ret = 0;
384 size_t buf_len = 0;
385 const char *ktype = NULL;
386 const BIGNUM *priv_key, *pub_key;
387
388 if (ptype == 2)
389 priv_key = x->priv_key;
390 else
391 priv_key = NULL;
392
393 if (ptype > 0)
394 pub_key = x->pub_key;
395 else
396 pub_key = NULL;
397
398 if (ptype == 2)
399 ktype = "Private-Key";
400 else if (ptype == 1)
401 ktype = "Public-Key";
402 else
403 ktype = "DSA-Parameters";
404
405 update_buflen(x->p, &buf_len);
406 update_buflen(x->q, &buf_len);
407 update_buflen(x->g, &buf_len);
408 update_buflen(priv_key, &buf_len);
409 update_buflen(pub_key, &buf_len);
410
411 m = malloc(buf_len + 10);
412 if (m == NULL) {
413 DSAerr(DSA_F_DO_DSA_PRINT, ERR_R_MALLOC_FAILURE);
414 goto err;
415 }
416
417 if (priv_key) {
418 if (!BIO_indent(bp, off, 128))
419 goto err;
420 if (BIO_printf(bp, "%s: (%d bit)\n", ktype,
421 BN_num_bits(x->p)) <= 0)
422 goto err;
423 }
424
425 if (!ASN1_bn_print(bp, "priv:", priv_key, m, off))
426 goto err;
427 if (!ASN1_bn_print(bp, "pub: ", pub_key, m, off))
428 goto err;
429 if (!ASN1_bn_print(bp, "P: ", x->p, m, off))
430 goto err;
431 if (!ASN1_bn_print(bp, "Q: ", x->q, m, off))
432 goto err;
433 if (!ASN1_bn_print(bp, "G: ", x->g, m, off))
434 goto err;
435 ret = 1;
436err:
437 free(m);
438 return(ret);
439}
440
441static int
442dsa_param_decode(EVP_PKEY *pkey, const unsigned char **pder, int derlen)
443{
444 DSA *dsa;
445
446 if (!(dsa = d2i_DSAparams(NULL, pder, derlen))) {
447 DSAerr(DSA_F_DSA_PARAM_DECODE, ERR_R_DSA_LIB);
448 return 0;
449 }
450 EVP_PKEY_assign_DSA(pkey, dsa);
451 return 1;
452}
453
454static int
455dsa_param_encode(const EVP_PKEY *pkey, unsigned char **pder)
456{
457 return i2d_DSAparams(pkey->pkey.dsa, pder);
458}
459
460static int
461dsa_param_print(BIO *bp, const EVP_PKEY *pkey, int indent, ASN1_PCTX *ctx)
462{
463 return do_dsa_print(bp, pkey->pkey.dsa, indent, 0);
464}
465
466static int
467dsa_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent, ASN1_PCTX *ctx)
468{
469 return do_dsa_print(bp, pkey->pkey.dsa, indent, 1);
470}
471
472static int
473dsa_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent, ASN1_PCTX *ctx)
474{
475 return do_dsa_print(bp, pkey->pkey.dsa, indent, 2);
476}
477
478static int
479old_dsa_priv_decode(EVP_PKEY *pkey, const unsigned char **pder, int derlen)
480{
481 DSA *dsa;
482 BN_CTX *ctx = NULL;
483 BIGNUM *j, *p1, *newp1;
484
485 if (!(dsa = d2i_DSAPrivateKey(NULL, pder, derlen))) {
486 DSAerr(DSA_F_OLD_DSA_PRIV_DECODE, ERR_R_DSA_LIB);
487 return 0;
488 }
489
490 ctx = BN_CTX_new();
491 if (ctx == NULL)
492 goto err;
493
494 /*
495 * Check that p and q are consistent with each other.
496 */
497
498 j = BN_CTX_get(ctx);
499 p1 = BN_CTX_get(ctx);
500 newp1 = BN_CTX_get(ctx);
501 if (j == NULL || p1 == NULL || newp1 == NULL)
502 goto err;
503 /* p1 = p - 1 */
504 if (BN_sub(p1, dsa->p, BN_value_one()) == 0)
505 goto err;
506 /* j = (p - 1) / q */
507 if (BN_div(j, NULL, p1, dsa->q, ctx) == 0)
508 goto err;
509 /* q * j should == p - 1 */
510 if (BN_mul(newp1, dsa->q, j, ctx) == 0)
511 goto err;
512 if (BN_cmp(newp1, p1) != 0) {
513 DSAerr(DSA_F_DSA_PARAM_DECODE, DSA_R_BAD_Q_VALUE);
514 goto err;
515 }
516
517 /*
518 * Check that q is not a composite number.
519 */
520
521 if (BN_is_prime_ex(dsa->q, BN_prime_checks, ctx, NULL) == 0) {
522 DSAerr(DSA_F_DSA_PARAM_DECODE, DSA_R_BAD_Q_VALUE);
523 goto err;
524 }
525
526 BN_CTX_free(ctx);
527
528 EVP_PKEY_assign_DSA(pkey, dsa);
529 return 1;
530
531err:
532 BN_CTX_free(ctx);
533 DSA_free(dsa);
534 return 0;
535}
536
537static int
538old_dsa_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
539{
540 return i2d_DSAPrivateKey(pkey->pkey.dsa, pder);
541}
542
543static int
544dsa_sig_print(BIO *bp, const X509_ALGOR *sigalg, const ASN1_STRING *sig,
545 int indent, ASN1_PCTX *pctx)
546{
547 DSA_SIG *dsa_sig;
548 const unsigned char *p;
549
550 if (!sig) {
551 if (BIO_puts(bp, "\n") <= 0)
552 return 0;
553 else
554 return 1;
555 }
556 p = sig->data;
557 dsa_sig = d2i_DSA_SIG(NULL, &p, sig->length);
558 if (dsa_sig) {
559 int rv = 0;
560 size_t buf_len = 0;
561 unsigned char *m = NULL;
562
563 update_buflen(dsa_sig->r, &buf_len);
564 update_buflen(dsa_sig->s, &buf_len);
565 m = malloc(buf_len + 10);
566 if (m == NULL) {
567 DSAerr(DSA_F_DSA_SIG_PRINT, ERR_R_MALLOC_FAILURE);
568 goto err;
569 }
570
571 if (BIO_write(bp, "\n", 1) != 1)
572 goto err;
573
574 if (!ASN1_bn_print(bp, "r: ", dsa_sig->r, m, indent))
575 goto err;
576 if (!ASN1_bn_print(bp, "s: ", dsa_sig->s, m, indent))
577 goto err;
578 rv = 1;
579err:
580 free(m);
581 DSA_SIG_free(dsa_sig);
582 return rv;
583 }
584 return X509_signature_dump(bp, sig, indent);
585}
586
587static int
588dsa_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
589{
590 switch (op) {
591 case ASN1_PKEY_CTRL_PKCS7_SIGN:
592 if (arg1 == 0) {
593 int snid, hnid;
594 X509_ALGOR *alg1, *alg2;
595
596 PKCS7_SIGNER_INFO_get0_algs(arg2, NULL, &alg1, &alg2);
597 if (alg1 == NULL || alg1->algorithm == NULL)
598 return -1;
599 hnid = OBJ_obj2nid(alg1->algorithm);
600 if (hnid == NID_undef)
601 return -1;
602 if (!OBJ_find_sigid_by_algs(&snid, hnid,
603 EVP_PKEY_id(pkey)))
604 return -1;
605 X509_ALGOR_set0(alg2, OBJ_nid2obj(snid), V_ASN1_UNDEF,
606 0);
607 }
608 return 1;
609#ifndef OPENSSL_NO_CMS
610 case ASN1_PKEY_CTRL_CMS_SIGN:
611 if (arg1 == 0) {
612 int snid, hnid;
613 X509_ALGOR *alg1, *alg2;
614
615 CMS_SignerInfo_get0_algs(arg2, NULL, NULL, &alg1, &alg2);
616 if (alg1 == NULL || alg1->algorithm == NULL)
617 return -1;
618 hnid = OBJ_obj2nid(alg1->algorithm);
619 if (hnid == NID_undef)
620 return -1;
621 if (!OBJ_find_sigid_by_algs(&snid, hnid,
622 EVP_PKEY_id(pkey)))
623 return -1;
624 X509_ALGOR_set0(alg2, OBJ_nid2obj(snid), V_ASN1_UNDEF,
625 0);
626 }
627 return 1;
628#endif
629
630 case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
631 *(int *)arg2 = NID_sha1;
632 return 2;
633
634 default:
635 return -2;
636 }
637}
638
639/* NB these are sorted in pkey_id order, lowest first */
640
641const EVP_PKEY_ASN1_METHOD dsa_asn1_meths[] = {
642 {
643 .pkey_id = EVP_PKEY_DSA2,
644 .pkey_base_id = EVP_PKEY_DSA,
645 .pkey_flags = ASN1_PKEY_ALIAS
646 },
647
648 {
649 .pkey_id = EVP_PKEY_DSA1,
650 .pkey_base_id = EVP_PKEY_DSA,
651 .pkey_flags = ASN1_PKEY_ALIAS
652 },
653
654 {
655 .pkey_id = EVP_PKEY_DSA4,
656 .pkey_base_id = EVP_PKEY_DSA,
657 .pkey_flags = ASN1_PKEY_ALIAS
658 },
659
660 {
661 .pkey_id = EVP_PKEY_DSA3,
662 .pkey_base_id = EVP_PKEY_DSA,
663 .pkey_flags = ASN1_PKEY_ALIAS
664 },
665
666 {
667 .pkey_id = EVP_PKEY_DSA,
668 .pkey_base_id = EVP_PKEY_DSA,
669
670 .pem_str = "DSA",
671 .info = "OpenSSL DSA method",
672
673 .pub_decode = dsa_pub_decode,
674 .pub_encode = dsa_pub_encode,
675 .pub_cmp = dsa_pub_cmp,
676 .pub_print = dsa_pub_print,
677
678 .priv_decode = dsa_priv_decode,
679 .priv_encode = dsa_priv_encode,
680 .priv_print = dsa_priv_print,
681
682 .pkey_size = int_dsa_size,
683 .pkey_bits = dsa_bits,
684
685 .param_decode = dsa_param_decode,
686 .param_encode = dsa_param_encode,
687 .param_missing = dsa_missing_parameters,
688 .param_copy = dsa_copy_parameters,
689 .param_cmp = dsa_cmp_parameters,
690 .param_print = dsa_param_print,
691 .sig_print = dsa_sig_print,
692
693 .pkey_free = int_dsa_free,
694 .pkey_ctrl = dsa_pkey_ctrl,
695 .old_priv_decode = old_dsa_priv_decode,
696 .old_priv_encode = old_dsa_priv_encode
697 }
698};
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-05-07 19:55:49 +0000