diff options
author | tb <> | 2023-08-11 13:57:24 +0000 |
---|---|---|
committer | tb <> | 2023-08-11 13:57:24 +0000 |
commit | 7bf985b2585d3c60a607e8ff8e3c261213a8dde3 (patch) | |
tree | dbf083621edfede4ae04f7171422bb7a3e2d64dd /src | |
parent | b0d988db635837f3218e3afae6b83c6a6091e0de (diff) | |
download | openbsd-7bf985b2585d3c60a607e8ff8e3c261213a8dde3.tar.gz openbsd-7bf985b2585d3c60a607e8ff8e3c261213a8dde3.tar.bz2 openbsd-7bf985b2585d3c60a607e8ff8e3c261213a8dde3.zip |
Improve variable names in {dh,dsa}_{pub,priv}_{de,en}code()
Use aint for the ASN1_INTEGER holding the key and astr for the ASN1_STRING
holding the parameters. This frees up key and params for their DER encoded
versions, matching the naming we use elsewhere much more closely.
ok jsing
Diffstat (limited to 'src')
-rw-r--r-- | src/lib/libcrypto/dh/dh_ameth.c | 114 | ||||
-rw-r--r-- | src/lib/libcrypto/dsa/dsa_ameth.c | 114 |
2 files changed, 114 insertions, 114 deletions
diff --git a/src/lib/libcrypto/dh/dh_ameth.c b/src/lib/libcrypto/dh/dh_ameth.c index c43ada8ed8..f0c20f9a43 100644 --- a/src/lib/libcrypto/dh/dh_ameth.c +++ b/src/lib/libcrypto/dh/dh_ameth.c | |||
@@ -1,4 +1,4 @@ | |||
1 | /* $OpenBSD: dh_ameth.c,v 1.35 2023/08/11 13:53:45 tb Exp $ */ | 1 | /* $OpenBSD: dh_ameth.c,v 1.36 2023/08/11 13:57:24 tb Exp $ */ |
2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL |
3 | * project 2006. | 3 | * project 2006. |
4 | */ | 4 | */ |
@@ -81,14 +81,14 @@ dh_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey) | |||
81 | X509_ALGOR *algor; | 81 | X509_ALGOR *algor; |
82 | int ptype; | 82 | int ptype; |
83 | const void *pval; | 83 | const void *pval; |
84 | const ASN1_STRING *params; | 84 | const ASN1_STRING *astr; |
85 | const unsigned char *key_der, *params_der, *p; | 85 | const unsigned char *key, *params, *p; |
86 | int key_len, params_len; | 86 | int key_len, params_len; |
87 | ASN1_INTEGER *key = NULL; | 87 | ASN1_INTEGER *aint = NULL; |
88 | DH *dh = NULL; | 88 | DH *dh = NULL; |
89 | int ret = 0; | 89 | int ret = 0; |
90 | 90 | ||
91 | if (!X509_PUBKEY_get0_param(NULL, &key_der, &key_len, &algor, pubkey)) | 91 | if (!X509_PUBKEY_get0_param(NULL, &key, &key_len, &algor, pubkey)) |
92 | goto err; | 92 | goto err; |
93 | X509_ALGOR_get0(NULL, &ptype, &pval, algor); | 93 | X509_ALGOR_get0(NULL, &ptype, &pval, algor); |
94 | 94 | ||
@@ -97,21 +97,21 @@ dh_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey) | |||
97 | goto err; | 97 | goto err; |
98 | } | 98 | } |
99 | 99 | ||
100 | params = pval; | 100 | astr = pval; |
101 | params_der = params->data; | 101 | params = astr->data; |
102 | params_len = params->length; | 102 | params_len = astr->length; |
103 | 103 | ||
104 | p = params_der; | 104 | p = params; |
105 | if ((dh = d2i_DHparams(NULL, &p, params_len)) == NULL) { | 105 | if ((dh = d2i_DHparams(NULL, &p, params_len)) == NULL) { |
106 | DHerror(DH_R_DECODE_ERROR); | 106 | DHerror(DH_R_DECODE_ERROR); |
107 | goto err; | 107 | goto err; |
108 | } | 108 | } |
109 | p = key_der; | 109 | p = key; |
110 | if ((key = d2i_ASN1_INTEGER(NULL, &p, key_len)) == NULL) { | 110 | if ((aint = d2i_ASN1_INTEGER(NULL, &p, key_len)) == NULL) { |
111 | DHerror(DH_R_DECODE_ERROR); | 111 | DHerror(DH_R_DECODE_ERROR); |
112 | goto err; | 112 | goto err; |
113 | } | 113 | } |
114 | if ((dh->pub_key = ASN1_INTEGER_to_BN(key, NULL)) == NULL) { | 114 | if ((dh->pub_key = ASN1_INTEGER_to_BN(aint, NULL)) == NULL) { |
115 | DHerror(DH_R_BN_DECODE_ERROR); | 115 | DHerror(DH_R_BN_DECODE_ERROR); |
116 | goto err; | 116 | goto err; |
117 | } | 117 | } |
@@ -123,7 +123,7 @@ dh_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey) | |||
123 | ret = 1; | 123 | ret = 1; |
124 | 124 | ||
125 | err: | 125 | err: |
126 | ASN1_INTEGER_free(key); | 126 | ASN1_INTEGER_free(aint); |
127 | DH_free(dh); | 127 | DH_free(dh); |
128 | 128 | ||
129 | return ret; | 129 | return ret; |
@@ -133,30 +133,30 @@ static int | |||
133 | dh_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey) | 133 | dh_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey) |
134 | { | 134 | { |
135 | const DH *dh = pkey->pkey.dh; | 135 | const DH *dh = pkey->pkey.dh; |
136 | ASN1_STRING *params = NULL; | 136 | ASN1_STRING *astr = NULL; |
137 | int ptype = V_ASN1_SEQUENCE; | 137 | int ptype = V_ASN1_SEQUENCE; |
138 | ASN1_INTEGER *key = NULL; | 138 | ASN1_INTEGER *aint = NULL; |
139 | ASN1_OBJECT *aobj; | 139 | ASN1_OBJECT *aobj; |
140 | unsigned char *params_der = NULL, *key_der = NULL; | 140 | unsigned char *params = NULL, *key = NULL; |
141 | int params_len = 0, key_len = 0; | 141 | int params_len = 0, key_len = 0; |
142 | int ret = 0; | 142 | int ret = 0; |
143 | 143 | ||
144 | if ((params_len = i2d_DHparams(dh, ¶ms_der)) <= 0) { | 144 | if ((params_len = i2d_DHparams(dh, ¶ms)) <= 0) { |
145 | DHerror(ERR_R_MALLOC_FAILURE); | 145 | DHerror(ERR_R_MALLOC_FAILURE); |
146 | params_len = 0; | 146 | params_len = 0; |
147 | goto err; | 147 | goto err; |
148 | } | 148 | } |
149 | if ((params = ASN1_STRING_new()) == NULL) { | 149 | if ((astr = ASN1_STRING_new()) == NULL) { |
150 | DHerror(ERR_R_MALLOC_FAILURE); | 150 | DHerror(ERR_R_MALLOC_FAILURE); |
151 | goto err; | 151 | goto err; |
152 | } | 152 | } |
153 | ASN1_STRING_set0(params, params_der, params_len); | 153 | ASN1_STRING_set0(astr, params, params_len); |
154 | params_der = NULL; | 154 | params = NULL; |
155 | params_len = 0; | 155 | params_len = 0; |
156 | 156 | ||
157 | if ((key = BN_to_ASN1_INTEGER(dh->pub_key, NULL)) == NULL) | 157 | if ((aint = BN_to_ASN1_INTEGER(dh->pub_key, NULL)) == NULL) |
158 | goto err; | 158 | goto err; |
159 | if ((key_len = i2d_ASN1_INTEGER(key, &key_der)) <= 0) { | 159 | if ((key_len = i2d_ASN1_INTEGER(aint, &key)) <= 0) { |
160 | DHerror(ERR_R_MALLOC_FAILURE); | 160 | DHerror(ERR_R_MALLOC_FAILURE); |
161 | key_len = 0; | 161 | key_len = 0; |
162 | goto err; | 162 | goto err; |
@@ -164,19 +164,19 @@ dh_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey) | |||
164 | 164 | ||
165 | if ((aobj = OBJ_nid2obj(EVP_PKEY_DH)) == NULL) | 165 | if ((aobj = OBJ_nid2obj(EVP_PKEY_DH)) == NULL) |
166 | goto err; | 166 | goto err; |
167 | if (!X509_PUBKEY_set0_param(pk, aobj, ptype, params, key_der, key_len)) | 167 | if (!X509_PUBKEY_set0_param(pk, aobj, ptype, astr, key, key_len)) |
168 | goto err; | 168 | goto err; |
169 | params = NULL; | 169 | astr = NULL; |
170 | key_der = NULL; | 170 | key = NULL; |
171 | key_len = 0; | 171 | key_len = 0; |
172 | 172 | ||
173 | ret = 1; | 173 | ret = 1; |
174 | 174 | ||
175 | err: | 175 | err: |
176 | ASN1_STRING_free(params); | 176 | ASN1_STRING_free(astr); |
177 | ASN1_INTEGER_free(key); | 177 | ASN1_INTEGER_free(aint); |
178 | freezero(params_der, params_len); | 178 | freezero(params, params_len); |
179 | freezero(key_der, key_len); | 179 | freezero(key, key_len); |
180 | 180 | ||
181 | return ret; | 181 | return ret; |
182 | } | 182 | } |
@@ -193,14 +193,14 @@ dh_priv_decode(EVP_PKEY *pkey, const PKCS8_PRIV_KEY_INFO *p8) | |||
193 | const X509_ALGOR *algor; | 193 | const X509_ALGOR *algor; |
194 | int ptype; | 194 | int ptype; |
195 | const void *pval; | 195 | const void *pval; |
196 | const ASN1_STRING *params; | 196 | const ASN1_STRING *astr; |
197 | const unsigned char *key_der, *params_der, *p; | 197 | const unsigned char *key, *params, *p; |
198 | int key_len, params_len; | 198 | int key_len, params_len; |
199 | ASN1_INTEGER *key = NULL; | 199 | ASN1_INTEGER *aint = NULL; |
200 | DH *dh = NULL; | 200 | DH *dh = NULL; |
201 | int ret = 0; | 201 | int ret = 0; |
202 | 202 | ||
203 | if (!PKCS8_pkey_get0(NULL, &key_der, &key_len, &algor, p8)) | 203 | if (!PKCS8_pkey_get0(NULL, &key, &key_len, &algor, p8)) |
204 | goto err; | 204 | goto err; |
205 | X509_ALGOR_get0(NULL, &ptype, &pval, algor); | 205 | X509_ALGOR_get0(NULL, &ptype, &pval, algor); |
206 | 206 | ||
@@ -209,21 +209,21 @@ dh_priv_decode(EVP_PKEY *pkey, const PKCS8_PRIV_KEY_INFO *p8) | |||
209 | goto err; | 209 | goto err; |
210 | } | 210 | } |
211 | 211 | ||
212 | params = pval; | 212 | astr = pval; |
213 | params_der = params->data; | 213 | params = astr->data; |
214 | params_len = params->length; | 214 | params_len = astr->length; |
215 | 215 | ||
216 | p = params_der; | 216 | p = params; |
217 | if ((dh = d2i_DHparams(NULL, &p, params_len)) == NULL) { | 217 | if ((dh = d2i_DHparams(NULL, &p, params_len)) == NULL) { |
218 | DHerror(DH_R_DECODE_ERROR); | 218 | DHerror(DH_R_DECODE_ERROR); |
219 | goto err; | 219 | goto err; |
220 | } | 220 | } |
221 | p = key_der; | 221 | p = key; |
222 | if ((key = d2i_ASN1_INTEGER(NULL, &p, key_len)) == NULL) { | 222 | if ((aint = d2i_ASN1_INTEGER(NULL, &p, key_len)) == NULL) { |
223 | DHerror(DH_R_DECODE_ERROR); | 223 | DHerror(DH_R_DECODE_ERROR); |
224 | goto err; | 224 | goto err; |
225 | } | 225 | } |
226 | if ((dh->priv_key = ASN1_INTEGER_to_BN(key, NULL)) == NULL) { | 226 | if ((dh->priv_key = ASN1_INTEGER_to_BN(aint, NULL)) == NULL) { |
227 | DHerror(DH_R_BN_DECODE_ERROR); | 227 | DHerror(DH_R_BN_DECODE_ERROR); |
228 | goto err; | 228 | goto err; |
229 | } | 229 | } |
@@ -237,7 +237,7 @@ dh_priv_decode(EVP_PKEY *pkey, const PKCS8_PRIV_KEY_INFO *p8) | |||
237 | ret = 1; | 237 | ret = 1; |
238 | 238 | ||
239 | err: | 239 | err: |
240 | ASN1_INTEGER_free(key); | 240 | ASN1_INTEGER_free(aint); |
241 | DH_free(dh); | 241 | DH_free(dh); |
242 | 242 | ||
243 | return ret; | 243 | return ret; |
@@ -247,32 +247,32 @@ static int | |||
247 | dh_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey) | 247 | dh_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey) |
248 | { | 248 | { |
249 | const DH *dh = pkey->pkey.dh; | 249 | const DH *dh = pkey->pkey.dh; |
250 | ASN1_STRING *params = NULL; | 250 | ASN1_STRING *astr = NULL; |
251 | int ptype = V_ASN1_SEQUENCE; | 251 | int ptype = V_ASN1_SEQUENCE; |
252 | ASN1_INTEGER *key = NULL; | 252 | ASN1_INTEGER *aint = NULL; |
253 | ASN1_OBJECT *aobj; | 253 | ASN1_OBJECT *aobj; |
254 | unsigned char *params_der = NULL, *key_der = NULL; | 254 | unsigned char *params = NULL, *key = NULL; |
255 | int params_len = 0, key_len = 0; | 255 | int params_len = 0, key_len = 0; |
256 | int ret = 0; | 256 | int ret = 0; |
257 | 257 | ||
258 | if ((params_len = i2d_DHparams(dh, ¶ms_der)) <= 0) { | 258 | if ((params_len = i2d_DHparams(dh, ¶ms)) <= 0) { |
259 | DHerror(ERR_R_MALLOC_FAILURE); | 259 | DHerror(ERR_R_MALLOC_FAILURE); |
260 | params_len = 0; | 260 | params_len = 0; |
261 | goto err; | 261 | goto err; |
262 | } | 262 | } |
263 | if ((params = ASN1_STRING_type_new(V_ASN1_SEQUENCE)) == NULL) { | 263 | if ((astr = ASN1_STRING_type_new(V_ASN1_SEQUENCE)) == NULL) { |
264 | DHerror(ERR_R_MALLOC_FAILURE); | 264 | DHerror(ERR_R_MALLOC_FAILURE); |
265 | goto err; | 265 | goto err; |
266 | } | 266 | } |
267 | ASN1_STRING_set0(params, params_der, params_len); | 267 | ASN1_STRING_set0(astr, params, params_len); |
268 | params_der = NULL; | 268 | params = NULL; |
269 | params_len = 0; | 269 | params_len = 0; |
270 | 270 | ||
271 | if ((key = BN_to_ASN1_INTEGER(dh->priv_key, NULL)) == NULL) { | 271 | if ((aint = BN_to_ASN1_INTEGER(dh->priv_key, NULL)) == NULL) { |
272 | DHerror(DH_R_BN_ERROR); | 272 | DHerror(DH_R_BN_ERROR); |
273 | goto err; | 273 | goto err; |
274 | } | 274 | } |
275 | if ((key_len = i2d_ASN1_INTEGER(key, &key_der)) <= 0) { | 275 | if ((key_len = i2d_ASN1_INTEGER(aint, &key)) <= 0) { |
276 | DHerror(ERR_R_MALLOC_FAILURE); | 276 | DHerror(ERR_R_MALLOC_FAILURE); |
277 | key_len = 0; | 277 | key_len = 0; |
278 | goto err; | 278 | goto err; |
@@ -280,19 +280,19 @@ dh_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey) | |||
280 | 280 | ||
281 | if ((aobj = OBJ_nid2obj(NID_dhKeyAgreement)) == NULL) | 281 | if ((aobj = OBJ_nid2obj(NID_dhKeyAgreement)) == NULL) |
282 | goto err; | 282 | goto err; |
283 | if (!PKCS8_pkey_set0(p8, aobj, 0, ptype, params, key_der, key_len)) | 283 | if (!PKCS8_pkey_set0(p8, aobj, 0, ptype, astr, key, key_len)) |
284 | goto err; | 284 | goto err; |
285 | params = NULL; | 285 | astr = NULL; |
286 | key_der = NULL; | 286 | key = NULL; |
287 | key_len = 0; | 287 | key_len = 0; |
288 | 288 | ||
289 | ret = 1; | 289 | ret = 1; |
290 | 290 | ||
291 | err: | 291 | err: |
292 | ASN1_STRING_free(params); | 292 | ASN1_STRING_free(astr); |
293 | ASN1_INTEGER_free(key); | 293 | ASN1_INTEGER_free(aint); |
294 | freezero(params_der, params_len); | 294 | freezero(params, params_len); |
295 | freezero(key_der, key_len); | 295 | freezero(key, key_len); |
296 | 296 | ||
297 | return ret; | 297 | return ret; |
298 | } | 298 | } |
diff --git a/src/lib/libcrypto/dsa/dsa_ameth.c b/src/lib/libcrypto/dsa/dsa_ameth.c index 529bab4d47..494bef3ce4 100644 --- a/src/lib/libcrypto/dsa/dsa_ameth.c +++ b/src/lib/libcrypto/dsa/dsa_ameth.c | |||
@@ -1,4 +1,4 @@ | |||
1 | /* $OpenBSD: dsa_ameth.c,v 1.50 2023/08/11 13:53:45 tb Exp $ */ | 1 | /* $OpenBSD: dsa_ameth.c,v 1.51 2023/08/11 13:57:24 tb Exp $ */ |
2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL |
3 | * project 2006. | 3 | * project 2006. |
4 | */ | 4 | */ |
@@ -78,23 +78,23 @@ dsa_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey) | |||
78 | X509_ALGOR *algor; | 78 | X509_ALGOR *algor; |
79 | int ptype; | 79 | int ptype; |
80 | const void *pval; | 80 | const void *pval; |
81 | const ASN1_STRING *params; | 81 | const ASN1_STRING *astr; |
82 | const unsigned char *key_der, *params_der, *p; | 82 | const unsigned char *key, *params, *p; |
83 | int key_len, params_len; | 83 | int key_len, params_len; |
84 | ASN1_INTEGER *key = NULL; | 84 | ASN1_INTEGER *aint = NULL; |
85 | DSA *dsa = NULL; | 85 | DSA *dsa = NULL; |
86 | int ret = 0; | 86 | int ret = 0; |
87 | 87 | ||
88 | if (!X509_PUBKEY_get0_param(NULL, &key_der, &key_len, &algor, pubkey)) | 88 | if (!X509_PUBKEY_get0_param(NULL, &key, &key_len, &algor, pubkey)) |
89 | goto err; | 89 | goto err; |
90 | X509_ALGOR_get0(NULL, &ptype, &pval, algor); | 90 | X509_ALGOR_get0(NULL, &ptype, &pval, algor); |
91 | 91 | ||
92 | if (ptype == V_ASN1_SEQUENCE) { | 92 | if (ptype == V_ASN1_SEQUENCE) { |
93 | params = pval; | 93 | astr = pval; |
94 | params_der = params->data; | 94 | params = astr->data; |
95 | params_len = params->length; | 95 | params_len = astr->length; |
96 | 96 | ||
97 | p = params_der; | 97 | p = params; |
98 | if ((dsa = d2i_DSAparams(NULL, &p, params_len)) == NULL) { | 98 | if ((dsa = d2i_DSAparams(NULL, &p, params_len)) == NULL) { |
99 | DSAerror(DSA_R_DECODE_ERROR); | 99 | DSAerror(DSA_R_DECODE_ERROR); |
100 | goto err; | 100 | goto err; |
@@ -109,12 +109,12 @@ dsa_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey) | |||
109 | goto err; | 109 | goto err; |
110 | } | 110 | } |
111 | 111 | ||
112 | p = key_der; | 112 | p = key; |
113 | if ((key = d2i_ASN1_INTEGER(NULL, &p, key_len)) == NULL) { | 113 | if ((aint = d2i_ASN1_INTEGER(NULL, &p, key_len)) == NULL) { |
114 | DSAerror(DSA_R_DECODE_ERROR); | 114 | DSAerror(DSA_R_DECODE_ERROR); |
115 | goto err; | 115 | goto err; |
116 | } | 116 | } |
117 | if ((dsa->pub_key = ASN1_INTEGER_to_BN(key, NULL)) == NULL) { | 117 | if ((dsa->pub_key = ASN1_INTEGER_to_BN(aint, NULL)) == NULL) { |
118 | DSAerror(DSA_R_BN_DECODE_ERROR); | 118 | DSAerror(DSA_R_BN_DECODE_ERROR); |
119 | goto err; | 119 | goto err; |
120 | } | 120 | } |
@@ -132,7 +132,7 @@ dsa_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey) | |||
132 | ret = 1; | 132 | ret = 1; |
133 | 133 | ||
134 | err: | 134 | err: |
135 | ASN1_INTEGER_free(key); | 135 | ASN1_INTEGER_free(aint); |
136 | DSA_free(dsa); | 136 | DSA_free(dsa); |
137 | 137 | ||
138 | return ret; | 138 | return ret; |
@@ -142,35 +142,35 @@ static int | |||
142 | dsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey) | 142 | dsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey) |
143 | { | 143 | { |
144 | const DSA *dsa = pkey->pkey.dsa; | 144 | const DSA *dsa = pkey->pkey.dsa; |
145 | ASN1_STRING *params = NULL; | 145 | ASN1_STRING *astr = NULL; |
146 | int ptype = V_ASN1_UNDEF; | 146 | int ptype = V_ASN1_UNDEF; |
147 | ASN1_INTEGER *key = NULL; | 147 | ASN1_INTEGER *aint = NULL; |
148 | ASN1_OBJECT *aobj; | 148 | ASN1_OBJECT *aobj; |
149 | unsigned char *params_der = NULL, *key_der = NULL; | 149 | unsigned char *params = NULL, *key = NULL; |
150 | int params_len = 0, key_len = 0; | 150 | int params_len = 0, key_len = 0; |
151 | int ret = 0; | 151 | int ret = 0; |
152 | 152 | ||
153 | if (pkey->save_parameters && dsa->p && dsa->q && dsa->g) { | 153 | if (pkey->save_parameters && dsa->p && dsa->q && dsa->g) { |
154 | if ((params_len = i2d_DSAparams(dsa, ¶ms_der)) <= 0) { | 154 | if ((params_len = i2d_DSAparams(dsa, ¶ms)) <= 0) { |
155 | DSAerror(ERR_R_MALLOC_FAILURE); | 155 | DSAerror(ERR_R_MALLOC_FAILURE); |
156 | params_len = 0; | 156 | params_len = 0; |
157 | goto err; | 157 | goto err; |
158 | } | 158 | } |
159 | if ((params = ASN1_STRING_new()) == NULL) { | 159 | if ((astr = ASN1_STRING_new()) == NULL) { |
160 | DSAerror(ERR_R_MALLOC_FAILURE); | 160 | DSAerror(ERR_R_MALLOC_FAILURE); |
161 | goto err; | 161 | goto err; |
162 | } | 162 | } |
163 | ASN1_STRING_set0(params, params_der, params_len); | 163 | ASN1_STRING_set0(astr, params, params_len); |
164 | params_der = NULL; | 164 | params = NULL; |
165 | params_len = 0; | 165 | params_len = 0; |
166 | ptype = V_ASN1_SEQUENCE; | 166 | ptype = V_ASN1_SEQUENCE; |
167 | } | 167 | } |
168 | 168 | ||
169 | if ((key = BN_to_ASN1_INTEGER(dsa->pub_key, NULL)) == NULL) { | 169 | if ((aint = BN_to_ASN1_INTEGER(dsa->pub_key, NULL)) == NULL) { |
170 | DSAerror(ERR_R_MALLOC_FAILURE); | 170 | DSAerror(ERR_R_MALLOC_FAILURE); |
171 | goto err; | 171 | goto err; |
172 | } | 172 | } |
173 | if ((key_len = i2d_ASN1_INTEGER(key, &key_der)) <= 0) { | 173 | if ((key_len = i2d_ASN1_INTEGER(aint, &key)) <= 0) { |
174 | DSAerror(ERR_R_MALLOC_FAILURE); | 174 | DSAerror(ERR_R_MALLOC_FAILURE); |
175 | key_len = 0; | 175 | key_len = 0; |
176 | goto err; | 176 | goto err; |
@@ -178,19 +178,19 @@ dsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey) | |||
178 | 178 | ||
179 | if ((aobj = OBJ_nid2obj(EVP_PKEY_DSA)) == NULL) | 179 | if ((aobj = OBJ_nid2obj(EVP_PKEY_DSA)) == NULL) |
180 | goto err; | 180 | goto err; |
181 | if (!X509_PUBKEY_set0_param(pk, aobj, ptype, params, key_der, key_len)) | 181 | if (!X509_PUBKEY_set0_param(pk, aobj, ptype, astr, key, key_len)) |
182 | goto err; | 182 | goto err; |
183 | params = NULL; | 183 | astr = NULL; |
184 | key_der = NULL; | 184 | key = NULL; |
185 | key_len = 0; | 185 | key_len = 0; |
186 | 186 | ||
187 | ret = 1; | 187 | ret = 1; |
188 | 188 | ||
189 | err: | 189 | err: |
190 | ASN1_STRING_free(params); | 190 | ASN1_STRING_free(astr); |
191 | ASN1_INTEGER_free(key); | 191 | ASN1_INTEGER_free(aint); |
192 | freezero(params_der, params_len); | 192 | freezero(params, params_len); |
193 | freezero(key_der, key_len); | 193 | freezero(key, key_len); |
194 | 194 | ||
195 | return ret; | 195 | return ret; |
196 | } | 196 | } |
@@ -205,15 +205,15 @@ dsa_priv_decode(EVP_PKEY *pkey, const PKCS8_PRIV_KEY_INFO *p8) | |||
205 | const X509_ALGOR *algor; | 205 | const X509_ALGOR *algor; |
206 | int ptype; | 206 | int ptype; |
207 | const void *pval; | 207 | const void *pval; |
208 | const ASN1_STRING *params; | 208 | const ASN1_STRING *astr; |
209 | const unsigned char *key_der, *params_der, *p; | 209 | const unsigned char *key, *params, *p; |
210 | int key_len, params_len; | 210 | int key_len, params_len; |
211 | ASN1_INTEGER *key = NULL; | 211 | ASN1_INTEGER *aint = NULL; |
212 | BN_CTX *ctx = NULL; | 212 | BN_CTX *ctx = NULL; |
213 | DSA *dsa = NULL; | 213 | DSA *dsa = NULL; |
214 | int ret = 0; | 214 | int ret = 0; |
215 | 215 | ||
216 | if (!PKCS8_pkey_get0(NULL, &key_der, &key_len, &algor, p8)) | 216 | if (!PKCS8_pkey_get0(NULL, &key, &key_len, &algor, p8)) |
217 | goto err; | 217 | goto err; |
218 | X509_ALGOR_get0(NULL, &ptype, &pval, algor); | 218 | X509_ALGOR_get0(NULL, &ptype, &pval, algor); |
219 | 219 | ||
@@ -222,21 +222,21 @@ dsa_priv_decode(EVP_PKEY *pkey, const PKCS8_PRIV_KEY_INFO *p8) | |||
222 | goto err; | 222 | goto err; |
223 | } | 223 | } |
224 | 224 | ||
225 | params = pval; | 225 | astr = pval; |
226 | params_der = params->data; | 226 | params = astr->data; |
227 | params_len = params->length; | 227 | params_len = astr->length; |
228 | 228 | ||
229 | p = params_der; | 229 | p = params; |
230 | if ((dsa = d2i_DSAparams(NULL, &p, params_len)) == NULL) { | 230 | if ((dsa = d2i_DSAparams(NULL, &p, params_len)) == NULL) { |
231 | DSAerror(DSA_R_DECODE_ERROR); | 231 | DSAerror(DSA_R_DECODE_ERROR); |
232 | goto err; | 232 | goto err; |
233 | } | 233 | } |
234 | p = key_der; | 234 | p = key; |
235 | if ((key = d2i_ASN1_INTEGER(NULL, &p, key_len)) == NULL) { | 235 | if ((aint = d2i_ASN1_INTEGER(NULL, &p, key_len)) == NULL) { |
236 | DSAerror(DSA_R_DECODE_ERROR); | 236 | DSAerror(DSA_R_DECODE_ERROR); |
237 | goto err; | 237 | goto err; |
238 | } | 238 | } |
239 | if ((dsa->priv_key = ASN1_INTEGER_to_BN(key, NULL)) == NULL) { | 239 | if ((dsa->priv_key = ASN1_INTEGER_to_BN(aint, NULL)) == NULL) { |
240 | DSAerror(DSA_R_BN_DECODE_ERROR); | 240 | DSAerror(DSA_R_BN_DECODE_ERROR); |
241 | goto err; | 241 | goto err; |
242 | } | 242 | } |
@@ -273,7 +273,7 @@ dsa_priv_decode(EVP_PKEY *pkey, const PKCS8_PRIV_KEY_INFO *p8) | |||
273 | DSA_free(dsa); | 273 | DSA_free(dsa); |
274 | BN_CTX_end(ctx); | 274 | BN_CTX_end(ctx); |
275 | BN_CTX_free(ctx); | 275 | BN_CTX_free(ctx); |
276 | ASN1_INTEGER_free(key); | 276 | ASN1_INTEGER_free(aint); |
277 | 277 | ||
278 | return ret; | 278 | return ret; |
279 | } | 279 | } |
@@ -282,32 +282,32 @@ static int | |||
282 | dsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey) | 282 | dsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey) |
283 | { | 283 | { |
284 | const DSA *dsa = pkey->pkey.dsa; | 284 | const DSA *dsa = pkey->pkey.dsa; |
285 | ASN1_STRING *params = NULL; | 285 | ASN1_STRING *astr = NULL; |
286 | int ptype = V_ASN1_SEQUENCE; | 286 | int ptype = V_ASN1_SEQUENCE; |
287 | ASN1_INTEGER *key = NULL; | 287 | ASN1_INTEGER *aint = NULL; |
288 | ASN1_OBJECT *aobj; | 288 | ASN1_OBJECT *aobj; |
289 | unsigned char *params_der = NULL, *key_der = NULL; | 289 | unsigned char *params = NULL, *key = NULL; |
290 | int params_len = 0, key_len = 0; | 290 | int params_len = 0, key_len = 0; |
291 | int ret = 0; | 291 | int ret = 0; |
292 | 292 | ||
293 | if ((params_len = i2d_DSAparams(dsa, ¶ms_der)) <= 0) { | 293 | if ((params_len = i2d_DSAparams(dsa, ¶ms)) <= 0) { |
294 | DSAerror(ERR_R_MALLOC_FAILURE); | 294 | DSAerror(ERR_R_MALLOC_FAILURE); |
295 | params_len = 0; | 295 | params_len = 0; |
296 | goto err; | 296 | goto err; |
297 | } | 297 | } |
298 | if ((params = ASN1_STRING_type_new(V_ASN1_SEQUENCE)) == NULL) { | 298 | if ((astr = ASN1_STRING_type_new(V_ASN1_SEQUENCE)) == NULL) { |
299 | DSAerror(ERR_R_MALLOC_FAILURE); | 299 | DSAerror(ERR_R_MALLOC_FAILURE); |
300 | goto err; | 300 | goto err; |
301 | } | 301 | } |
302 | ASN1_STRING_set0(params, params_der, params_len); | 302 | ASN1_STRING_set0(astr, params, params_len); |
303 | params_der = NULL; | 303 | params = NULL; |
304 | params_len = 0; | 304 | params_len = 0; |
305 | 305 | ||
306 | if ((key = BN_to_ASN1_INTEGER(dsa->priv_key, NULL)) == NULL) { | 306 | if ((aint = BN_to_ASN1_INTEGER(dsa->priv_key, NULL)) == NULL) { |
307 | DSAerror(DSA_R_BN_ERROR); | 307 | DSAerror(DSA_R_BN_ERROR); |
308 | goto err; | 308 | goto err; |
309 | } | 309 | } |
310 | if ((key_len = i2d_ASN1_INTEGER(key, &key_der)) <= 0) { | 310 | if ((key_len = i2d_ASN1_INTEGER(aint, &key)) <= 0) { |
311 | DSAerror(ERR_R_MALLOC_FAILURE); | 311 | DSAerror(ERR_R_MALLOC_FAILURE); |
312 | key_len = 0; | 312 | key_len = 0; |
313 | goto err; | 313 | goto err; |
@@ -315,19 +315,19 @@ dsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey) | |||
315 | 315 | ||
316 | if ((aobj = OBJ_nid2obj(NID_dsa)) == NULL) | 316 | if ((aobj = OBJ_nid2obj(NID_dsa)) == NULL) |
317 | goto err; | 317 | goto err; |
318 | if (!PKCS8_pkey_set0(p8, aobj, 0, ptype, params, key_der, key_len)) | 318 | if (!PKCS8_pkey_set0(p8, aobj, 0, ptype, astr, key, key_len)) |
319 | goto err; | 319 | goto err; |
320 | params = NULL; | 320 | astr = NULL; |
321 | key_der = NULL; | 321 | key = NULL; |
322 | key_len = 0; | 322 | key_len = 0; |
323 | 323 | ||
324 | ret = 1; | 324 | ret = 1; |
325 | 325 | ||
326 | err: | 326 | err: |
327 | ASN1_STRING_free(params); | 327 | ASN1_STRING_free(astr); |
328 | ASN1_INTEGER_free(key); | 328 | ASN1_INTEGER_free(aint); |
329 | freezero(params_der, params_len); | 329 | freezero(params, params_len); |
330 | freezero(key_der, key_len); | 330 | freezero(key, key_len); |
331 | 331 | ||
332 | return ret; | 332 | return ret; |
333 | } | 333 | } |