]>
Commit | Line | Data |
---|---|---|
d02b48c6 | 1 | /* crypto/asn1/t_pkey.c */ |
58964a49 | 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) |
d02b48c6 RE |
3 | * All rights reserved. |
4 | * | |
5 | * This package is an SSL implementation written | |
6 | * by Eric Young (eay@cryptsoft.com). | |
7 | * The implementation was written so as to conform with Netscapes SSL. | |
8 | * | |
9 | * This library is free for commercial and non-commercial use as long as | |
10 | * the following conditions are aheared to. The following conditions | |
11 | * apply to all code found in this distribution, be it the RC4, RSA, | |
12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | |
13 | * included with this distribution is covered by the same copyright terms | |
14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | |
15 | * | |
16 | * Copyright remains Eric Young's, and as such any Copyright notices in | |
17 | * the code are not to be removed. | |
18 | * If this package is used in a product, Eric Young should be given attribution | |
19 | * as the author of the parts of the library used. | |
20 | * This can be in the form of a textual message at program startup or | |
21 | * in documentation (online or textual) provided with the package. | |
22 | * | |
23 | * Redistribution and use in source and binary forms, with or without | |
24 | * modification, are permitted provided that the following conditions | |
25 | * are met: | |
26 | * 1. Redistributions of source code must retain the copyright | |
27 | * notice, this list of conditions and the following disclaimer. | |
28 | * 2. Redistributions in binary form must reproduce the above copyright | |
29 | * notice, this list of conditions and the following disclaimer in the | |
30 | * documentation and/or other materials provided with the distribution. | |
31 | * 3. All advertising materials mentioning features or use of this software | |
32 | * must display the following acknowledgement: | |
33 | * "This product includes cryptographic software written by | |
34 | * Eric Young (eay@cryptsoft.com)" | |
35 | * The word 'cryptographic' can be left out if the rouines from the library | |
36 | * being used are not cryptographic related :-). | |
37 | * 4. If you include any Windows specific code (or a derivative thereof) from | |
38 | * the apps directory (application code) you must include an acknowledgement: | |
39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | |
40 | * | |
41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | |
42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | |
45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
51 | * SUCH DAMAGE. | |
52 | * | |
53 | * The licence and distribution terms for any publically available version or | |
54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | |
55 | * copied and put under another distribution licence | |
56 | * [including the GNU Public Licence.] | |
57 | */ | |
e172d60d BM |
58 | /* ==================================================================== |
59 | * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. | |
60 | * Binary polynomial ECC support in OpenSSL originally developed by | |
61 | * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. | |
62 | */ | |
d02b48c6 RE |
63 | |
64 | #include <stdio.h> | |
65 | #include "cryptlib.h" | |
5f3d6f70 | 66 | #include <openssl/objects.h> |
ec577822 BM |
67 | #include <openssl/buffer.h> |
68 | #include <openssl/bn.h> | |
cf1b7d96 | 69 | #ifndef OPENSSL_NO_RSA |
ec577822 | 70 | #include <openssl/rsa.h> |
d02b48c6 | 71 | #endif |
cf1b7d96 | 72 | #ifndef OPENSSL_NO_DH |
ec577822 | 73 | #include <openssl/dh.h> |
d02b48c6 | 74 | #endif |
cf1b7d96 | 75 | #ifndef OPENSSL_NO_DSA |
ec577822 | 76 | #include <openssl/dsa.h> |
d02b48c6 | 77 | #endif |
14a7cfb3 BM |
78 | #ifndef OPENSSL_NO_EC |
79 | #include <openssl/ec.h> | |
4d94ae00 | 80 | #endif |
d02b48c6 | 81 | |
e778802f | 82 | static int print(BIO *fp,const char *str,BIGNUM *num, |
d02b48c6 | 83 | unsigned char *buf,int off); |
60cc56b1 BM |
84 | static int print_bin(BIO *fp, const char *str, const unsigned char *num, |
85 | size_t len, int off); | |
cf1b7d96 RL |
86 | #ifndef OPENSSL_NO_RSA |
87 | #ifndef OPENSSL_NO_FP_API | |
7081f3bd | 88 | int RSA_print_fp(FILE *fp, const RSA *x, int off) |
4d94ae00 BM |
89 | { |
90 | BIO *b; | |
91 | int ret; | |
d02b48c6 | 92 | |
4d94ae00 | 93 | if ((b=BIO_new(BIO_s_file())) == NULL) |
d02b48c6 RE |
94 | { |
95 | RSAerr(RSA_F_RSA_PRINT_FP,ERR_R_BUF_LIB); | |
4d94ae00 | 96 | return(0); |
d02b48c6 | 97 | } |
4d94ae00 BM |
98 | BIO_set_fp(b,fp,BIO_NOCLOSE); |
99 | ret=RSA_print(b,x,off); | |
100 | BIO_free(b); | |
101 | return(ret); | |
102 | } | |
d02b48c6 RE |
103 | #endif |
104 | ||
7081f3bd | 105 | int RSA_print(BIO *bp, const RSA *x, int off) |
d02b48c6 | 106 | { |
e778802f BL |
107 | char str[128]; |
108 | const char *s; | |
d02b48c6 | 109 | unsigned char *m=NULL; |
9ae08a9c BM |
110 | int ret=0; |
111 | size_t buf_len=0, i; | |
d02b48c6 | 112 | |
9ae08a9c BM |
113 | if (x->n) |
114 | buf_len = (size_t)BN_num_bytes(x->n); | |
115 | if (x->e) | |
116 | if (buf_len < (i = (size_t)BN_num_bytes(x->e))) | |
117 | buf_len = i; | |
118 | if (x->d) | |
119 | if (buf_len < (i = (size_t)BN_num_bytes(x->d))) | |
120 | buf_len = i; | |
121 | if (x->p) | |
122 | if (buf_len < (i = (size_t)BN_num_bytes(x->p))) | |
123 | buf_len = i; | |
124 | if (x->q) | |
125 | if (buf_len < (i = (size_t)BN_num_bytes(x->q))) | |
126 | buf_len = i; | |
127 | if (x->dmp1) | |
128 | if (buf_len < (i = (size_t)BN_num_bytes(x->dmp1))) | |
129 | buf_len = i; | |
130 | if (x->dmq1) | |
131 | if (buf_len < (i = (size_t)BN_num_bytes(x->dmq1))) | |
132 | buf_len = i; | |
133 | if (x->iqmp) | |
134 | if (buf_len < (i = (size_t)BN_num_bytes(x->iqmp))) | |
135 | buf_len = i; | |
136 | ||
137 | m=(unsigned char *)OPENSSL_malloc(buf_len+10); | |
d02b48c6 RE |
138 | if (m == NULL) |
139 | { | |
140 | RSAerr(RSA_F_RSA_PRINT,ERR_R_MALLOC_FAILURE); | |
141 | goto err; | |
142 | } | |
143 | ||
d02b48c6 RE |
144 | if (x->d != NULL) |
145 | { | |
54a656ef BL |
146 | if(!BIO_indent(bp,off,128)) |
147 | goto err; | |
d02b48c6 RE |
148 | if (BIO_printf(bp,"Private-Key: (%d bit)\n",BN_num_bits(x->n)) |
149 | <= 0) goto err; | |
150 | } | |
151 | ||
152 | if (x->d == NULL) | |
d420ac2c | 153 | BIO_snprintf(str,sizeof str,"Modulus (%d bit):",BN_num_bits(x->n)); |
d02b48c6 | 154 | else |
d420ac2c | 155 | BUF_strlcpy(str,"modulus:",sizeof str); |
d02b48c6 RE |
156 | if (!print(bp,str,x->n,m,off)) goto err; |
157 | s=(x->d == NULL)?"Exponent:":"publicExponent:"; | |
158 | if (!print(bp,s,x->e,m,off)) goto err; | |
159 | if (!print(bp,"privateExponent:",x->d,m,off)) goto err; | |
160 | if (!print(bp,"prime1:",x->p,m,off)) goto err; | |
161 | if (!print(bp,"prime2:",x->q,m,off)) goto err; | |
162 | if (!print(bp,"exponent1:",x->dmp1,m,off)) goto err; | |
163 | if (!print(bp,"exponent2:",x->dmq1,m,off)) goto err; | |
164 | if (!print(bp,"coefficient:",x->iqmp,m,off)) goto err; | |
165 | ret=1; | |
166 | err: | |
26a3a48d | 167 | if (m != NULL) OPENSSL_free(m); |
d02b48c6 RE |
168 | return(ret); |
169 | } | |
cf1b7d96 | 170 | #endif /* OPENSSL_NO_RSA */ |
d02b48c6 | 171 | |
cf1b7d96 RL |
172 | #ifndef OPENSSL_NO_DSA |
173 | #ifndef OPENSSL_NO_FP_API | |
a4aba800 | 174 | int DSA_print_fp(FILE *fp, const DSA *x, int off) |
d02b48c6 RE |
175 | { |
176 | BIO *b; | |
177 | int ret; | |
178 | ||
179 | if ((b=BIO_new(BIO_s_file())) == NULL) | |
180 | { | |
181 | DSAerr(DSA_F_DSA_PRINT_FP,ERR_R_BUF_LIB); | |
182 | return(0); | |
183 | } | |
184 | BIO_set_fp(b,fp,BIO_NOCLOSE); | |
185 | ret=DSA_print(b,x,off); | |
186 | BIO_free(b); | |
187 | return(ret); | |
188 | } | |
189 | #endif | |
190 | ||
a4aba800 | 191 | int DSA_print(BIO *bp, const DSA *x, int off) |
d02b48c6 | 192 | { |
d02b48c6 | 193 | unsigned char *m=NULL; |
9ae08a9c BM |
194 | int ret=0; |
195 | size_t buf_len=0,i; | |
196 | ||
197 | if (x->p) | |
198 | buf_len = (size_t)BN_num_bytes(x->p); | |
199 | if (x->q) | |
200 | if (buf_len < (i = (size_t)BN_num_bytes(x->q))) | |
201 | buf_len = i; | |
202 | if (x->g) | |
203 | if (buf_len < (i = (size_t)BN_num_bytes(x->g))) | |
204 | buf_len = i; | |
205 | if (x->priv_key) | |
206 | if (buf_len < (i = (size_t)BN_num_bytes(x->priv_key))) | |
207 | buf_len = i; | |
208 | if (x->pub_key) | |
209 | if (buf_len < (i = (size_t)BN_num_bytes(x->pub_key))) | |
210 | buf_len = i; | |
211 | ||
212 | m=(unsigned char *)OPENSSL_malloc(buf_len+10); | |
d02b48c6 RE |
213 | if (m == NULL) |
214 | { | |
215 | DSAerr(DSA_F_DSA_PRINT,ERR_R_MALLOC_FAILURE); | |
216 | goto err; | |
217 | } | |
218 | ||
d02b48c6 RE |
219 | if (x->priv_key != NULL) |
220 | { | |
54a656ef BL |
221 | if(!BIO_indent(bp,off,128)) |
222 | goto err; | |
d02b48c6 RE |
223 | if (BIO_printf(bp,"Private-Key: (%d bit)\n",BN_num_bits(x->p)) |
224 | <= 0) goto err; | |
225 | } | |
226 | ||
227 | if ((x->priv_key != NULL) && !print(bp,"priv:",x->priv_key,m,off)) | |
228 | goto err; | |
229 | if ((x->pub_key != NULL) && !print(bp,"pub: ",x->pub_key,m,off)) | |
230 | goto err; | |
231 | if ((x->p != NULL) && !print(bp,"P: ",x->p,m,off)) goto err; | |
232 | if ((x->q != NULL) && !print(bp,"Q: ",x->q,m,off)) goto err; | |
233 | if ((x->g != NULL) && !print(bp,"G: ",x->g,m,off)) goto err; | |
234 | ret=1; | |
235 | err: | |
26a3a48d | 236 | if (m != NULL) OPENSSL_free(m); |
d02b48c6 RE |
237 | return(ret); |
238 | } | |
cf1b7d96 | 239 | #endif /* !OPENSSL_NO_DSA */ |
d02b48c6 | 240 | |
5f3d6f70 BM |
241 | #ifndef OPENSSL_NO_EC |
242 | #ifndef OPENSSL_NO_FP_API | |
243 | int ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x, int off) | |
244 | { | |
245 | BIO *b; | |
246 | int ret; | |
247 | ||
248 | if ((b=BIO_new(BIO_s_file())) == NULL) | |
249 | { | |
250 | ECerr(EC_F_ECPKPARAMETERS_PRINT_FP,ERR_R_BUF_LIB); | |
251 | return(0); | |
252 | } | |
253 | BIO_set_fp(b, fp, BIO_NOCLOSE); | |
254 | ret = ECPKParameters_print(b, x, off); | |
255 | BIO_free(b); | |
256 | return(ret); | |
257 | } | |
14a7cfb3 BM |
258 | |
259 | int EC_KEY_print_fp(FILE *fp, const EC_KEY *x, int off) | |
260 | { | |
261 | BIO *b; | |
262 | int ret; | |
263 | ||
264 | if ((b=BIO_new(BIO_s_file())) == NULL) | |
265 | { | |
266 | ECerr(EC_F_EC_KEY_PRINT_FP, ERR_R_BIO_LIB); | |
267 | return(0); | |
268 | } | |
269 | BIO_set_fp(b, fp, BIO_NOCLOSE); | |
270 | ret = EC_KEY_print(b, x, off); | |
271 | BIO_free(b); | |
272 | return(ret); | |
273 | } | |
5f3d6f70 BM |
274 | #endif |
275 | ||
276 | int ECPKParameters_print(BIO *bp, const EC_GROUP *x, int off) | |
277 | { | |
5f3d6f70 BM |
278 | unsigned char *buffer=NULL; |
279 | size_t buf_len=0, i; | |
280 | int ret=0, reason=ERR_R_BIO_LIB; | |
281 | BN_CTX *ctx=NULL; | |
282 | EC_POINT *point=NULL; | |
283 | BIGNUM *p=NULL, *a=NULL, *b=NULL, *gen=NULL, | |
60cc56b1 BM |
284 | *order=NULL, *cofactor=NULL; |
285 | const unsigned char *seed; | |
286 | size_t seed_len=0; | |
5f3d6f70 BM |
287 | |
288 | static const char *gen_compressed = "Generator (compressed):"; | |
289 | static const char *gen_uncompressed = "Generator (uncompressed):"; | |
290 | static const char *gen_hybrid = "Generator (hybrid):"; | |
291 | ||
292 | if (!x) | |
293 | { | |
294 | reason = ERR_R_PASSED_NULL_PARAMETER; | |
295 | goto err; | |
296 | } | |
297 | ||
298 | if (EC_GROUP_get_asn1_flag(x)) | |
299 | { | |
300 | /* the curve parameter are given by an asn1 OID */ | |
301 | int nid; | |
302 | ||
555d7525 BM |
303 | if (!BIO_indent(bp, off, 128)) |
304 | goto err; | |
5f3d6f70 BM |
305 | |
306 | nid = EC_GROUP_get_nid(x); | |
307 | if (nid == 0) | |
308 | goto err; | |
309 | ||
310 | if (BIO_printf(bp, "ASN1 OID: %s", OBJ_nid2sn(nid)) <= 0) | |
311 | goto err; | |
312 | if (BIO_printf(bp, "\n") <= 0) | |
313 | goto err; | |
314 | } | |
315 | else | |
316 | { | |
317 | /* explicit parameters */ | |
60cc56b1 | 318 | int is_char_two = 0; |
5f3d6f70 | 319 | point_conversion_form_t form; |
60cc56b1 BM |
320 | int tmp_nid = EC_METHOD_get_field_type(EC_GROUP_method_of(x)); |
321 | ||
322 | if (tmp_nid == NID_X9_62_characteristic_two_field) | |
323 | is_char_two = 1; | |
5f3d6f70 BM |
324 | |
325 | if ((p = BN_new()) == NULL || (a = BN_new()) == NULL || | |
326 | (b = BN_new()) == NULL || (order = BN_new()) == NULL || | |
327 | (cofactor = BN_new()) == NULL) | |
328 | { | |
329 | reason = ERR_R_MALLOC_FAILURE; | |
330 | goto err; | |
331 | } | |
332 | ||
60cc56b1 | 333 | if (is_char_two) |
5f3d6f70 | 334 | { |
60cc56b1 | 335 | if (!EC_GROUP_get_curve_GF2m(x, p, a, b, ctx)) |
e172d60d BM |
336 | { |
337 | reason = ERR_R_EC_LIB; | |
338 | goto err; | |
339 | } | |
340 | } | |
60cc56b1 | 341 | else /* prime field */ |
e172d60d | 342 | { |
60cc56b1 | 343 | if (!EC_GROUP_get_curve_GFp(x, p, a, b, ctx)) |
e172d60d BM |
344 | { |
345 | reason = ERR_R_EC_LIB; | |
346 | goto err; | |
347 | } | |
5f3d6f70 BM |
348 | } |
349 | ||
350 | if ((point = EC_GROUP_get0_generator(x)) == NULL) | |
351 | { | |
352 | reason = ERR_R_EC_LIB; | |
353 | goto err; | |
354 | } | |
355 | if (!EC_GROUP_get_order(x, order, NULL) || | |
356 | !EC_GROUP_get_cofactor(x, cofactor, NULL)) | |
357 | { | |
358 | reason = ERR_R_EC_LIB; | |
359 | goto err; | |
360 | } | |
361 | ||
362 | form = EC_GROUP_get_point_conversion_form(x); | |
363 | ||
364 | if ((gen = EC_POINT_point2bn(x, point, | |
365 | form, NULL, ctx)) == NULL) | |
366 | { | |
367 | reason = ERR_R_EC_LIB; | |
368 | goto err; | |
369 | } | |
370 | ||
371 | buf_len = (size_t)BN_num_bytes(p); | |
372 | if (buf_len < (i = (size_t)BN_num_bytes(a))) | |
373 | buf_len = i; | |
374 | if (buf_len < (i = (size_t)BN_num_bytes(b))) | |
375 | buf_len = i; | |
376 | if (buf_len < (i = (size_t)BN_num_bytes(gen))) | |
377 | buf_len = i; | |
378 | if (buf_len < (i = (size_t)BN_num_bytes(order))) | |
379 | buf_len = i; | |
380 | if (buf_len < (i = (size_t)BN_num_bytes(cofactor))) | |
381 | buf_len = i; | |
382 | ||
60cc56b1 BM |
383 | if ((seed = EC_GROUP_get0_seed(x)) != NULL) |
384 | seed_len = EC_GROUP_get_seed_len(x); | |
5f3d6f70 BM |
385 | |
386 | buf_len += 10; | |
387 | if ((buffer = OPENSSL_malloc(buf_len)) == NULL) | |
388 | { | |
389 | reason = ERR_R_MALLOC_FAILURE; | |
390 | goto err; | |
391 | } | |
555d7525 BM |
392 | |
393 | if (!BIO_indent(bp, off, 128)) | |
394 | goto err; | |
395 | ||
7e31164a | 396 | /* print the 'short name' of the field type */ |
60cc56b1 BM |
397 | if (BIO_printf(bp, "Field Type: %s\n", OBJ_nid2sn(tmp_nid)) |
398 | <= 0) | |
399 | goto err; | |
400 | ||
401 | if (is_char_two) | |
402 | { | |
7e31164a | 403 | /* print the 'short name' of the base type OID */ |
34f1f2a8 | 404 | int basis_type = EC_GROUP_get_basis_type(x); |
7e31164a BM |
405 | if (basis_type == 0) |
406 | goto err; | |
407 | ||
555d7525 BM |
408 | if (!BIO_indent(bp, off, 128)) |
409 | goto err; | |
7e31164a BM |
410 | |
411 | if (BIO_printf(bp, "Basis Type: %s\n", | |
412 | OBJ_nid2sn(basis_type)) <= 0) | |
413 | goto err; | |
414 | ||
415 | /* print the polynomial */ | |
60cc56b1 BM |
416 | if ((p != NULL) && !print(bp, "Polynomial:", p, buffer, |
417 | off)) | |
418 | goto err; | |
419 | } | |
420 | else | |
421 | { | |
422 | if ((p != NULL) && !print(bp, "Prime:", p, buffer,off)) | |
423 | goto err; | |
5f3d6f70 | 424 | } |
5f3d6f70 BM |
425 | if ((a != NULL) && !print(bp, "A: ", a, buffer, off)) |
426 | goto err; | |
427 | if ((b != NULL) && !print(bp, "B: ", b, buffer, off)) | |
428 | goto err; | |
429 | if (form == POINT_CONVERSION_COMPRESSED) | |
430 | { | |
431 | if ((gen != NULL) && !print(bp, gen_compressed, gen, | |
432 | buffer, off)) | |
433 | goto err; | |
434 | } | |
435 | else if (form == POINT_CONVERSION_UNCOMPRESSED) | |
436 | { | |
437 | if ((gen != NULL) && !print(bp, gen_uncompressed, gen, | |
438 | buffer, off)) | |
439 | goto err; | |
440 | } | |
441 | else /* form == POINT_CONVERSION_HYBRID */ | |
442 | { | |
443 | if ((gen != NULL) && !print(bp, gen_hybrid, gen, | |
444 | buffer, off)) | |
445 | goto err; | |
446 | } | |
447 | if ((order != NULL) && !print(bp, "Order: ", order, | |
448 | buffer, off)) goto err; | |
449 | if ((cofactor != NULL) && !print(bp, "Cofactor: ", cofactor, | |
450 | buffer, off)) goto err; | |
60cc56b1 BM |
451 | if (seed && !print_bin(bp, "Seed:", seed, seed_len, off)) |
452 | goto err; | |
5f3d6f70 BM |
453 | } |
454 | ret=1; | |
455 | err: | |
456 | if (!ret) | |
457 | ECerr(EC_F_ECPKPARAMETERS_PRINT, reason); | |
458 | if (p) | |
459 | BN_free(p); | |
460 | if (a) | |
461 | BN_free(a); | |
462 | if (b) | |
463 | BN_free(b); | |
464 | if (gen) | |
465 | BN_free(gen); | |
466 | if (order) | |
467 | BN_free(order); | |
468 | if (cofactor) | |
469 | BN_free(cofactor); | |
5f3d6f70 BM |
470 | if (ctx) |
471 | BN_CTX_free(ctx); | |
472 | if (buffer != NULL) | |
473 | OPENSSL_free(buffer); | |
474 | return(ret); | |
475 | } | |
4d94ae00 | 476 | |
14a7cfb3 | 477 | int EC_KEY_print(BIO *bp, const EC_KEY *x, int off) |
4d94ae00 | 478 | { |
4d94ae00 | 479 | unsigned char *buffer=NULL; |
5f3d6f70 BM |
480 | size_t buf_len=0, i; |
481 | int ret=0, reason=ERR_R_BIO_LIB; | |
7e8c30b5 | 482 | BIGNUM *pub_key=NULL, *order=NULL; |
4d94ae00 | 483 | BN_CTX *ctx=NULL; |
4d94ae00 | 484 | |
4d94ae00 BM |
485 | if (!x || !x->group) |
486 | { | |
5f3d6f70 | 487 | reason = ERR_R_PASSED_NULL_PARAMETER; |
d0561b5c BM |
488 | goto err; |
489 | } | |
5f3d6f70 BM |
490 | |
491 | if ((pub_key = EC_POINT_point2bn(x->group, x->pub_key, | |
14a7cfb3 | 492 | x->conv_form, NULL, ctx)) == NULL) |
4d94ae00 BM |
493 | { |
494 | reason = ERR_R_EC_LIB; | |
495 | goto err; | |
496 | } | |
5f3d6f70 BM |
497 | |
498 | buf_len = (size_t)BN_num_bytes(pub_key); | |
499 | if (x->priv_key) | |
4d94ae00 | 500 | { |
5f3d6f70 BM |
501 | if ((i = (size_t)BN_num_bytes(x->priv_key)) > buf_len) |
502 | buf_len = i; | |
4d94ae00 | 503 | } |
6cbe6382 | 504 | |
6cbe6382 BM |
505 | buf_len += 10; |
506 | if ((buffer = OPENSSL_malloc(buf_len)) == NULL) | |
4d94ae00 BM |
507 | { |
508 | reason = ERR_R_MALLOC_FAILURE; | |
4d94ae00 BM |
509 | goto err; |
510 | } | |
555d7525 | 511 | |
4d94ae00 BM |
512 | if (x->priv_key != NULL) |
513 | { | |
555d7525 BM |
514 | if (!BIO_indent(bp, off, 128)) |
515 | goto err; | |
7e8c30b5 BM |
516 | if ((order = BN_new()) == NULL) |
517 | goto err; | |
518 | if (!EC_GROUP_get_order(x->group, order, NULL)) | |
519 | goto err; | |
5f3d6f70 | 520 | if (BIO_printf(bp, "Private-Key: (%d bit)\n", |
7e8c30b5 | 521 | BN_num_bits(order)) <= 0) goto err; |
4d94ae00 BM |
522 | } |
523 | ||
5f3d6f70 BM |
524 | if ((x->priv_key != NULL) && !print(bp, "priv:", x->priv_key, |
525 | buffer, off)) | |
526 | goto err; | |
527 | if ((pub_key != NULL) && !print(bp, "pub: ", pub_key, | |
528 | buffer, off)) | |
529 | goto err; | |
530 | if (!ECPKParameters_print(bp, x->group, off)) | |
531 | goto err; | |
4d94ae00 BM |
532 | ret=1; |
533 | err: | |
534 | if (!ret) | |
14a7cfb3 | 535 | ECerr(EC_F_EC_KEY_PRINT, reason); |
5f3d6f70 BM |
536 | if (pub_key) |
537 | BN_free(pub_key); | |
7e8c30b5 BM |
538 | if (order) |
539 | BN_free(order); | |
5f3d6f70 BM |
540 | if (ctx) |
541 | BN_CTX_free(ctx); | |
542 | if (buffer != NULL) | |
543 | OPENSSL_free(buffer); | |
4d94ae00 BM |
544 | return(ret); |
545 | } | |
14a7cfb3 | 546 | #endif /* OPENSSL_NO_EC */ |
4d94ae00 | 547 | |
6b691a5c UM |
548 | static int print(BIO *bp, const char *number, BIGNUM *num, unsigned char *buf, |
549 | int off) | |
d02b48c6 RE |
550 | { |
551 | int n,i; | |
e778802f | 552 | const char *neg; |
d02b48c6 RE |
553 | |
554 | if (num == NULL) return(1); | |
ff22e913 | 555 | neg = (BN_is_negative(num))?"-":""; |
c112323d RL |
556 | if(!BIO_indent(bp,off,128)) |
557 | return 0; | |
7e31164a BM |
558 | if (BN_is_zero(num)) |
559 | { | |
560 | if (BIO_printf(bp, "%s 0\n", number) <= 0) | |
561 | return 0; | |
562 | return 1; | |
563 | } | |
564 | ||
d02b48c6 RE |
565 | if (BN_num_bytes(num) <= BN_BYTES) |
566 | { | |
567 | if (BIO_printf(bp,"%s %s%lu (%s0x%lx)\n",number,neg, | |
568 | (unsigned long)num->d[0],neg,(unsigned long)num->d[0]) | |
569 | <= 0) return(0); | |
570 | } | |
571 | else | |
572 | { | |
573 | buf[0]=0; | |
574 | if (BIO_printf(bp,"%s%s",number, | |
575 | (neg[0] == '-')?" (Negative)":"") <= 0) | |
576 | return(0); | |
577 | n=BN_bn2bin(num,&buf[1]); | |
578 | ||
579 | if (buf[1] & 0x80) | |
580 | n++; | |
581 | else buf++; | |
582 | ||
583 | for (i=0; i<n; i++) | |
584 | { | |
585 | if ((i%15) == 0) | |
586 | { | |
54a656ef BL |
587 | if(BIO_puts(bp,"\n") <= 0 |
588 | || !BIO_indent(bp,off+4,128)) | |
589 | return 0; | |
d02b48c6 RE |
590 | } |
591 | if (BIO_printf(bp,"%02x%s",buf[i],((i+1) == n)?"":":") | |
592 | <= 0) return(0); | |
593 | } | |
594 | if (BIO_write(bp,"\n",1) <= 0) return(0); | |
595 | } | |
596 | return(1); | |
597 | } | |
598 | ||
60cc56b1 BM |
599 | static int print_bin(BIO *fp, const char *name, const unsigned char *buf, |
600 | size_t len, int off) | |
601 | { | |
74e3931f | 602 | size_t i; |
60cc56b1 BM |
603 | char str[128]; |
604 | ||
605 | if (buf == NULL) | |
606 | return 1; | |
607 | if (off) | |
608 | { | |
609 | if (off > 128) | |
610 | off=128; | |
611 | memset(str,' ',off); | |
612 | if (BIO_write(fp, str, off) <= 0) | |
613 | return 0; | |
614 | } | |
615 | ||
616 | if (BIO_printf(fp,"%s", name) <= 0) | |
617 | return 0; | |
618 | ||
619 | for (i=0; i<len; i++) | |
620 | { | |
621 | if ((i%15) == 0) | |
622 | { | |
623 | str[0]='\n'; | |
624 | memset(&(str[1]),' ',off+4); | |
625 | if (BIO_write(fp, str, off+1+4) <= 0) | |
626 | return 0; | |
627 | } | |
628 | if (BIO_printf(fp,"%02x%s",buf[i],((i+1) == len)?"":":") <= 0) | |
629 | return 0; | |
630 | } | |
631 | if (BIO_write(fp,"\n",1) <= 0) | |
632 | return 0; | |
633 | ||
634 | return 1; | |
635 | } | |
636 | ||
cf1b7d96 RL |
637 | #ifndef OPENSSL_NO_DH |
638 | #ifndef OPENSSL_NO_FP_API | |
f971ccb2 | 639 | int DHparams_print_fp(FILE *fp, const DH *x) |
4d94ae00 BM |
640 | { |
641 | BIO *b; | |
642 | int ret; | |
d02b48c6 | 643 | |
4d94ae00 | 644 | if ((b=BIO_new(BIO_s_file())) == NULL) |
d02b48c6 RE |
645 | { |
646 | DHerr(DH_F_DHPARAMS_PRINT_FP,ERR_R_BUF_LIB); | |
4d94ae00 | 647 | return(0); |
d02b48c6 | 648 | } |
4d94ae00 BM |
649 | BIO_set_fp(b,fp,BIO_NOCLOSE); |
650 | ret=DHparams_print(b, x); | |
651 | BIO_free(b); | |
652 | return(ret); | |
653 | } | |
d02b48c6 RE |
654 | #endif |
655 | ||
f971ccb2 | 656 | int DHparams_print(BIO *bp, const DH *x) |
d02b48c6 RE |
657 | { |
658 | unsigned char *m=NULL; | |
9ae08a9c BM |
659 | int reason=ERR_R_BUF_LIB,ret=0; |
660 | size_t buf_len=0, i; | |
d02b48c6 | 661 | |
9ae08a9c BM |
662 | if (x->p) |
663 | buf_len = (size_t)BN_num_bytes(x->p); | |
664 | if (x->g) | |
665 | if (buf_len < (i = (size_t)BN_num_bytes(x->g))) | |
666 | buf_len = i; | |
667 | m=(unsigned char *)OPENSSL_malloc(buf_len+10); | |
d02b48c6 RE |
668 | if (m == NULL) |
669 | { | |
670 | reason=ERR_R_MALLOC_FAILURE; | |
671 | goto err; | |
672 | } | |
673 | ||
674 | if (BIO_printf(bp,"Diffie-Hellman-Parameters: (%d bit)\n", | |
675 | BN_num_bits(x->p)) <= 0) | |
676 | goto err; | |
677 | if (!print(bp,"prime:",x->p,m,4)) goto err; | |
678 | if (!print(bp,"generator:",x->g,m,4)) goto err; | |
679 | if (x->length != 0) | |
680 | { | |
657e60fa | 681 | if (BIO_printf(bp," recommended-private-length: %d bits\n", |
d02b48c6 RE |
682 | (int)x->length) <= 0) goto err; |
683 | } | |
684 | ret=1; | |
58964a49 RE |
685 | if (0) |
686 | { | |
d02b48c6 | 687 | err: |
58964a49 RE |
688 | DHerr(DH_F_DHPARAMS_PRINT,reason); |
689 | } | |
26a3a48d | 690 | if (m != NULL) OPENSSL_free(m); |
d02b48c6 RE |
691 | return(ret); |
692 | } | |
693 | #endif | |
694 | ||
cf1b7d96 RL |
695 | #ifndef OPENSSL_NO_DSA |
696 | #ifndef OPENSSL_NO_FP_API | |
a4aba800 | 697 | int DSAparams_print_fp(FILE *fp, const DSA *x) |
4d94ae00 BM |
698 | { |
699 | BIO *b; | |
700 | int ret; | |
d02b48c6 | 701 | |
4d94ae00 | 702 | if ((b=BIO_new(BIO_s_file())) == NULL) |
d02b48c6 RE |
703 | { |
704 | DSAerr(DSA_F_DSAPARAMS_PRINT_FP,ERR_R_BUF_LIB); | |
4d94ae00 | 705 | return(0); |
d02b48c6 | 706 | } |
4d94ae00 BM |
707 | BIO_set_fp(b,fp,BIO_NOCLOSE); |
708 | ret=DSAparams_print(b, x); | |
709 | BIO_free(b); | |
710 | return(ret); | |
711 | } | |
d02b48c6 RE |
712 | #endif |
713 | ||
a4aba800 | 714 | int DSAparams_print(BIO *bp, const DSA *x) |
d02b48c6 RE |
715 | { |
716 | unsigned char *m=NULL; | |
9ae08a9c BM |
717 | int reason=ERR_R_BUF_LIB,ret=0; |
718 | size_t buf_len=0,i; | |
d02b48c6 | 719 | |
9ae08a9c BM |
720 | if (x->p) |
721 | buf_len = (size_t)BN_num_bytes(x->p); | |
722 | if (x->q) | |
723 | if (buf_len < (i = (size_t)BN_num_bytes(x->q))) | |
724 | buf_len = i; | |
725 | if (x->g) | |
726 | if (buf_len < (i = (size_t)BN_num_bytes(x->g))) | |
727 | buf_len = i; | |
728 | m=(unsigned char *)OPENSSL_malloc(buf_len+10); | |
d02b48c6 RE |
729 | if (m == NULL) |
730 | { | |
731 | reason=ERR_R_MALLOC_FAILURE; | |
732 | goto err; | |
733 | } | |
734 | ||
735 | if (BIO_printf(bp,"DSA-Parameters: (%d bit)\n", | |
736 | BN_num_bits(x->p)) <= 0) | |
737 | goto err; | |
738 | if (!print(bp,"p:",x->p,m,4)) goto err; | |
739 | if (!print(bp,"q:",x->q,m,4)) goto err; | |
740 | if (!print(bp,"g:",x->g,m,4)) goto err; | |
741 | ret=1; | |
742 | err: | |
26a3a48d | 743 | if (m != NULL) OPENSSL_free(m); |
d02b48c6 RE |
744 | DSAerr(DSA_F_DSAPARAMS_PRINT,reason); |
745 | return(ret); | |
746 | } | |
747 | ||
cf1b7d96 | 748 | #endif /* !OPENSSL_NO_DSA */ |
d02b48c6 | 749 | |
14a7cfb3 | 750 | #ifndef OPENSSL_NO_EC |
4d94ae00 | 751 | #ifndef OPENSSL_NO_FP_API |
14a7cfb3 | 752 | int ECParameters_print_fp(FILE *fp, const EC_KEY *x) |
4d94ae00 BM |
753 | { |
754 | BIO *b; | |
755 | int ret; | |
756 | ||
757 | if ((b=BIO_new(BIO_s_file())) == NULL) | |
14a7cfb3 BM |
758 | { |
759 | ECerr(EC_F_ECPARAMETERS_PRINT_FP, ERR_R_BIO_LIB); | |
4d94ae00 | 760 | return(0); |
14a7cfb3 | 761 | } |
4d94ae00 | 762 | BIO_set_fp(b, fp, BIO_NOCLOSE); |
14a7cfb3 | 763 | ret = ECParameters_print(b, x); |
4d94ae00 BM |
764 | BIO_free(b); |
765 | return(ret); | |
766 | } | |
767 | #endif | |
768 | ||
14a7cfb3 | 769 | int ECParameters_print(BIO *bp, const EC_KEY *x) |
5f3d6f70 BM |
770 | { |
771 | int reason=ERR_R_EC_LIB, ret=0; | |
772 | BIGNUM *order=NULL; | |
4d94ae00 | 773 | |
5f3d6f70 BM |
774 | if (!x || !x->group) |
775 | { | |
776 | reason = ERR_R_PASSED_NULL_PARAMETER;; | |
4d94ae00 | 777 | goto err; |
5f3d6f70 BM |
778 | } |
779 | ||
780 | if ((order = BN_new()) == NULL) | |
781 | { | |
4d94ae00 BM |
782 | reason = ERR_R_MALLOC_FAILURE; |
783 | goto err; | |
5f3d6f70 | 784 | } |
6cbe6382 | 785 | |
5f3d6f70 | 786 | if (!EC_GROUP_get_order(x->group, order, NULL)) |
6cbe6382 | 787 | { |
4d94ae00 BM |
788 | reason = ERR_R_EC_LIB; |
789 | goto err; | |
6cbe6382 | 790 | } |
4d94ae00 | 791 | |
5f3d6f70 BM |
792 | if (BIO_printf(bp, "ECDSA-Parameters: (%d bit)\n", |
793 | BN_num_bits(order)) <= 0) | |
794 | goto err; | |
795 | if (!ECPKParameters_print(bp, x->group, 4)) | |
796 | goto err; | |
4d94ae00 BM |
797 | ret=1; |
798 | err: | |
5f3d6f70 BM |
799 | if (order) |
800 | BN_free(order); | |
14a7cfb3 | 801 | ECerr(EC_F_ECPARAMETERS_PRINT, reason); |
4d94ae00 BM |
802 | return(ret); |
803 | } | |
804 | ||
805 | #endif |