use new BIO_indent() function here as well
[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         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,
284                 *order=NULL, *cofactor=NULL;
285         const unsigned char *seed;
286         size_t  seed_len=0;
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
303                 if (!BIO_indent(bp, off, 128))
304                         goto err;
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 */
318                 int is_char_two = 0;
319                 point_conversion_form_t form;
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;
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
333                 if (is_char_two)
334                         {
335                         if (!EC_GROUP_get_curve_GF2m(x, p, a, b, ctx))
336                                 {
337                                 reason = ERR_R_EC_LIB;
338                                 goto err;
339                                 }
340                         }
341                 else /* prime field */
342                         {
343                         if (!EC_GROUP_get_curve_GFp(x, p, a, b, ctx))
344                                 {
345                                 reason = ERR_R_EC_LIB;
346                                 goto err;
347                                 }
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
383                 if ((seed = EC_GROUP_get0_seed(x)) != NULL)
384                         seed_len = EC_GROUP_get_seed_len(x);
385
386                 buf_len += 10;
387                 if ((buffer = OPENSSL_malloc(buf_len)) == NULL)
388                         {
389                         reason = ERR_R_MALLOC_FAILURE;
390                         goto err;
391                         }
392
393                 if (!BIO_indent(bp, off, 128))
394                         goto err;
395
396                 /* print the 'short name' of the field type */
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                         {
403                         /* print the 'short name' of the base type OID */
404                         int basis_type = EC_GROUP_get_basis_type(x);
405                         if (basis_type == 0)
406                                 goto err;
407
408                         if (!BIO_indent(bp, off, 128))
409                                 goto err;
410
411                         if (BIO_printf(bp, "Basis Type: %s\n", 
412                                 OBJ_nid2sn(basis_type)) <= 0)
413                                 goto err;
414
415                         /* print the polynomial */
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;
424                         }
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;
451                 if (seed && !print_bin(bp, "Seed:", seed, seed_len, off))
452                         goto err;
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);
470         if (ctx)
471                 BN_CTX_free(ctx);
472         if (buffer != NULL) 
473                 OPENSSL_free(buffer);
474         return(ret);    
475         }
476
477 int EC_KEY_print(BIO *bp, const EC_KEY *x, int off)
478         {
479         unsigned char *buffer=NULL;
480         size_t  buf_len=0, i;
481         int     ret=0, reason=ERR_R_BIO_LIB;
482         BIGNUM  *pub_key=NULL;
483         BN_CTX  *ctx=NULL;
484  
485         if (!x || !x->group)
486                 {
487                 reason = ERR_R_PASSED_NULL_PARAMETER;
488                 goto err;
489                 }
490
491         if ((pub_key = EC_POINT_point2bn(x->group, x->pub_key,
492                 x->conv_form, NULL, ctx)) == NULL)
493                 {
494                 reason = ERR_R_EC_LIB;
495                 goto err;
496                 }
497
498         buf_len = (size_t)BN_num_bytes(pub_key);
499         if (x->priv_key)
500                 {
501                 if ((i = (size_t)BN_num_bytes(x->priv_key)) > buf_len)
502                         buf_len = i;
503                 }
504
505         buf_len += 10;
506         if ((buffer = OPENSSL_malloc(buf_len)) == NULL)
507                 {
508                 reason = ERR_R_MALLOC_FAILURE;
509                 goto err;
510                 }
511
512         if (x->priv_key != NULL)
513                 {
514                 if (!BIO_indent(bp, off, 128))
515                         goto err;
516                 if (BIO_printf(bp, "Private-Key: (%d bit)\n", 
517                         BN_num_bits(x->priv_key)) <= 0) goto err;
518                 }
519   
520         if ((x->priv_key != NULL) && !print(bp, "priv:", x->priv_key, 
521                 buffer, off))
522                 goto err;
523         if ((pub_key != NULL) && !print(bp, "pub: ", pub_key,
524                 buffer, off))
525                 goto err;
526         if (!ECPKParameters_print(bp, x->group, off))
527                 goto err;
528         ret=1;
529 err:
530         if (!ret)
531                 ECerr(EC_F_EC_KEY_PRINT, reason);
532         if (pub_key) 
533                 BN_free(pub_key);
534         if (ctx)
535                 BN_CTX_free(ctx);
536         if (buffer != NULL)
537                 OPENSSL_free(buffer);
538         return(ret);
539         }
540 #endif /* OPENSSL_NO_EC */
541
542 static int print(BIO *bp, const char *number, BIGNUM *num, unsigned char *buf,
543              int off)
544         {
545         int n,i;
546         const char *neg;
547
548         if (num == NULL) return(1);
549         neg = (BN_get_sign(num))?"-":"";
550         if(!BIO_indent(bp,off,128))
551                 return 0;
552         if (BN_is_zero(num))
553                 {
554                 if (BIO_printf(bp, "%s 0\n", number) <= 0)
555                         return 0;
556                 return 1;
557                 }
558
559         if (BN_num_bytes(num) <= BN_BYTES)
560                 {
561                 if (BIO_printf(bp,"%s %s%lu (%s0x%lx)\n",number,neg,
562                         (unsigned long)num->d[0],neg,(unsigned long)num->d[0])
563                         <= 0) return(0);
564                 }
565         else
566                 {
567                 buf[0]=0;
568                 if (BIO_printf(bp,"%s%s",number,
569                         (neg[0] == '-')?" (Negative)":"") <= 0)
570                         return(0);
571                 n=BN_bn2bin(num,&buf[1]);
572         
573                 if (buf[1] & 0x80)
574                         n++;
575                 else    buf++;
576
577                 for (i=0; i<n; i++)
578                         {
579                         if ((i%15) == 0)
580                                 {
581                                 if(BIO_puts(bp,"\n") <= 0
582                                    || !BIO_indent(bp,off+4,128))
583                                     return 0;
584                                 }
585                         if (BIO_printf(bp,"%02x%s",buf[i],((i+1) == n)?"":":")
586                                 <= 0) return(0);
587                         }
588                 if (BIO_write(bp,"\n",1) <= 0) return(0);
589                 }
590         return(1);
591         }
592
593 static int print_bin(BIO *fp, const char *name, const unsigned char *buf,
594                 size_t len, int off)
595         {
596         size_t i;
597         char str[128];
598
599         if (buf == NULL)
600                 return 1;
601         if (off)
602                 {
603                 if (off > 128)
604                         off=128;
605                 memset(str,' ',off);
606                 if (BIO_write(fp, str, off) <= 0)
607                         return 0;
608                 }
609
610         if (BIO_printf(fp,"%s", name) <= 0)
611                 return 0;
612
613         for (i=0; i<len; i++)
614                 {
615                 if ((i%15) == 0)
616                         {
617                         str[0]='\n';
618                         memset(&(str[1]),' ',off+4);
619                         if (BIO_write(fp, str, off+1+4) <= 0)
620                                 return 0;
621                         }
622                 if (BIO_printf(fp,"%02x%s",buf[i],((i+1) == len)?"":":") <= 0)
623                         return 0;
624                 }
625         if (BIO_write(fp,"\n",1) <= 0)
626                 return 0;
627
628         return 1;
629         }
630
631 #ifndef OPENSSL_NO_DH
632 #ifndef OPENSSL_NO_FP_API
633 int DHparams_print_fp(FILE *fp, const DH *x)
634         {
635         BIO *b;
636         int ret;
637
638         if ((b=BIO_new(BIO_s_file())) == NULL)
639                 {
640                 DHerr(DH_F_DHPARAMS_PRINT_FP,ERR_R_BUF_LIB);
641                 return(0);
642                 }
643         BIO_set_fp(b,fp,BIO_NOCLOSE);
644         ret=DHparams_print(b, x);
645         BIO_free(b);
646         return(ret);
647         }
648 #endif
649
650 int DHparams_print(BIO *bp, const DH *x)
651         {
652         unsigned char *m=NULL;
653         int reason=ERR_R_BUF_LIB,ret=0;
654         size_t buf_len=0, i;
655
656         if (x->p)
657                 buf_len = (size_t)BN_num_bytes(x->p);
658         if (x->g)
659                 if (buf_len < (i = (size_t)BN_num_bytes(x->g)))
660                         buf_len = i;
661         m=(unsigned char *)OPENSSL_malloc(buf_len+10);
662         if (m == NULL)
663                 {
664                 reason=ERR_R_MALLOC_FAILURE;
665                 goto err;
666                 }
667
668         if (BIO_printf(bp,"Diffie-Hellman-Parameters: (%d bit)\n",
669                 BN_num_bits(x->p)) <= 0)
670                 goto err;
671         if (!print(bp,"prime:",x->p,m,4)) goto err;
672         if (!print(bp,"generator:",x->g,m,4)) goto err;
673         if (x->length != 0)
674                 {
675                 if (BIO_printf(bp,"    recommended-private-length: %d bits\n",
676                         (int)x->length) <= 0) goto err;
677                 }
678         ret=1;
679         if (0)
680                 {
681 err:
682                 DHerr(DH_F_DHPARAMS_PRINT,reason);
683                 }
684         if (m != NULL) OPENSSL_free(m);
685         return(ret);
686         }
687 #endif
688
689 #ifndef OPENSSL_NO_DSA
690 #ifndef OPENSSL_NO_FP_API
691 int DSAparams_print_fp(FILE *fp, const DSA *x)
692         {
693         BIO *b;
694         int ret;
695
696         if ((b=BIO_new(BIO_s_file())) == NULL)
697                 {
698                 DSAerr(DSA_F_DSAPARAMS_PRINT_FP,ERR_R_BUF_LIB);
699                 return(0);
700                 }
701         BIO_set_fp(b,fp,BIO_NOCLOSE);
702         ret=DSAparams_print(b, x);
703         BIO_free(b);
704         return(ret);
705         }
706 #endif
707
708 int DSAparams_print(BIO *bp, const DSA *x)
709         {
710         unsigned char *m=NULL;
711         int reason=ERR_R_BUF_LIB,ret=0;
712         size_t buf_len=0,i;
713
714         if (x->p)
715                 buf_len = (size_t)BN_num_bytes(x->p);
716         if (x->q)
717                 if (buf_len < (i = (size_t)BN_num_bytes(x->q)))
718                         buf_len = i;
719         if (x->g)
720                 if (buf_len < (i = (size_t)BN_num_bytes(x->g)))
721                         buf_len = i;
722         m=(unsigned char *)OPENSSL_malloc(buf_len+10);
723         if (m == NULL)
724                 {
725                 reason=ERR_R_MALLOC_FAILURE;
726                 goto err;
727                 }
728
729         if (BIO_printf(bp,"DSA-Parameters: (%d bit)\n",
730                 BN_num_bits(x->p)) <= 0)
731                 goto err;
732         if (!print(bp,"p:",x->p,m,4)) goto err;
733         if (!print(bp,"q:",x->q,m,4)) goto err;
734         if (!print(bp,"g:",x->g,m,4)) goto err;
735         ret=1;
736 err:
737         if (m != NULL) OPENSSL_free(m);
738         DSAerr(DSA_F_DSAPARAMS_PRINT,reason);
739         return(ret);
740         }
741
742 #endif /* !OPENSSL_NO_DSA */
743
744 #ifndef OPENSSL_NO_EC
745 #ifndef OPENSSL_NO_FP_API
746 int ECParameters_print_fp(FILE *fp, const EC_KEY *x)
747         {
748         BIO *b;
749         int ret;
750  
751         if ((b=BIO_new(BIO_s_file())) == NULL)
752                 {
753                 ECerr(EC_F_ECPARAMETERS_PRINT_FP, ERR_R_BIO_LIB);
754                 return(0);
755                 }
756         BIO_set_fp(b, fp, BIO_NOCLOSE);
757         ret = ECParameters_print(b, x);
758         BIO_free(b);
759         return(ret);
760         }
761 #endif
762
763 int ECParameters_print(BIO *bp, const EC_KEY *x)
764         {
765         int     reason=ERR_R_EC_LIB, ret=0;
766         BIGNUM  *order=NULL;
767  
768         if (!x || !x->group)
769                 {
770                 reason = ERR_R_PASSED_NULL_PARAMETER;;
771                 goto err;
772                 }
773
774         if ((order = BN_new()) == NULL)
775                 {
776                 reason = ERR_R_MALLOC_FAILURE;
777                 goto err;
778                 }
779
780         if (!EC_GROUP_get_order(x->group, order, NULL))
781                 {
782                 reason = ERR_R_EC_LIB;
783                 goto err;
784                 }
785  
786         if (BIO_printf(bp, "ECDSA-Parameters: (%d bit)\n", 
787                 BN_num_bits(order)) <= 0)
788                 goto err;
789         if (!ECPKParameters_print(bp, x->group, 4))
790                 goto err;
791         ret=1;
792 err:
793         if (order)
794                 BN_free(order);
795         ECerr(EC_F_ECPARAMETERS_PRINT, reason);
796         return(ret);
797         }
798   
799 #endif