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