1/* ====================================================================
2 * Copyright (c) 2006 The OpenSSL Project. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in
13 * the documentation and/or other materials provided with the
14 * distribution.
15 *
16 * 3. All advertising materials mentioning features or use of this
17 * software must display the following acknowledgment:
18 * "This product includes software developed by the OpenSSL Project
19 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
20 *
21 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
22 * endorse or promote products derived from this software without
23 * prior written permission. For written permission, please contact
24 * licensing@OpenSSL.org.
25 *
26 * 5. Products derived from this software may not be called "OpenSSL"
27 * nor may "OpenSSL" appear in their names without prior written
28 * permission of the OpenSSL Project.
29 *
30 * 6. Redistributions of any form whatsoever must retain the following
31 * acknowledgment:
32 * "This product includes software developed by the OpenSSL Project
33 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
34 *
35 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
36 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
38 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
39 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
41 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
42 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
43 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
44 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
45 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
46 * OF THE POSSIBILITY OF SUCH DAMAGE.
47 * ====================================================================
48 *
49 * This product includes cryptographic software written by Eric Young
50 * (eay@cryptsoft.com). This product includes software written by Tim
51 * Hudson (tjh@cryptsoft.com). */
52
53#include <openssl/evp.h>
54
55#include <openssl/bio.h>
56#include <openssl/bn.h>
57#include <openssl/dsa.h>
58#include <openssl/ec.h>
59#include <openssl/ec_key.h>
60#include <openssl/mem.h>
61#include <openssl/rsa.h>
62
63#include "../internal.h"
64#include "../fipsmodule/rsa/internal.h"
65
66
67static int bn_print(BIO *bp, const char *number, const BIGNUM *num,
68 uint8_t *buf, int off) {
69 if (num == NULL) {
70 return 1;
71 }
72
73 if (!BIO_indent(bp, off, 128)) {
74 return 0;
75 }
76 if (BN_is_zero(num)) {
77 if (BIO_printf(bp, "%s 0\n", number) <= 0) {
78 return 0;
79 }
80 return 1;
81 }
82
83 if (BN_num_bytes(num) <= sizeof(long)) {
84 const char *neg = BN_is_negative(num) ? "-" : "";
85 if (BIO_printf(bp, "%s %s%lu (%s0x%lx)\n", number, neg,
86 (unsigned long)num->d[0], neg,
87 (unsigned long)num->d[0]) <= 0) {
88 return 0;
89 }
90 } else {
91 buf[0] = 0;
92 if (BIO_printf(bp, "%s%s", number,
93 (BN_is_negative(num)) ? " (Negative)" : "") <= 0) {
94 return 0;
95 }
96 int n = BN_bn2bin(num, &buf[1]);
97
98 if (buf[1] & 0x80) {
99 n++;
100 } else {
101 buf++;
102 }
103
104 int i;
105 for (i = 0; i < n; i++) {
106 if ((i % 15) == 0) {
107 if (BIO_puts(bp, "\n") <= 0 ||
108 !BIO_indent(bp, off + 4, 128)) {
109 return 0;
110 }
111 }
112 if (BIO_printf(bp, "%02x%s", buf[i], ((i + 1) == n) ? "" : ":") <= 0) {
113 return 0;
114 }
115 }
116 if (BIO_write(bp, "\n", 1) <= 0) {
117 return 0;
118 }
119 }
120 return 1;
121}
122
123static void update_buflen(const BIGNUM *b, size_t *pbuflen) {
124 if (!b) {
125 return;
126 }
127
128 size_t len = BN_num_bytes(b);
129 if (*pbuflen < len) {
130 *pbuflen = len;
131 }
132}
133
134// RSA keys.
135
136static int do_rsa_print(BIO *out, const RSA *rsa, int off,
137 int include_private) {
138 const char *s, *str;
139 uint8_t *m = NULL;
140 int ret = 0, mod_len = 0;
141 size_t buf_len = 0;
142
143 update_buflen(rsa->n, &buf_len);
144 update_buflen(rsa->e, &buf_len);
145
146 if (include_private) {
147 update_buflen(rsa->d, &buf_len);
148 update_buflen(rsa->p, &buf_len);
149 update_buflen(rsa->q, &buf_len);
150 update_buflen(rsa->dmp1, &buf_len);
151 update_buflen(rsa->dmq1, &buf_len);
152 update_buflen(rsa->iqmp, &buf_len);
153 }
154
155 m = (uint8_t *)OPENSSL_malloc(buf_len + 10);
156 if (m == NULL) {
157 OPENSSL_PUT_ERROR(EVP, ERR_R_MALLOC_FAILURE);
158 goto err;
159 }
160
161 if (rsa->n != NULL) {
162 mod_len = BN_num_bits(rsa->n);
163 }
164
165 if (!BIO_indent(out, off, 128)) {
166 goto err;
167 }
168
169 if (include_private && rsa->d) {
170 if (BIO_printf(out, "Private-Key: (%d bit)\n", mod_len) <= 0) {
171 goto err;
172 }
173 str = "modulus:";
174 s = "publicExponent:";
175 } else {
176 if (BIO_printf(out, "Public-Key: (%d bit)\n", mod_len) <= 0) {
177 goto err;
178 }
179 str = "Modulus:";
180 s = "Exponent:";
181 }
182 if (!bn_print(out, str, rsa->n, m, off) ||
183 !bn_print(out, s, rsa->e, m, off)) {
184 goto err;
185 }
186
187 if (include_private) {
188 if (!bn_print(out, "privateExponent:", rsa->d, m, off) ||
189 !bn_print(out, "prime1:", rsa->p, m, off) ||
190 !bn_print(out, "prime2:", rsa->q, m, off) ||
191 !bn_print(out, "exponent1:", rsa->dmp1, m, off) ||
192 !bn_print(out, "exponent2:", rsa->dmq1, m, off) ||
193 !bn_print(out, "coefficient:", rsa->iqmp, m, off)) {
194 goto err;
195 }
196 }
197 ret = 1;
198
199err:
200 OPENSSL_free(m);
201 return ret;
202}
203
204static int rsa_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
205 ASN1_PCTX *ctx) {
206 return do_rsa_print(bp, pkey->pkey.rsa, indent, 0);
207}
208
209static int rsa_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
210 ASN1_PCTX *ctx) {
211 return do_rsa_print(bp, pkey->pkey.rsa, indent, 1);
212}
213
214
215// DSA keys.
216
217static int do_dsa_print(BIO *bp, const DSA *x, int off, int ptype) {
218 uint8_t *m = NULL;
219 int ret = 0;
220 size_t buf_len = 0;
221 const char *ktype = NULL;
222
223 const BIGNUM *priv_key, *pub_key;
224
225 priv_key = NULL;
226 if (ptype == 2) {
227 priv_key = x->priv_key;
228 }
229
230 pub_key = NULL;
231 if (ptype > 0) {
232 pub_key = x->pub_key;
233 }
234
235 ktype = "DSA-Parameters";
236 if (ptype == 2) {
237 ktype = "Private-Key";
238 } else if (ptype == 1) {
239 ktype = "Public-Key";
240 }
241
242 update_buflen(x->p, &buf_len);
243 update_buflen(x->q, &buf_len);
244 update_buflen(x->g, &buf_len);
245 update_buflen(priv_key, &buf_len);
246 update_buflen(pub_key, &buf_len);
247
248 m = (uint8_t *)OPENSSL_malloc(buf_len + 10);
249 if (m == NULL) {
250 OPENSSL_PUT_ERROR(EVP, ERR_R_MALLOC_FAILURE);
251 goto err;
252 }
253
254 if (priv_key) {
255 if (!BIO_indent(bp, off, 128) ||
256 BIO_printf(bp, "%s: (%d bit)\n", ktype, BN_num_bits(x->p)) <= 0) {
257 goto err;
258 }
259 }
260
261 if (!bn_print(bp, "priv:", priv_key, m, off) ||
262 !bn_print(bp, "pub: ", pub_key, m, off) ||
263 !bn_print(bp, "P: ", x->p, m, off) ||
264 !bn_print(bp, "Q: ", x->q, m, off) ||
265 !bn_print(bp, "G: ", x->g, m, off)) {
266 goto err;
267 }
268 ret = 1;
269
270err:
271 OPENSSL_free(m);
272 return ret;
273}
274
275static int dsa_param_print(BIO *bp, const EVP_PKEY *pkey, int indent,
276 ASN1_PCTX *ctx) {
277 return do_dsa_print(bp, pkey->pkey.dsa, indent, 0);
278}
279
280static int dsa_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
281 ASN1_PCTX *ctx) {
282 return do_dsa_print(bp, pkey->pkey.dsa, indent, 1);
283}
284
285static int dsa_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
286 ASN1_PCTX *ctx) {
287 return do_dsa_print(bp, pkey->pkey.dsa, indent, 2);
288}
289
290
291// EC keys.
292
293static int do_EC_KEY_print(BIO *bp, const EC_KEY *x, int off, int ktype) {
294 uint8_t *buffer = NULL;
295 const char *ecstr;
296 size_t buf_len = 0, i;
297 int ret = 0, reason = ERR_R_BIO_LIB;
298 BIGNUM *order = NULL;
299 BN_CTX *ctx = NULL;
300 const EC_GROUP *group;
301 const EC_POINT *public_key;
302 const BIGNUM *priv_key;
303 uint8_t *pub_key_bytes = NULL;
304 size_t pub_key_bytes_len = 0;
305
306 if (x == NULL || (group = EC_KEY_get0_group(x)) == NULL) {
307 reason = ERR_R_PASSED_NULL_PARAMETER;
308 goto err;
309 }
310
311 ctx = BN_CTX_new();
312 if (ctx == NULL) {
313 reason = ERR_R_MALLOC_FAILURE;
314 goto err;
315 }
316
317 if (ktype > 0) {
318 public_key = EC_KEY_get0_public_key(x);
319 if (public_key != NULL) {
320 pub_key_bytes_len = EC_POINT_point2oct(
321 group, public_key, EC_KEY_get_conv_form(x), NULL, 0, ctx);
322 if (pub_key_bytes_len == 0) {
323 reason = ERR_R_MALLOC_FAILURE;
324 goto err;
325 }
326 pub_key_bytes = OPENSSL_malloc(pub_key_bytes_len);
327 if (pub_key_bytes == NULL) {
328 reason = ERR_R_MALLOC_FAILURE;
329 goto err;
330 }
331 pub_key_bytes_len =
332 EC_POINT_point2oct(group, public_key, EC_KEY_get_conv_form(x),
333 pub_key_bytes, pub_key_bytes_len, ctx);
334 if (pub_key_bytes_len == 0) {
335 reason = ERR_R_MALLOC_FAILURE;
336 goto err;
337 }
338 buf_len = pub_key_bytes_len;
339 }
340 }
341
342 if (ktype == 2) {
343 priv_key = EC_KEY_get0_private_key(x);
344 if (priv_key && (i = (size_t)BN_num_bytes(priv_key)) > buf_len) {
345 buf_len = i;
346 }
347 } else {
348 priv_key = NULL;
349 }
350
351 if (ktype > 0) {
352 buf_len += 10;
353 if ((buffer = OPENSSL_malloc(buf_len)) == NULL) {
354 reason = ERR_R_MALLOC_FAILURE;
355 goto err;
356 }
357 }
358 if (ktype == 2) {
359 ecstr = "Private-Key";
360 } else if (ktype == 1) {
361 ecstr = "Public-Key";
362 } else {
363 ecstr = "ECDSA-Parameters";
364 }
365
366 if (!BIO_indent(bp, off, 128)) {
367 goto err;
368 }
369 order = BN_new();
370 if (order == NULL || !EC_GROUP_get_order(group, order, NULL) ||
371 BIO_printf(bp, "%s: (%d bit)\n", ecstr, BN_num_bits(order)) <= 0) {
372 goto err;
373 }
374
375 if ((priv_key != NULL) &&
376 !bn_print(bp, "priv:", priv_key, buffer, off)) {
377 goto err;
378 }
379 if (pub_key_bytes != NULL) {
380 BIO_hexdump(bp, pub_key_bytes, pub_key_bytes_len, off);
381 }
382 // TODO(fork): implement
383 /*
384 if (!ECPKParameters_print(bp, group, off))
385 goto err; */
386 ret = 1;
387
388err:
389 if (!ret) {
390 OPENSSL_PUT_ERROR(EVP, reason);
391 }
392 OPENSSL_free(pub_key_bytes);
393 BN_free(order);
394 BN_CTX_free(ctx);
395 OPENSSL_free(buffer);
396 return ret;
397}
398
399static int eckey_param_print(BIO *bp, const EVP_PKEY *pkey, int indent,
400 ASN1_PCTX *ctx) {
401 return do_EC_KEY_print(bp, pkey->pkey.ec, indent, 0);
402}
403
404static int eckey_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
405 ASN1_PCTX *ctx) {
406 return do_EC_KEY_print(bp, pkey->pkey.ec, indent, 1);
407}
408
409
410static int eckey_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
411 ASN1_PCTX *ctx) {
412 return do_EC_KEY_print(bp, pkey->pkey.ec, indent, 2);
413}
414
415
416typedef struct {
417 int type;
418 int (*pub_print)(BIO *out, const EVP_PKEY *pkey, int indent, ASN1_PCTX *pctx);
419 int (*priv_print)(BIO *out, const EVP_PKEY *pkey, int indent,
420 ASN1_PCTX *pctx);
421 int (*param_print)(BIO *out, const EVP_PKEY *pkey, int indent,
422 ASN1_PCTX *pctx);
423} EVP_PKEY_PRINT_METHOD;
424
425static EVP_PKEY_PRINT_METHOD kPrintMethods[] = {
426 {
427 EVP_PKEY_RSA,
428 rsa_pub_print,
429 rsa_priv_print,
430 NULL /* param_print */,
431 },
432 {
433 EVP_PKEY_DSA,
434 dsa_pub_print,
435 dsa_priv_print,
436 dsa_param_print,
437 },
438 {
439 EVP_PKEY_EC,
440 eckey_pub_print,
441 eckey_priv_print,
442 eckey_param_print,
443 },
444};
445
446static size_t kPrintMethodsLen = OPENSSL_ARRAY_SIZE(kPrintMethods);
447
448static EVP_PKEY_PRINT_METHOD *find_method(int type) {
449 for (size_t i = 0; i < kPrintMethodsLen; i++) {
450 if (kPrintMethods[i].type == type) {
451 return &kPrintMethods[i];
452 }
453 }
454 return NULL;
455}
456
457static int print_unsupported(BIO *out, const EVP_PKEY *pkey, int indent,
458 const char *kstr) {
459 BIO_indent(out, indent, 128);
460 BIO_printf(out, "%s algorithm unsupported\n", kstr);
461 return 1;
462}
463
464int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey, int indent,
465 ASN1_PCTX *pctx) {
466 EVP_PKEY_PRINT_METHOD *method = find_method(pkey->type);
467 if (method != NULL && method->pub_print != NULL) {
468 return method->pub_print(out, pkey, indent, pctx);
469 }
470 return print_unsupported(out, pkey, indent, "Public Key");
471}
472
473int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey, int indent,
474 ASN1_PCTX *pctx) {
475 EVP_PKEY_PRINT_METHOD *method = find_method(pkey->type);
476 if (method != NULL && method->priv_print != NULL) {
477 return method->priv_print(out, pkey, indent, pctx);
478 }
479 return print_unsupported(out, pkey, indent, "Private Key");
480}
481
482int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey, int indent,
483 ASN1_PCTX *pctx) {
484 EVP_PKEY_PRINT_METHOD *method = find_method(pkey->type);
485 if (method != NULL && method->param_print != NULL) {
486 return method->param_print(out, pkey, indent, pctx);
487 }
488 return print_unsupported(out, pkey, indent, "Parameters");
489}
490