5ce93396cf439c637ccd77c5afece46553834139
[openssl.git] / crypto / dsa / dsa_meth.c
1 /*
2  * Copyright 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 /*
11  * Licensed under the OpenSSL licenses, (the "License");
12  * you may not use this file except in compliance with the License.
13  * You may obtain a copy of the License at
14  * https://www.openssl.org/source/license.html
15  * or in the file LICENSE in the source distribution.
16  */
17
18 #include "dsa_locl.h"
19 #include <string.h>
20 #include <openssl/err.h>
21
22 DSA_METHOD *DSA_meth_new(const char *name, int flags)
23 {
24     DSA_METHOD *dsam = OPENSSL_zalloc(sizeof(DSA_METHOD));
25
26     if (dsam != NULL) {
27         dsam->name = OPENSSL_strdup(name);
28         if (dsam->name == NULL) {
29             OPENSSL_free(dsam);
30             DSAerr(DSA_F_DSA_METH_NEW, ERR_R_MALLOC_FAILURE);
31             return NULL;
32         }
33         dsam->flags = flags;
34     }
35
36     return dsam;
37 }
38
39 void DSA_meth_free(DSA_METHOD *dsam)
40 {
41     if (dsam != NULL) {
42         if (dsam->name != NULL)
43             OPENSSL_free(dsam->name);
44         OPENSSL_free(dsam);
45     }
46 }
47
48 DSA_METHOD *DSA_meth_dup(const DSA_METHOD *dsam)
49 {
50     DSA_METHOD *ret;
51
52     ret = OPENSSL_malloc(sizeof(DSA_METHOD));
53
54     if (ret != NULL) {
55         memcpy(ret, dsam, sizeof(*dsam));
56         ret->name = OPENSSL_strdup(dsam->name);
57         if (ret->name == NULL) {
58             OPENSSL_free(ret);
59             DSAerr(DSA_F_DSA_METH_DUP, ERR_R_MALLOC_FAILURE);
60             return NULL;
61         }
62     }
63
64     return ret;
65 }
66
67 const char *DSA_meth_get0_name(const DSA_METHOD *dsam)
68 {
69     return dsam->name;
70 }
71
72 int DSA_meth_set1_name(DSA_METHOD *dsam, const char *name)
73 {
74     char *tmpname;
75
76     tmpname = OPENSSL_strdup(name);
77     if (tmpname == NULL) {
78         DSAerr(DSA_F_DSA_METH_SET1_NAME, ERR_R_MALLOC_FAILURE);
79         return 0;
80     }
81
82     OPENSSL_free(dsam->name);
83     dsam->name = tmpname;
84
85     return 1;
86 }
87
88 int DSA_meth_get_flags(DSA_METHOD *dsam)
89 {
90     return dsam->flags;
91 }
92
93 int DSA_meth_set_flags(DSA_METHOD *dsam, int flags)
94 {
95     dsam->flags = flags;
96     return 1;
97 }
98
99 void *DSA_meth_get0_app_data(const DSA_METHOD *dsam)
100 {
101     return dsam->app_data;
102 }
103
104 int DSA_meth_set0_app_data(DSA_METHOD *dsam, void *app_data)
105 {
106     dsam->app_data = app_data;
107     return 1;
108 }
109
110 DSA_SIG *(*DSA_meth_get_sign(const DSA_METHOD *dsam))
111         (const unsigned char *, int, DSA *)
112 {
113     return dsam->dsa_do_sign;
114 }
115
116 int DSA_meth_set_sign(DSA_METHOD *dsam,
117                        DSA_SIG *(*sign) (const unsigned char *, int, DSA *))
118 {
119     dsam->dsa_do_sign = sign;
120     return 1;
121 }
122
123 int (*DSA_meth_get_sign_setup(const DSA_METHOD *dsam))
124         (DSA *, BN_CTX *, BIGNUM **, BIGNUM **)
125 {
126     return dsam->dsa_sign_setup;
127 }
128
129 int DSA_meth_set_sign_setup(DSA_METHOD *dsam,
130         int (*sign_setup) (DSA *, BN_CTX *, BIGNUM **, BIGNUM **))
131 {
132     dsam->dsa_sign_setup = sign_setup;
133     return 1;
134 }
135
136 int (*DSA_meth_get_verify(const DSA_METHOD *dsam))
137         (const unsigned char *, int , DSA_SIG *, DSA *)
138 {
139     return dsam->dsa_do_verify;
140 }
141
142 int DSA_meth_set_verify(DSA_METHOD *dsam,
143     int (*verify) (const unsigned char *, int, DSA_SIG *, DSA *))
144 {
145     dsam->dsa_do_verify = verify;
146     return 1;
147 }
148
149 int (*DSA_meth_get_mod_exp(const DSA_METHOD *dsam))
150         (DSA *, BIGNUM *, BIGNUM *, BIGNUM *, BIGNUM *, BIGNUM *, BIGNUM *,
151          BN_CTX *, BN_MONT_CTX *)
152 {
153     return dsam->dsa_mod_exp;
154 }
155
156 int DSA_meth_set_mod_exp(DSA_METHOD *dsam,
157     int (*mod_exp) (DSA *, BIGNUM *, BIGNUM *, BIGNUM *, BIGNUM *, BIGNUM *,
158                     BIGNUM *, BN_CTX *, BN_MONT_CTX *))
159 {
160     dsam->dsa_mod_exp = mod_exp;
161     return 1;
162 }
163
164 int (*DSA_meth_get_bn_mod_exp(const DSA_METHOD *dsam))
165     (DSA *, BIGNUM *, BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *,
166      BN_MONT_CTX *)
167 {
168     return dsam->bn_mod_exp;
169 }
170
171 int DSA_meth_set_bn_mod_exp(DSA_METHOD *dsam,
172     int (*bn_mod_exp) (DSA *, BIGNUM *, BIGNUM *, const BIGNUM *,
173                        const BIGNUM *, BN_CTX *, BN_MONT_CTX *))
174 {
175     dsam->bn_mod_exp = bn_mod_exp;
176     return 1;
177 }
178
179 int (*DSA_meth_get_init(const DSA_METHOD *dsam))(DSA *)
180 {
181     return dsam->init;
182 }
183
184 int DSA_meth_set_init(DSA_METHOD *dsam, int (*init)(DSA *))
185 {
186     dsam->init = init;
187     return 1;
188 }
189
190 int (*DSA_meth_get_finish(const DSA_METHOD *dsam)) (DSA *)
191 {
192     return dsam->finish;
193 }
194
195 int DSA_meth_set_finish(DSA_METHOD *dsam, int (*finish) (DSA *))
196 {
197     dsam->finish = finish;
198     return 1;
199 }
200
201 int (*DSA_meth_get_paramgen(const DSA_METHOD *dsam))
202         (DSA *, int, const unsigned char *, int, int *, unsigned long *,
203          BN_GENCB *)
204 {
205     return dsam->dsa_paramgen;
206 }
207
208 int DSA_meth_set_paramgen(DSA_METHOD *dsam,
209         int (*paramgen) (DSA *, int, const unsigned char *, int, int *,
210                          unsigned long *, BN_GENCB *))
211 {
212     dsam->dsa_paramgen = paramgen;
213     return 1;
214 }
215
216 int (*DSA_meth_get_keygen(const DSA_METHOD *dsam)) (DSA *)
217 {
218     return dsam->dsa_keygen;
219 }
220
221 int DSA_meth_set_keygen(DSA_METHOD *dsam, int (*keygen) (DSA *))
222 {
223     dsam->dsa_keygen = keygen;
224     return 1;
225 }