make
[openssl.git] / crypto / asn1 / t_pkey.c
1 /* crypto/asn1/t_pkey.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
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  */
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  */
63
64 #include <stdio.h>
65 #include "cryptlib.h"
66 #include <openssl/objects.h>
67 #include <openssl/buffer.h>
68 #include <openssl/bn.h>
69 #ifndef OPENSSL_NO_RSA
70 #include <openssl/rsa.h>
71 #endif
72 #ifndef OPENSSL_NO_DH
73 #include <openssl/dh.h>
74 #endif
75 #ifndef OPENSSL_NO_DSA
76 #include <openssl/dsa.h>
77 #endif
78 #ifndef OPENSSL_NO_EC
79 #include <openssl/ec.h>
80 #endif
81
82 static int print(BIO *fp,const char *str, const BIGNUM *num,
83                 unsigned char *buf,int off);
84 #ifndef OPENSSL_NO_EC
85 static int print_bin(BIO *fp, const char *str, const unsigned char *num,
86                 size_t len, int off);
87 #endif
88 #ifndef OPENSSL_NO_RSA
89 #ifndef OPENSSL_NO_FP_API
90 int RSA_print_fp(FILE *fp, const RSA *x, int off)
91         {
92         BIO *b;
93         int ret;
94
95         if ((b=BIO_new(BIO_s_file())) == NULL)
96                 {
97                 RSAerr(RSA_F_RSA_PRINT_FP,ERR_R_BUF_LIB);
98                 return(0);
99                 }
100         BIO_set_fp(b,fp,BIO_NOCLOSE);
101         ret=RSA_print(b,x,off);
102         BIO_free(b);
103         return(ret);
104         }
105 #endif
106
107 int RSA_print(BIO *bp, const RSA *x, int off)
108         {
109         char str[128];
110         const char *s;
111         unsigned char *m=NULL;
112         int ret=0;
113         size_t buf_len=0, i;
114
115         if (x->n)
116                 buf_len = (size_t)BN_num_bytes(x->n);
117         if (x->e)
118                 if (buf_len < (i = (size_t)BN_num_bytes(x->e)))
119                         buf_len = i;
120         if (x->d)
121                 if (buf_len < (i = (size_t)BN_num_bytes(x->d)))
122                         buf_len = i;
123         if (x->p)
124                 if (buf_len < (i = (size_t)BN_num_bytes(x->p)))
125                         buf_len = i;
126         if (x->q)
127                 if (buf_len < (i = (size_t)BN_num_bytes(x->q)))
128                         buf_len = i;
129         if (x->dmp1)
130                 if (buf_len < (i = (size_t)BN_num_bytes(x->dmp1)))
131                         buf_len = i;
132         if (x->dmq1)
133                 if (buf_len < (i = (size_t)BN_num_bytes(x->dmq1)))
134                         buf_len = i;
135         if (x->iqmp)
136                 if (buf_len < (i = (size_t)BN_num_bytes(x->iqmp)))
137                         buf_len = i;
138
139         m=(unsigned char *)OPENSSL_malloc(buf_len+10);
140         if (m == NULL)
141                 {
142                 RSAerr(RSA_F_RSA_PRINT,ERR_R_MALLOC_FAILURE);
143                 goto err;
144                 }
145
146         if (x->d != NULL)
147                 {
148                 if(!BIO_indent(bp,off,128))
149                    goto err;
150                 if (BIO_printf(bp,"Private-Key: (%d bit)\n",BN_num_bits(x->n))
151                         <= 0) goto err;
152                 }
153
154         if (x->d == NULL)
155                 BIO_snprintf(str,sizeof str,"Modulus (%d bit):",BN_num_bits(x->n));
156         else
157                 BUF_strlcpy(str,"modulus:",sizeof str);
158         if (!print(bp,str,x->n,m,off)) goto err;
159         s=(x->d == NULL)?"Exponent:":"publicExponent:";
160         if (!print(bp,s,x->e,m,off)) goto err;
161         if (!print(bp,"privateExponent:",x->d,m,off)) goto err;
162         if (!print(bp,"prime1:",x->p,m,off)) goto err;
163         if (!print(bp,"prime2:",x->q,m,off)) goto err;
164         if (!print(bp,"exponent1:",x->dmp1,m,off)) goto err;
165         if (!print(bp,"exponent2:",x->dmq1,m,off)) goto err;
166         if (!print(bp,"coefficient:",x->iqmp,m,off)) goto err;
167         ret=1;
168 err:
169         if (m != NULL) OPENSSL_free(m);
170         return(ret);
171         }
172 #endif /* OPENSSL_NO_RSA */
173
174 #ifndef OPENSSL_NO_DSA
175 #ifndef OPENSSL_NO_FP_API
176 int DSA_print_fp(FILE *fp, const DSA *x, int off)
177         {
178         BIO *b;
179         int ret;
180
181         if ((b=BIO_new(BIO_s_file())) == NULL)
182                 {
183                 DSAerr(DSA_F_DSA_PRINT_FP,ERR_R_BUF_LIB);
184                 return(0);
185                 }
186         BIO_set_fp(b,fp,BIO_NOCLOSE);
187         ret=DSA_print(b,x,off);
188         BIO_free(b);
189         return(ret);
190         }
191 #endif
192
193 int DSA_print(BIO *bp, const DSA *x, int off)
194         {
195         unsigned char *m=NULL;
196         int ret=0;
197         size_t buf_len=0,i;
198
199         if (x->p)
200                 buf_len = (size_t)BN_num_bytes(x->p);
201         if (x->q)
202                 if (buf_len < (i = (size_t)BN_num_bytes(x->q)))
203                         buf_len = i;
204         if (x->g)
205                 if (buf_len < (i = (size_t)BN_num_bytes(x->g)))
206                         buf_len = i;
207         if (x->priv_key)
208                 if (buf_len < (i = (size_t)BN_num_bytes(x->priv_key)))
209                         buf_len = i;
210         if (x->pub_key)
211                 if (buf_len < (i = (size_t)BN_num_bytes(x->pub_key)))
212                         buf_len = i;
213
214         m=(unsigned char *)OPENSSL_malloc(buf_len+10);
215         if (m == NULL)
216                 {
217                 DSAerr(DSA_F_DSA_PRINT,ERR_R_MALLOC_FAILURE);
218                 goto err;
219                 }
220
221         if (x->priv_key != NULL)
222                 {
223                 if(!BIO_indent(bp,off,128))
224                    goto err;
225                 if (BIO_printf(bp,"Private-Key: (%d bit)\n",BN_num_bits(x->p))
226                         <= 0) goto err;
227                 }
228
229         if ((x->priv_key != NULL) && !print(bp,"priv:",x->priv_key,m,off))
230                 goto err;
231         if ((x->pub_key  != NULL) && !print(bp,"pub: ",x->pub_key,m,off))
232                 goto err;
233         if ((x->p != NULL) && !print(bp,"P:   ",x->p,m,off)) goto err;
234         if ((x->q != NULL) && !print(bp,"Q:   ",x->q,m,off)) goto err;
235         if ((x->g != NULL) && !print(bp,"G:   ",x->g,m,off)) goto err;
236         ret=1;
237 err:
238         if (m != NULL) OPENSSL_free(m);
239         return(ret);
240         }
241 #endif /* !OPENSSL_NO_DSA */
242
243 #ifndef OPENSSL_NO_EC
244 #ifndef OPENSSL_NO_FP_API
245 int ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x, int off)
246         {
247         BIO *b;
248         int ret;
249
250         if ((b=BIO_new(BIO_s_file())) == NULL)
251                 {
252                 ECerr(EC_F_ECPKPARAMETERS_PRINT_FP,ERR_R_BUF_LIB);
253                 return(0);
254                 }
255         BIO_set_fp(b, fp, BIO_NOCLOSE);
256         ret = ECPKParameters_print(b, x, off);
257         BIO_free(b);
258         return(ret);
259         }
260
261 int EC_KEY_print_fp(FILE *fp, const EC_KEY *x, int off)
262         {
263         BIO *b;
264         int ret;
265  
266         if ((b=BIO_new(BIO_s_file())) == NULL)
267                 {
268                 ECerr(EC_F_EC_KEY_PRINT_FP, ERR_R_BIO_LIB);
269                 return(0);
270                 }
271         BIO_set_fp(b, fp, BIO_NOCLOSE);
272         ret = EC_KEY_print(b, x, off);
273         BIO_free(b);
274         return(ret);
275         }
276 #endif
277
278 int ECPKParameters_print(BIO *bp, const EC_GROUP *x, int off)
279         {
280         unsigned char *buffer=NULL;
281         size_t  buf_len=0, i;
282         int     ret=0, reason=ERR_R_BIO_LIB;
283         BN_CTX  *ctx=NULL;
284         const EC_POINT *point=NULL;
285         BIGNUM  *p=NULL, *a=NULL, *b=NULL, *gen=NULL,
286                 *order=NULL, *cofactor=NULL;
287         const unsigned char *seed;
288         size_t  seed_len=0;
289         
290         static const char *gen_compressed = "Generator (compressed):";
291         static const char *gen_uncompressed = "Generator (uncompressed):";
292         static const char *gen_hybrid = "Generator (hybrid):";
293  
294         if (!x)
295                 {
296                 reason = ERR_R_PASSED_NULL_PARAMETER;
297                 goto err;
298                 }
299
300         if (EC_GROUP_get_asn1_flag(x))
301                 {
302                 /* the curve parameter are given by an asn1 OID */
303                 int nid;
304
305                 if (!BIO_indent(bp, off, 128))
306                         goto err;
307
308                 nid = EC_GROUP_get_curve_name(x);
309                 if (nid == 0)
310                         goto err;
311
312                 if (BIO_printf(bp, "ASN1 OID: %s", OBJ_nid2sn(nid)) <= 0)
313                         goto err;
314                 if (BIO_printf(bp, "\n") <= 0)
315                         goto err;
316                 }
317         else
318                 {
319                 /* explicit parameters */
320                 int is_char_two = 0;
321                 point_conversion_form_t form;
322                 int tmp_nid = EC_METHOD_get_field_type(EC_GROUP_method_of(x));
323
324                 if (tmp_nid == NID_X9_62_characteristic_two_field)
325                         is_char_two = 1;
326
327                 if ((p = BN_new()) == NULL || (a = BN_new()) == NULL ||
328                         (b = BN_new()) == NULL || (order = BN_new()) == NULL ||
329                         (cofactor = BN_new()) == NULL)
330                         {
331                         reason = ERR_R_MALLOC_FAILURE;
332                         goto err;
333                         }
334
335                 if (is_char_two)
336                         {
337                         if (!EC_GROUP_get_curve_GF2m(x, p, a, b, ctx))
338                                 {
339                                 reason = ERR_R_EC_LIB;
340                                 goto err;
341                                 }
342                         }
343                 else /* prime field */
344                         {
345                         if (!EC_GROUP_get_curve_GFp(x, p, a, b, ctx))
346                                 {
347                                 reason = ERR_R_EC_LIB;
348                                 goto err;
349                                 }
350                         }
351
352                 if ((point = EC_GROUP_get0_generator(x)) == NULL)
353                         {
354                         reason = ERR_R_EC_LIB;
355                         goto err;
356                         }
357                 if (!EC_GROUP_get_order(x, order, NULL) || 
358                         !EC_GROUP_get_cofactor(x, cofactor, NULL))
359                         {
360                         reason = ERR_R_EC_LIB;
361                         goto err;
362                         }
363                 
364                 form = EC_GROUP_get_point_conversion_form(x);
365
366                 if ((gen = EC_POINT_point2bn(x, point, 
367                                 form, NULL, ctx)) == NULL)
368                         {
369                         reason = ERR_R_EC_LIB;
370                         goto err;
371                         }
372
373                 buf_len = (size_t)BN_num_bytes(p);
374                 if (buf_len < (i = (size_t)BN_num_bytes(a)))
375                         buf_len = i;
376                 if (buf_len < (i = (size_t)BN_num_bytes(b)))
377                         buf_len = i;
378                 if (buf_len < (i = (size_t)BN_num_bytes(gen)))
379                         buf_len = i;
380                 if (buf_len < (i = (size_t)BN_num_bytes(order)))
381                         buf_len = i;
382                 if (buf_len < (i = (size_t)BN_num_bytes(cofactor))) 
383                         buf_len = i;
384
385                 if ((seed = EC_GROUP_get0_seed(x)) != NULL)
386                         seed_len = EC_GROUP_get_seed_len(x);
387
388                 buf_len += 10;
389                 if ((buffer = OPENSSL_malloc(buf_len)) == NULL)
390                         {
391                         reason = ERR_R_MALLOC_FAILURE;
392                         goto err;
393                         }
394
395                 if (!BIO_indent(bp, off, 128))
396                         goto err;
397
398                 /* print the 'short name' of the field type */
399                 if (BIO_printf(bp, "Field Type: %s\n", OBJ_nid2sn(tmp_nid))
400                         <= 0)
401                         goto err;  
402
403                 if (is_char_two)
404                         {
405                         /* print the 'short name' of the base type OID */
406                         int basis_type = EC_GROUP_get_basis_type(x);
407                         if (basis_type == 0)
408                                 goto err;
409
410                         if (!BIO_indent(bp, off, 128))
411                                 goto err;
412
413                         if (BIO_printf(bp, "Basis Type: %s\n", 
414                                 OBJ_nid2sn(basis_type)) <= 0)
415                                 goto err;
416
417                         /* print the polynomial */
418                         if ((p != NULL) && !print(bp, "Polynomial:", p, buffer,
419                                 off))
420                                 goto err;
421                         }
422                 else
423                         {
424                         if ((p != NULL) && !print(bp, "Prime:", p, buffer,off))
425                                 goto err;
426                         }
427                 if ((a != NULL) && !print(bp, "A:   ", a, buffer, off)) 
428                         goto err;
429                 if ((b != NULL) && !print(bp, "B:   ", b, buffer, off))
430                         goto err;
431                 if (form == POINT_CONVERSION_COMPRESSED)
432                         {
433                         if ((gen != NULL) && !print(bp, gen_compressed, gen,
434                                 buffer, off))
435                                 goto err;
436                         }
437                 else if (form == POINT_CONVERSION_UNCOMPRESSED)
438                         {
439                         if ((gen != NULL) && !print(bp, gen_uncompressed, gen,
440                                 buffer, off))
441                                 goto err;
442                         }
443                 else /* form == POINT_CONVERSION_HYBRID */
444                         {
445                         if ((gen != NULL) && !print(bp, gen_hybrid, gen,
446                                 buffer, off))
447                                 goto err;
448                         }
449                 if ((order != NULL) && !print(bp, "Order: ", order, 
450                         buffer, off)) goto err;
451                 if ((cofactor != NULL) && !print(bp, "Cofactor: ", cofactor, 
452                         buffer, off)) goto err;
453                 if (seed && !print_bin(bp, "Seed:", seed, seed_len, off))
454                         goto err;
455                 }
456         ret=1;
457 err:
458         if (!ret)
459                 ECerr(EC_F_ECPKPARAMETERS_PRINT, reason);
460         if (p) 
461                 BN_free(p);
462         if (a) 
463                 BN_free(a);
464         if (b)
465                 BN_free(b);
466         if (gen)
467                 BN_free(gen);
468         if (order)
469                 BN_free(order);
470         if (cofactor)
471                 BN_free(cofactor);
472         if (ctx)
473                 BN_CTX_free(ctx);
474         if (buffer != NULL) 
475                 OPENSSL_free(buffer);
476         return(ret);    
477         }
478
479 int EC_KEY_print(BIO *bp, const EC_KEY *x, int off)
480         {
481         unsigned char *buffer=NULL;
482         size_t  buf_len=0, i;
483         int     ret=0, reason=ERR_R_BIO_LIB;
484         BIGNUM  *pub_key=NULL, *order=NULL;
485         BN_CTX  *ctx=NULL;
486         const EC_GROUP *group;
487         const EC_POINT *public_key;
488         const BIGNUM *priv_key;
489  
490         if (x == NULL || (group = EC_KEY_get0_group(x)) == NULL)
491                 {
492                 reason = ERR_R_PASSED_NULL_PARAMETER;
493                 goto err;
494                 }
495
496         public_key = EC_KEY_get0_public_key(x);
497         if ((pub_key = EC_POINT_point2bn(group, public_key,
498                 EC_KEY_get_conv_form(x), NULL, ctx)) == NULL)
499                 {
500                 reason = ERR_R_EC_LIB;
501                 goto err;
502                 }
503
504         buf_len = (size_t)BN_num_bytes(pub_key);
505         priv_key = EC_KEY_get0_private_key(x);
506         if (priv_key != NULL)
507                 {
508                 if ((i = (size_t)BN_num_bytes(priv_key)) > buf_len)
509                         buf_len = i;
510                 }
511
512         buf_len += 10;
513         if ((buffer = OPENSSL_malloc(buf_len)) == NULL)
514                 {
515                 reason = ERR_R_MALLOC_FAILURE;
516                 goto err;
517                 }
518
519         if (priv_key != NULL)
520                 {
521                 if (!BIO_indent(bp, off, 128))
522                         goto err;
523                 if ((order = BN_new()) == NULL)
524                         goto err;
525                 if (!EC_GROUP_get_order(group, order, NULL))
526                         goto err;
527                 if (BIO_printf(bp, "Private-Key: (%d bit)\n", 
528                         BN_num_bits(order)) <= 0) goto err;
529                 }
530   
531         if ((priv_key != NULL) && !print(bp, "priv:", priv_key, 
532                 buffer, off))
533                 goto err;
534         if ((pub_key != NULL) && !print(bp, "pub: ", pub_key,
535                 buffer, off))
536                 goto err;
537         if (!ECPKParameters_print(bp, group, off))
538                 goto err;
539         ret=1;
540 err:
541         if (!ret)
542                 ECerr(EC_F_EC_KEY_PRINT, reason);
543         if (pub_key) 
544                 BN_free(pub_key);
545         if (order)
546                 BN_free(order);
547         if (ctx)
548                 BN_CTX_free(ctx);
549         if (buffer != NULL)
550                 OPENSSL_free(buffer);
551         return(ret);
552         }
553 #endif /* OPENSSL_NO_EC */
554
555 static int print(BIO *bp, const char *number, const BIGNUM *num, unsigned char *buf,
556              int off)
557         {
558         int n,i;
559         const char *neg;
560
561         if (num == NULL) return(1);
562         neg = (BN_is_negative(num))?"-":"";
563         if(!BIO_indent(bp,off,128))
564                 return 0;
565         if (BN_is_zero(num))
566                 {
567                 if (BIO_printf(bp, "%s 0\n", number) <= 0)
568                         return 0;
569                 return 1;
570                 }
571
572         if (BN_num_bytes(num) <= BN_BYTES)
573                 {
574                 if (BIO_printf(bp,"%s %s%lu (%s0x%lx)\n",number,neg,
575                         (unsigned long)num->d[0],neg,(unsigned long)num->d[0])
576                         <= 0) return(0);
577                 }
578         else
579                 {
580                 buf[0]=0;
581                 if (BIO_printf(bp,"%s%s",number,
582                         (neg[0] == '-')?" (Negative)":"") <= 0)
583                         return(0);
584                 n=BN_bn2bin(num,&buf[1]);
585         
586                 if (buf[1] & 0x80)
587                         n++;
588                 else    buf++;
589
590                 for (i=0; i<n; i++)
591                         {
592                         if ((i%15) == 0)
593                                 {
594                                 if(BIO_puts(bp,"\n") <= 0
595                                    || !BIO_indent(bp,off+4,128))
596                                     return 0;
597                                 }
598                         if (BIO_printf(bp,"%02x%s",buf[i],((i+1) == n)?"":":")
599                                 <= 0) return(0);
600                         }
601                 if (BIO_write(bp,"\n",1) <= 0) return(0);
602                 }
603         return(1);
604         }
605
606 #ifndef OPENSSL_NO_EC
607 static int print_bin(BIO *fp, const char *name, const unsigned char *buf,
608                 size_t len, int off)
609         {
610         size_t i;
611         char str[128];
612
613         if (buf == NULL)
614                 return 1;
615         if (off)
616                 {
617                 if (off > 128)
618                         off=128;
619                 memset(str,' ',off);
620                 if (BIO_write(fp, str, off) <= 0)
621                         return 0;
622                 }
623
624         if (BIO_printf(fp,"%s", name) <= 0)
625                 return 0;
626
627         for (i=0; i<len; i++)
628                 {
629                 if ((i%15) == 0)
630                         {
631                         str[0]='\n';
632                         memset(&(str[1]),' ',off+4);
633                         if (BIO_write(fp, str, off+1+4) <= 0)
634                                 return 0;
635                         }
636                 if (BIO_printf(fp,"%02x%s",buf[i],((i+1) == len)?"":":") <= 0)
637                         return 0;
638                 }
639         if (BIO_write(fp,"\n",1) <= 0)
640                 return 0;
641
642         return 1;
643         }
644 #endif
645
646 #ifndef OPENSSL_NO_DH
647 #ifndef OPENSSL_NO_FP_API
648 int DHparams_print_fp(FILE *fp, const DH *x)
649         {
650         BIO *b;
651         int ret;
652
653         if ((b=BIO_new(BIO_s_file())) == NULL)
654                 {
655                 DHerr(DH_F_DHPARAMS_PRINT_FP,ERR_R_BUF_LIB);
656                 return(0);
657                 }
658         BIO_set_fp(b,fp,BIO_NOCLOSE);
659         ret=DHparams_print(b, x);
660         BIO_free(b);
661         return(ret);
662         }
663 #endif
664
665 int DHparams_print(BIO *bp, const DH *x)
666         {
667         unsigned char *m=NULL;
668         int reason=ERR_R_BUF_LIB,ret=0;
669         size_t buf_len=0, i;
670
671         if (x->p)
672                 buf_len = (size_t)BN_num_bytes(x->p);
673         if (x->g)
674                 if (buf_len < (i = (size_t)BN_num_bytes(x->g)))
675                         buf_len = i;
676         m=(unsigned char *)OPENSSL_malloc(buf_len+10);
677         if (m == NULL)
678                 {
679                 reason=ERR_R_MALLOC_FAILURE;
680                 goto err;
681                 }
682
683         if (BIO_printf(bp,"Diffie-Hellman-Parameters: (%d bit)\n",
684                 BN_num_bits(x->p)) <= 0)
685                 goto err;
686         if (!print(bp,"prime:",x->p,m,4)) goto err;
687         if (!print(bp,"generator:",x->g,m,4)) goto err;
688         if (x->length != 0)
689                 {
690                 if (BIO_printf(bp,"    recommended-private-length: %d bits\n",
691                         (int)x->length) <= 0) goto err;
692                 }
693         ret=1;
694         if (0)
695                 {
696 err:
697                 DHerr(DH_F_DHPARAMS_PRINT,reason);
698                 }
699         if (m != NULL) OPENSSL_free(m);
700         return(ret);
701         }
702 #endif
703
704 #ifndef OPENSSL_NO_DSA
705 #ifndef OPENSSL_NO_FP_API
706 int DSAparams_print_fp(FILE *fp, const DSA *x)
707         {
708         BIO *b;
709         int ret;
710
711         if ((b=BIO_new(BIO_s_file())) == NULL)
712                 {
713                 DSAerr(DSA_F_DSAPARAMS_PRINT_FP,ERR_R_BUF_LIB);
714                 return(0);
715                 }
716         BIO_set_fp(b,fp,BIO_NOCLOSE);
717         ret=DSAparams_print(b, x);
718         BIO_free(b);
719         return(ret);
720         }
721 #endif
722
723 int DSAparams_print(BIO *bp, const DSA *x)
724         {
725         unsigned char *m=NULL;
726         int reason=ERR_R_BUF_LIB,ret=0;
727         size_t buf_len=0,i;
728
729         if (x->p)
730                 buf_len = (size_t)BN_num_bytes(x->p);
731         if (x->q)
732                 if (buf_len < (i = (size_t)BN_num_bytes(x->q)))
733                         buf_len = i;
734         if (x->g)
735                 if (buf_len < (i = (size_t)BN_num_bytes(x->g)))
736                         buf_len = i;
737         m=(unsigned char *)OPENSSL_malloc(buf_len+10);
738         if (m == NULL)
739                 {
740                 reason=ERR_R_MALLOC_FAILURE;
741                 goto err;
742                 }
743
744         if (BIO_printf(bp,"DSA-Parameters: (%d bit)\n",
745                 BN_num_bits(x->p)) <= 0)
746                 goto err;
747         if (!print(bp,"p:",x->p,m,4)) goto err;
748         if (!print(bp,"q:",x->q,m,4)) goto err;
749         if (!print(bp,"g:",x->g,m,4)) goto err;
750         ret=1;
751 err:
752         if (m != NULL) OPENSSL_free(m);
753         DSAerr(DSA_F_DSAPARAMS_PRINT,reason);
754         return(ret);
755         }
756
757 #endif /* !OPENSSL_NO_DSA */
758
759 #ifndef OPENSSL_NO_EC
760 #ifndef OPENSSL_NO_FP_API
761 int ECParameters_print_fp(FILE *fp, const EC_KEY *x)
762         {
763         BIO *b;
764         int ret;
765  
766         if ((b=BIO_new(BIO_s_file())) == NULL)
767                 {
768                 ECerr(EC_F_ECPARAMETERS_PRINT_FP, ERR_R_BIO_LIB);
769                 return(0);
770                 }
771         BIO_set_fp(b, fp, BIO_NOCLOSE);
772         ret = ECParameters_print(b, x);
773         BIO_free(b);
774         return(ret);
775         }
776 #endif
777
778 int ECParameters_print(BIO *bp, const EC_KEY *x)
779         {
780         int     reason=ERR_R_EC_LIB, ret=0;
781         BIGNUM  *order=NULL;
782         const EC_GROUP *group;
783  
784         if (x == NULL || (group = EC_KEY_get0_group(x)) == NULL)
785                 {
786                 reason = ERR_R_PASSED_NULL_PARAMETER;;
787                 goto err;
788                 }
789
790         if ((order = BN_new()) == NULL)
791                 {
792                 reason = ERR_R_MALLOC_FAILURE;
793                 goto err;
794                 }
795
796         if (!EC_GROUP_get_order(group, order, NULL))
797                 {
798                 reason = ERR_R_EC_LIB;
799                 goto err;
800                 }
801  
802         if (BIO_printf(bp, "ECDSA-Parameters: (%d bit)\n", 
803                 BN_num_bits(order)) <= 0)
804                 goto err;
805         if (!ECPKParameters_print(bp, group, 4))
806                 goto err;
807         ret=1;
808 err:
809         if (order)
810                 BN_free(order);
811         ECerr(EC_F_ECPARAMETERS_PRINT, reason);
812         return(ret);
813         }
814   
815 #endif