← Back to branch summary

~ubuntu-branches/ubuntu/hardy/openssl/hardy-security

« back to all changes in this revision

Viewing changes to crypto/asn1/t_pkey.c

  • Committer: Bazaar Package Importer
  • Author(s): Kurt Roeckx
  • Date: 2005-12-13 21:37:42 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051213213742-7em5nrw5c7ceegyd
Tags: 0.9.8a-5
http://bugs.debian.org/335912
Stop ssh from crashing randomly on sparc (Closes: #335912)
Patch from upstream cvs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
crypto/asn1/t_pkey.c
55
55
 * copied and put under another distribution licence
56
56
 * [including the GNU Public Licence.]
57
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
 */
58
63
 
59
64
#include <stdio.h>
60
65
#include "cryptlib.h"
 
66
#include <openssl/objects.h>
61
67
#include <openssl/buffer.h>
62
68
#include <openssl/bn.h>
63
69
#ifndef OPENSSL_NO_RSA
69
75
#ifndef OPENSSL_NO_DSA
70
76
#include <openssl/dsa.h>
71
77
#endif
 
78
#ifndef OPENSSL_NO_EC
 
79
#include <openssl/ec.h>
 
80
#endif
72
81
 
73
 
static int print(BIO *fp,const char *str,BIGNUM *num,
 
82
static int print(BIO *fp,const char *str, const BIGNUM *num,
74
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
75
88
#ifndef OPENSSL_NO_RSA
76
89
#ifndef OPENSSL_NO_FP_API
77
90
int RSA_print_fp(FILE *fp, const RSA *x, int off)
78
 
        {
79
 
        BIO *b;
80
 
        int ret;
 
91
        {
 
92
        BIO *b;
 
93
        int ret;
81
94
 
82
 
        if ((b=BIO_new(BIO_s_file())) == NULL)
 
95
        if ((b=BIO_new(BIO_s_file())) == NULL)
83
96
                {
84
97
                RSAerr(RSA_F_RSA_PRINT_FP,ERR_R_BUF_LIB);
85
 
                return(0);
 
98
                return(0);
86
99
                }
87
 
        BIO_set_fp(b,fp,BIO_NOCLOSE);
88
 
        ret=RSA_print(b,x,off);
89
 
        BIO_free(b);
90
 
        return(ret);
91
 
        }
 
100
        BIO_set_fp(b,fp,BIO_NOCLOSE);
 
101
        ret=RSA_print(b,x,off);
 
102
        BIO_free(b);
 
103
        return(ret);
 
104
        }
92
105
#endif
93
106
 
94
107
int RSA_print(BIO *bp, const RSA *x, int off)
185
198
 
186
199
        if (x->p)
187
200
                buf_len = (size_t)BN_num_bytes(x->p);
 
201
        else
 
202
                {
 
203
                DSAerr(DSA_F_DSA_PRINT,DSA_R_MISSING_PARAMETERS);
 
204
                goto err;
 
205
                }
188
206
        if (x->q)
189
207
                if (buf_len < (i = (size_t)BN_num_bytes(x->q)))
190
208
                        buf_len = i;
227
245
        }
228
246
#endif /* !OPENSSL_NO_DSA */
229
247
 
230
 
static int print(BIO *bp, const char *number, BIGNUM *num, unsigned char *buf,
 
248
#ifndef OPENSSL_NO_EC
 
249
#ifndef OPENSSL_NO_FP_API
 
250
int ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x, int off)
 
251
        {
 
252
        BIO *b;
 
253
        int ret;
 
254
 
 
255
        if ((b=BIO_new(BIO_s_file())) == NULL)
 
256
                {
 
257
                ECerr(EC_F_ECPKPARAMETERS_PRINT_FP,ERR_R_BUF_LIB);
 
258
                return(0);
 
259
                }
 
260
        BIO_set_fp(b, fp, BIO_NOCLOSE);
 
261
        ret = ECPKParameters_print(b, x, off);
 
262
        BIO_free(b);
 
263
        return(ret);
 
264
        }
 
265
 
 
266
int EC_KEY_print_fp(FILE *fp, const EC_KEY *x, int off)
 
267
        {
 
268
        BIO *b;
 
269
        int ret;
 
270
 
 
271
        if ((b=BIO_new(BIO_s_file())) == NULL)
 
272
                {
 
273
                ECerr(EC_F_EC_KEY_PRINT_FP, ERR_R_BIO_LIB);
 
274
                return(0);
 
275
                }
 
276
        BIO_set_fp(b, fp, BIO_NOCLOSE);
 
277
        ret = EC_KEY_print(b, x, off);
 
278
        BIO_free(b);
 
279
        return(ret);
 
280
        }
 
281
#endif
 
282
 
 
283
int ECPKParameters_print(BIO *bp, const EC_GROUP *x, int off)
 
284
        {
 
285
        unsigned char *buffer=NULL;
 
286
        size_t  buf_len=0, i;
 
287
        int     ret=0, reason=ERR_R_BIO_LIB;
 
288
        BN_CTX  *ctx=NULL;
 
289
        const EC_POINT *point=NULL;
 
290
        BIGNUM  *p=NULL, *a=NULL, *b=NULL, *gen=NULL,
 
291
                *order=NULL, *cofactor=NULL;
 
292
        const unsigned char *seed;
 
293
        size_t  seed_len=0;
 
294
        
 
295
        static const char *gen_compressed = "Generator (compressed):";
 
296
        static const char *gen_uncompressed = "Generator (uncompressed):";
 
297
        static const char *gen_hybrid = "Generator (hybrid):";
 
298
 
 
299
        if (!x)
 
300
                {
 
301
                reason = ERR_R_PASSED_NULL_PARAMETER;
 
302
                goto err;
 
303
                }
 
304
 
 
305
        if (EC_GROUP_get_asn1_flag(x))
 
306
                {
 
307
                /* the curve parameter are given by an asn1 OID */
 
308
                int nid;
 
309
 
 
310
                if (!BIO_indent(bp, off, 128))
 
311
                        goto err;
 
312
 
 
313
                nid = EC_GROUP_get_curve_name(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
 
 
400
                if (!BIO_indent(bp, off, 128))
 
401
                        goto err;
 
402
 
 
403
                /* print the 'short name' of the field type */
 
404
                if (BIO_printf(bp, "Field Type: %s\n", OBJ_nid2sn(tmp_nid))
 
405
                        <= 0)
 
406
                        goto err;  
 
407
 
 
408
                if (is_char_two)
 
409
                        {
 
410
                        /* print the 'short name' of the base type OID */
 
411
                        int basis_type = EC_GROUP_get_basis_type(x);
 
412
                        if (basis_type == 0)
 
413
                                goto err;
 
414
 
 
415
                        if (!BIO_indent(bp, off, 128))
 
416
                                goto err;
 
417
 
 
418
                        if (BIO_printf(bp, "Basis Type: %s\n", 
 
419
                                OBJ_nid2sn(basis_type)) <= 0)
 
420
                                goto err;
 
421
 
 
422
                        /* print the polynomial */
 
423
                        if ((p != NULL) && !print(bp, "Polynomial:", p, buffer,
 
424
                                off))
 
425
                                goto err;
 
426
                        }
 
427
                else
 
428
                        {
 
429
                        if ((p != NULL) && !print(bp, "Prime:", p, buffer,off))
 
430
                                goto err;
 
431
                        }
 
432
                if ((a != NULL) && !print(bp, "A:   ", a, buffer, off)) 
 
433
                        goto err;
 
434
                if ((b != NULL) && !print(bp, "B:   ", b, buffer, off))
 
435
                        goto err;
 
436
                if (form == POINT_CONVERSION_COMPRESSED)
 
437
                        {
 
438
                        if ((gen != NULL) && !print(bp, gen_compressed, gen,
 
439
                                buffer, off))
 
440
                                goto err;
 
441
                        }
 
442
                else if (form == POINT_CONVERSION_UNCOMPRESSED)
 
443
                        {
 
444
                        if ((gen != NULL) && !print(bp, gen_uncompressed, gen,
 
445
                                buffer, off))
 
446
                                goto err;
 
447
                        }
 
448
                else /* form == POINT_CONVERSION_HYBRID */
 
449
                        {
 
450
                        if ((gen != NULL) && !print(bp, gen_hybrid, gen,
 
451
                                buffer, off))
 
452
                                goto err;
 
453
                        }
 
454
                if ((order != NULL) && !print(bp, "Order: ", order, 
 
455
                        buffer, off)) goto err;
 
456
                if ((cofactor != NULL) && !print(bp, "Cofactor: ", cofactor, 
 
457
                        buffer, off)) goto err;
 
458
                if (seed && !print_bin(bp, "Seed:", seed, seed_len, off))
 
459
                        goto err;
 
460
                }
 
461
        ret=1;
 
462
err:
 
463
        if (!ret)
 
464
                ECerr(EC_F_ECPKPARAMETERS_PRINT, reason);
 
465
        if (p) 
 
466
                BN_free(p);
 
467
        if (a) 
 
468
                BN_free(a);
 
469
        if (b)
 
470
                BN_free(b);
 
471
        if (gen)
 
472
                BN_free(gen);
 
473
        if (order)
 
474
                BN_free(order);
 
475
        if (cofactor)
 
476
                BN_free(cofactor);
 
477
        if (ctx)
 
478
                BN_CTX_free(ctx);
 
479
        if (buffer != NULL) 
 
480
                OPENSSL_free(buffer);
 
481
        return(ret);    
 
482
        }
 
483
 
 
484
int EC_KEY_print(BIO *bp, const EC_KEY *x, int off)
 
485
        {
 
486
        unsigned char *buffer=NULL;
 
487
        size_t  buf_len=0, i;
 
488
        int     ret=0, reason=ERR_R_BIO_LIB;
 
489
        BIGNUM  *pub_key=NULL, *order=NULL;
 
490
        BN_CTX  *ctx=NULL;
 
491
        const EC_GROUP *group;
 
492
        const EC_POINT *public_key;
 
493
        const BIGNUM *priv_key;
 
494
 
 
495
        if (x == NULL || (group = EC_KEY_get0_group(x)) == NULL)
 
496
                {
 
497
                reason = ERR_R_PASSED_NULL_PARAMETER;
 
498
                goto err;
 
499
                }
 
500
 
 
501
        public_key = EC_KEY_get0_public_key(x);
 
502
        if ((pub_key = EC_POINT_point2bn(group, public_key,
 
503
                EC_KEY_get_conv_form(x), NULL, ctx)) == NULL)
 
504
                {
 
505
                reason = ERR_R_EC_LIB;
 
506
                goto err;
 
507
                }
 
508
 
 
509
        buf_len = (size_t)BN_num_bytes(pub_key);
 
510
        priv_key = EC_KEY_get0_private_key(x);
 
511
        if (priv_key != NULL)
 
512
                {
 
513
                if ((i = (size_t)BN_num_bytes(priv_key)) > buf_len)
 
514
                        buf_len = i;
 
515
                }
 
516
 
 
517
        buf_len += 10;
 
518
        if ((buffer = OPENSSL_malloc(buf_len)) == NULL)
 
519
                {
 
520
                reason = ERR_R_MALLOC_FAILURE;
 
521
                goto err;
 
522
                }
 
523
 
 
524
        if (priv_key != NULL)
 
525
                {
 
526
                if (!BIO_indent(bp, off, 128))
 
527
                        goto err;
 
528
                if ((order = BN_new()) == NULL)
 
529
                        goto err;
 
530
                if (!EC_GROUP_get_order(group, order, NULL))
 
531
                        goto err;
 
532
                if (BIO_printf(bp, "Private-Key: (%d bit)\n", 
 
533
                        BN_num_bits(order)) <= 0) goto err;
 
534
                }
 
535
  
 
536
        if ((priv_key != NULL) && !print(bp, "priv:", priv_key, 
 
537
                buffer, off))
 
538
                goto err;
 
539
        if ((pub_key != NULL) && !print(bp, "pub: ", pub_key,
 
540
                buffer, off))
 
541
                goto err;
 
542
        if (!ECPKParameters_print(bp, group, off))
 
543
                goto err;
 
544
        ret=1;
 
545
err:
 
546
        if (!ret)
 
547
                ECerr(EC_F_EC_KEY_PRINT, reason);
 
548
        if (pub_key) 
 
549
                BN_free(pub_key);
 
550
        if (order)
 
551
                BN_free(order);
 
552
        if (ctx)
 
553
                BN_CTX_free(ctx);
 
554
        if (buffer != NULL)
 
555
                OPENSSL_free(buffer);
 
556
        return(ret);
 
557
        }
 
558
#endif /* OPENSSL_NO_EC */
 
559
 
 
560
static int print(BIO *bp, const char *number, const BIGNUM *num, unsigned char *buf,
231
561
             int off)
232
562
        {
233
563
        int n,i;
234
564
        const char *neg;
235
565
 
236
566
        if (num == NULL) return(1);
237
 
        neg=(num->neg)?"-":"";
 
567
        neg = (BN_is_negative(num))?"-":"";
238
568
        if(!BIO_indent(bp,off,128))
239
569
                return 0;
 
570
        if (BN_is_zero(num))
 
571
                {
 
572
                if (BIO_printf(bp, "%s 0\n", number) <= 0)
 
573
                        return 0;
 
574
                return 1;
 
575
                }
240
576
 
241
577
        if (BN_num_bytes(num) <= BN_BYTES)
242
578
                {
272
608
        return(1);
273
609
        }
274
610
 
 
611
#ifndef OPENSSL_NO_EC
 
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
#endif
 
650
 
275
651
#ifndef OPENSSL_NO_DH
276
652
#ifndef OPENSSL_NO_FP_API
277
653
int DHparams_print_fp(FILE *fp, const DH *x)
278
 
        {
279
 
        BIO *b;
280
 
        int ret;
 
654
        {
 
655
        BIO *b;
 
656
        int ret;
281
657
 
282
 
        if ((b=BIO_new(BIO_s_file())) == NULL)
 
658
        if ((b=BIO_new(BIO_s_file())) == NULL)
283
659
                {
284
660
                DHerr(DH_F_DHPARAMS_PRINT_FP,ERR_R_BUF_LIB);
285
 
                return(0);
 
661
                return(0);
286
662
                }
287
 
        BIO_set_fp(b,fp,BIO_NOCLOSE);
288
 
        ret=DHparams_print(b, x);
289
 
        BIO_free(b);
290
 
        return(ret);
291
 
        }
 
663
        BIO_set_fp(b,fp,BIO_NOCLOSE);
 
664
        ret=DHparams_print(b, x);
 
665
        BIO_free(b);
 
666
        return(ret);
 
667
        }
292
668
#endif
293
669
 
294
670
int DHparams_print(BIO *bp, const DH *x)
299
675
 
300
676
        if (x->p)
301
677
                buf_len = (size_t)BN_num_bytes(x->p);
 
678
        else
 
679
                {
 
680
                reason = ERR_R_PASSED_NULL_PARAMETER;
 
681
                goto err;
 
682
                }
302
683
        if (x->g)
303
684
                if (buf_len < (i = (size_t)BN_num_bytes(x->g)))
304
685
                        buf_len = i;
333
714
#ifndef OPENSSL_NO_DSA
334
715
#ifndef OPENSSL_NO_FP_API
335
716
int DSAparams_print_fp(FILE *fp, const DSA *x)
336
 
        {
337
 
        BIO *b;
338
 
        int ret;
 
717
        {
 
718
        BIO *b;
 
719
        int ret;
339
720
 
340
 
        if ((b=BIO_new(BIO_s_file())) == NULL)
 
721
        if ((b=BIO_new(BIO_s_file())) == NULL)
341
722
                {
342
723
                DSAerr(DSA_F_DSAPARAMS_PRINT_FP,ERR_R_BUF_LIB);
343
 
                return(0);
 
724
                return(0);
344
725
                }
345
 
        BIO_set_fp(b,fp,BIO_NOCLOSE);
346
 
        ret=DSAparams_print(b, x);
347
 
        BIO_free(b);
348
 
        return(ret);
349
 
        }
 
726
        BIO_set_fp(b,fp,BIO_NOCLOSE);
 
727
        ret=DSAparams_print(b, x);
 
728
        BIO_free(b);
 
729
        return(ret);
 
730
        }
350
731
#endif
351
732
 
352
733
int DSAparams_print(BIO *bp, const DSA *x)
353
734
        {
354
735
        unsigned char *m=NULL;
355
 
        int reason=ERR_R_BUF_LIB,ret=0;
 
736
        int ret=0;
356
737
        size_t buf_len=0,i;
357
738
 
358
739
        if (x->p)
359
740
                buf_len = (size_t)BN_num_bytes(x->p);
 
741
        else
 
742
                {
 
743
                DSAerr(DSA_F_DSA_PRINT,DSA_R_MISSING_PARAMETERS);
 
744
                goto err;
 
745
                }
360
746
        if (x->q)
361
747
                if (buf_len < (i = (size_t)BN_num_bytes(x->q)))
362
748
                        buf_len = i;
366
752
        m=(unsigned char *)OPENSSL_malloc(buf_len+10);
367
753
        if (m == NULL)
368
754
                {
369
 
                reason=ERR_R_MALLOC_FAILURE;
 
755
                DSAerr(DSA_F_DSA_PRINT,ERR_R_MALLOC_FAILURE);
370
756
                goto err;
371
757
                }
372
758
 
379
765
        ret=1;
380
766
err:
381
767
        if (m != NULL) OPENSSL_free(m);
382
 
        DSAerr(DSA_F_DSAPARAMS_PRINT,reason);
383
768
        return(ret);
384
769
        }
385
770
 
386
771
#endif /* !OPENSSL_NO_DSA */
387
772
 
 
773
#ifndef OPENSSL_NO_EC
 
774
#ifndef OPENSSL_NO_FP_API
 
775
int ECParameters_print_fp(FILE *fp, const EC_KEY *x)
 
776
        {
 
777
        BIO *b;
 
778
        int ret;
 
779
 
 
780
        if ((b=BIO_new(BIO_s_file())) == NULL)
 
781
                {
 
782
                ECerr(EC_F_ECPARAMETERS_PRINT_FP, ERR_R_BIO_LIB);
 
783
                return(0);
 
784
                }
 
785
        BIO_set_fp(b, fp, BIO_NOCLOSE);
 
786
        ret = ECParameters_print(b, x);
 
787
        BIO_free(b);
 
788
        return(ret);
 
789
        }
 
790
#endif
 
791
 
 
792
int ECParameters_print(BIO *bp, const EC_KEY *x)
 
793
        {
 
794
        int     reason=ERR_R_EC_LIB, ret=0;
 
795
        BIGNUM  *order=NULL;
 
796
        const EC_GROUP *group;
 
797
 
 
798
        if (x == NULL || (group = EC_KEY_get0_group(x)) == NULL)
 
799
                {
 
800
                reason = ERR_R_PASSED_NULL_PARAMETER;;
 
801
                goto err;
 
802
                }
 
803
 
 
804
        if ((order = BN_new()) == NULL)
 
805
                {
 
806
                reason = ERR_R_MALLOC_FAILURE;
 
807
                goto err;
 
808
                }
 
809
 
 
810
        if (!EC_GROUP_get_order(group, order, NULL))
 
811
                {
 
812
                reason = ERR_R_EC_LIB;
 
813
                goto err;
 
814
                }
 
815
 
 
816
        if (BIO_printf(bp, "ECDSA-Parameters: (%d bit)\n", 
 
817
                BN_num_bits(order)) <= 0)
 
818
                goto err;
 
819
        if (!ECPKParameters_print(bp, group, 4))
 
820
                goto err;
 
821
        ret=1;
 
822
err:
 
823
        if (order)
 
824
                BN_free(order);
 
825
        ECerr(EC_F_ECPARAMETERS_PRINT, reason);
 
826
        return(ret);
 
827
        }
 
828
  
 
829
#endif