|
sl@0
|
1 |
/* evp_pkey.c */
|
|
sl@0
|
2 |
/* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL
|
|
sl@0
|
3 |
* project 1999.
|
|
sl@0
|
4 |
*/
|
|
sl@0
|
5 |
/* ====================================================================
|
|
sl@0
|
6 |
* Copyright (c) 1999-2002 The OpenSSL Project. All rights reserved.
|
|
sl@0
|
7 |
*
|
|
sl@0
|
8 |
* Redistribution and use in source and binary forms, with or without
|
|
sl@0
|
9 |
* modification, are permitted provided that the following conditions
|
|
sl@0
|
10 |
* are met:
|
|
sl@0
|
11 |
*
|
|
sl@0
|
12 |
* 1. Redistributions of source code must retain the above copyright
|
|
sl@0
|
13 |
* notice, this list of conditions and the following disclaimer.
|
|
sl@0
|
14 |
*
|
|
sl@0
|
15 |
* 2. Redistributions in binary form must reproduce the above copyright
|
|
sl@0
|
16 |
* notice, this list of conditions and the following disclaimer in
|
|
sl@0
|
17 |
* the documentation and/or other materials provided with the
|
|
sl@0
|
18 |
* distribution.
|
|
sl@0
|
19 |
*
|
|
sl@0
|
20 |
* 3. All advertising materials mentioning features or use of this
|
|
sl@0
|
21 |
* software must display the following acknowledgment:
|
|
sl@0
|
22 |
* "This product includes software developed by the OpenSSL Project
|
|
sl@0
|
23 |
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
|
|
sl@0
|
24 |
*
|
|
sl@0
|
25 |
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
|
|
sl@0
|
26 |
* endorse or promote products derived from this software without
|
|
sl@0
|
27 |
* prior written permission. For written permission, please contact
|
|
sl@0
|
28 |
* licensing@OpenSSL.org.
|
|
sl@0
|
29 |
*
|
|
sl@0
|
30 |
* 5. Products derived from this software may not be called "OpenSSL"
|
|
sl@0
|
31 |
* nor may "OpenSSL" appear in their names without prior written
|
|
sl@0
|
32 |
* permission of the OpenSSL Project.
|
|
sl@0
|
33 |
*
|
|
sl@0
|
34 |
* 6. Redistributions of any form whatsoever must retain the following
|
|
sl@0
|
35 |
* acknowledgment:
|
|
sl@0
|
36 |
* "This product includes software developed by the OpenSSL Project
|
|
sl@0
|
37 |
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
|
|
sl@0
|
38 |
*
|
|
sl@0
|
39 |
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
|
|
sl@0
|
40 |
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
sl@0
|
41 |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
sl@0
|
42 |
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
|
|
sl@0
|
43 |
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
sl@0
|
44 |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
sl@0
|
45 |
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
sl@0
|
46 |
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
sl@0
|
47 |
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
sl@0
|
48 |
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
sl@0
|
49 |
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|
sl@0
|
50 |
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
sl@0
|
51 |
* ====================================================================
|
|
sl@0
|
52 |
*
|
|
sl@0
|
53 |
* This product includes cryptographic software written by Eric Young
|
|
sl@0
|
54 |
* (eay@cryptsoft.com). This product includes software written by Tim
|
|
sl@0
|
55 |
* Hudson (tjh@cryptsoft.com).
|
|
sl@0
|
56 |
*
|
|
sl@0
|
57 |
*/
|
|
sl@0
|
58 |
|
|
sl@0
|
59 |
#include <stdio.h>
|
|
sl@0
|
60 |
#include <stdlib.h>
|
|
sl@0
|
61 |
#include "cryptlib.h"
|
|
sl@0
|
62 |
#include <openssl/x509.h>
|
|
sl@0
|
63 |
#include <openssl/rand.h>
|
|
sl@0
|
64 |
#ifndef OPENSSL_NO_RSA
|
|
sl@0
|
65 |
#include <openssl/rsa.h>
|
|
sl@0
|
66 |
#endif
|
|
sl@0
|
67 |
#ifndef OPENSSL_NO_DSA
|
|
sl@0
|
68 |
#include <openssl/dsa.h>
|
|
sl@0
|
69 |
#endif
|
|
sl@0
|
70 |
#include <openssl/bn.h>
|
|
sl@0
|
71 |
|
|
sl@0
|
72 |
#ifndef OPENSSL_NO_DSA
|
|
sl@0
|
73 |
static int dsa_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8inf, EVP_PKEY *pkey);
|
|
sl@0
|
74 |
#endif
|
|
sl@0
|
75 |
#ifndef OPENSSL_NO_EC
|
|
sl@0
|
76 |
static int eckey_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8inf, EVP_PKEY *pkey);
|
|
sl@0
|
77 |
#endif
|
|
sl@0
|
78 |
|
|
sl@0
|
79 |
/* Extract a private key from a PKCS8 structure */
|
|
sl@0
|
80 |
|
|
sl@0
|
81 |
EXPORT_C EVP_PKEY *EVP_PKCS82PKEY(PKCS8_PRIV_KEY_INFO *p8)
|
|
sl@0
|
82 |
{
|
|
sl@0
|
83 |
EVP_PKEY *pkey = NULL;
|
|
sl@0
|
84 |
#ifndef OPENSSL_NO_RSA
|
|
sl@0
|
85 |
RSA *rsa = NULL;
|
|
sl@0
|
86 |
#endif
|
|
sl@0
|
87 |
#ifndef OPENSSL_NO_DSA
|
|
sl@0
|
88 |
DSA *dsa = NULL;
|
|
sl@0
|
89 |
ASN1_TYPE *t1, *t2;
|
|
sl@0
|
90 |
ASN1_INTEGER *privkey;
|
|
sl@0
|
91 |
STACK_OF(ASN1_TYPE) *ndsa = NULL;
|
|
sl@0
|
92 |
#endif
|
|
sl@0
|
93 |
#ifndef OPENSSL_NO_EC
|
|
sl@0
|
94 |
EC_KEY *eckey = NULL;
|
|
sl@0
|
95 |
const unsigned char *p_tmp;
|
|
sl@0
|
96 |
#endif
|
|
sl@0
|
97 |
#if !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_EC)
|
|
sl@0
|
98 |
ASN1_TYPE *param = NULL;
|
|
sl@0
|
99 |
BN_CTX *ctx = NULL;
|
|
sl@0
|
100 |
int plen;
|
|
sl@0
|
101 |
#endif
|
|
sl@0
|
102 |
X509_ALGOR *a;
|
|
sl@0
|
103 |
const unsigned char *p;
|
|
sl@0
|
104 |
const unsigned char *cp;
|
|
sl@0
|
105 |
int pkeylen;
|
|
sl@0
|
106 |
int nid;
|
|
sl@0
|
107 |
char obj_tmp[80];
|
|
sl@0
|
108 |
|
|
sl@0
|
109 |
if(p8->pkey->type == V_ASN1_OCTET_STRING) {
|
|
sl@0
|
110 |
p8->broken = PKCS8_OK;
|
|
sl@0
|
111 |
p = p8->pkey->value.octet_string->data;
|
|
sl@0
|
112 |
pkeylen = p8->pkey->value.octet_string->length;
|
|
sl@0
|
113 |
} else {
|
|
sl@0
|
114 |
p8->broken = PKCS8_NO_OCTET;
|
|
sl@0
|
115 |
p = p8->pkey->value.sequence->data;
|
|
sl@0
|
116 |
pkeylen = p8->pkey->value.sequence->length;
|
|
sl@0
|
117 |
}
|
|
sl@0
|
118 |
if (!(pkey = EVP_PKEY_new())) {
|
|
sl@0
|
119 |
EVPerr(EVP_F_EVP_PKCS82PKEY,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
120 |
return NULL;
|
|
sl@0
|
121 |
}
|
|
sl@0
|
122 |
a = p8->pkeyalg;
|
|
sl@0
|
123 |
nid = OBJ_obj2nid(a->algorithm);
|
|
sl@0
|
124 |
switch(nid)
|
|
sl@0
|
125 |
{
|
|
sl@0
|
126 |
#ifndef OPENSSL_NO_RSA
|
|
sl@0
|
127 |
case NID_rsaEncryption:
|
|
sl@0
|
128 |
cp = p;
|
|
sl@0
|
129 |
if (!(rsa = d2i_RSAPrivateKey (NULL,&cp, pkeylen))) {
|
|
sl@0
|
130 |
EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);
|
|
sl@0
|
131 |
return NULL;
|
|
sl@0
|
132 |
}
|
|
sl@0
|
133 |
EVP_PKEY_assign_RSA (pkey, rsa);
|
|
sl@0
|
134 |
break;
|
|
sl@0
|
135 |
#endif
|
|
sl@0
|
136 |
#ifndef OPENSSL_NO_DSA
|
|
sl@0
|
137 |
case NID_dsa:
|
|
sl@0
|
138 |
/* PKCS#8 DSA is weird: you just get a private key integer
|
|
sl@0
|
139 |
* and parameters in the AlgorithmIdentifier the pubkey must
|
|
sl@0
|
140 |
* be recalculated.
|
|
sl@0
|
141 |
*/
|
|
sl@0
|
142 |
|
|
sl@0
|
143 |
/* Check for broken DSA PKCS#8, UGH! */
|
|
sl@0
|
144 |
if(*p == (V_ASN1_SEQUENCE|V_ASN1_CONSTRUCTED)) {
|
|
sl@0
|
145 |
if(!(ndsa = ASN1_seq_unpack_ASN1_TYPE(p, pkeylen,
|
|
sl@0
|
146 |
d2i_ASN1_TYPE,
|
|
sl@0
|
147 |
ASN1_TYPE_free))) {
|
|
sl@0
|
148 |
EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);
|
|
sl@0
|
149 |
goto dsaerr;
|
|
sl@0
|
150 |
}
|
|
sl@0
|
151 |
if(sk_ASN1_TYPE_num(ndsa) != 2 ) {
|
|
sl@0
|
152 |
EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);
|
|
sl@0
|
153 |
goto dsaerr;
|
|
sl@0
|
154 |
}
|
|
sl@0
|
155 |
/* Handle Two broken types:
|
|
sl@0
|
156 |
* SEQUENCE {parameters, priv_key}
|
|
sl@0
|
157 |
* SEQUENCE {pub_key, priv_key}
|
|
sl@0
|
158 |
*/
|
|
sl@0
|
159 |
|
|
sl@0
|
160 |
t1 = sk_ASN1_TYPE_value(ndsa, 0);
|
|
sl@0
|
161 |
t2 = sk_ASN1_TYPE_value(ndsa, 1);
|
|
sl@0
|
162 |
if(t1->type == V_ASN1_SEQUENCE) {
|
|
sl@0
|
163 |
p8->broken = PKCS8_EMBEDDED_PARAM;
|
|
sl@0
|
164 |
param = t1;
|
|
sl@0
|
165 |
} else if(a->parameter->type == V_ASN1_SEQUENCE) {
|
|
sl@0
|
166 |
p8->broken = PKCS8_NS_DB;
|
|
sl@0
|
167 |
param = a->parameter;
|
|
sl@0
|
168 |
} else {
|
|
sl@0
|
169 |
EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);
|
|
sl@0
|
170 |
goto dsaerr;
|
|
sl@0
|
171 |
}
|
|
sl@0
|
172 |
|
|
sl@0
|
173 |
if(t2->type != V_ASN1_INTEGER) {
|
|
sl@0
|
174 |
EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);
|
|
sl@0
|
175 |
goto dsaerr;
|
|
sl@0
|
176 |
}
|
|
sl@0
|
177 |
privkey = t2->value.integer;
|
|
sl@0
|
178 |
} else {
|
|
sl@0
|
179 |
if (!(privkey=d2i_ASN1_INTEGER (NULL, &p, pkeylen))) {
|
|
sl@0
|
180 |
EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);
|
|
sl@0
|
181 |
goto dsaerr;
|
|
sl@0
|
182 |
}
|
|
sl@0
|
183 |
param = p8->pkeyalg->parameter;
|
|
sl@0
|
184 |
}
|
|
sl@0
|
185 |
if (!param || (param->type != V_ASN1_SEQUENCE)) {
|
|
sl@0
|
186 |
EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);
|
|
sl@0
|
187 |
goto dsaerr;
|
|
sl@0
|
188 |
}
|
|
sl@0
|
189 |
cp = p = param->value.sequence->data;
|
|
sl@0
|
190 |
plen = param->value.sequence->length;
|
|
sl@0
|
191 |
if (!(dsa = d2i_DSAparams (NULL, &cp, plen))) {
|
|
sl@0
|
192 |
EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);
|
|
sl@0
|
193 |
goto dsaerr;
|
|
sl@0
|
194 |
}
|
|
sl@0
|
195 |
/* We have parameters now set private key */
|
|
sl@0
|
196 |
if (!(dsa->priv_key = ASN1_INTEGER_to_BN(privkey, NULL))) {
|
|
sl@0
|
197 |
EVPerr(EVP_F_EVP_PKCS82PKEY,EVP_R_BN_DECODE_ERROR);
|
|
sl@0
|
198 |
goto dsaerr;
|
|
sl@0
|
199 |
}
|
|
sl@0
|
200 |
/* Calculate public key (ouch!) */
|
|
sl@0
|
201 |
if (!(dsa->pub_key = BN_new())) {
|
|
sl@0
|
202 |
EVPerr(EVP_F_EVP_PKCS82PKEY,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
203 |
goto dsaerr;
|
|
sl@0
|
204 |
}
|
|
sl@0
|
205 |
if (!(ctx = BN_CTX_new())) {
|
|
sl@0
|
206 |
EVPerr(EVP_F_EVP_PKCS82PKEY,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
207 |
goto dsaerr;
|
|
sl@0
|
208 |
}
|
|
sl@0
|
209 |
|
|
sl@0
|
210 |
if (!BN_mod_exp(dsa->pub_key, dsa->g,
|
|
sl@0
|
211 |
dsa->priv_key, dsa->p, ctx)) {
|
|
sl@0
|
212 |
|
|
sl@0
|
213 |
EVPerr(EVP_F_EVP_PKCS82PKEY,EVP_R_BN_PUBKEY_ERROR);
|
|
sl@0
|
214 |
goto dsaerr;
|
|
sl@0
|
215 |
}
|
|
sl@0
|
216 |
|
|
sl@0
|
217 |
EVP_PKEY_assign_DSA(pkey, dsa);
|
|
sl@0
|
218 |
BN_CTX_free (ctx);
|
|
sl@0
|
219 |
if(ndsa) sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);
|
|
sl@0
|
220 |
else ASN1_INTEGER_free(privkey);
|
|
sl@0
|
221 |
break;
|
|
sl@0
|
222 |
dsaerr:
|
|
sl@0
|
223 |
BN_CTX_free (ctx);
|
|
sl@0
|
224 |
sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);
|
|
sl@0
|
225 |
DSA_free(dsa);
|
|
sl@0
|
226 |
EVP_PKEY_free(pkey);
|
|
sl@0
|
227 |
return NULL;
|
|
sl@0
|
228 |
break;
|
|
sl@0
|
229 |
#endif
|
|
sl@0
|
230 |
#ifndef OPENSSL_NO_EC
|
|
sl@0
|
231 |
case NID_X9_62_id_ecPublicKey:
|
|
sl@0
|
232 |
p_tmp = p;
|
|
sl@0
|
233 |
/* extract the ec parameters */
|
|
sl@0
|
234 |
param = p8->pkeyalg->parameter;
|
|
sl@0
|
235 |
|
|
sl@0
|
236 |
if (!param || ((param->type != V_ASN1_SEQUENCE) &&
|
|
sl@0
|
237 |
(param->type != V_ASN1_OBJECT)))
|
|
sl@0
|
238 |
{
|
|
sl@0
|
239 |
EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);
|
|
sl@0
|
240 |
goto ecerr;
|
|
sl@0
|
241 |
}
|
|
sl@0
|
242 |
|
|
sl@0
|
243 |
if (param->type == V_ASN1_SEQUENCE)
|
|
sl@0
|
244 |
{
|
|
sl@0
|
245 |
cp = p = param->value.sequence->data;
|
|
sl@0
|
246 |
plen = param->value.sequence->length;
|
|
sl@0
|
247 |
|
|
sl@0
|
248 |
if (!(eckey = d2i_ECParameters(NULL, &cp, plen)))
|
|
sl@0
|
249 |
{
|
|
sl@0
|
250 |
EVPerr(EVP_F_EVP_PKCS82PKEY,
|
|
sl@0
|
251 |
EVP_R_DECODE_ERROR);
|
|
sl@0
|
252 |
goto ecerr;
|
|
sl@0
|
253 |
}
|
|
sl@0
|
254 |
}
|
|
sl@0
|
255 |
else
|
|
sl@0
|
256 |
{
|
|
sl@0
|
257 |
EC_GROUP *group;
|
|
sl@0
|
258 |
cp = p = param->value.object->data;
|
|
sl@0
|
259 |
plen = param->value.object->length;
|
|
sl@0
|
260 |
|
|
sl@0
|
261 |
/* type == V_ASN1_OBJECT => the parameters are given
|
|
sl@0
|
262 |
* by an asn1 OID
|
|
sl@0
|
263 |
*/
|
|
sl@0
|
264 |
if ((eckey = EC_KEY_new()) == NULL)
|
|
sl@0
|
265 |
{
|
|
sl@0
|
266 |
EVPerr(EVP_F_EVP_PKCS82PKEY,
|
|
sl@0
|
267 |
ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
268 |
goto ecerr;
|
|
sl@0
|
269 |
}
|
|
sl@0
|
270 |
group = EC_GROUP_new_by_curve_name(OBJ_obj2nid(a->parameter->value.object));
|
|
sl@0
|
271 |
if (group == NULL)
|
|
sl@0
|
272 |
goto ecerr;
|
|
sl@0
|
273 |
EC_GROUP_set_asn1_flag(group, OPENSSL_EC_NAMED_CURVE);
|
|
sl@0
|
274 |
if (EC_KEY_set_group(eckey, group) == 0)
|
|
sl@0
|
275 |
goto ecerr;
|
|
sl@0
|
276 |
EC_GROUP_free(group);
|
|
sl@0
|
277 |
}
|
|
sl@0
|
278 |
|
|
sl@0
|
279 |
/* We have parameters now set private key */
|
|
sl@0
|
280 |
if (!d2i_ECPrivateKey(&eckey, &p_tmp, pkeylen))
|
|
sl@0
|
281 |
{
|
|
sl@0
|
282 |
EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);
|
|
sl@0
|
283 |
goto ecerr;
|
|
sl@0
|
284 |
}
|
|
sl@0
|
285 |
|
|
sl@0
|
286 |
/* calculate public key (if necessary) */
|
|
sl@0
|
287 |
if (EC_KEY_get0_public_key(eckey) == NULL)
|
|
sl@0
|
288 |
{
|
|
sl@0
|
289 |
const BIGNUM *priv_key;
|
|
sl@0
|
290 |
const EC_GROUP *group;
|
|
sl@0
|
291 |
EC_POINT *pub_key;
|
|
sl@0
|
292 |
/* the public key was not included in the SEC1 private
|
|
sl@0
|
293 |
* key => calculate the public key */
|
|
sl@0
|
294 |
group = EC_KEY_get0_group(eckey);
|
|
sl@0
|
295 |
pub_key = EC_POINT_new(group);
|
|
sl@0
|
296 |
if (pub_key == NULL)
|
|
sl@0
|
297 |
{
|
|
sl@0
|
298 |
EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_EC_LIB);
|
|
sl@0
|
299 |
goto ecerr;
|
|
sl@0
|
300 |
}
|
|
sl@0
|
301 |
if (!EC_POINT_copy(pub_key, EC_GROUP_get0_generator(group)))
|
|
sl@0
|
302 |
{
|
|
sl@0
|
303 |
EC_POINT_free(pub_key);
|
|
sl@0
|
304 |
EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_EC_LIB);
|
|
sl@0
|
305 |
goto ecerr;
|
|
sl@0
|
306 |
}
|
|
sl@0
|
307 |
priv_key = EC_KEY_get0_private_key(eckey);
|
|
sl@0
|
308 |
if (!EC_POINT_mul(group, pub_key, priv_key, NULL, NULL, ctx))
|
|
sl@0
|
309 |
{
|
|
sl@0
|
310 |
EC_POINT_free(pub_key);
|
|
sl@0
|
311 |
EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_EC_LIB);
|
|
sl@0
|
312 |
goto ecerr;
|
|
sl@0
|
313 |
}
|
|
sl@0
|
314 |
if (EC_KEY_set_public_key(eckey, pub_key) == 0)
|
|
sl@0
|
315 |
{
|
|
sl@0
|
316 |
EC_POINT_free(pub_key);
|
|
sl@0
|
317 |
EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_EC_LIB);
|
|
sl@0
|
318 |
goto ecerr;
|
|
sl@0
|
319 |
}
|
|
sl@0
|
320 |
EC_POINT_free(pub_key);
|
|
sl@0
|
321 |
}
|
|
sl@0
|
322 |
|
|
sl@0
|
323 |
EVP_PKEY_assign_EC_KEY(pkey, eckey);
|
|
sl@0
|
324 |
if (ctx)
|
|
sl@0
|
325 |
BN_CTX_free(ctx);
|
|
sl@0
|
326 |
break;
|
|
sl@0
|
327 |
ecerr:
|
|
sl@0
|
328 |
if (ctx)
|
|
sl@0
|
329 |
BN_CTX_free(ctx);
|
|
sl@0
|
330 |
if (eckey)
|
|
sl@0
|
331 |
EC_KEY_free(eckey);
|
|
sl@0
|
332 |
if (pkey)
|
|
sl@0
|
333 |
EVP_PKEY_free(pkey);
|
|
sl@0
|
334 |
return NULL;
|
|
sl@0
|
335 |
#endif
|
|
sl@0
|
336 |
default:
|
|
sl@0
|
337 |
EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM);
|
|
sl@0
|
338 |
if (!a->algorithm) BUF_strlcpy (obj_tmp, "NULL", sizeof obj_tmp);
|
|
sl@0
|
339 |
else i2t_ASN1_OBJECT(obj_tmp, 80, a->algorithm);
|
|
sl@0
|
340 |
ERR_add_error_data(2, "TYPE=", obj_tmp);
|
|
sl@0
|
341 |
EVP_PKEY_free (pkey);
|
|
sl@0
|
342 |
return NULL;
|
|
sl@0
|
343 |
}
|
|
sl@0
|
344 |
return pkey;
|
|
sl@0
|
345 |
}
|
|
sl@0
|
346 |
|
|
sl@0
|
347 |
EXPORT_C PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8(EVP_PKEY *pkey)
|
|
sl@0
|
348 |
{
|
|
sl@0
|
349 |
return EVP_PKEY2PKCS8_broken(pkey, PKCS8_OK);
|
|
sl@0
|
350 |
}
|
|
sl@0
|
351 |
|
|
sl@0
|
352 |
/* Turn a private key into a PKCS8 structure */
|
|
sl@0
|
353 |
|
|
sl@0
|
354 |
EXPORT_C PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8_broken(EVP_PKEY *pkey, int broken)
|
|
sl@0
|
355 |
{
|
|
sl@0
|
356 |
PKCS8_PRIV_KEY_INFO *p8;
|
|
sl@0
|
357 |
|
|
sl@0
|
358 |
if (!(p8 = PKCS8_PRIV_KEY_INFO_new())) {
|
|
sl@0
|
359 |
EVPerr(EVP_F_EVP_PKEY2PKCS8_BROKEN,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
360 |
return NULL;
|
|
sl@0
|
361 |
}
|
|
sl@0
|
362 |
p8->broken = broken;
|
|
sl@0
|
363 |
if (!ASN1_INTEGER_set(p8->version, 0)) {
|
|
sl@0
|
364 |
EVPerr(EVP_F_EVP_PKEY2PKCS8_BROKEN,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
365 |
PKCS8_PRIV_KEY_INFO_free (p8);
|
|
sl@0
|
366 |
return NULL;
|
|
sl@0
|
367 |
}
|
|
sl@0
|
368 |
if (!(p8->pkeyalg->parameter = ASN1_TYPE_new ())) {
|
|
sl@0
|
369 |
EVPerr(EVP_F_EVP_PKEY2PKCS8_BROKEN,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
370 |
PKCS8_PRIV_KEY_INFO_free (p8);
|
|
sl@0
|
371 |
return NULL;
|
|
sl@0
|
372 |
}
|
|
sl@0
|
373 |
p8->pkey->type = V_ASN1_OCTET_STRING;
|
|
sl@0
|
374 |
switch (EVP_PKEY_type(pkey->type)) {
|
|
sl@0
|
375 |
#ifndef OPENSSL_NO_RSA
|
|
sl@0
|
376 |
case EVP_PKEY_RSA:
|
|
sl@0
|
377 |
|
|
sl@0
|
378 |
if(p8->broken == PKCS8_NO_OCTET) p8->pkey->type = V_ASN1_SEQUENCE;
|
|
sl@0
|
379 |
|
|
sl@0
|
380 |
p8->pkeyalg->algorithm = OBJ_nid2obj(NID_rsaEncryption);
|
|
sl@0
|
381 |
p8->pkeyalg->parameter->type = V_ASN1_NULL;
|
|
sl@0
|
382 |
if (!ASN1_pack_string_of (EVP_PKEY,pkey, i2d_PrivateKey,
|
|
sl@0
|
383 |
&p8->pkey->value.octet_string)) {
|
|
sl@0
|
384 |
EVPerr(EVP_F_EVP_PKEY2PKCS8_BROKEN,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
385 |
PKCS8_PRIV_KEY_INFO_free (p8);
|
|
sl@0
|
386 |
return NULL;
|
|
sl@0
|
387 |
}
|
|
sl@0
|
388 |
break;
|
|
sl@0
|
389 |
#endif
|
|
sl@0
|
390 |
#ifndef OPENSSL_NO_DSA
|
|
sl@0
|
391 |
case EVP_PKEY_DSA:
|
|
sl@0
|
392 |
if(!dsa_pkey2pkcs8(p8, pkey)) {
|
|
sl@0
|
393 |
PKCS8_PRIV_KEY_INFO_free (p8);
|
|
sl@0
|
394 |
return NULL;
|
|
sl@0
|
395 |
}
|
|
sl@0
|
396 |
|
|
sl@0
|
397 |
break;
|
|
sl@0
|
398 |
#endif
|
|
sl@0
|
399 |
#ifndef OPENSSL_NO_EC
|
|
sl@0
|
400 |
case EVP_PKEY_EC:
|
|
sl@0
|
401 |
if (!eckey_pkey2pkcs8(p8, pkey))
|
|
sl@0
|
402 |
{
|
|
sl@0
|
403 |
PKCS8_PRIV_KEY_INFO_free(p8);
|
|
sl@0
|
404 |
return(NULL);
|
|
sl@0
|
405 |
}
|
|
sl@0
|
406 |
break;
|
|
sl@0
|
407 |
#endif
|
|
sl@0
|
408 |
default:
|
|
sl@0
|
409 |
EVPerr(EVP_F_EVP_PKEY2PKCS8_BROKEN, EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM);
|
|
sl@0
|
410 |
PKCS8_PRIV_KEY_INFO_free (p8);
|
|
sl@0
|
411 |
return NULL;
|
|
sl@0
|
412 |
}
|
|
sl@0
|
413 |
RAND_add(p8->pkey->value.octet_string->data,
|
|
sl@0
|
414 |
p8->pkey->value.octet_string->length, 0.0);
|
|
sl@0
|
415 |
return p8;
|
|
sl@0
|
416 |
}
|
|
sl@0
|
417 |
|
|
sl@0
|
418 |
EXPORT_C PKCS8_PRIV_KEY_INFO *PKCS8_set_broken(PKCS8_PRIV_KEY_INFO *p8, int broken)
|
|
sl@0
|
419 |
{
|
|
sl@0
|
420 |
switch (broken) {
|
|
sl@0
|
421 |
|
|
sl@0
|
422 |
case PKCS8_OK:
|
|
sl@0
|
423 |
p8->broken = PKCS8_OK;
|
|
sl@0
|
424 |
return p8;
|
|
sl@0
|
425 |
break;
|
|
sl@0
|
426 |
|
|
sl@0
|
427 |
case PKCS8_NO_OCTET:
|
|
sl@0
|
428 |
p8->broken = PKCS8_NO_OCTET;
|
|
sl@0
|
429 |
p8->pkey->type = V_ASN1_SEQUENCE;
|
|
sl@0
|
430 |
return p8;
|
|
sl@0
|
431 |
break;
|
|
sl@0
|
432 |
|
|
sl@0
|
433 |
default:
|
|
sl@0
|
434 |
EVPerr(EVP_F_PKCS8_SET_BROKEN,EVP_R_PKCS8_UNKNOWN_BROKEN_TYPE);
|
|
sl@0
|
435 |
return NULL;
|
|
sl@0
|
436 |
}
|
|
sl@0
|
437 |
}
|
|
sl@0
|
438 |
|
|
sl@0
|
439 |
#ifndef OPENSSL_NO_DSA
|
|
sl@0
|
440 |
static int dsa_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8, EVP_PKEY *pkey)
|
|
sl@0
|
441 |
{
|
|
sl@0
|
442 |
ASN1_STRING *params = NULL;
|
|
sl@0
|
443 |
ASN1_INTEGER *prkey = NULL;
|
|
sl@0
|
444 |
ASN1_TYPE *ttmp = NULL;
|
|
sl@0
|
445 |
STACK_OF(ASN1_TYPE) *ndsa = NULL;
|
|
sl@0
|
446 |
unsigned char *p = NULL, *q;
|
|
sl@0
|
447 |
int len;
|
|
sl@0
|
448 |
|
|
sl@0
|
449 |
p8->pkeyalg->algorithm = OBJ_nid2obj(NID_dsa);
|
|
sl@0
|
450 |
len = i2d_DSAparams (pkey->pkey.dsa, NULL);
|
|
sl@0
|
451 |
if (!(p = OPENSSL_malloc(len))) {
|
|
sl@0
|
452 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
453 |
goto err;
|
|
sl@0
|
454 |
}
|
|
sl@0
|
455 |
q = p;
|
|
sl@0
|
456 |
i2d_DSAparams (pkey->pkey.dsa, &q);
|
|
sl@0
|
457 |
if (!(params = ASN1_STRING_new())) {
|
|
sl@0
|
458 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
459 |
goto err;
|
|
sl@0
|
460 |
}
|
|
sl@0
|
461 |
if (!ASN1_STRING_set(params, p, len)) {
|
|
sl@0
|
462 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
463 |
goto err;
|
|
sl@0
|
464 |
}
|
|
sl@0
|
465 |
OPENSSL_free(p);
|
|
sl@0
|
466 |
p = NULL;
|
|
sl@0
|
467 |
/* Get private key into integer */
|
|
sl@0
|
468 |
if (!(prkey = BN_to_ASN1_INTEGER (pkey->pkey.dsa->priv_key, NULL))) {
|
|
sl@0
|
469 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,EVP_R_ENCODE_ERROR);
|
|
sl@0
|
470 |
goto err;
|
|
sl@0
|
471 |
}
|
|
sl@0
|
472 |
|
|
sl@0
|
473 |
switch(p8->broken) {
|
|
sl@0
|
474 |
|
|
sl@0
|
475 |
case PKCS8_OK:
|
|
sl@0
|
476 |
case PKCS8_NO_OCTET:
|
|
sl@0
|
477 |
|
|
sl@0
|
478 |
if (!ASN1_pack_string_of(ASN1_INTEGER,prkey, i2d_ASN1_INTEGER,
|
|
sl@0
|
479 |
&p8->pkey->value.octet_string)) {
|
|
sl@0
|
480 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
481 |
goto err;
|
|
sl@0
|
482 |
}
|
|
sl@0
|
483 |
|
|
sl@0
|
484 |
M_ASN1_INTEGER_free (prkey);
|
|
sl@0
|
485 |
prkey = NULL;
|
|
sl@0
|
486 |
p8->pkeyalg->parameter->value.sequence = params;
|
|
sl@0
|
487 |
params = NULL;
|
|
sl@0
|
488 |
p8->pkeyalg->parameter->type = V_ASN1_SEQUENCE;
|
|
sl@0
|
489 |
|
|
sl@0
|
490 |
break;
|
|
sl@0
|
491 |
|
|
sl@0
|
492 |
case PKCS8_NS_DB:
|
|
sl@0
|
493 |
|
|
sl@0
|
494 |
p8->pkeyalg->parameter->value.sequence = params;
|
|
sl@0
|
495 |
params = NULL;
|
|
sl@0
|
496 |
p8->pkeyalg->parameter->type = V_ASN1_SEQUENCE;
|
|
sl@0
|
497 |
if (!(ndsa = sk_ASN1_TYPE_new_null())) {
|
|
sl@0
|
498 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
499 |
goto err;
|
|
sl@0
|
500 |
}
|
|
sl@0
|
501 |
if (!(ttmp = ASN1_TYPE_new())) {
|
|
sl@0
|
502 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
503 |
goto err;
|
|
sl@0
|
504 |
}
|
|
sl@0
|
505 |
if (!(ttmp->value.integer =
|
|
sl@0
|
506 |
BN_to_ASN1_INTEGER(pkey->pkey.dsa->pub_key, NULL))) {
|
|
sl@0
|
507 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,EVP_R_ENCODE_ERROR);
|
|
sl@0
|
508 |
goto err;
|
|
sl@0
|
509 |
}
|
|
sl@0
|
510 |
ttmp->type = V_ASN1_INTEGER;
|
|
sl@0
|
511 |
if (!sk_ASN1_TYPE_push(ndsa, ttmp)) {
|
|
sl@0
|
512 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
513 |
goto err;
|
|
sl@0
|
514 |
}
|
|
sl@0
|
515 |
|
|
sl@0
|
516 |
if (!(ttmp = ASN1_TYPE_new())) {
|
|
sl@0
|
517 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
518 |
goto err;
|
|
sl@0
|
519 |
}
|
|
sl@0
|
520 |
ttmp->value.integer = prkey;
|
|
sl@0
|
521 |
prkey = NULL;
|
|
sl@0
|
522 |
ttmp->type = V_ASN1_INTEGER;
|
|
sl@0
|
523 |
if (!sk_ASN1_TYPE_push(ndsa, ttmp)) {
|
|
sl@0
|
524 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
525 |
goto err;
|
|
sl@0
|
526 |
}
|
|
sl@0
|
527 |
ttmp = NULL;
|
|
sl@0
|
528 |
|
|
sl@0
|
529 |
if (!(p8->pkey->value.octet_string = ASN1_OCTET_STRING_new())) {
|
|
sl@0
|
530 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
531 |
goto err;
|
|
sl@0
|
532 |
}
|
|
sl@0
|
533 |
|
|
sl@0
|
534 |
if (!ASN1_seq_pack_ASN1_TYPE(ndsa, i2d_ASN1_TYPE,
|
|
sl@0
|
535 |
&p8->pkey->value.octet_string->data,
|
|
sl@0
|
536 |
&p8->pkey->value.octet_string->length)) {
|
|
sl@0
|
537 |
|
|
sl@0
|
538 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
539 |
goto err;
|
|
sl@0
|
540 |
}
|
|
sl@0
|
541 |
sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);
|
|
sl@0
|
542 |
break;
|
|
sl@0
|
543 |
|
|
sl@0
|
544 |
case PKCS8_EMBEDDED_PARAM:
|
|
sl@0
|
545 |
|
|
sl@0
|
546 |
p8->pkeyalg->parameter->type = V_ASN1_NULL;
|
|
sl@0
|
547 |
if (!(ndsa = sk_ASN1_TYPE_new_null())) {
|
|
sl@0
|
548 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
549 |
goto err;
|
|
sl@0
|
550 |
}
|
|
sl@0
|
551 |
if (!(ttmp = ASN1_TYPE_new())) {
|
|
sl@0
|
552 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
553 |
goto err;
|
|
sl@0
|
554 |
}
|
|
sl@0
|
555 |
ttmp->value.sequence = params;
|
|
sl@0
|
556 |
params = NULL;
|
|
sl@0
|
557 |
ttmp->type = V_ASN1_SEQUENCE;
|
|
sl@0
|
558 |
if (!sk_ASN1_TYPE_push(ndsa, ttmp)) {
|
|
sl@0
|
559 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
560 |
goto err;
|
|
sl@0
|
561 |
}
|
|
sl@0
|
562 |
|
|
sl@0
|
563 |
if (!(ttmp = ASN1_TYPE_new())) {
|
|
sl@0
|
564 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
565 |
goto err;
|
|
sl@0
|
566 |
}
|
|
sl@0
|
567 |
ttmp->value.integer = prkey;
|
|
sl@0
|
568 |
prkey = NULL;
|
|
sl@0
|
569 |
ttmp->type = V_ASN1_INTEGER;
|
|
sl@0
|
570 |
if (!sk_ASN1_TYPE_push(ndsa, ttmp)) {
|
|
sl@0
|
571 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
572 |
goto err;
|
|
sl@0
|
573 |
}
|
|
sl@0
|
574 |
ttmp = NULL;
|
|
sl@0
|
575 |
|
|
sl@0
|
576 |
if (!(p8->pkey->value.octet_string = ASN1_OCTET_STRING_new())) {
|
|
sl@0
|
577 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
578 |
goto err;
|
|
sl@0
|
579 |
}
|
|
sl@0
|
580 |
|
|
sl@0
|
581 |
if (!ASN1_seq_pack_ASN1_TYPE(ndsa, i2d_ASN1_TYPE,
|
|
sl@0
|
582 |
&p8->pkey->value.octet_string->data,
|
|
sl@0
|
583 |
&p8->pkey->value.octet_string->length)) {
|
|
sl@0
|
584 |
|
|
sl@0
|
585 |
EVPerr(EVP_F_DSA_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
586 |
goto err;
|
|
sl@0
|
587 |
}
|
|
sl@0
|
588 |
sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);
|
|
sl@0
|
589 |
break;
|
|
sl@0
|
590 |
}
|
|
sl@0
|
591 |
return 1;
|
|
sl@0
|
592 |
err:
|
|
sl@0
|
593 |
if (p != NULL) OPENSSL_free(p);
|
|
sl@0
|
594 |
if (params != NULL) ASN1_STRING_free(params);
|
|
sl@0
|
595 |
if (prkey != NULL) M_ASN1_INTEGER_free(prkey);
|
|
sl@0
|
596 |
if (ttmp != NULL) ASN1_TYPE_free(ttmp);
|
|
sl@0
|
597 |
if (ndsa != NULL) sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);
|
|
sl@0
|
598 |
return 0;
|
|
sl@0
|
599 |
}
|
|
sl@0
|
600 |
#endif
|
|
sl@0
|
601 |
|
|
sl@0
|
602 |
#ifndef OPENSSL_NO_EC
|
|
sl@0
|
603 |
static int eckey_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8, EVP_PKEY *pkey)
|
|
sl@0
|
604 |
{
|
|
sl@0
|
605 |
EC_KEY *ec_key;
|
|
sl@0
|
606 |
const EC_GROUP *group;
|
|
sl@0
|
607 |
unsigned char *p, *pp;
|
|
sl@0
|
608 |
int nid, i, ret = 0;
|
|
sl@0
|
609 |
unsigned int tmp_flags, old_flags;
|
|
sl@0
|
610 |
|
|
sl@0
|
611 |
ec_key = pkey->pkey.ec;
|
|
sl@0
|
612 |
if (ec_key == NULL || (group = EC_KEY_get0_group(ec_key)) == NULL)
|
|
sl@0
|
613 |
{
|
|
sl@0
|
614 |
EVPerr(EVP_F_ECKEY_PKEY2PKCS8, EVP_R_MISSING_PARAMETERS);
|
|
sl@0
|
615 |
return 0;
|
|
sl@0
|
616 |
}
|
|
sl@0
|
617 |
|
|
sl@0
|
618 |
/* set the ec parameters OID */
|
|
sl@0
|
619 |
if (p8->pkeyalg->algorithm)
|
|
sl@0
|
620 |
ASN1_OBJECT_free(p8->pkeyalg->algorithm);
|
|
sl@0
|
621 |
|
|
sl@0
|
622 |
p8->pkeyalg->algorithm = OBJ_nid2obj(NID_X9_62_id_ecPublicKey);
|
|
sl@0
|
623 |
|
|
sl@0
|
624 |
/* set the ec parameters */
|
|
sl@0
|
625 |
|
|
sl@0
|
626 |
if (p8->pkeyalg->parameter)
|
|
sl@0
|
627 |
{
|
|
sl@0
|
628 |
ASN1_TYPE_free(p8->pkeyalg->parameter);
|
|
sl@0
|
629 |
p8->pkeyalg->parameter = NULL;
|
|
sl@0
|
630 |
}
|
|
sl@0
|
631 |
|
|
sl@0
|
632 |
if ((p8->pkeyalg->parameter = ASN1_TYPE_new()) == NULL)
|
|
sl@0
|
633 |
{
|
|
sl@0
|
634 |
EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
635 |
return 0;
|
|
sl@0
|
636 |
}
|
|
sl@0
|
637 |
|
|
sl@0
|
638 |
if (EC_GROUP_get_asn1_flag(group)
|
|
sl@0
|
639 |
&& (nid = EC_GROUP_get_curve_name(group)))
|
|
sl@0
|
640 |
{
|
|
sl@0
|
641 |
/* we have a 'named curve' => just set the OID */
|
|
sl@0
|
642 |
p8->pkeyalg->parameter->type = V_ASN1_OBJECT;
|
|
sl@0
|
643 |
p8->pkeyalg->parameter->value.object = OBJ_nid2obj(nid);
|
|
sl@0
|
644 |
}
|
|
sl@0
|
645 |
else /* explicit parameters */
|
|
sl@0
|
646 |
{
|
|
sl@0
|
647 |
if ((i = i2d_ECParameters(ec_key, NULL)) == 0)
|
|
sl@0
|
648 |
{
|
|
sl@0
|
649 |
EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_EC_LIB);
|
|
sl@0
|
650 |
return 0;
|
|
sl@0
|
651 |
}
|
|
sl@0
|
652 |
if ((p = (unsigned char *) OPENSSL_malloc(i)) == NULL)
|
|
sl@0
|
653 |
{
|
|
sl@0
|
654 |
EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
655 |
return 0;
|
|
sl@0
|
656 |
}
|
|
sl@0
|
657 |
pp = p;
|
|
sl@0
|
658 |
if (!i2d_ECParameters(ec_key, &pp))
|
|
sl@0
|
659 |
{
|
|
sl@0
|
660 |
EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_EC_LIB);
|
|
sl@0
|
661 |
OPENSSL_free(p);
|
|
sl@0
|
662 |
return 0;
|
|
sl@0
|
663 |
}
|
|
sl@0
|
664 |
p8->pkeyalg->parameter->type = V_ASN1_SEQUENCE;
|
|
sl@0
|
665 |
if ((p8->pkeyalg->parameter->value.sequence
|
|
sl@0
|
666 |
= ASN1_STRING_new()) == NULL)
|
|
sl@0
|
667 |
{
|
|
sl@0
|
668 |
EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_ASN1_LIB);
|
|
sl@0
|
669 |
OPENSSL_free(p);
|
|
sl@0
|
670 |
return 0;
|
|
sl@0
|
671 |
}
|
|
sl@0
|
672 |
ASN1_STRING_set(p8->pkeyalg->parameter->value.sequence, p, i);
|
|
sl@0
|
673 |
OPENSSL_free(p);
|
|
sl@0
|
674 |
}
|
|
sl@0
|
675 |
|
|
sl@0
|
676 |
/* set the private key */
|
|
sl@0
|
677 |
|
|
sl@0
|
678 |
/* do not include the parameters in the SEC1 private key
|
|
sl@0
|
679 |
* see PKCS#11 12.11 */
|
|
sl@0
|
680 |
old_flags = EC_KEY_get_enc_flags(pkey->pkey.ec);
|
|
sl@0
|
681 |
tmp_flags = old_flags | EC_PKEY_NO_PARAMETERS;
|
|
sl@0
|
682 |
EC_KEY_set_enc_flags(pkey->pkey.ec, tmp_flags);
|
|
sl@0
|
683 |
i = i2d_ECPrivateKey(pkey->pkey.ec, NULL);
|
|
sl@0
|
684 |
if (!i)
|
|
sl@0
|
685 |
{
|
|
sl@0
|
686 |
EC_KEY_set_enc_flags(pkey->pkey.ec, old_flags);
|
|
sl@0
|
687 |
EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_EC_LIB);
|
|
sl@0
|
688 |
return 0;
|
|
sl@0
|
689 |
}
|
|
sl@0
|
690 |
p = (unsigned char *) OPENSSL_malloc(i);
|
|
sl@0
|
691 |
if (!p)
|
|
sl@0
|
692 |
{
|
|
sl@0
|
693 |
EC_KEY_set_enc_flags(pkey->pkey.ec, old_flags);
|
|
sl@0
|
694 |
EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
695 |
return 0;
|
|
sl@0
|
696 |
}
|
|
sl@0
|
697 |
pp = p;
|
|
sl@0
|
698 |
if (!i2d_ECPrivateKey(pkey->pkey.ec, &pp))
|
|
sl@0
|
699 |
{
|
|
sl@0
|
700 |
EC_KEY_set_enc_flags(pkey->pkey.ec, old_flags);
|
|
sl@0
|
701 |
EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_EC_LIB);
|
|
sl@0
|
702 |
OPENSSL_free(p);
|
|
sl@0
|
703 |
return 0;
|
|
sl@0
|
704 |
}
|
|
sl@0
|
705 |
/* restore old encoding flags */
|
|
sl@0
|
706 |
EC_KEY_set_enc_flags(pkey->pkey.ec, old_flags);
|
|
sl@0
|
707 |
|
|
sl@0
|
708 |
switch(p8->broken) {
|
|
sl@0
|
709 |
|
|
sl@0
|
710 |
case PKCS8_OK:
|
|
sl@0
|
711 |
p8->pkey->value.octet_string = ASN1_OCTET_STRING_new();
|
|
sl@0
|
712 |
if (!p8->pkey->value.octet_string ||
|
|
sl@0
|
713 |
!M_ASN1_OCTET_STRING_set(p8->pkey->value.octet_string,
|
|
sl@0
|
714 |
(const void *)p, i))
|
|
sl@0
|
715 |
|
|
sl@0
|
716 |
{
|
|
sl@0
|
717 |
EVPerr(EVP_F_ECKEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
|
|
sl@0
|
718 |
}
|
|
sl@0
|
719 |
else
|
|
sl@0
|
720 |
ret = 1;
|
|
sl@0
|
721 |
break;
|
|
sl@0
|
722 |
case PKCS8_NO_OCTET: /* RSA specific */
|
|
sl@0
|
723 |
case PKCS8_NS_DB: /* DSA specific */
|
|
sl@0
|
724 |
case PKCS8_EMBEDDED_PARAM: /* DSA specific */
|
|
sl@0
|
725 |
default:
|
|
sl@0
|
726 |
EVPerr(EVP_F_ECKEY_PKEY2PKCS8,EVP_R_ENCODE_ERROR);
|
|
sl@0
|
727 |
}
|
|
sl@0
|
728 |
OPENSSL_cleanse(p, (size_t)i);
|
|
sl@0
|
729 |
OPENSSL_free(p);
|
|
sl@0
|
730 |
return ret;
|
|
sl@0
|
731 |
}
|
|
sl@0
|
732 |
#endif
|
|
sl@0
|
733 |
|
|
sl@0
|
734 |
/* EVP_PKEY attribute functions */
|
|
sl@0
|
735 |
|
|
sl@0
|
736 |
EXPORT_C int EVP_PKEY_get_attr_count(const EVP_PKEY *key)
|
|
sl@0
|
737 |
{
|
|
sl@0
|
738 |
return X509at_get_attr_count(key->attributes);
|
|
sl@0
|
739 |
}
|
|
sl@0
|
740 |
|
|
sl@0
|
741 |
EXPORT_C int EVP_PKEY_get_attr_by_NID(const EVP_PKEY *key, int nid,
|
|
sl@0
|
742 |
int lastpos)
|
|
sl@0
|
743 |
{
|
|
sl@0
|
744 |
return X509at_get_attr_by_NID(key->attributes, nid, lastpos);
|
|
sl@0
|
745 |
}
|
|
sl@0
|
746 |
|
|
sl@0
|
747 |
EXPORT_C int EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, ASN1_OBJECT *obj,
|
|
sl@0
|
748 |
int lastpos)
|
|
sl@0
|
749 |
{
|
|
sl@0
|
750 |
return X509at_get_attr_by_OBJ(key->attributes, obj, lastpos);
|
|
sl@0
|
751 |
}
|
|
sl@0
|
752 |
|
|
sl@0
|
753 |
EXPORT_C X509_ATTRIBUTE *EVP_PKEY_get_attr(const EVP_PKEY *key, int loc)
|
|
sl@0
|
754 |
{
|
|
sl@0
|
755 |
return X509at_get_attr(key->attributes, loc);
|
|
sl@0
|
756 |
}
|
|
sl@0
|
757 |
|
|
sl@0
|
758 |
EXPORT_C X509_ATTRIBUTE *EVP_PKEY_delete_attr(EVP_PKEY *key, int loc)
|
|
sl@0
|
759 |
{
|
|
sl@0
|
760 |
return X509at_delete_attr(key->attributes, loc);
|
|
sl@0
|
761 |
}
|
|
sl@0
|
762 |
|
|
sl@0
|
763 |
EXPORT_C int EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr)
|
|
sl@0
|
764 |
{
|
|
sl@0
|
765 |
if(X509at_add1_attr(&key->attributes, attr)) return 1;
|
|
sl@0
|
766 |
return 0;
|
|
sl@0
|
767 |
}
|
|
sl@0
|
768 |
|
|
sl@0
|
769 |
EXPORT_C int EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key,
|
|
sl@0
|
770 |
const ASN1_OBJECT *obj, int type,
|
|
sl@0
|
771 |
const unsigned char *bytes, int len)
|
|
sl@0
|
772 |
{
|
|
sl@0
|
773 |
if(X509at_add1_attr_by_OBJ(&key->attributes, obj,
|
|
sl@0
|
774 |
type, bytes, len)) return 1;
|
|
sl@0
|
775 |
return 0;
|
|
sl@0
|
776 |
}
|
|
sl@0
|
777 |
|
|
sl@0
|
778 |
EXPORT_C int EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key,
|
|
sl@0
|
779 |
int nid, int type,
|
|
sl@0
|
780 |
const unsigned char *bytes, int len)
|
|
sl@0
|
781 |
{
|
|
sl@0
|
782 |
if(X509at_add1_attr_by_NID(&key->attributes, nid,
|
|
sl@0
|
783 |
type, bytes, len)) return 1;
|
|
sl@0
|
784 |
return 0;
|
|
sl@0
|
785 |
}
|
|
sl@0
|
786 |
|
|
sl@0
|
787 |
EXPORT_C int EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key,
|
|
sl@0
|
788 |
const char *attrname, int type,
|
|
sl@0
|
789 |
const unsigned char *bytes, int len)
|
|
sl@0
|
790 |
{
|
|
sl@0
|
791 |
if(X509at_add1_attr_by_txt(&key->attributes, attrname,
|
|
sl@0
|
792 |
type, bytes, len)) return 1;
|
|
sl@0
|
793 |
return 0;
|
|
sl@0
|
794 |
}
|