← Back to branch summary

~sbeattie/ubuntu/oneiric/openssl/lp850608

« back to all changes in this revision

Viewing changes to crypto/asn1/t_pkey.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson
  • Date: 2011-05-01 23:51:53 UTC
  • mfrom: (11.1.20 sid)
  • Revision ID: james.westby@ubuntu.com-20110501235153-bjcxitndquaezb68
Tags: 1.0.0d-2ubuntu1
https://launchpad.net/bugs/675566
* Resynchronise with Debian (LP: #675566).  Remaining changes:
  - debian/libssl1.0.0.postinst:
    + Display a system restart required notification bubble on libssl1.0.0
      upgrade.
    + Use a different priority for libssl1.0.0/restart-services depending
      on whether a desktop, or server dist-upgrade is being performed.
  - debian/{libssl1.0.0-udeb.dirs, control, rules}: Create
    libssl1.0.0-udeb, for the benefit of wget-udeb (no wget-udeb package
    in Debian).
  - debian/{libcrypto1.0.0-udeb.dirs, libssl1.0.0.dirs, libssl1.0.0.files,
    rules}: Move runtime libraries to /lib, for the benefit of
    wpasupplicant.
  - debian/patches/aesni.patch: Backport Intel AES-NI support, now from
    http://rt.openssl.org/Ticket/Display.html?id=2065 rather than the
    0.9.8 variant.
  - debian/patches/Bsymbolic-functions.patch: Link using
    -Bsymbolic-functions.
  - debian/patches/perlpath-quilt.patch: Don't change perl #! paths under
    .pc.
  - debian/rules:
    + Don't run 'make test' when cross-building.
    + Use host compiler when cross-building.  Patch from Neil Williams.
    + Don't build for processors no longer supported: i486, i586 (on
      i386), v8 (on sparc).
    + Fix Makefile to properly clean up libs/ dirs in clean target.
    + Replace duplicate files in the doc directory with symlinks.
* Update architectures affected by Bsymbolic-functions.patch.
* Drop debian/patches/no-sslv2.patch; Debian now adds the 'no-ssl2'
  configure option, which compiles out SSLv2 support entirely, so this is
  no longer needed.
* Drop openssl-doc in favour of the libssl-doc package introduced by
  Debian.  Add Conflicts/Replaces until the next LTS release.

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