?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdb/lvm: Fix two -Wformat-extra-args warnings.
[dragonfly.git] / crypto / openssh / sshkey.c
blobe91c54f53bbd03554aca00919018c6459421be4e
1 /* $OpenBSD: sshkey.c,v 1.56 2017/08/12 06:42:52 djm Exp $ */
2 /*
3 * Copyright (c) 2000, 2001 Markus Friedl. All rights reserved.
4 * Copyright (c) 2008 Alexander von Gernler. All rights reserved.
5 * Copyright (c) 2010,2011 Damien Miller. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include "includes.h"
29
30 #include <sys/types.h>
31 #include <netinet/in.h>
32
33 #ifdef WITH_OPENSSL
34 #include <openssl/evp.h>
35 #include <openssl/err.h>
36 #include <openssl/pem.h>
37 #endif
38
39 #include "crypto_api.h"
40
41 #include <errno.h>
42 #include <limits.h>
43 #include <stdio.h>
44 #include <string.h>
45 #include <resolv.h>
46 #ifdef HAVE_UTIL_H
47 #include <util.h>
48 #endif /* HAVE_UTIL_H */
49
50 #include "ssh2.h"
51 #include "ssherr.h"
52 #include "misc.h"
53 #include "sshbuf.h"
54 #include "cipher.h"
55 #include "digest.h"
56 #define SSHKEY_INTERNAL
57 #include "sshkey.h"
58 #include "match.h"
59
60 /* openssh private key file format */
61 #define MARK_BEGIN "-----BEGIN OPENSSH PRIVATE KEY-----\n"
62 #define MARK_END "-----END OPENSSH PRIVATE KEY-----\n"
63 #define MARK_BEGIN_LEN (sizeof(MARK_BEGIN) - 1)
64 #define MARK_END_LEN (sizeof(MARK_END) - 1)
65 #define KDFNAME "bcrypt"
66 #define AUTH_MAGIC "openssh-key-v1"
67 #define SALT_LEN 16
68 #define DEFAULT_CIPHERNAME "aes256-ctr"
69 #define DEFAULT_ROUNDS 16
70
71 /* Version identification string for SSH v1 identity files. */
72 #define LEGACY_BEGIN "SSH PRIVATE KEY FILE FORMAT 1.1\n"
73
74 static int sshkey_from_blob_internal(struct sshbuf *buf,
75 struct sshkey **keyp, int allow_cert);
76
77 /* Supported key types */
78 struct keytype {
79 const char *name;
80 const char *shortname;
81 int type;
82 int nid;
83 int cert;
84 int sigonly;
85 };
86 static const struct keytype keytypes[] = {
87 { "ssh-ed25519", "ED25519", KEY_ED25519, 0, 0, 0 },
88 { "ssh-ed25519-cert-v01@openssh.com", "ED25519-CERT",
89 KEY_ED25519_CERT, 0, 1, 0 },
90 #ifdef WITH_OPENSSL
91 { "ssh-rsa", "RSA", KEY_RSA, 0, 0, 0 },
92 { "rsa-sha2-256", "RSA", KEY_RSA, 0, 0, 1 },
93 { "rsa-sha2-512", "RSA", KEY_RSA, 0, 0, 1 },
94 { "ssh-dss", "DSA", KEY_DSA, 0, 0, 0 },
95 # ifdef OPENSSL_HAS_ECC
96 { "ecdsa-sha2-nistp256", "ECDSA", KEY_ECDSA, NID_X9_62_prime256v1, 0, 0 },
97 { "ecdsa-sha2-nistp384", "ECDSA", KEY_ECDSA, NID_secp384r1, 0, 0 },
98 # ifdef OPENSSL_HAS_NISTP521
99 { "ecdsa-sha2-nistp521", "ECDSA", KEY_ECDSA, NID_secp521r1, 0, 0 },
100 # endif /* OPENSSL_HAS_NISTP521 */
101 # endif /* OPENSSL_HAS_ECC */
102 { "ssh-rsa-cert-v01@openssh.com", "RSA-CERT", KEY_RSA_CERT, 0, 1, 0 },
103 { "ssh-dss-cert-v01@openssh.com", "DSA-CERT", KEY_DSA_CERT, 0, 1, 0 },
104 # ifdef OPENSSL_HAS_ECC
105 { "ecdsa-sha2-nistp256-cert-v01@openssh.com", "ECDSA-CERT",
106 KEY_ECDSA_CERT, NID_X9_62_prime256v1, 1, 0 },
107 { "ecdsa-sha2-nistp384-cert-v01@openssh.com", "ECDSA-CERT",
108 KEY_ECDSA_CERT, NID_secp384r1, 1, 0 },
109 # ifdef OPENSSL_HAS_NISTP521
110 { "ecdsa-sha2-nistp521-cert-v01@openssh.com", "ECDSA-CERT",
111 KEY_ECDSA_CERT, NID_secp521r1, 1, 0 },
112 # endif /* OPENSSL_HAS_NISTP521 */
113 # endif /* OPENSSL_HAS_ECC */
114 #endif /* WITH_OPENSSL */
115 { NULL, NULL, -1, -1, 0, 0 }
116 };
117
118 const char *
119 sshkey_type(const struct sshkey *k)
120 {
121 const struct keytype *kt;
122
123 for (kt = keytypes; kt->type != -1; kt++) {
124 if (kt->type == k->type)
125 return kt->shortname;
126 }
127 return "unknown";
128 }
129
130 static const char *
131 sshkey_ssh_name_from_type_nid(int type, int nid)
132 {
133 const struct keytype *kt;
134
135 for (kt = keytypes; kt->type != -1; kt++) {
136 if (kt->type == type && (kt->nid == 0 || kt->nid == nid))
137 return kt->name;
138 }
139 return "ssh-unknown";
140 }
141
142 int
143 sshkey_type_is_cert(int type)
144 {
145 const struct keytype *kt;
146
147 for (kt = keytypes; kt->type != -1; kt++) {
148 if (kt->type == type)
149 return kt->cert;
150 }
151 return 0;
152 }
153
154 const char *
155 sshkey_ssh_name(const struct sshkey *k)
156 {
157 return sshkey_ssh_name_from_type_nid(k->type, k->ecdsa_nid);
158 }
159
160 const char *
161 sshkey_ssh_name_plain(const struct sshkey *k)
162 {
163 return sshkey_ssh_name_from_type_nid(sshkey_type_plain(k->type),
164 k->ecdsa_nid);
165 }
166
167 int
168 sshkey_type_from_name(const char *name)
169 {
170 const struct keytype *kt;
171
172 for (kt = keytypes; kt->type != -1; kt++) {
173 /* Only allow shortname matches for plain key types */
174 if ((kt->name != NULL && strcmp(name, kt->name) == 0) ||
175 (!kt->cert && strcasecmp(kt->shortname, name) == 0))
176 return kt->type;
177 }
178 return KEY_UNSPEC;
179 }
180
181 int
182 sshkey_ecdsa_nid_from_name(const char *name)
183 {
184 const struct keytype *kt;
185
186 for (kt = keytypes; kt->type != -1; kt++) {
187 if (kt->type != KEY_ECDSA && kt->type != KEY_ECDSA_CERT)
188 continue;
189 if (kt->name != NULL && strcmp(name, kt->name) == 0)
190 return kt->nid;
191 }
192 return -1;
193 }
194
195 char *
196 sshkey_alg_list(int certs_only, int plain_only, int include_sigonly, char sep)
197 {
198 char *tmp, *ret = NULL;
199 size_t nlen, rlen = 0;
200 const struct keytype *kt;
201
202 for (kt = keytypes; kt->type != -1; kt++) {
203 if (kt->name == NULL)
204 continue;
205 if (!include_sigonly && kt->sigonly)
206 continue;
207 if ((certs_only && !kt->cert) || (plain_only && kt->cert))
208 continue;
209 if (ret != NULL)
210 ret[rlen++] = sep;
211 nlen = strlen(kt->name);
212 if ((tmp = realloc(ret, rlen + nlen + 2)) == NULL) {
213 free(ret);
214 return NULL;
215 }
216 ret = tmp;
217 memcpy(ret + rlen, kt->name, nlen + 1);
218 rlen += nlen;
219 }
220 return ret;
221 }
222
223 int
224 sshkey_names_valid2(const char *names, int allow_wildcard)
225 {
226 char *s, *cp, *p;
227 const struct keytype *kt;
228 int type;
229
230 if (names == NULL || strcmp(names, "") == 0)
231 return 0;
232 if ((s = cp = strdup(names)) == NULL)
233 return 0;
234 for ((p = strsep(&cp, ",")); p && *p != '\0';
235 (p = strsep(&cp, ","))) {
236 type = sshkey_type_from_name(p);
237 if (type == KEY_UNSPEC) {
238 if (allow_wildcard) {
239 /*
240 * Try matching key types against the string.
241 * If any has a positive or negative match then
242 * the component is accepted.
243 */
244 for (kt = keytypes; kt->type != -1; kt++) {
245 if (match_pattern_list(kt->name,
246 p, 0) != 0)
247 break;
248 }
249 if (kt->type != -1)
250 continue;
251 }
252 free(s);
253 return 0;
254 }
255 }
256 free(s);
257 return 1;
258 }
259
260 u_int
261 sshkey_size(const struct sshkey *k)
262 {
263 switch (k->type) {
264 #ifdef WITH_OPENSSL
265 case KEY_RSA:
266 case KEY_RSA_CERT:
267 return BN_num_bits(k->rsa->n);
268 case KEY_DSA:
269 case KEY_DSA_CERT:
270 return BN_num_bits(k->dsa->p);
271 case KEY_ECDSA:
272 case KEY_ECDSA_CERT:
273 return sshkey_curve_nid_to_bits(k->ecdsa_nid);
274 #endif /* WITH_OPENSSL */
275 case KEY_ED25519:
276 case KEY_ED25519_CERT:
277 return 256; /* XXX */
278 }
279 return 0;
280 }
281
282 static int
283 sshkey_type_is_valid_ca(int type)
284 {
285 switch (type) {
286 case KEY_RSA:
287 case KEY_DSA:
288 case KEY_ECDSA:
289 case KEY_ED25519:
290 return 1;
291 default:
292 return 0;
293 }
294 }
295
296 int
297 sshkey_is_cert(const struct sshkey *k)
298 {
299 if (k == NULL)
300 return 0;
301 return sshkey_type_is_cert(k->type);
302 }
303
304 /* Return the cert-less equivalent to a certified key type */
305 int
306 sshkey_type_plain(int type)
307 {
308 switch (type) {
309 case KEY_RSA_CERT:
310 return KEY_RSA;
311 case KEY_DSA_CERT:
312 return KEY_DSA;
313 case KEY_ECDSA_CERT:
314 return KEY_ECDSA;
315 case KEY_ED25519_CERT:
316 return KEY_ED25519;
317 default:
318 return type;
319 }
320 }
321
322 #ifdef WITH_OPENSSL
323 /* XXX: these are really begging for a table-driven approach */
324 int
325 sshkey_curve_name_to_nid(const char *name)
326 {
327 if (strcmp(name, "nistp256") == 0)
328 return NID_X9_62_prime256v1;
329 else if (strcmp(name, "nistp384") == 0)
330 return NID_secp384r1;
331 # ifdef OPENSSL_HAS_NISTP521
332 else if (strcmp(name, "nistp521") == 0)
333 return NID_secp521r1;
334 # endif /* OPENSSL_HAS_NISTP521 */
335 else
336 return -1;
337 }
338
339 u_int
340 sshkey_curve_nid_to_bits(int nid)
341 {
342 switch (nid) {
343 case NID_X9_62_prime256v1:
344 return 256;
345 case NID_secp384r1:
346 return 384;
347 # ifdef OPENSSL_HAS_NISTP521
348 case NID_secp521r1:
349 return 521;
350 # endif /* OPENSSL_HAS_NISTP521 */
351 default:
352 return 0;
353 }
354 }
355
356 int
357 sshkey_ecdsa_bits_to_nid(int bits)
358 {
359 switch (bits) {
360 case 256:
361 return NID_X9_62_prime256v1;
362 case 384:
363 return NID_secp384r1;
364 # ifdef OPENSSL_HAS_NISTP521
365 case 521:
366 return NID_secp521r1;
367 # endif /* OPENSSL_HAS_NISTP521 */
368 default:
369 return -1;
370 }
371 }
372
373 const char *
374 sshkey_curve_nid_to_name(int nid)
375 {
376 switch (nid) {
377 case NID_X9_62_prime256v1:
378 return "nistp256";
379 case NID_secp384r1:
380 return "nistp384";
381 # ifdef OPENSSL_HAS_NISTP521
382 case NID_secp521r1:
383 return "nistp521";
384 # endif /* OPENSSL_HAS_NISTP521 */
385 default:
386 return NULL;
387 }
388 }
389
390 int
391 sshkey_ec_nid_to_hash_alg(int nid)
392 {
393 int kbits = sshkey_curve_nid_to_bits(nid);
394
395 if (kbits <= 0)
396 return -1;
397
398 /* RFC5656 section 6.2.1 */
399 if (kbits <= 256)
400 return SSH_DIGEST_SHA256;
401 else if (kbits <= 384)
402 return SSH_DIGEST_SHA384;
403 else
404 return SSH_DIGEST_SHA512;
405 }
406 #endif /* WITH_OPENSSL */
407
408 static void
409 cert_free(struct sshkey_cert *cert)
410 {
411 u_int i;
412
413 if (cert == NULL)
414 return;
415 sshbuf_free(cert->certblob);
416 sshbuf_free(cert->critical);
417 sshbuf_free(cert->extensions);
418 free(cert->key_id);
419 for (i = 0; i < cert->nprincipals; i++)
420 free(cert->principals[i]);
421 free(cert->principals);
422 sshkey_free(cert->signature_key);
423 explicit_bzero(cert, sizeof(*cert));
424 free(cert);
425 }
426
427 static struct sshkey_cert *
428 cert_new(void)
429 {
430 struct sshkey_cert *cert;
431
432 if ((cert = calloc(1, sizeof(*cert))) == NULL)
433 return NULL;
434 if ((cert->certblob = sshbuf_new()) == NULL ||
435 (cert->critical = sshbuf_new()) == NULL ||
436 (cert->extensions = sshbuf_new()) == NULL) {
437 cert_free(cert);
438 return NULL;
439 }
440 cert->key_id = NULL;
441 cert->principals = NULL;
442 cert->signature_key = NULL;
443 return cert;
444 }
445
446 struct sshkey *
447 sshkey_new(int type)
448 {
449 struct sshkey *k;
450 #ifdef WITH_OPENSSL
451 RSA *rsa;
452 DSA *dsa;
453 #endif /* WITH_OPENSSL */
454
455 if ((k = calloc(1, sizeof(*k))) == NULL)
456 return NULL;
457 k->type = type;
458 k->ecdsa = NULL;
459 k->ecdsa_nid = -1;
460 k->dsa = NULL;
461 k->rsa = NULL;
462 k->cert = NULL;
463 k->ed25519_sk = NULL;
464 k->ed25519_pk = NULL;
465 switch (k->type) {
466 #ifdef WITH_OPENSSL
467 case KEY_RSA:
468 case KEY_RSA_CERT:
469 if ((rsa = RSA_new()) == NULL ||
470 (rsa->n = BN_new()) == NULL ||
471 (rsa->e = BN_new()) == NULL) {
472 if (rsa != NULL)
473 RSA_free(rsa);
474 free(k);
475 return NULL;
476 }
477 k->rsa = rsa;
478 break;
479 case KEY_DSA:
480 case KEY_DSA_CERT:
481 if ((dsa = DSA_new()) == NULL ||
482 (dsa->p = BN_new()) == NULL ||
483 (dsa->q = BN_new()) == NULL ||
484 (dsa->g = BN_new()) == NULL ||
485 (dsa->pub_key = BN_new()) == NULL) {
486 if (dsa != NULL)
487 DSA_free(dsa);
488 free(k);
489 return NULL;
490 }
491 k->dsa = dsa;
492 break;
493 case KEY_ECDSA:
494 case KEY_ECDSA_CERT:
495 /* Cannot do anything until we know the group */
496 break;
497 #endif /* WITH_OPENSSL */
498 case KEY_ED25519:
499 case KEY_ED25519_CERT:
500 /* no need to prealloc */
501 break;
502 case KEY_UNSPEC:
503 break;
504 default:
505 free(k);
506 return NULL;
507 }
508
509 if (sshkey_is_cert(k)) {
510 if ((k->cert = cert_new()) == NULL) {
511 sshkey_free(k);
512 return NULL;
513 }
514 }
515
516 return k;
517 }
518
519 int
520 sshkey_add_private(struct sshkey *k)
521 {
522 switch (k->type) {
523 #ifdef WITH_OPENSSL
524 case KEY_RSA:
525 case KEY_RSA_CERT:
526 #define bn_maybe_alloc_failed(p) (p == NULL && (p = BN_new()) == NULL)
527 if (bn_maybe_alloc_failed(k->rsa->d) ||
528 bn_maybe_alloc_failed(k->rsa->iqmp) ||
529 bn_maybe_alloc_failed(k->rsa->q) ||
530 bn_maybe_alloc_failed(k->rsa->p) ||
531 bn_maybe_alloc_failed(k->rsa->dmq1) ||
532 bn_maybe_alloc_failed(k->rsa->dmp1))
533 return SSH_ERR_ALLOC_FAIL;
534 break;
535 case KEY_DSA:
536 case KEY_DSA_CERT:
537 if (bn_maybe_alloc_failed(k->dsa->priv_key))
538 return SSH_ERR_ALLOC_FAIL;
539 break;
540 #undef bn_maybe_alloc_failed
541 case KEY_ECDSA:
542 case KEY_ECDSA_CERT:
543 /* Cannot do anything until we know the group */
544 break;
545 #endif /* WITH_OPENSSL */
546 case KEY_ED25519:
547 case KEY_ED25519_CERT:
548 /* no need to prealloc */
549 break;
550 case KEY_UNSPEC:
551 break;
552 default:
553 return SSH_ERR_INVALID_ARGUMENT;
554 }
555 return 0;
556 }
557
558 struct sshkey *
559 sshkey_new_private(int type)
560 {
561 struct sshkey *k = sshkey_new(type);
562
563 if (k == NULL)
564 return NULL;
565 if (sshkey_add_private(k) != 0) {
566 sshkey_free(k);
567 return NULL;
568 }
569 return k;
570 }
571
572 void
573 sshkey_free(struct sshkey *k)
574 {
575 if (k == NULL)
576 return;
577 switch (k->type) {
578 #ifdef WITH_OPENSSL
579 case KEY_RSA:
580 case KEY_RSA_CERT:
581 if (k->rsa != NULL)
582 RSA_free(k->rsa);
583 k->rsa = NULL;
584 break;
585 case KEY_DSA:
586 case KEY_DSA_CERT:
587 if (k->dsa != NULL)
588 DSA_free(k->dsa);
589 k->dsa = NULL;
590 break;
591 # ifdef OPENSSL_HAS_ECC
592 case KEY_ECDSA:
593 case KEY_ECDSA_CERT:
594 if (k->ecdsa != NULL)
595 EC_KEY_free(k->ecdsa);
596 k->ecdsa = NULL;
597 break;
598 # endif /* OPENSSL_HAS_ECC */
599 #endif /* WITH_OPENSSL */
600 case KEY_ED25519:
601 case KEY_ED25519_CERT:
602 if (k->ed25519_pk) {
603 explicit_bzero(k->ed25519_pk, ED25519_PK_SZ);
604 free(k->ed25519_pk);
605 k->ed25519_pk = NULL;
606 }
607 if (k->ed25519_sk) {
608 explicit_bzero(k->ed25519_sk, ED25519_SK_SZ);
609 free(k->ed25519_sk);
610 k->ed25519_sk = NULL;
611 }
612 break;
613 case KEY_UNSPEC:
614 break;
615 default:
616 break;
617 }
618 if (sshkey_is_cert(k))
619 cert_free(k->cert);
620 explicit_bzero(k, sizeof(*k));
621 free(k);
622 }
623
624 static int
625 cert_compare(struct sshkey_cert *a, struct sshkey_cert *b)
626 {
627 if (a == NULL && b == NULL)
628 return 1;
629 if (a == NULL || b == NULL)
630 return 0;
631 if (sshbuf_len(a->certblob) != sshbuf_len(b->certblob))
632 return 0;
633 if (timingsafe_bcmp(sshbuf_ptr(a->certblob), sshbuf_ptr(b->certblob),
634 sshbuf_len(a->certblob)) != 0)
635 return 0;
636 return 1;
637 }
638
639 /*
640 * Compare public portions of key only, allowing comparisons between
641 * certificates and plain keys too.
642 */
643 int
644 sshkey_equal_public(const struct sshkey *a, const struct sshkey *b)
645 {
646 #if defined(WITH_OPENSSL) && defined(OPENSSL_HAS_ECC)
647 BN_CTX *bnctx;
648 #endif /* WITH_OPENSSL && OPENSSL_HAS_ECC */
649
650 if (a == NULL || b == NULL ||
651 sshkey_type_plain(a->type) != sshkey_type_plain(b->type))
652 return 0;
653
654 switch (a->type) {
655 #ifdef WITH_OPENSSL
656 case KEY_RSA_CERT:
657 case KEY_RSA:
658 return a->rsa != NULL && b->rsa != NULL &&
659 BN_cmp(a->rsa->e, b->rsa->e) == 0 &&
660 BN_cmp(a->rsa->n, b->rsa->n) == 0;
661 case KEY_DSA_CERT:
662 case KEY_DSA:
663 return a->dsa != NULL && b->dsa != NULL &&
664 BN_cmp(a->dsa->p, b->dsa->p) == 0 &&
665 BN_cmp(a->dsa->q, b->dsa->q) == 0 &&
666 BN_cmp(a->dsa->g, b->dsa->g) == 0 &&
667 BN_cmp(a->dsa->pub_key, b->dsa->pub_key) == 0;
668 # ifdef OPENSSL_HAS_ECC
669 case KEY_ECDSA_CERT:
670 case KEY_ECDSA:
671 if (a->ecdsa == NULL || b->ecdsa == NULL ||
672 EC_KEY_get0_public_key(a->ecdsa) == NULL ||
673 EC_KEY_get0_public_key(b->ecdsa) == NULL)
674 return 0;
675 if ((bnctx = BN_CTX_new()) == NULL)
676 return 0;
677 if (EC_GROUP_cmp(EC_KEY_get0_group(a->ecdsa),
678 EC_KEY_get0_group(b->ecdsa), bnctx) != 0 ||
679 EC_POINT_cmp(EC_KEY_get0_group(a->ecdsa),
680 EC_KEY_get0_public_key(a->ecdsa),
681 EC_KEY_get0_public_key(b->ecdsa), bnctx) != 0) {
682 BN_CTX_free(bnctx);
683 return 0;
684 }
685 BN_CTX_free(bnctx);
686 return 1;
687 # endif /* OPENSSL_HAS_ECC */
688 #endif /* WITH_OPENSSL */
689 case KEY_ED25519:
690 case KEY_ED25519_CERT:
691 return a->ed25519_pk != NULL && b->ed25519_pk != NULL &&
692 memcmp(a->ed25519_pk, b->ed25519_pk, ED25519_PK_SZ) == 0;
693 default:
694 return 0;
695 }
696 /* NOTREACHED */
697 }
698
699 int
700 sshkey_equal(const struct sshkey *a, const struct sshkey *b)
701 {
702 if (a == NULL || b == NULL || a->type != b->type)
703 return 0;
704 if (sshkey_is_cert(a)) {
705 if (!cert_compare(a->cert, b->cert))
706 return 0;
707 }
708 return sshkey_equal_public(a, b);
709 }
710
711 static int
712 to_blob_buf(const struct sshkey *key, struct sshbuf *b, int force_plain)
713 {
714 int type, ret = SSH_ERR_INTERNAL_ERROR;
715 const char *typename;
716
717 if (key == NULL)
718 return SSH_ERR_INVALID_ARGUMENT;
719
720 if (sshkey_is_cert(key)) {
721 if (key->cert == NULL)
722 return SSH_ERR_EXPECTED_CERT;
723 if (sshbuf_len(key->cert->certblob) == 0)
724 return SSH_ERR_KEY_LACKS_CERTBLOB;
725 }
726 type = force_plain ? sshkey_type_plain(key->type) : key->type;
727 typename = sshkey_ssh_name_from_type_nid(type, key->ecdsa_nid);
728
729 switch (type) {
730 #ifdef WITH_OPENSSL
731 case KEY_DSA_CERT:
732 case KEY_ECDSA_CERT:
733 case KEY_RSA_CERT:
734 #endif /* WITH_OPENSSL */
735 case KEY_ED25519_CERT:
736 /* Use the existing blob */
737 /* XXX modified flag? */
738 if ((ret = sshbuf_putb(b, key->cert->certblob)) != 0)
739 return ret;
740 break;
741 #ifdef WITH_OPENSSL
742 case KEY_DSA:
743 if (key->dsa == NULL)
744 return SSH_ERR_INVALID_ARGUMENT;
745 if ((ret = sshbuf_put_cstring(b, typename)) != 0 ||
746 (ret = sshbuf_put_bignum2(b, key->dsa->p)) != 0 ||
747 (ret = sshbuf_put_bignum2(b, key->dsa->q)) != 0 ||
748 (ret = sshbuf_put_bignum2(b, key->dsa->g)) != 0 ||
749 (ret = sshbuf_put_bignum2(b, key->dsa->pub_key)) != 0)
750 return ret;
751 break;
752 # ifdef OPENSSL_HAS_ECC
753 case KEY_ECDSA:
754 if (key->ecdsa == NULL)
755 return SSH_ERR_INVALID_ARGUMENT;
756 if ((ret = sshbuf_put_cstring(b, typename)) != 0 ||
757 (ret = sshbuf_put_cstring(b,
758 sshkey_curve_nid_to_name(key->ecdsa_nid))) != 0 ||
759 (ret = sshbuf_put_eckey(b, key->ecdsa)) != 0)
760 return ret;
761 break;
762 # endif
763 case KEY_RSA:
764 if (key->rsa == NULL)
765 return SSH_ERR_INVALID_ARGUMENT;
766 if ((ret = sshbuf_put_cstring(b, typename)) != 0 ||
767 (ret = sshbuf_put_bignum2(b, key->rsa->e)) != 0 ||
768 (ret = sshbuf_put_bignum2(b, key->rsa->n)) != 0)
769 return ret;
770 break;
771 #endif /* WITH_OPENSSL */
772 case KEY_ED25519:
773 if (key->ed25519_pk == NULL)
774 return SSH_ERR_INVALID_ARGUMENT;
775 if ((ret = sshbuf_put_cstring(b, typename)) != 0 ||
776 (ret = sshbuf_put_string(b,
777 key->ed25519_pk, ED25519_PK_SZ)) != 0)
778 return ret;
779 break;
780 default:
781 return SSH_ERR_KEY_TYPE_UNKNOWN;
782 }
783 return 0;
784 }
785
786 int
787 sshkey_putb(const struct sshkey *key, struct sshbuf *b)
788 {
789 return to_blob_buf(key, b, 0);
790 }
791
792 int
793 sshkey_puts(const struct sshkey *key, struct sshbuf *b)
794 {
795 struct sshbuf *tmp;
796 int r;
797
798 if ((tmp = sshbuf_new()) == NULL)
799 return SSH_ERR_ALLOC_FAIL;
800 r = to_blob_buf(key, tmp, 0);
801 if (r == 0)
802 r = sshbuf_put_stringb(b, tmp);
803 sshbuf_free(tmp);
804 return r;
805 }
806
807 int
808 sshkey_putb_plain(const struct sshkey *key, struct sshbuf *b)
809 {
810 return to_blob_buf(key, b, 1);
811 }
812
813 static int
814 to_blob(const struct sshkey *key, u_char **blobp, size_t *lenp, int force_plain)
815 {
816 int ret = SSH_ERR_INTERNAL_ERROR;
817 size_t len;
818 struct sshbuf *b = NULL;
819
820 if (lenp != NULL)
821 *lenp = 0;
822 if (blobp != NULL)
823 *blobp = NULL;
824 if ((b = sshbuf_new()) == NULL)
825 return SSH_ERR_ALLOC_FAIL;
826 if ((ret = to_blob_buf(key, b, force_plain)) != 0)
827 goto out;
828 len = sshbuf_len(b);
829 if (lenp != NULL)
830 *lenp = len;
831 if (blobp != NULL) {
832 if ((*blobp = malloc(len)) == NULL) {
833 ret = SSH_ERR_ALLOC_FAIL;
834 goto out;
835 }
836 memcpy(*blobp, sshbuf_ptr(b), len);
837 }
838 ret = 0;
839 out:
840 sshbuf_free(b);
841 return ret;
842 }
843
844 int
845 sshkey_to_blob(const struct sshkey *key, u_char **blobp, size_t *lenp)
846 {
847 return to_blob(key, blobp, lenp, 0);
848 }
849
850 int
851 sshkey_plain_to_blob(const struct sshkey *key, u_char **blobp, size_t *lenp)
852 {
853 return to_blob(key, blobp, lenp, 1);
854 }
855
856 int
857 sshkey_fingerprint_raw(const struct sshkey *k, int dgst_alg,
858 u_char **retp, size_t *lenp)
859 {
860 u_char *blob = NULL, *ret = NULL;
861 size_t blob_len = 0;
862 int r = SSH_ERR_INTERNAL_ERROR;
863
864 if (retp != NULL)
865 *retp = NULL;
866 if (lenp != NULL)
867 *lenp = 0;
868 if (ssh_digest_bytes(dgst_alg) == 0) {
869 r = SSH_ERR_INVALID_ARGUMENT;
870 goto out;
871 }
872 if ((r = to_blob(k, &blob, &blob_len, 1)) != 0)
873 goto out;
874 if ((ret = calloc(1, SSH_DIGEST_MAX_LENGTH)) == NULL) {
875 r = SSH_ERR_ALLOC_FAIL;
876 goto out;
877 }
878 if ((r = ssh_digest_memory(dgst_alg, blob, blob_len,
879 ret, SSH_DIGEST_MAX_LENGTH)) != 0)
880 goto out;
881 /* success */
882 if (retp != NULL) {
883 *retp = ret;
884 ret = NULL;
885 }
886 if (lenp != NULL)
887 *lenp = ssh_digest_bytes(dgst_alg);
888 r = 0;
889 out:
890 free(ret);
891 if (blob != NULL) {
892 explicit_bzero(blob, blob_len);
893 free(blob);
894 }
895 return r;
896 }
897
898 static char *
899 fingerprint_b64(const char *alg, u_char *dgst_raw, size_t dgst_raw_len)
900 {
901 char *ret;
902 size_t plen = strlen(alg) + 1;
903 size_t rlen = ((dgst_raw_len + 2) / 3) * 4 + plen + 1;
904 int r;
905
906 if (dgst_raw_len > 65536 || (ret = calloc(1, rlen)) == NULL)
907 return NULL;
908 strlcpy(ret, alg, rlen);
909 strlcat(ret, ":", rlen);
910 if (dgst_raw_len == 0)
911 return ret;
912 if ((r = b64_ntop(dgst_raw, dgst_raw_len,
913 ret + plen, rlen - plen)) == -1) {
914 explicit_bzero(ret, rlen);
915 free(ret);
916 return NULL;
917 }
918 /* Trim padding characters from end */
919 ret[strcspn(ret, "=")] = '\0';
920 return ret;
921 }
922
923 static char *
924 fingerprint_hex(const char *alg, u_char *dgst_raw, size_t dgst_raw_len)
925 {
926 char *retval, hex[5];
927 size_t i, rlen = dgst_raw_len * 3 + strlen(alg) + 2;
928
929 if (dgst_raw_len > 65536 || (retval = calloc(1, rlen)) == NULL)
930 return NULL;
931 strlcpy(retval, alg, rlen);
932 strlcat(retval, ":", rlen);
933 for (i = 0; i < dgst_raw_len; i++) {
934 snprintf(hex, sizeof(hex), "%s%02x",
935 i > 0 ? ":" : "", dgst_raw[i]);
936 strlcat(retval, hex, rlen);
937 }
938 return retval;
939 }
940
941 static char *
942 fingerprint_bubblebabble(u_char *dgst_raw, size_t dgst_raw_len)
943 {
944 char vowels[] = { 'a', 'e', 'i', 'o', 'u', 'y' };
945 char consonants[] = { 'b', 'c', 'd', 'f', 'g', 'h', 'k', 'l', 'm',
946 'n', 'p', 'r', 's', 't', 'v', 'z', 'x' };
947 u_int i, j = 0, rounds, seed = 1;
948 char *retval;
949
950 rounds = (dgst_raw_len / 2) + 1;
951 if ((retval = calloc(rounds, 6)) == NULL)
952 return NULL;
953 retval[j++] = 'x';
954 for (i = 0; i < rounds; i++) {
955 u_int idx0, idx1, idx2, idx3, idx4;
956 if ((i + 1 < rounds) || (dgst_raw_len % 2 != 0)) {
957 idx0 = (((((u_int)(dgst_raw[2 * i])) >> 6) & 3) +
958 seed) % 6;
959 idx1 = (((u_int)(dgst_raw[2 * i])) >> 2) & 15;
960 idx2 = ((((u_int)(dgst_raw[2 * i])) & 3) +
961 (seed / 6)) % 6;
962 retval[j++] = vowels[idx0];
963 retval[j++] = consonants[idx1];
964 retval[j++] = vowels[idx2];
965 if ((i + 1) < rounds) {
966 idx3 = (((u_int)(dgst_raw[(2 * i) + 1])) >> 4) & 15;
967 idx4 = (((u_int)(dgst_raw[(2 * i) + 1]))) & 15;
968 retval[j++] = consonants[idx3];
969 retval[j++] = '-';
970 retval[j++] = consonants[idx4];
971 seed = ((seed * 5) +
972 ((((u_int)(dgst_raw[2 * i])) * 7) +
973 ((u_int)(dgst_raw[(2 * i) + 1])))) % 36;
974 }
975 } else {
976 idx0 = seed % 6;
977 idx1 = 16;
978 idx2 = seed / 6;
979 retval[j++] = vowels[idx0];
980 retval[j++] = consonants[idx1];
981 retval[j++] = vowels[idx2];
982 }
983 }
984 retval[j++] = 'x';
985 retval[j++] = '\0';
986 return retval;
987 }
988
989 /*
990 * Draw an ASCII-Art representing the fingerprint so human brain can
991 * profit from its built-in pattern recognition ability.
992 * This technique is called "random art" and can be found in some
993 * scientific publications like this original paper:
994 *
995 * "Hash Visualization: a New Technique to improve Real-World Security",
996 * Perrig A. and Song D., 1999, International Workshop on Cryptographic
997 * Techniques and E-Commerce (CrypTEC '99)
998 * sparrow.ece.cmu.edu/~adrian/projects/validation/validation.pdf
999 *
1000 * The subject came up in a talk by Dan Kaminsky, too.
1001 *
1002 * If you see the picture is different, the key is different.
1003 * If the picture looks the same, you still know nothing.
1004 *
1005 * The algorithm used here is a worm crawling over a discrete plane,
1006 * leaving a trace (augmenting the field) everywhere it goes.
1007 * Movement is taken from dgst_raw 2bit-wise. Bumping into walls
1008 * makes the respective movement vector be ignored for this turn.
1009 * Graphs are not unambiguous, because circles in graphs can be
1010 * walked in either direction.
1011 */
1012
1013 /*
1014 * Field sizes for the random art. Have to be odd, so the starting point
1015 * can be in the exact middle of the picture, and FLDBASE should be >=8 .
1016 * Else pictures would be too dense, and drawing the frame would
1017 * fail, too, because the key type would not fit in anymore.
1018 */
1019 #define FLDBASE 8
1020 #define FLDSIZE_Y (FLDBASE + 1)
1021 #define FLDSIZE_X (FLDBASE * 2 + 1)
1022 static char *
1023 fingerprint_randomart(const char *alg, u_char *dgst_raw, size_t dgst_raw_len,
1024 const struct sshkey *k)
1025 {
1026 /*
1027 * Chars to be used after each other every time the worm
1028 * intersects with itself. Matter of taste.
1029 */
1030 char *augmentation_string = " .o+=*BOX@%&#/^SE";
1031 char *retval, *p, title[FLDSIZE_X], hash[FLDSIZE_X];
1032 u_char field[FLDSIZE_X][FLDSIZE_Y];
1033 size_t i, tlen, hlen;
1034 u_int b;
1035 int x, y, r;
1036 size_t len = strlen(augmentation_string) - 1;
1037
1038 if ((retval = calloc((FLDSIZE_X + 3), (FLDSIZE_Y + 2))) == NULL)
1039 return NULL;
1040
1041 /* initialize field */
1042 memset(field, 0, FLDSIZE_X * FLDSIZE_Y * sizeof(char));
1043 x = FLDSIZE_X / 2;
1044 y = FLDSIZE_Y / 2;
1045
1046 /* process raw key */
1047 for (i = 0; i < dgst_raw_len; i++) {
1048 int input;
1049 /* each byte conveys four 2-bit move commands */
1050 input = dgst_raw[i];
1051 for (b = 0; b < 4; b++) {
1052 /* evaluate 2 bit, rest is shifted later */
1053 x += (input & 0x1) ? 1 : -1;
1054 y += (input & 0x2) ? 1 : -1;
1055
1056 /* assure we are still in bounds */
1057 x = MAXIMUM(x, 0);
1058 y = MAXIMUM(y, 0);
1059 x = MINIMUM(x, FLDSIZE_X - 1);
1060 y = MINIMUM(y, FLDSIZE_Y - 1);
1061
1062 /* augment the field */
1063 if (field[x][y] < len - 2)
1064 field[x][y]++;
1065 input = input >> 2;
1066 }
1067 }
1068
1069 /* mark starting point and end point*/
1070 field[FLDSIZE_X / 2][FLDSIZE_Y / 2] = len - 1;
1071 field[x][y] = len;
1072
1073 /* assemble title */
1074 r = snprintf(title, sizeof(title), "[%s %u]",
1075 sshkey_type(k), sshkey_size(k));
1076 /* If [type size] won't fit, then try [type]; fits "[ED25519-CERT]" */
1077 if (r < 0 || r > (int)sizeof(title))
1078 r = snprintf(title, sizeof(title), "[%s]", sshkey_type(k));
1079 tlen = (r <= 0) ? 0 : strlen(title);
1080
1081 /* assemble hash ID. */
1082 r = snprintf(hash, sizeof(hash), "[%s]", alg);
1083 hlen = (r <= 0) ? 0 : strlen(hash);
1084
1085 /* output upper border */
1086 p = retval;
1087 *p++ = '+';
1088 for (i = 0; i < (FLDSIZE_X - tlen) / 2; i++)
1089 *p++ = '-';
1090 memcpy(p, title, tlen);
1091 p += tlen;
1092 for (i += tlen; i < FLDSIZE_X; i++)
1093 *p++ = '-';
1094 *p++ = '+';
1095 *p++ = '\n';
1096
1097 /* output content */
1098 for (y = 0; y < FLDSIZE_Y; y++) {
1099 *p++ = '|';
1100 for (x = 0; x < FLDSIZE_X; x++)
1101 *p++ = augmentation_string[MINIMUM(field[x][y], len)];
1102 *p++ = '|';
1103 *p++ = '\n';
1104 }
1105
1106 /* output lower border */
1107 *p++ = '+';
1108 for (i = 0; i < (FLDSIZE_X - hlen) / 2; i++)
1109 *p++ = '-';
1110 memcpy(p, hash, hlen);
1111 p += hlen;
1112 for (i += hlen; i < FLDSIZE_X; i++)
1113 *p++ = '-';
1114 *p++ = '+';
1115
1116 return retval;
1117 }
1118
1119 char *
1120 sshkey_fingerprint(const struct sshkey *k, int dgst_alg,
1121 enum sshkey_fp_rep dgst_rep)
1122 {
1123 char *retval = NULL;
1124 u_char *dgst_raw;
1125 size_t dgst_raw_len;
1126
1127 if (sshkey_fingerprint_raw(k, dgst_alg, &dgst_raw, &dgst_raw_len) != 0)
1128 return NULL;
1129 switch (dgst_rep) {
1130 case SSH_FP_DEFAULT:
1131 if (dgst_alg == SSH_DIGEST_MD5) {
1132 retval = fingerprint_hex(ssh_digest_alg_name(dgst_alg),
1133 dgst_raw, dgst_raw_len);
1134 } else {
1135 retval = fingerprint_b64(ssh_digest_alg_name(dgst_alg),
1136 dgst_raw, dgst_raw_len);
1137 }
1138 break;
1139 case SSH_FP_HEX:
1140 retval = fingerprint_hex(ssh_digest_alg_name(dgst_alg),
1141 dgst_raw, dgst_raw_len);
1142 break;
1143 case SSH_FP_BASE64:
1144 retval = fingerprint_b64(ssh_digest_alg_name(dgst_alg),
1145 dgst_raw, dgst_raw_len);
1146 break;
1147 case SSH_FP_BUBBLEBABBLE:
1148 retval = fingerprint_bubblebabble(dgst_raw, dgst_raw_len);
1149 break;
1150 case SSH_FP_RANDOMART:
1151 retval = fingerprint_randomart(ssh_digest_alg_name(dgst_alg),
1152 dgst_raw, dgst_raw_len, k);
1153 break;
1154 default:
1155 explicit_bzero(dgst_raw, dgst_raw_len);
1156 free(dgst_raw);
1157 return NULL;
1158 }
1159 explicit_bzero(dgst_raw, dgst_raw_len);
1160 free(dgst_raw);
1161 return retval;
1162 }
1163
1164
1165 /* returns 0 ok, and < 0 error */
1166 int
1167 sshkey_read(struct sshkey *ret, char **cpp)
1168 {
1169 struct sshkey *k;
1170 int retval = SSH_ERR_INVALID_FORMAT;
1171 char *ep, *cp, *space;
1172 int r, type, curve_nid = -1;
1173 struct sshbuf *blob;
1174
1175 if (ret == NULL)
1176 return SSH_ERR_INVALID_ARGUMENT;
1177
1178 cp = *cpp;
1179
1180 switch (ret->type) {
1181 case KEY_UNSPEC:
1182 case KEY_RSA:
1183 case KEY_DSA:
1184 case KEY_ECDSA:
1185 case KEY_ED25519:
1186 case KEY_DSA_CERT:
1187 case KEY_ECDSA_CERT:
1188 case KEY_RSA_CERT:
1189 case KEY_ED25519_CERT:
1190 space = strchr(cp, ' ');
1191 if (space == NULL)
1192 return SSH_ERR_INVALID_FORMAT;
1193 *space = '\0';
1194 type = sshkey_type_from_name(cp);
1195 if (sshkey_type_plain(type) == KEY_ECDSA &&
1196 (curve_nid = sshkey_ecdsa_nid_from_name(cp)) == -1)
1197 return SSH_ERR_EC_CURVE_INVALID;
1198 *space = ' ';
1199 if (type == KEY_UNSPEC)
1200 return SSH_ERR_INVALID_FORMAT;
1201 cp = space+1;
1202 if (*cp == '\0')
1203 return SSH_ERR_INVALID_FORMAT;
1204 if (ret->type != KEY_UNSPEC && ret->type != type)
1205 return SSH_ERR_KEY_TYPE_MISMATCH;
1206 if ((blob = sshbuf_new()) == NULL)
1207 return SSH_ERR_ALLOC_FAIL;
1208 /* trim comment */
1209 space = strchr(cp, ' ');
1210 if (space) {
1211 /* advance 'space': skip whitespace */
1212 *space++ = '\0';
1213 while (*space == ' ' || *space == '\t')
1214 space++;
1215 ep = space;
1216 } else
1217 ep = cp + strlen(cp);
1218 if ((r = sshbuf_b64tod(blob, cp)) != 0) {
1219 sshbuf_free(blob);
1220 return r;
1221 }
1222 if ((r = sshkey_from_blob(sshbuf_ptr(blob),
1223 sshbuf_len(blob), &k)) != 0) {
1224 sshbuf_free(blob);
1225 return r;
1226 }
1227 sshbuf_free(blob);
1228 if (k->type != type) {
1229 sshkey_free(k);
1230 return SSH_ERR_KEY_TYPE_MISMATCH;
1231 }
1232 if (sshkey_type_plain(type) == KEY_ECDSA &&
1233 curve_nid != k->ecdsa_nid) {
1234 sshkey_free(k);
1235 return SSH_ERR_EC_CURVE_MISMATCH;
1236 }
1237 ret->type = type;
1238 if (sshkey_is_cert(ret)) {
1239 if (!sshkey_is_cert(k)) {
1240 sshkey_free(k);
1241 return SSH_ERR_EXPECTED_CERT;
1242 }
1243 if (ret->cert != NULL)
1244 cert_free(ret->cert);
1245 ret->cert = k->cert;
1246 k->cert = NULL;
1247 }
1248 switch (sshkey_type_plain(ret->type)) {
1249 #ifdef WITH_OPENSSL
1250 case KEY_RSA:
1251 if (ret->rsa != NULL)
1252 RSA_free(ret->rsa);
1253 ret->rsa = k->rsa;
1254 k->rsa = NULL;
1255 #ifdef DEBUG_PK
1256 RSA_print_fp(stderr, ret->rsa, 8);
1257 #endif
1258 break;
1259 case KEY_DSA:
1260 if (ret->dsa != NULL)
1261 DSA_free(ret->dsa);
1262 ret->dsa = k->dsa;
1263 k->dsa = NULL;
1264 #ifdef DEBUG_PK
1265 DSA_print_fp(stderr, ret->dsa, 8);
1266 #endif
1267 break;
1268 # ifdef OPENSSL_HAS_ECC
1269 case KEY_ECDSA:
1270 if (ret->ecdsa != NULL)
1271 EC_KEY_free(ret->ecdsa);
1272 ret->ecdsa = k->ecdsa;
1273 ret->ecdsa_nid = k->ecdsa_nid;
1274 k->ecdsa = NULL;
1275 k->ecdsa_nid = -1;
1276 #ifdef DEBUG_PK
1277 sshkey_dump_ec_key(ret->ecdsa);
1278 #endif
1279 break;
1280 # endif /* OPENSSL_HAS_ECC */
1281 #endif /* WITH_OPENSSL */
1282 case KEY_ED25519:
1283 free(ret->ed25519_pk);
1284 ret->ed25519_pk = k->ed25519_pk;
1285 k->ed25519_pk = NULL;
1286 #ifdef DEBUG_PK
1287 /* XXX */
1288 #endif
1289 break;
1290 }
1291 *cpp = ep;
1292 retval = 0;
1293 /*XXXX*/
1294 sshkey_free(k);
1295 if (retval != 0)
1296 break;
1297 break;
1298 default:
1299 return SSH_ERR_INVALID_ARGUMENT;
1300 }
1301 return retval;
1302 }
1303
1304 int
1305 sshkey_to_base64(const struct sshkey *key, char **b64p)
1306 {
1307 int r = SSH_ERR_INTERNAL_ERROR;
1308 struct sshbuf *b = NULL;
1309 char *uu = NULL;
1310
1311 if (b64p != NULL)
1312 *b64p = NULL;
1313 if ((b = sshbuf_new()) == NULL)
1314 return SSH_ERR_ALLOC_FAIL;
1315 if ((r = sshkey_putb(key, b)) != 0)
1316 goto out;
1317 if ((uu = sshbuf_dtob64(b)) == NULL) {
1318 r = SSH_ERR_ALLOC_FAIL;
1319 goto out;
1320 }
1321 /* Success */
1322 if (b64p != NULL) {
1323 *b64p = uu;
1324 uu = NULL;
1325 }
1326 r = 0;
1327 out:
1328 sshbuf_free(b);
1329 free(uu);
1330 return r;
1331 }
1332
1333 int
1334 sshkey_format_text(const struct sshkey *key, struct sshbuf *b)
1335 {
1336 int r = SSH_ERR_INTERNAL_ERROR;
1337 char *uu = NULL;
1338
1339 if ((r = sshkey_to_base64(key, &uu)) != 0)
1340 goto out;
1341 if ((r = sshbuf_putf(b, "%s %s",
1342 sshkey_ssh_name(key), uu)) != 0)
1343 goto out;
1344 r = 0;
1345 out:
1346 free(uu);
1347 return r;
1348 }
1349
1350 int
1351 sshkey_write(const struct sshkey *key, FILE *f)
1352 {
1353 struct sshbuf *b = NULL;
1354 int r = SSH_ERR_INTERNAL_ERROR;
1355
1356 if ((b = sshbuf_new()) == NULL)
1357 return SSH_ERR_ALLOC_FAIL;
1358 if ((r = sshkey_format_text(key, b)) != 0)
1359 goto out;
1360 if (fwrite(sshbuf_ptr(b), sshbuf_len(b), 1, f) != 1) {
1361 if (feof(f))
1362 errno = EPIPE;
1363 r = SSH_ERR_SYSTEM_ERROR;
1364 goto out;
1365 }
1366 /* Success */
1367 r = 0;
1368 out:
1369 sshbuf_free(b);
1370 return r;
1371 }
1372
1373 const char *
1374 sshkey_cert_type(const struct sshkey *k)
1375 {
1376 switch (k->cert->type) {
1377 case SSH2_CERT_TYPE_USER:
1378 return "user";
1379 case SSH2_CERT_TYPE_HOST:
1380 return "host";
1381 default:
1382 return "unknown";
1383 }
1384 }
1385
1386 #ifdef WITH_OPENSSL
1387 static int
1388 rsa_generate_private_key(u_int bits, RSA **rsap)
1389 {
1390 RSA *private = NULL;
1391 BIGNUM *f4 = NULL;
1392 int ret = SSH_ERR_INTERNAL_ERROR;
1393
1394 if (rsap == NULL)
1395 return SSH_ERR_INVALID_ARGUMENT;
1396 if (bits < SSH_RSA_MINIMUM_MODULUS_SIZE ||
1397 bits > SSHBUF_MAX_BIGNUM * 8)
1398 return SSH_ERR_KEY_LENGTH;
1399 *rsap = NULL;
1400 if ((private = RSA_new()) == NULL || (f4 = BN_new()) == NULL) {
1401 ret = SSH_ERR_ALLOC_FAIL;
1402 goto out;
1403 }
1404 if (!BN_set_word(f4, RSA_F4) ||
1405 !RSA_generate_key_ex(private, bits, f4, NULL)) {
1406 ret = SSH_ERR_LIBCRYPTO_ERROR;
1407 goto out;
1408 }
1409 *rsap = private;
1410 private = NULL;
1411 ret = 0;
1412 out:
1413 if (private != NULL)
1414 RSA_free(private);
1415 if (f4 != NULL)
1416 BN_free(f4);
1417 return ret;
1418 }
1419
1420 static int
1421 dsa_generate_private_key(u_int bits, DSA **dsap)
1422 {
1423 DSA *private;
1424 int ret = SSH_ERR_INTERNAL_ERROR;
1425
1426 if (dsap == NULL)
1427 return SSH_ERR_INVALID_ARGUMENT;
1428 if (bits != 1024)
1429 return SSH_ERR_KEY_LENGTH;
1430 if ((private = DSA_new()) == NULL) {
1431 ret = SSH_ERR_ALLOC_FAIL;
1432 goto out;
1433 }
1434 *dsap = NULL;
1435 if (!DSA_generate_parameters_ex(private, bits, NULL, 0, NULL,
1436 NULL, NULL) || !DSA_generate_key(private)) {
1437 ret = SSH_ERR_LIBCRYPTO_ERROR;
1438 goto out;
1439 }
1440 *dsap = private;
1441 private = NULL;
1442 ret = 0;
1443 out:
1444 if (private != NULL)
1445 DSA_free(private);
1446 return ret;
1447 }
1448
1449 # ifdef OPENSSL_HAS_ECC
1450 int
1451 sshkey_ecdsa_key_to_nid(EC_KEY *k)
1452 {
1453 EC_GROUP *eg;
1454 int nids[] = {
1455 NID_X9_62_prime256v1,
1456 NID_secp384r1,
1457 # ifdef OPENSSL_HAS_NISTP521
1458 NID_secp521r1,
1459 # endif /* OPENSSL_HAS_NISTP521 */
1460 -1
1461 };
1462 int nid;
1463 u_int i;
1464 BN_CTX *bnctx;
1465 const EC_GROUP *g = EC_KEY_get0_group(k);
1466
1467 /*
1468 * The group may be stored in a ASN.1 encoded private key in one of two
1469 * ways: as a "named group", which is reconstituted by ASN.1 object ID
1470 * or explicit group parameters encoded into the key blob. Only the
1471 * "named group" case sets the group NID for us, but we can figure
1472 * it out for the other case by comparing against all the groups that
1473 * are supported.
1474 */
1475 if ((nid = EC_GROUP_get_curve_name(g)) > 0)
1476 return nid;
1477 if ((bnctx = BN_CTX_new()) == NULL)
1478 return -1;
1479 for (i = 0; nids[i] != -1; i++) {
1480 if ((eg = EC_GROUP_new_by_curve_name(nids[i])) == NULL) {
1481 BN_CTX_free(bnctx);
1482 return -1;
1483 }
1484 if (EC_GROUP_cmp(g, eg, bnctx) == 0)
1485 break;
1486 EC_GROUP_free(eg);
1487 }
1488 BN_CTX_free(bnctx);
1489 if (nids[i] != -1) {
1490 /* Use the group with the NID attached */
1491 EC_GROUP_set_asn1_flag(eg, OPENSSL_EC_NAMED_CURVE);
1492 if (EC_KEY_set_group(k, eg) != 1) {
1493 EC_GROUP_free(eg);
1494 return -1;
1495 }
1496 }
1497 return nids[i];
1498 }
1499
1500 static int
1501 ecdsa_generate_private_key(u_int bits, int *nid, EC_KEY **ecdsap)
1502 {
1503 EC_KEY *private;
1504 int ret = SSH_ERR_INTERNAL_ERROR;
1505
1506 if (nid == NULL || ecdsap == NULL)
1507 return SSH_ERR_INVALID_ARGUMENT;
1508 if ((*nid = sshkey_ecdsa_bits_to_nid(bits)) == -1)
1509 return SSH_ERR_KEY_LENGTH;
1510 *ecdsap = NULL;
1511 if ((private = EC_KEY_new_by_curve_name(*nid)) == NULL) {
1512 ret = SSH_ERR_ALLOC_FAIL;
1513 goto out;
1514 }
1515 if (EC_KEY_generate_key(private) != 1) {
1516 ret = SSH_ERR_LIBCRYPTO_ERROR;
1517 goto out;
1518 }
1519 EC_KEY_set_asn1_flag(private, OPENSSL_EC_NAMED_CURVE);
1520 *ecdsap = private;
1521 private = NULL;
1522 ret = 0;
1523 out:
1524 if (private != NULL)
1525 EC_KEY_free(private);
1526 return ret;
1527 }
1528 # endif /* OPENSSL_HAS_ECC */
1529 #endif /* WITH_OPENSSL */
1530
1531 int
1532 sshkey_generate(int type, u_int bits, struct sshkey **keyp)
1533 {
1534 struct sshkey *k;
1535 int ret = SSH_ERR_INTERNAL_ERROR;
1536
1537 if (keyp == NULL)
1538 return SSH_ERR_INVALID_ARGUMENT;
1539 *keyp = NULL;
1540 if ((k = sshkey_new(KEY_UNSPEC)) == NULL)
1541 return SSH_ERR_ALLOC_FAIL;
1542 switch (type) {
1543 case KEY_ED25519:
1544 if ((k->ed25519_pk = malloc(ED25519_PK_SZ)) == NULL ||
1545 (k->ed25519_sk = malloc(ED25519_SK_SZ)) == NULL) {
1546 ret = SSH_ERR_ALLOC_FAIL;
1547 break;
1548 }
1549 crypto_sign_ed25519_keypair(k->ed25519_pk, k->ed25519_sk);
1550 ret = 0;
1551 break;
1552 #ifdef WITH_OPENSSL
1553 case KEY_DSA:
1554 ret = dsa_generate_private_key(bits, &k->dsa);
1555 break;
1556 # ifdef OPENSSL_HAS_ECC
1557 case KEY_ECDSA:
1558 ret = ecdsa_generate_private_key(bits, &k->ecdsa_nid,
1559 &k->ecdsa);
1560 break;
1561 # endif /* OPENSSL_HAS_ECC */
1562 case KEY_RSA:
1563 ret = rsa_generate_private_key(bits, &k->rsa);
1564 break;
1565 #endif /* WITH_OPENSSL */
1566 default:
1567 ret = SSH_ERR_INVALID_ARGUMENT;
1568 }
1569 if (ret == 0) {
1570 k->type = type;
1571 *keyp = k;
1572 } else
1573 sshkey_free(k);
1574 return ret;
1575 }
1576
1577 int
1578 sshkey_cert_copy(const struct sshkey *from_key, struct sshkey *to_key)
1579 {
1580 u_int i;
1581 const struct sshkey_cert *from;
1582 struct sshkey_cert *to;
1583 int ret = SSH_ERR_INTERNAL_ERROR;
1584
1585 if (to_key->cert != NULL) {
1586 cert_free(to_key->cert);
1587 to_key->cert = NULL;
1588 }
1589
1590 if ((from = from_key->cert) == NULL)
1591 return SSH_ERR_INVALID_ARGUMENT;
1592
1593 if ((to = to_key->cert = cert_new()) == NULL)
1594 return SSH_ERR_ALLOC_FAIL;
1595
1596 if ((ret = sshbuf_putb(to->certblob, from->certblob)) != 0 ||
1597 (ret = sshbuf_putb(to->critical, from->critical)) != 0 ||
1598 (ret = sshbuf_putb(to->extensions, from->extensions)) != 0)
1599 return ret;
1600
1601 to->serial = from->serial;
1602 to->type = from->type;
1603 if (from->key_id == NULL)
1604 to->key_id = NULL;
1605 else if ((to->key_id = strdup(from->key_id)) == NULL)
1606 return SSH_ERR_ALLOC_FAIL;
1607 to->valid_after = from->valid_after;
1608 to->valid_before = from->valid_before;
1609 if (from->signature_key == NULL)
1610 to->signature_key = NULL;
1611 else if ((ret = sshkey_from_private(from->signature_key,
1612 &to->signature_key)) != 0)
1613 return ret;
1614
1615 if (from->nprincipals > SSHKEY_CERT_MAX_PRINCIPALS)
1616 return SSH_ERR_INVALID_ARGUMENT;
1617 if (from->nprincipals > 0) {
1618 if ((to->principals = calloc(from->nprincipals,
1619 sizeof(*to->principals))) == NULL)
1620 return SSH_ERR_ALLOC_FAIL;
1621 for (i = 0; i < from->nprincipals; i++) {
1622 to->principals[i] = strdup(from->principals[i]);
1623 if (to->principals[i] == NULL) {
1624 to->nprincipals = i;
1625 return SSH_ERR_ALLOC_FAIL;
1626 }
1627 }
1628 }
1629 to->nprincipals = from->nprincipals;
1630 return 0;
1631 }
1632
1633 int
1634 sshkey_from_private(const struct sshkey *k, struct sshkey **pkp)
1635 {
1636 struct sshkey *n = NULL;
1637 int ret = SSH_ERR_INTERNAL_ERROR;
1638
1639 *pkp = NULL;
1640 switch (k->type) {
1641 #ifdef WITH_OPENSSL
1642 case KEY_DSA:
1643 case KEY_DSA_CERT:
1644 if ((n = sshkey_new(k->type)) == NULL)
1645 return SSH_ERR_ALLOC_FAIL;
1646 if ((BN_copy(n->dsa->p, k->dsa->p) == NULL) ||
1647 (BN_copy(n->dsa->q, k->dsa->q) == NULL) ||
1648 (BN_copy(n->dsa->g, k->dsa->g) == NULL) ||
1649 (BN_copy(n->dsa->pub_key, k->dsa->pub_key) == NULL)) {
1650 sshkey_free(n);
1651 return SSH_ERR_ALLOC_FAIL;
1652 }
1653 break;
1654 # ifdef OPENSSL_HAS_ECC
1655 case KEY_ECDSA:
1656 case KEY_ECDSA_CERT:
1657 if ((n = sshkey_new(k->type)) == NULL)
1658 return SSH_ERR_ALLOC_FAIL;
1659 n->ecdsa_nid = k->ecdsa_nid;
1660 n->ecdsa = EC_KEY_new_by_curve_name(k->ecdsa_nid);
1661 if (n->ecdsa == NULL) {
1662 sshkey_free(n);
1663 return SSH_ERR_ALLOC_FAIL;
1664 }
1665 if (EC_KEY_set_public_key(n->ecdsa,
1666 EC_KEY_get0_public_key(k->ecdsa)) != 1) {
1667 sshkey_free(n);
1668 return SSH_ERR_LIBCRYPTO_ERROR;
1669 }
1670 break;
1671 # endif /* OPENSSL_HAS_ECC */
1672 case KEY_RSA:
1673 case KEY_RSA_CERT:
1674 if ((n = sshkey_new(k->type)) == NULL)
1675 return SSH_ERR_ALLOC_FAIL;
1676 if ((BN_copy(n->rsa->n, k->rsa->n) == NULL) ||
1677 (BN_copy(n->rsa->e, k->rsa->e) == NULL)) {
1678 sshkey_free(n);
1679 return SSH_ERR_ALLOC_FAIL;
1680 }
1681 break;
1682 #endif /* WITH_OPENSSL */
1683 case KEY_ED25519:
1684 case KEY_ED25519_CERT:
1685 if ((n = sshkey_new(k->type)) == NULL)
1686 return SSH_ERR_ALLOC_FAIL;
1687 if (k->ed25519_pk != NULL) {
1688 if ((n->ed25519_pk = malloc(ED25519_PK_SZ)) == NULL) {
1689 sshkey_free(n);
1690 return SSH_ERR_ALLOC_FAIL;
1691 }
1692 memcpy(n->ed25519_pk, k->ed25519_pk, ED25519_PK_SZ);
1693 }
1694 break;
1695 default:
1696 return SSH_ERR_KEY_TYPE_UNKNOWN;
1697 }
1698 if (sshkey_is_cert(k)) {
1699 if ((ret = sshkey_cert_copy(k, n)) != 0) {
1700 sshkey_free(n);
1701 return ret;
1702 }
1703 }
1704 *pkp = n;
1705 return 0;
1706 }
1707
1708 static int
1709 cert_parse(struct sshbuf *b, struct sshkey *key, struct sshbuf *certbuf)
1710 {
1711 struct sshbuf *principals = NULL, *crit = NULL;
1712 struct sshbuf *exts = NULL, *ca = NULL;
1713 u_char *sig = NULL;
1714 size_t signed_len = 0, slen = 0, kidlen = 0;
1715 int ret = SSH_ERR_INTERNAL_ERROR;
1716
1717 /* Copy the entire key blob for verification and later serialisation */
1718 if ((ret = sshbuf_putb(key->cert->certblob, certbuf)) != 0)
1719 return ret;
1720
1721 /* Parse body of certificate up to signature */
1722 if ((ret = sshbuf_get_u64(b, &key->cert->serial)) != 0 ||
1723 (ret = sshbuf_get_u32(b, &key->cert->type)) != 0 ||
1724 (ret = sshbuf_get_cstring(b, &key->cert->key_id, &kidlen)) != 0 ||
1725 (ret = sshbuf_froms(b, &principals)) != 0 ||
1726 (ret = sshbuf_get_u64(b, &key->cert->valid_after)) != 0 ||
1727 (ret = sshbuf_get_u64(b, &key->cert->valid_before)) != 0 ||
1728 (ret = sshbuf_froms(b, &crit)) != 0 ||
1729 (ret = sshbuf_froms(b, &exts)) != 0 ||
1730 (ret = sshbuf_get_string_direct(b, NULL, NULL)) != 0 ||
1731 (ret = sshbuf_froms(b, &ca)) != 0) {
1732 /* XXX debug print error for ret */
1733 ret = SSH_ERR_INVALID_FORMAT;
1734 goto out;
1735 }
1736
1737 /* Signature is left in the buffer so we can calculate this length */
1738 signed_len = sshbuf_len(key->cert->certblob) - sshbuf_len(b);
1739
1740 if ((ret = sshbuf_get_string(b, &sig, &slen)) != 0) {
1741 ret = SSH_ERR_INVALID_FORMAT;
1742 goto out;
1743 }
1744
1745 if (key->cert->type != SSH2_CERT_TYPE_USER &&
1746 key->cert->type != SSH2_CERT_TYPE_HOST) {
1747 ret = SSH_ERR_KEY_CERT_UNKNOWN_TYPE;
1748 goto out;
1749 }
1750
1751 /* Parse principals section */
1752 while (sshbuf_len(principals) > 0) {
1753 char *principal = NULL;
1754 char **oprincipals = NULL;
1755
1756 if (key->cert->nprincipals >= SSHKEY_CERT_MAX_PRINCIPALS) {
1757 ret = SSH_ERR_INVALID_FORMAT;
1758 goto out;
1759 }
1760 if ((ret = sshbuf_get_cstring(principals, &principal,
1761 NULL)) != 0) {
1762 ret = SSH_ERR_INVALID_FORMAT;
1763 goto out;
1764 }
1765 oprincipals = key->cert->principals;
1766 key->cert->principals = recallocarray(key->cert->principals,
1767 key->cert->nprincipals, key->cert->nprincipals + 1,
1768 sizeof(*key->cert->principals));
1769 if (key->cert->principals == NULL) {
1770 free(principal);
1771 key->cert->principals = oprincipals;
1772 ret = SSH_ERR_ALLOC_FAIL;
1773 goto out;
1774 }
1775 key->cert->principals[key->cert->nprincipals++] = principal;
1776 }
1777
1778 /*
1779 * Stash a copies of the critical options and extensions sections
1780 * for later use.
1781 */
1782 if ((ret = sshbuf_putb(key->cert->critical, crit)) != 0 ||
1783 (exts != NULL &&
1784 (ret = sshbuf_putb(key->cert->extensions, exts)) != 0))
1785 goto out;
1786
1787 /*
1788 * Validate critical options and extensions sections format.
1789 */
1790 while (sshbuf_len(crit) != 0) {
1791 if ((ret = sshbuf_get_string_direct(crit, NULL, NULL)) != 0 ||
1792 (ret = sshbuf_get_string_direct(crit, NULL, NULL)) != 0) {
1793 sshbuf_reset(key->cert->critical);
1794 ret = SSH_ERR_INVALID_FORMAT;
1795 goto out;
1796 }
1797 }
1798 while (exts != NULL && sshbuf_len(exts) != 0) {
1799 if ((ret = sshbuf_get_string_direct(exts, NULL, NULL)) != 0 ||
1800 (ret = sshbuf_get_string_direct(exts, NULL, NULL)) != 0) {
1801 sshbuf_reset(key->cert->extensions);
1802 ret = SSH_ERR_INVALID_FORMAT;
1803 goto out;
1804 }
1805 }
1806
1807 /* Parse CA key and check signature */
1808 if (sshkey_from_blob_internal(ca, &key->cert->signature_key, 0) != 0) {
1809 ret = SSH_ERR_KEY_CERT_INVALID_SIGN_KEY;
1810 goto out;
1811 }
1812 if (!sshkey_type_is_valid_ca(key->cert->signature_key->type)) {
1813 ret = SSH_ERR_KEY_CERT_INVALID_SIGN_KEY;
1814 goto out;
1815 }
1816 if ((ret = sshkey_verify(key->cert->signature_key, sig, slen,
1817 sshbuf_ptr(key->cert->certblob), signed_len, 0)) != 0)
1818 goto out;
1819
1820 /* Success */
1821 ret = 0;
1822 out:
1823 sshbuf_free(ca);
1824 sshbuf_free(crit);
1825 sshbuf_free(exts);
1826 sshbuf_free(principals);
1827 free(sig);
1828 return ret;
1829 }
1830
1831 static int
1832 sshkey_from_blob_internal(struct sshbuf *b, struct sshkey **keyp,
1833 int allow_cert)
1834 {
1835 int type, ret = SSH_ERR_INTERNAL_ERROR;
1836 char *ktype = NULL, *curve = NULL;
1837 struct sshkey *key = NULL;
1838 size_t len;
1839 u_char *pk = NULL;
1840 struct sshbuf *copy;
1841 #if defined(WITH_OPENSSL) && defined(OPENSSL_HAS_ECC)
1842 EC_POINT *q = NULL;
1843 #endif /* WITH_OPENSSL && OPENSSL_HAS_ECC */
1844
1845 #ifdef DEBUG_PK /* XXX */
1846 sshbuf_dump(b, stderr);
1847 #endif
1848 if (keyp != NULL)
1849 *keyp = NULL;
1850 if ((copy = sshbuf_fromb(b)) == NULL) {
1851 ret = SSH_ERR_ALLOC_FAIL;
1852 goto out;
1853 }
1854 if (sshbuf_get_cstring(b, &ktype, NULL) != 0) {
1855 ret = SSH_ERR_INVALID_FORMAT;
1856 goto out;
1857 }
1858
1859 type = sshkey_type_from_name(ktype);
1860 if (!allow_cert && sshkey_type_is_cert(type)) {
1861 ret = SSH_ERR_KEY_CERT_INVALID_SIGN_KEY;
1862 goto out;
1863 }
1864 switch (type) {
1865 #ifdef WITH_OPENSSL
1866 case KEY_RSA_CERT:
1867 /* Skip nonce */
1868 if (sshbuf_get_string_direct(b, NULL, NULL) != 0) {
1869 ret = SSH_ERR_INVALID_FORMAT;
1870 goto out;
1871 }
1872 /* FALLTHROUGH */
1873 case KEY_RSA:
1874 if ((key = sshkey_new(type)) == NULL) {
1875 ret = SSH_ERR_ALLOC_FAIL;
1876 goto out;
1877 }
1878 if (sshbuf_get_bignum2(b, key->rsa->e) != 0 ||
1879 sshbuf_get_bignum2(b, key->rsa->n) != 0) {
1880 ret = SSH_ERR_INVALID_FORMAT;
1881 goto out;
1882 }
1883 if (BN_num_bits(key->rsa->n) < SSH_RSA_MINIMUM_MODULUS_SIZE) {
1884 ret = SSH_ERR_KEY_LENGTH;
1885 goto out;
1886 }
1887 #ifdef DEBUG_PK
1888 RSA_print_fp(stderr, key->rsa, 8);
1889 #endif
1890 break;
1891 case KEY_DSA_CERT:
1892 /* Skip nonce */
1893 if (sshbuf_get_string_direct(b, NULL, NULL) != 0) {
1894 ret = SSH_ERR_INVALID_FORMAT;
1895 goto out;
1896 }
1897 /* FALLTHROUGH */
1898 case KEY_DSA:
1899 if ((key = sshkey_new(type)) == NULL) {
1900 ret = SSH_ERR_ALLOC_FAIL;
1901 goto out;
1902 }
1903 if (sshbuf_get_bignum2(b, key->dsa->p) != 0 ||
1904 sshbuf_get_bignum2(b, key->dsa->q) != 0 ||
1905 sshbuf_get_bignum2(b, key->dsa->g) != 0 ||
1906 sshbuf_get_bignum2(b, key->dsa->pub_key) != 0) {
1907 ret = SSH_ERR_INVALID_FORMAT;
1908 goto out;
1909 }
1910 #ifdef DEBUG_PK
1911 DSA_print_fp(stderr, key->dsa, 8);
1912 #endif
1913 break;
1914 case KEY_ECDSA_CERT:
1915 /* Skip nonce */
1916 if (sshbuf_get_string_direct(b, NULL, NULL) != 0) {
1917 ret = SSH_ERR_INVALID_FORMAT;
1918 goto out;
1919 }
1920 /* FALLTHROUGH */
1921 # ifdef OPENSSL_HAS_ECC
1922 case KEY_ECDSA:
1923 if ((key = sshkey_new(type)) == NULL) {
1924 ret = SSH_ERR_ALLOC_FAIL;
1925 goto out;
1926 }
1927 key->ecdsa_nid = sshkey_ecdsa_nid_from_name(ktype);
1928 if (sshbuf_get_cstring(b, &curve, NULL) != 0) {
1929 ret = SSH_ERR_INVALID_FORMAT;
1930 goto out;
1931 }
1932 if (key->ecdsa_nid != sshkey_curve_name_to_nid(curve)) {
1933 ret = SSH_ERR_EC_CURVE_MISMATCH;
1934 goto out;
1935 }
1936 if (key->ecdsa != NULL)
1937 EC_KEY_free(key->ecdsa);
1938 if ((key->ecdsa = EC_KEY_new_by_curve_name(key->ecdsa_nid))
1939 == NULL) {
1940 ret = SSH_ERR_EC_CURVE_INVALID;
1941 goto out;
1942 }
1943 if ((q = EC_POINT_new(EC_KEY_get0_group(key->ecdsa))) == NULL) {
1944 ret = SSH_ERR_ALLOC_FAIL;
1945 goto out;
1946 }
1947 if (sshbuf_get_ec(b, q, EC_KEY_get0_group(key->ecdsa)) != 0) {
1948 ret = SSH_ERR_INVALID_FORMAT;
1949 goto out;
1950 }
1951 if (sshkey_ec_validate_public(EC_KEY_get0_group(key->ecdsa),
1952 q) != 0) {
1953 ret = SSH_ERR_KEY_INVALID_EC_VALUE;
1954 goto out;
1955 }
1956 if (EC_KEY_set_public_key(key->ecdsa, q) != 1) {
1957 /* XXX assume it is a allocation error */
1958 ret = SSH_ERR_ALLOC_FAIL;
1959 goto out;
1960 }
1961 #ifdef DEBUG_PK
1962 sshkey_dump_ec_point(EC_KEY_get0_group(key->ecdsa), q);
1963 #endif
1964 break;
1965 # endif /* OPENSSL_HAS_ECC */
1966 #endif /* WITH_OPENSSL */
1967 case KEY_ED25519_CERT:
1968 /* Skip nonce */
1969 if (sshbuf_get_string_direct(b, NULL, NULL) != 0) {
1970 ret = SSH_ERR_INVALID_FORMAT;
1971 goto out;
1972 }
1973 /* FALLTHROUGH */
1974 case KEY_ED25519:
1975 if ((ret = sshbuf_get_string(b, &pk, &len)) != 0)
1976 goto out;
1977 if (len != ED25519_PK_SZ) {
1978 ret = SSH_ERR_INVALID_FORMAT;
1979 goto out;
1980 }
1981 if ((key = sshkey_new(type)) == NULL) {
1982 ret = SSH_ERR_ALLOC_FAIL;
1983 goto out;
1984 }
1985 key->ed25519_pk = pk;
1986 pk = NULL;
1987 break;
1988 case KEY_UNSPEC:
1989 default:
1990 ret = SSH_ERR_KEY_TYPE_UNKNOWN;
1991 goto out;
1992 }
1993
1994 /* Parse certificate potion */
1995 if (sshkey_is_cert(key) && (ret = cert_parse(b, key, copy)) != 0)
1996 goto out;
1997
1998 if (key != NULL && sshbuf_len(b) != 0) {
1999 ret = SSH_ERR_INVALID_FORMAT;
2000 goto out;
2001 }
2002 ret = 0;
2003 if (keyp != NULL) {
2004 *keyp = key;
2005 key = NULL;
2006 }
2007 out:
2008 sshbuf_free(copy);
2009 sshkey_free(key);
2010 free(ktype);
2011 free(curve);
2012 free(pk);
2013 #if defined(WITH_OPENSSL) && defined(OPENSSL_HAS_ECC)
2014 if (q != NULL)
2015 EC_POINT_free(q);
2016 #endif /* WITH_OPENSSL && OPENSSL_HAS_ECC */
2017 return ret;
2018 }
2019
2020 int
2021 sshkey_from_blob(const u_char *blob, size_t blen, struct sshkey **keyp)
2022 {
2023 struct sshbuf *b;
2024 int r;
2025
2026 if ((b = sshbuf_from(blob, blen)) == NULL)
2027 return SSH_ERR_ALLOC_FAIL;
2028 r = sshkey_from_blob_internal(b, keyp, 1);
2029 sshbuf_free(b);
2030 return r;
2031 }
2032
2033 int
2034 sshkey_fromb(struct sshbuf *b, struct sshkey **keyp)
2035 {
2036 return sshkey_from_blob_internal(b, keyp, 1);
2037 }
2038
2039 int
2040 sshkey_froms(struct sshbuf *buf, struct sshkey **keyp)
2041 {
2042 struct sshbuf *b;
2043 int r;
2044
2045 if ((r = sshbuf_froms(buf, &b)) != 0)
2046 return r;
2047 r = sshkey_from_blob_internal(b, keyp, 1);
2048 sshbuf_free(b);
2049 return r;
2050 }
2051
2052 int
2053 sshkey_sign(const struct sshkey *key,
2054 u_char **sigp, size_t *lenp,
2055 const u_char *data, size_t datalen, const char *alg, u_int compat)
2056 {
2057 if (sigp != NULL)
2058 *sigp = NULL;
2059 if (lenp != NULL)
2060 *lenp = 0;
2061 if (datalen > SSH_KEY_MAX_SIGN_DATA_SIZE)
2062 return SSH_ERR_INVALID_ARGUMENT;
2063 switch (key->type) {
2064 #ifdef WITH_OPENSSL
2065 case KEY_DSA_CERT:
2066 case KEY_DSA:
2067 return ssh_dss_sign(key, sigp, lenp, data, datalen, compat);
2068 # ifdef OPENSSL_HAS_ECC
2069 case KEY_ECDSA_CERT:
2070 case KEY_ECDSA:
2071 return ssh_ecdsa_sign(key, sigp, lenp, data, datalen, compat);
2072 # endif /* OPENSSL_HAS_ECC */
2073 case KEY_RSA_CERT:
2074 case KEY_RSA:
2075 return ssh_rsa_sign(key, sigp, lenp, data, datalen, alg);
2076 #endif /* WITH_OPENSSL */
2077 case KEY_ED25519:
2078 case KEY_ED25519_CERT:
2079 return ssh_ed25519_sign(key, sigp, lenp, data, datalen, compat);
2080 default:
2081 return SSH_ERR_KEY_TYPE_UNKNOWN;
2082 }
2083 }
2084
2085 /*
2086 * ssh_key_verify returns 0 for a correct signature and < 0 on error.
2087 */
2088 int
2089 sshkey_verify(const struct sshkey *key,
2090 const u_char *sig, size_t siglen,
2091 const u_char *data, size_t dlen, u_int compat)
2092 {
2093 if (siglen == 0 || dlen > SSH_KEY_MAX_SIGN_DATA_SIZE)
2094 return SSH_ERR_INVALID_ARGUMENT;
2095 switch (key->type) {
2096 #ifdef WITH_OPENSSL
2097 case KEY_DSA_CERT:
2098 case KEY_DSA:
2099 return ssh_dss_verify(key, sig, siglen, data, dlen, compat);
2100 # ifdef OPENSSL_HAS_ECC
2101 case KEY_ECDSA_CERT:
2102 case KEY_ECDSA:
2103 return ssh_ecdsa_verify(key, sig, siglen, data, dlen, compat);
2104 # endif /* OPENSSL_HAS_ECC */
2105 case KEY_RSA_CERT:
2106 case KEY_RSA:
2107 return ssh_rsa_verify(key, sig, siglen, data, dlen);
2108 #endif /* WITH_OPENSSL */
2109 case KEY_ED25519:
2110 case KEY_ED25519_CERT:
2111 return ssh_ed25519_verify(key, sig, siglen, data, dlen, compat);
2112 default:
2113 return SSH_ERR_KEY_TYPE_UNKNOWN;
2114 }
2115 }
2116
2117 /* Converts a private to a public key */
2118 int
2119 sshkey_demote(const struct sshkey *k, struct sshkey **dkp)
2120 {
2121 struct sshkey *pk;
2122 int ret = SSH_ERR_INTERNAL_ERROR;
2123
2124 *dkp = NULL;
2125 if ((pk = calloc(1, sizeof(*pk))) == NULL)
2126 return SSH_ERR_ALLOC_FAIL;
2127 pk->type = k->type;
2128 pk->flags = k->flags;
2129 pk->ecdsa_nid = k->ecdsa_nid;
2130 pk->dsa = NULL;
2131 pk->ecdsa = NULL;
2132 pk->rsa = NULL;
2133 pk->ed25519_pk = NULL;
2134 pk->ed25519_sk = NULL;
2135
2136 switch (k->type) {
2137 #ifdef WITH_OPENSSL
2138 case KEY_RSA_CERT:
2139 if ((ret = sshkey_cert_copy(k, pk)) != 0)
2140 goto fail;
2141 /* FALLTHROUGH */
2142 case KEY_RSA:
2143 if ((pk->rsa = RSA_new()) == NULL ||
2144 (pk->rsa->e = BN_dup(k->rsa->e)) == NULL ||
2145 (pk->rsa->n = BN_dup(k->rsa->n)) == NULL) {
2146 ret = SSH_ERR_ALLOC_FAIL;
2147 goto fail;
2148 }
2149 break;
2150 case KEY_DSA_CERT:
2151 if ((ret = sshkey_cert_copy(k, pk)) != 0)
2152 goto fail;
2153 /* FALLTHROUGH */
2154 case KEY_DSA:
2155 if ((pk->dsa = DSA_new()) == NULL ||
2156 (pk->dsa->p = BN_dup(k->dsa->p)) == NULL ||
2157 (pk->dsa->q = BN_dup(k->dsa->q)) == NULL ||
2158 (pk->dsa->g = BN_dup(k->dsa->g)) == NULL ||
2159 (pk->dsa->pub_key = BN_dup(k->dsa->pub_key)) == NULL) {
2160 ret = SSH_ERR_ALLOC_FAIL;
2161 goto fail;
2162 }
2163 break;
2164 case KEY_ECDSA_CERT:
2165 if ((ret = sshkey_cert_copy(k, pk)) != 0)
2166 goto fail;
2167 /* FALLTHROUGH */
2168 # ifdef OPENSSL_HAS_ECC
2169 case KEY_ECDSA:
2170 pk->ecdsa = EC_KEY_new_by_curve_name(pk->ecdsa_nid);
2171 if (pk->ecdsa == NULL) {
2172 ret = SSH_ERR_ALLOC_FAIL;
2173 goto fail;
2174 }
2175 if (EC_KEY_set_public_key(pk->ecdsa,
2176 EC_KEY_get0_public_key(k->ecdsa)) != 1) {
2177 ret = SSH_ERR_LIBCRYPTO_ERROR;
2178 goto fail;
2179 }
2180 break;
2181 # endif /* OPENSSL_HAS_ECC */
2182 #endif /* WITH_OPENSSL */
2183 case KEY_ED25519_CERT:
2184 if ((ret = sshkey_cert_copy(k, pk)) != 0)
2185 goto fail;
2186 /* FALLTHROUGH */
2187 case KEY_ED25519:
2188 if (k->ed25519_pk != NULL) {
2189 if ((pk->ed25519_pk = malloc(ED25519_PK_SZ)) == NULL) {
2190 ret = SSH_ERR_ALLOC_FAIL;
2191 goto fail;
2192 }
2193 memcpy(pk->ed25519_pk, k->ed25519_pk, ED25519_PK_SZ);
2194 }
2195 break;
2196 default:
2197 ret = SSH_ERR_KEY_TYPE_UNKNOWN;
2198 fail:
2199 sshkey_free(pk);
2200 return ret;
2201 }
2202 *dkp = pk;
2203 return 0;
2204 }
2205
2206 /* Convert a plain key to their _CERT equivalent */
2207 int
2208 sshkey_to_certified(struct sshkey *k)
2209 {
2210 int newtype;
2211
2212 switch (k->type) {
2213 #ifdef WITH_OPENSSL
2214 case KEY_RSA:
2215 newtype = KEY_RSA_CERT;
2216 break;
2217 case KEY_DSA:
2218 newtype = KEY_DSA_CERT;
2219 break;
2220 case KEY_ECDSA:
2221 newtype = KEY_ECDSA_CERT;
2222 break;
2223 #endif /* WITH_OPENSSL */
2224 case KEY_ED25519:
2225 newtype = KEY_ED25519_CERT;
2226 break;
2227 default:
2228 return SSH_ERR_INVALID_ARGUMENT;
2229 }
2230 if ((k->cert = cert_new()) == NULL)
2231 return SSH_ERR_ALLOC_FAIL;
2232 k->type = newtype;
2233 return 0;
2234 }
2235
2236 /* Convert a certificate to its raw key equivalent */
2237 int
2238 sshkey_drop_cert(struct sshkey *k)
2239 {
2240 if (!sshkey_type_is_cert(k->type))
2241 return SSH_ERR_KEY_TYPE_UNKNOWN;
2242 cert_free(k->cert);
2243 k->cert = NULL;
2244 k->type = sshkey_type_plain(k->type);
2245 return 0;
2246 }
2247
2248 /* Sign a certified key, (re-)generating the signed certblob. */
2249 int
2250 sshkey_certify_custom(struct sshkey *k, struct sshkey *ca, const char *alg,
2251 sshkey_certify_signer *signer, void *signer_ctx)
2252 {
2253 struct sshbuf *principals = NULL;
2254 u_char *ca_blob = NULL, *sig_blob = NULL, nonce[32];
2255 size_t i, ca_len, sig_len;
2256 int ret = SSH_ERR_INTERNAL_ERROR;
2257 struct sshbuf *cert;
2258
2259 if (k == NULL || k->cert == NULL ||
2260 k->cert->certblob == NULL || ca == NULL)
2261 return SSH_ERR_INVALID_ARGUMENT;
2262 if (!sshkey_is_cert(k))
2263 return SSH_ERR_KEY_TYPE_UNKNOWN;
2264 if (!sshkey_type_is_valid_ca(ca->type))
2265 return SSH_ERR_KEY_CERT_INVALID_SIGN_KEY;
2266
2267 if ((ret = sshkey_to_blob(ca, &ca_blob, &ca_len)) != 0)
2268 return SSH_ERR_KEY_CERT_INVALID_SIGN_KEY;
2269
2270 cert = k->cert->certblob; /* for readability */
2271 sshbuf_reset(cert);
2272 if ((ret = sshbuf_put_cstring(cert, sshkey_ssh_name(k))) != 0)
2273 goto out;
2274
2275 /* -v01 certs put nonce first */
2276 arc4random_buf(&nonce, sizeof(nonce));
2277 if ((ret = sshbuf_put_string(cert, nonce, sizeof(nonce))) != 0)
2278 goto out;
2279
2280 /* XXX this substantially duplicates to_blob(); refactor */
2281 switch (k->type) {
2282 #ifdef WITH_OPENSSL
2283 case KEY_DSA_CERT:
2284 if ((ret = sshbuf_put_bignum2(cert, k->dsa->p)) != 0 ||
2285 (ret = sshbuf_put_bignum2(cert, k->dsa->q)) != 0 ||
2286 (ret = sshbuf_put_bignum2(cert, k->dsa->g)) != 0 ||
2287 (ret = sshbuf_put_bignum2(cert, k->dsa->pub_key)) != 0)
2288 goto out;
2289 break;
2290 # ifdef OPENSSL_HAS_ECC
2291 case KEY_ECDSA_CERT:
2292 if ((ret = sshbuf_put_cstring(cert,
2293 sshkey_curve_nid_to_name(k->ecdsa_nid))) != 0 ||
2294 (ret = sshbuf_put_ec(cert,
2295 EC_KEY_get0_public_key(k->ecdsa),
2296 EC_KEY_get0_group(k->ecdsa))) != 0)
2297 goto out;
2298 break;
2299 # endif /* OPENSSL_HAS_ECC */
2300 case KEY_RSA_CERT:
2301 if ((ret = sshbuf_put_bignum2(cert, k->rsa->e)) != 0 ||
2302 (ret = sshbuf_put_bignum2(cert, k->rsa->n)) != 0)
2303 goto out;
2304 break;
2305 #endif /* WITH_OPENSSL */
2306 case KEY_ED25519_CERT:
2307 if ((ret = sshbuf_put_string(cert,
2308 k->ed25519_pk, ED25519_PK_SZ)) != 0)
2309 goto out;
2310 break;
2311 default:
2312 ret = SSH_ERR_INVALID_ARGUMENT;
2313 goto out;
2314 }
2315
2316 if ((ret = sshbuf_put_u64(cert, k->cert->serial)) != 0 ||
2317 (ret = sshbuf_put_u32(cert, k->cert->type)) != 0 ||
2318 (ret = sshbuf_put_cstring(cert, k->cert->key_id)) != 0)
2319 goto out;
2320
2321 if ((principals = sshbuf_new()) == NULL) {
2322 ret = SSH_ERR_ALLOC_FAIL;
2323 goto out;
2324 }
2325 for (i = 0; i < k->cert->nprincipals; i++) {
2326 if ((ret = sshbuf_put_cstring(principals,
2327 k->cert->principals[i])) != 0)
2328 goto out;
2329 }
2330 if ((ret = sshbuf_put_stringb(cert, principals)) != 0 ||
2331 (ret = sshbuf_put_u64(cert, k->cert->valid_after)) != 0 ||
2332 (ret = sshbuf_put_u64(cert, k->cert->valid_before)) != 0 ||
2333 (ret = sshbuf_put_stringb(cert, k->cert->critical)) != 0 ||
2334 (ret = sshbuf_put_stringb(cert, k->cert->extensions)) != 0 ||
2335 (ret = sshbuf_put_string(cert, NULL, 0)) != 0 || /* Reserved */
2336 (ret = sshbuf_put_string(cert, ca_blob, ca_len)) != 0)
2337 goto out;
2338
2339 /* Sign the whole mess */
2340 if ((ret = signer(ca, &sig_blob, &sig_len, sshbuf_ptr(cert),
2341 sshbuf_len(cert), alg, 0, signer_ctx)) != 0)
2342 goto out;
2343
2344 /* Append signature and we are done */
2345 if ((ret = sshbuf_put_string(cert, sig_blob, sig_len)) != 0)
2346 goto out;
2347 ret = 0;
2348 out:
2349 if (ret != 0)
2350 sshbuf_reset(cert);
2351 free(sig_blob);
2352 free(ca_blob);
2353 sshbuf_free(principals);
2354 return ret;
2355 }
2356
2357 static int
2358 default_key_sign(const struct sshkey *key, u_char **sigp, size_t *lenp,
2359 const u_char *data, size_t datalen,
2360 const char *alg, u_int compat, void *ctx)
2361 {
2362 if (ctx != NULL)
2363 return SSH_ERR_INVALID_ARGUMENT;
2364 return sshkey_sign(key, sigp, lenp, data, datalen, alg, compat);
2365 }
2366
2367 int
2368 sshkey_certify(struct sshkey *k, struct sshkey *ca, const char *alg)
2369 {
2370 return sshkey_certify_custom(k, ca, alg, default_key_sign, NULL);
2371 }
2372
2373 int
2374 sshkey_cert_check_authority(const struct sshkey *k,
2375 int want_host, int require_principal,
2376 const char *name, const char **reason)
2377 {
2378 u_int i, principal_matches;
2379 time_t now = time(NULL);
2380
2381 if (reason != NULL)
2382 *reason = NULL;
2383
2384 if (want_host) {
2385 if (k->cert->type != SSH2_CERT_TYPE_HOST) {
2386 *reason = "Certificate invalid: not a host certificate";
2387 return SSH_ERR_KEY_CERT_INVALID;
2388 }
2389 } else {
2390 if (k->cert->type != SSH2_CERT_TYPE_USER) {
2391 *reason = "Certificate invalid: not a user certificate";
2392 return SSH_ERR_KEY_CERT_INVALID;
2393 }
2394 }
2395 if (now < 0) {
2396 /* yikes - system clock before epoch! */
2397 *reason = "Certificate invalid: not yet valid";
2398 return SSH_ERR_KEY_CERT_INVALID;
2399 }
2400 if ((u_int64_t)now < k->cert->valid_after) {
2401 *reason = "Certificate invalid: not yet valid";
2402 return SSH_ERR_KEY_CERT_INVALID;
2403 }
2404 if ((u_int64_t)now >= k->cert->valid_before) {
2405 *reason = "Certificate invalid: expired";
2406 return SSH_ERR_KEY_CERT_INVALID;
2407 }
2408 if (k->cert->nprincipals == 0) {
2409 if (require_principal) {
2410 *reason = "Certificate lacks principal list";
2411 return SSH_ERR_KEY_CERT_INVALID;
2412 }
2413 } else if (name != NULL) {
2414 principal_matches = 0;
2415 for (i = 0; i < k->cert->nprincipals; i++) {
2416 if (strcmp(name, k->cert->principals[i]) == 0) {
2417 principal_matches = 1;
2418 break;
2419 }
2420 }
2421 if (!principal_matches) {
2422 *reason = "Certificate invalid: name is not a listed "
2423 "principal";
2424 return SSH_ERR_KEY_CERT_INVALID;
2425 }
2426 }
2427 return 0;
2428 }
2429
2430 size_t
2431 sshkey_format_cert_validity(const struct sshkey_cert *cert, char *s, size_t l)
2432 {
2433 char from[32], to[32], ret[64];
2434 time_t tt;
2435 struct tm *tm;
2436
2437 *from = *to = '\0';
2438 if (cert->valid_after == 0 &&
2439 cert->valid_before == 0xffffffffffffffffULL)
2440 return strlcpy(s, "forever", l);
2441
2442 if (cert->valid_after != 0) {
2443 /* XXX revisit INT_MAX in 2038 :) */
2444 tt = cert->valid_after > INT_MAX ?
2445 INT_MAX : cert->valid_after;
2446 tm = localtime(&tt);
2447 strftime(from, sizeof(from), "%Y-%m-%dT%H:%M:%S", tm);
2448 }
2449 if (cert->valid_before != 0xffffffffffffffffULL) {
2450 /* XXX revisit INT_MAX in 2038 :) */
2451 tt = cert->valid_before > INT_MAX ?
2452 INT_MAX : cert->valid_before;
2453 tm = localtime(&tt);
2454 strftime(to, sizeof(to), "%Y-%m-%dT%H:%M:%S", tm);
2455 }
2456
2457 if (cert->valid_after == 0)
2458 snprintf(ret, sizeof(ret), "before %s", to);
2459 else if (cert->valid_before == 0xffffffffffffffffULL)
2460 snprintf(ret, sizeof(ret), "after %s", from);
2461 else
2462 snprintf(ret, sizeof(ret), "from %s to %s", from, to);
2463
2464 return strlcpy(s, ret, l);
2465 }
2466
2467 int
2468 sshkey_private_serialize(const struct sshkey *key, struct sshbuf *b)
2469 {
2470 int r = SSH_ERR_INTERNAL_ERROR;
2471
2472 if ((r = sshbuf_put_cstring(b, sshkey_ssh_name(key))) != 0)
2473 goto out;
2474 switch (key->type) {
2475 #ifdef WITH_OPENSSL
2476 case KEY_RSA:
2477 if ((r = sshbuf_put_bignum2(b, key->rsa->n)) != 0 ||
2478 (r = sshbuf_put_bignum2(b, key->rsa->e)) != 0 ||
2479 (r = sshbuf_put_bignum2(b, key->rsa->d)) != 0 ||
2480 (r = sshbuf_put_bignum2(b, key->rsa->iqmp)) != 0 ||
2481 (r = sshbuf_put_bignum2(b, key->rsa->p)) != 0 ||
2482 (r = sshbuf_put_bignum2(b, key->rsa->q)) != 0)
2483 goto out;
2484 break;
2485 case KEY_RSA_CERT:
2486 if (key->cert == NULL || sshbuf_len(key->cert->certblob) == 0) {
2487 r = SSH_ERR_INVALID_ARGUMENT;
2488 goto out;
2489 }
2490 if ((r = sshbuf_put_stringb(b, key->cert->certblob)) != 0 ||
2491 (r = sshbuf_put_bignum2(b, key->rsa->d)) != 0 ||
2492 (r = sshbuf_put_bignum2(b, key->rsa->iqmp)) != 0 ||
2493 (r = sshbuf_put_bignum2(b, key->rsa->p)) != 0 ||
2494 (r = sshbuf_put_bignum2(b, key->rsa->q)) != 0)
2495 goto out;
2496 break;
2497 case KEY_DSA:
2498 if ((r = sshbuf_put_bignum2(b, key->dsa->p)) != 0 ||
2499 (r = sshbuf_put_bignum2(b, key->dsa->q)) != 0 ||
2500 (r = sshbuf_put_bignum2(b, key->dsa->g)) != 0 ||
2501 (r = sshbuf_put_bignum2(b, key->dsa->pub_key)) != 0 ||
2502 (r = sshbuf_put_bignum2(b, key->dsa->priv_key)) != 0)
2503 goto out;
2504 break;
2505 case KEY_DSA_CERT:
2506 if (key->cert == NULL || sshbuf_len(key->cert->certblob) == 0) {
2507 r = SSH_ERR_INVALID_ARGUMENT;
2508 goto out;
2509 }
2510 if ((r = sshbuf_put_stringb(b, key->cert->certblob)) != 0 ||
2511 (r = sshbuf_put_bignum2(b, key->dsa->priv_key)) != 0)
2512 goto out;
2513 break;
2514 # ifdef OPENSSL_HAS_ECC
2515 case KEY_ECDSA:
2516 if ((r = sshbuf_put_cstring(b,
2517 sshkey_curve_nid_to_name(key->ecdsa_nid))) != 0 ||
2518 (r = sshbuf_put_eckey(b, key->ecdsa)) != 0 ||
2519 (r = sshbuf_put_bignum2(b,
2520 EC_KEY_get0_private_key(key->ecdsa))) != 0)
2521 goto out;
2522 break;
2523 case KEY_ECDSA_CERT:
2524 if (key->cert == NULL || sshbuf_len(key->cert->certblob) == 0) {
2525 r = SSH_ERR_INVALID_ARGUMENT;
2526 goto out;
2527 }
2528 if ((r = sshbuf_put_stringb(b, key->cert->certblob)) != 0 ||
2529 (r = sshbuf_put_bignum2(b,
2530 EC_KEY_get0_private_key(key->ecdsa))) != 0)
2531 goto out;
2532 break;
2533 # endif /* OPENSSL_HAS_ECC */
2534 #endif /* WITH_OPENSSL */
2535 case KEY_ED25519:
2536 if ((r = sshbuf_put_string(b, key->ed25519_pk,
2537 ED25519_PK_SZ)) != 0 ||
2538 (r = sshbuf_put_string(b, key->ed25519_sk,
2539 ED25519_SK_SZ)) != 0)
2540 goto out;
2541 break;
2542 case KEY_ED25519_CERT:
2543 if (key->cert == NULL || sshbuf_len(key->cert->certblob) == 0) {
2544 r = SSH_ERR_INVALID_ARGUMENT;
2545 goto out;
2546 }
2547 if ((r = sshbuf_put_stringb(b, key->cert->certblob)) != 0 ||
2548 (r = sshbuf_put_string(b, key->ed25519_pk,
2549 ED25519_PK_SZ)) != 0 ||
2550 (r = sshbuf_put_string(b, key->ed25519_sk,
2551 ED25519_SK_SZ)) != 0)
2552 goto out;
2553 break;
2554 default:
2555 r = SSH_ERR_INVALID_ARGUMENT;
2556 goto out;
2557 }
2558 /* success */
2559 r = 0;
2560 out:
2561 return r;
2562 }
2563
2564 int
2565 sshkey_private_deserialize(struct sshbuf *buf, struct sshkey **kp)
2566 {
2567 char *tname = NULL, *curve = NULL;
2568 struct sshkey *k = NULL;
2569 size_t pklen = 0, sklen = 0;
2570 int type, r = SSH_ERR_INTERNAL_ERROR;
2571 u_char *ed25519_pk = NULL, *ed25519_sk = NULL;
2572 #ifdef WITH_OPENSSL
2573 BIGNUM *exponent = NULL;
2574 #endif /* WITH_OPENSSL */
2575
2576 if (kp != NULL)
2577 *kp = NULL;
2578 if ((r = sshbuf_get_cstring(buf, &tname, NULL)) != 0)
2579 goto out;
2580 type = sshkey_type_from_name(tname);
2581 switch (type) {
2582 #ifdef WITH_OPENSSL
2583 case KEY_DSA:
2584 if ((k = sshkey_new_private(type)) == NULL) {
2585 r = SSH_ERR_ALLOC_FAIL;
2586 goto out;
2587 }
2588 if ((r = sshbuf_get_bignum2(buf, k->dsa->p)) != 0 ||
2589 (r = sshbuf_get_bignum2(buf, k->dsa->q)) != 0 ||
2590 (r = sshbuf_get_bignum2(buf, k->dsa->g)) != 0 ||
2591 (r = sshbuf_get_bignum2(buf, k->dsa->pub_key)) != 0 ||
2592 (r = sshbuf_get_bignum2(buf, k->dsa->priv_key)) != 0)
2593 goto out;
2594 break;
2595 case KEY_DSA_CERT:
2596 if ((r = sshkey_froms(buf, &k)) != 0 ||
2597 (r = sshkey_add_private(k)) != 0 ||
2598 (r = sshbuf_get_bignum2(buf, k->dsa->priv_key)) != 0)
2599 goto out;
2600 break;
2601 # ifdef OPENSSL_HAS_ECC
2602 case KEY_ECDSA:
2603 if ((k = sshkey_new_private(type)) == NULL) {
2604 r = SSH_ERR_ALLOC_FAIL;
2605 goto out;
2606 }
2607 if ((k->ecdsa_nid = sshkey_ecdsa_nid_from_name(tname)) == -1) {
2608 r = SSH_ERR_INVALID_ARGUMENT;
2609 goto out;
2610 }
2611 if ((r = sshbuf_get_cstring(buf, &curve, NULL)) != 0)
2612 goto out;
2613 if (k->ecdsa_nid != sshkey_curve_name_to_nid(curve)) {
2614 r = SSH_ERR_EC_CURVE_MISMATCH;
2615 goto out;
2616 }
2617 k->ecdsa = EC_KEY_new_by_curve_name(k->ecdsa_nid);
2618 if (k->ecdsa == NULL || (exponent = BN_new()) == NULL) {
2619 r = SSH_ERR_LIBCRYPTO_ERROR;
2620 goto out;
2621 }
2622 if ((r = sshbuf_get_eckey(buf, k->ecdsa)) != 0 ||
2623 (r = sshbuf_get_bignum2(buf, exponent)))
2624 goto out;
2625 if (EC_KEY_set_private_key(k->ecdsa, exponent) != 1) {
2626 r = SSH_ERR_LIBCRYPTO_ERROR;
2627 goto out;
2628 }
2629 if ((r = sshkey_ec_validate_public(EC_KEY_get0_group(k->ecdsa),
2630 EC_KEY_get0_public_key(k->ecdsa))) != 0 ||
2631 (r = sshkey_ec_validate_private(k->ecdsa)) != 0)
2632 goto out;
2633 break;
2634 case KEY_ECDSA_CERT:
2635 if ((exponent = BN_new()) == NULL) {
2636 r = SSH_ERR_LIBCRYPTO_ERROR;
2637 goto out;
2638 }
2639 if ((r = sshkey_froms(buf, &k)) != 0 ||
2640 (r = sshkey_add_private(k)) != 0 ||
2641 (r = sshbuf_get_bignum2(buf, exponent)) != 0)
2642 goto out;
2643 if (EC_KEY_set_private_key(k->ecdsa, exponent) != 1) {
2644 r = SSH_ERR_LIBCRYPTO_ERROR;
2645 goto out;
2646 }
2647 if ((r = sshkey_ec_validate_public(EC_KEY_get0_group(k->ecdsa),
2648 EC_KEY_get0_public_key(k->ecdsa))) != 0 ||
2649 (r = sshkey_ec_validate_private(k->ecdsa)) != 0)
2650 goto out;
2651 break;
2652 # endif /* OPENSSL_HAS_ECC */
2653 case KEY_RSA:
2654 if ((k = sshkey_new_private(type)) == NULL) {
2655 r = SSH_ERR_ALLOC_FAIL;
2656 goto out;
2657 }
2658 if ((r = sshbuf_get_bignum2(buf, k->rsa->n)) != 0 ||
2659 (r = sshbuf_get_bignum2(buf, k->rsa->e)) != 0 ||
2660 (r = sshbuf_get_bignum2(buf, k->rsa->d)) != 0 ||
2661 (r = sshbuf_get_bignum2(buf, k->rsa->iqmp)) != 0 ||
2662 (r = sshbuf_get_bignum2(buf, k->rsa->p)) != 0 ||
2663 (r = sshbuf_get_bignum2(buf, k->rsa->q)) != 0 ||
2664 (r = ssh_rsa_generate_additional_parameters(k)) != 0)
2665 goto out;
2666 if (BN_num_bits(k->rsa->n) < SSH_RSA_MINIMUM_MODULUS_SIZE) {
2667 r = SSH_ERR_KEY_LENGTH;
2668 goto out;
2669 }
2670 break;
2671 case KEY_RSA_CERT:
2672 if ((r = sshkey_froms(buf, &k)) != 0 ||
2673 (r = sshkey_add_private(k)) != 0 ||
2674 (r = sshbuf_get_bignum2(buf, k->rsa->d)) != 0 ||
2675 (r = sshbuf_get_bignum2(buf, k->rsa->iqmp)) != 0 ||
2676 (r = sshbuf_get_bignum2(buf, k->rsa->p)) != 0 ||
2677 (r = sshbuf_get_bignum2(buf, k->rsa->q)) != 0 ||
2678 (r = ssh_rsa_generate_additional_parameters(k)) != 0)
2679 goto out;
2680 if (BN_num_bits(k->rsa->n) < SSH_RSA_MINIMUM_MODULUS_SIZE) {
2681 r = SSH_ERR_KEY_LENGTH;
2682 goto out;
2683 }
2684 break;
2685 #endif /* WITH_OPENSSL */
2686 case KEY_ED25519:
2687 if ((k = sshkey_new_private(type)) == NULL) {
2688 r = SSH_ERR_ALLOC_FAIL;
2689 goto out;
2690 }
2691 if ((r = sshbuf_get_string(buf, &ed25519_pk, &pklen)) != 0 ||
2692 (r = sshbuf_get_string(buf, &ed25519_sk, &sklen)) != 0)
2693 goto out;
2694 if (pklen != ED25519_PK_SZ || sklen != ED25519_SK_SZ) {
2695 r = SSH_ERR_INVALID_FORMAT;
2696 goto out;
2697 }
2698 k->ed25519_pk = ed25519_pk;
2699 k->ed25519_sk = ed25519_sk;
2700 ed25519_pk = ed25519_sk = NULL;
2701 break;
2702 case KEY_ED25519_CERT:
2703 if ((r = sshkey_froms(buf, &k)) != 0 ||
2704 (r = sshkey_add_private(k)) != 0 ||
2705 (r = sshbuf_get_string(buf, &ed25519_pk, &pklen)) != 0 ||
2706 (r = sshbuf_get_string(buf, &ed25519_sk, &sklen)) != 0)
2707 goto out;
2708 if (pklen != ED25519_PK_SZ || sklen != ED25519_SK_SZ) {
2709 r = SSH_ERR_INVALID_FORMAT;
2710 goto out;
2711 }
2712 k->ed25519_pk = ed25519_pk;
2713 k->ed25519_sk = ed25519_sk;
2714 ed25519_pk = ed25519_sk = NULL;
2715 break;
2716 default:
2717 r = SSH_ERR_KEY_TYPE_UNKNOWN;
2718 goto out;
2719 }
2720 #ifdef WITH_OPENSSL
2721 /* enable blinding */
2722 switch (k->type) {
2723 case KEY_RSA:
2724 case KEY_RSA_CERT:
2725 if (RSA_blinding_on(k->rsa, NULL) != 1) {
2726 r = SSH_ERR_LIBCRYPTO_ERROR;
2727 goto out;
2728 }
2729 break;
2730 }
2731 #endif /* WITH_OPENSSL */
2732 /* success */
2733 r = 0;
2734 if (kp != NULL) {
2735 *kp = k;
2736 k = NULL;
2737 }
2738 out:
2739 free(tname);
2740 free(curve);
2741 #ifdef WITH_OPENSSL
2742 if (exponent != NULL)
2743 BN_clear_free(exponent);
2744 #endif /* WITH_OPENSSL */
2745 sshkey_free(k);
2746 if (ed25519_pk != NULL) {
2747 explicit_bzero(ed25519_pk, pklen);
2748 free(ed25519_pk);
2749 }
2750 if (ed25519_sk != NULL) {
2751 explicit_bzero(ed25519_sk, sklen);
2752 free(ed25519_sk);
2753 }
2754 return r;
2755 }
2756
2757 #if defined(WITH_OPENSSL) && defined(OPENSSL_HAS_ECC)
2758 int
2759 sshkey_ec_validate_public(const EC_GROUP *group, const EC_POINT *public)
2760 {
2761 BN_CTX *bnctx;
2762 EC_POINT *nq = NULL;
2763 BIGNUM *order, *x, *y, *tmp;
2764 int ret = SSH_ERR_KEY_INVALID_EC_VALUE;
2765
2766 /*
2767 * NB. This assumes OpenSSL has already verified that the public
2768 * point lies on the curve. This is done by EC_POINT_oct2point()
2769 * implicitly calling EC_POINT_is_on_curve(). If this code is ever
2770 * reachable with public points not unmarshalled using
2771 * EC_POINT_oct2point then the caller will need to explicitly check.
2772 */
2773
2774 if ((bnctx = BN_CTX_new()) == NULL)
2775 return SSH_ERR_ALLOC_FAIL;
2776 BN_CTX_start(bnctx);
2777
2778 /*
2779 * We shouldn't ever hit this case because bignum_get_ecpoint()
2780 * refuses to load GF2m points.
2781 */
2782 if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) !=
2783 NID_X9_62_prime_field)
2784 goto out;
2785
2786 /* Q != infinity */
2787 if (EC_POINT_is_at_infinity(group, public))
2788 goto out;
2789
2790 if ((x = BN_CTX_get(bnctx)) == NULL ||
2791 (y = BN_CTX_get(bnctx)) == NULL ||
2792 (order = BN_CTX_get(bnctx)) == NULL ||
2793 (tmp = BN_CTX_get(bnctx)) == NULL) {
2794 ret = SSH_ERR_ALLOC_FAIL;
2795 goto out;
2796 }
2797
2798 /* log2(x) > log2(order)/2, log2(y) > log2(order)/2 */
2799 if (EC_GROUP_get_order(group, order, bnctx) != 1 ||
2800 EC_POINT_get_affine_coordinates_GFp(group, public,
2801 x, y, bnctx) != 1) {
2802 ret = SSH_ERR_LIBCRYPTO_ERROR;
2803 goto out;
2804 }
2805 if (BN_num_bits(x) <= BN_num_bits(order) / 2 ||
2806 BN_num_bits(y) <= BN_num_bits(order) / 2)
2807 goto out;
2808
2809 /* nQ == infinity (n == order of subgroup) */
2810 if ((nq = EC_POINT_new(group)) == NULL) {
2811 ret = SSH_ERR_ALLOC_FAIL;
2812 goto out;
2813 }
2814 if (EC_POINT_mul(group, nq, NULL, public, order, bnctx) != 1) {
2815 ret = SSH_ERR_LIBCRYPTO_ERROR;
2816 goto out;
2817 }
2818 if (EC_POINT_is_at_infinity(group, nq) != 1)
2819 goto out;
2820
2821 /* x < order - 1, y < order - 1 */
2822 if (!BN_sub(tmp, order, BN_value_one())) {
2823 ret = SSH_ERR_LIBCRYPTO_ERROR;
2824 goto out;
2825 }
2826 if (BN_cmp(x, tmp) >= 0 || BN_cmp(y, tmp) >= 0)
2827 goto out;
2828 ret = 0;
2829 out:
2830 BN_CTX_free(bnctx);
2831 if (nq != NULL)
2832 EC_POINT_free(nq);
2833 return ret;
2834 }
2835
2836 int
2837 sshkey_ec_validate_private(const EC_KEY *key)
2838 {
2839 BN_CTX *bnctx;
2840 BIGNUM *order, *tmp;
2841 int ret = SSH_ERR_KEY_INVALID_EC_VALUE;
2842
2843 if ((bnctx = BN_CTX_new()) == NULL)
2844 return SSH_ERR_ALLOC_FAIL;
2845 BN_CTX_start(bnctx);
2846
2847 if ((order = BN_CTX_get(bnctx)) == NULL ||
2848 (tmp = BN_CTX_get(bnctx)) == NULL) {
2849 ret = SSH_ERR_ALLOC_FAIL;
2850 goto out;
2851 }
2852
2853 /* log2(private) > log2(order)/2 */
2854 if (EC_GROUP_get_order(EC_KEY_get0_group(key), order, bnctx) != 1) {
2855 ret = SSH_ERR_LIBCRYPTO_ERROR;
2856 goto out;
2857 }
2858 if (BN_num_bits(EC_KEY_get0_private_key(key)) <=
2859 BN_num_bits(order) / 2)
2860 goto out;
2861
2862 /* private < order - 1 */
2863 if (!BN_sub(tmp, order, BN_value_one())) {
2864 ret = SSH_ERR_LIBCRYPTO_ERROR;
2865 goto out;
2866 }
2867 if (BN_cmp(EC_KEY_get0_private_key(key), tmp) >= 0)
2868 goto out;
2869 ret = 0;
2870 out:
2871 BN_CTX_free(bnctx);
2872 return ret;
2873 }
2874
2875 void
2876 sshkey_dump_ec_point(const EC_GROUP *group, const EC_POINT *point)
2877 {
2878 BIGNUM *x, *y;
2879 BN_CTX *bnctx;
2880
2881 if (point == NULL) {
2882 fputs("point=(NULL)\n", stderr);
2883 return;
2884 }
2885 if ((bnctx = BN_CTX_new()) == NULL) {
2886 fprintf(stderr, "%s: BN_CTX_new failed\n", __func__);
2887 return;
2888 }
2889 BN_CTX_start(bnctx);
2890 if ((x = BN_CTX_get(bnctx)) == NULL ||
2891 (y = BN_CTX_get(bnctx)) == NULL) {
2892 fprintf(stderr, "%s: BN_CTX_get failed\n", __func__);
2893 return;
2894 }
2895 if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) !=
2896 NID_X9_62_prime_field) {
2897 fprintf(stderr, "%s: group is not a prime field\n", __func__);
2898 return;
2899 }
2900 if (EC_POINT_get_affine_coordinates_GFp(group, point, x, y,
2901 bnctx) != 1) {
2902 fprintf(stderr, "%s: EC_POINT_get_affine_coordinates_GFp\n",
2903 __func__);
2904 return;
2905 }
2906 fputs("x=", stderr);
2907 BN_print_fp(stderr, x);
2908 fputs("\ny=", stderr);
2909 BN_print_fp(stderr, y);
2910 fputs("\n", stderr);
2911 BN_CTX_free(bnctx);
2912 }
2913
2914 void
2915 sshkey_dump_ec_key(const EC_KEY *key)
2916 {
2917 const BIGNUM *exponent;
2918
2919 sshkey_dump_ec_point(EC_KEY_get0_group(key),
2920 EC_KEY_get0_public_key(key));
2921 fputs("exponent=", stderr);
2922 if ((exponent = EC_KEY_get0_private_key(key)) == NULL)
2923 fputs("(NULL)", stderr);
2924 else
2925 BN_print_fp(stderr, EC_KEY_get0_private_key(key));
2926 fputs("\n", stderr);
2927 }
2928 #endif /* WITH_OPENSSL && OPENSSL_HAS_ECC */
2929
2930 static int
2931 sshkey_private_to_blob2(const struct sshkey *prv, struct sshbuf *blob,
2932 const char *passphrase, const char *comment, const char *ciphername,
2933 int rounds)
2934 {
2935 u_char *cp, *key = NULL, *pubkeyblob = NULL;
2936 u_char salt[SALT_LEN];
2937 char *b64 = NULL;
2938 size_t i, pubkeylen, keylen, ivlen, blocksize, authlen;
2939 u_int check;
2940 int r = SSH_ERR_INTERNAL_ERROR;
2941 struct sshcipher_ctx *ciphercontext = NULL;
2942 const struct sshcipher *cipher;
2943 const char *kdfname = KDFNAME;
2944 struct sshbuf *encoded = NULL, *encrypted = NULL, *kdf = NULL;
2945
2946 if (rounds <= 0)
2947 rounds = DEFAULT_ROUNDS;
2948 if (passphrase == NULL || !strlen(passphrase)) {
2949 ciphername = "none";
2950 kdfname = "none";
2951 } else if (ciphername == NULL)
2952 ciphername = DEFAULT_CIPHERNAME;
2953 if ((cipher = cipher_by_name(ciphername)) == NULL) {
2954 r = SSH_ERR_INVALID_ARGUMENT;
2955 goto out;
2956 }
2957
2958 if ((kdf = sshbuf_new()) == NULL ||
2959 (encoded = sshbuf_new()) == NULL ||
2960 (encrypted = sshbuf_new()) == NULL) {
2961 r = SSH_ERR_ALLOC_FAIL;
2962 goto out;
2963 }
2964 blocksize = cipher_blocksize(cipher);
2965 keylen = cipher_keylen(cipher);
2966 ivlen = cipher_ivlen(cipher);
2967 authlen = cipher_authlen(cipher);
2968 if ((key = calloc(1, keylen + ivlen)) == NULL) {
2969 r = SSH_ERR_ALLOC_FAIL;
2970 goto out;
2971 }
2972 if (strcmp(kdfname, "bcrypt") == 0) {
2973 arc4random_buf(salt, SALT_LEN);
2974 if (bcrypt_pbkdf(passphrase, strlen(passphrase),
2975 salt, SALT_LEN, key, keylen + ivlen, rounds) < 0) {
2976 r = SSH_ERR_INVALID_ARGUMENT;
2977 goto out;
2978 }
2979 if ((r = sshbuf_put_string(kdf, salt, SALT_LEN)) != 0 ||
2980 (r = sshbuf_put_u32(kdf, rounds)) != 0)
2981 goto out;
2982 } else if (strcmp(kdfname, "none") != 0) {
2983 /* Unsupported KDF type */
2984 r = SSH_ERR_KEY_UNKNOWN_CIPHER;
2985 goto out;
2986 }
2987 if ((r = cipher_init(&ciphercontext, cipher, key, keylen,
2988 key + keylen, ivlen, 1)) != 0)
2989 goto out;
2990
2991 if ((r = sshbuf_put(encoded, AUTH_MAGIC, sizeof(AUTH_MAGIC))) != 0 ||
2992 (r = sshbuf_put_cstring(encoded, ciphername)) != 0 ||
2993 (r = sshbuf_put_cstring(encoded, kdfname)) != 0 ||
2994 (r = sshbuf_put_stringb(encoded, kdf)) != 0 ||
2995 (r = sshbuf_put_u32(encoded, 1)) != 0 || /* number of keys */
2996 (r = sshkey_to_blob(prv, &pubkeyblob, &pubkeylen)) != 0 ||
2997 (r = sshbuf_put_string(encoded, pubkeyblob, pubkeylen)) != 0)
2998 goto out;
2999
3000 /* set up the buffer that will be encrypted */
3001
3002 /* Random check bytes */
3003 check = arc4random();
3004 if ((r = sshbuf_put_u32(encrypted, check)) != 0 ||
3005 (r = sshbuf_put_u32(encrypted, check)) != 0)
3006 goto out;
3007
3008 /* append private key and comment*/
3009 if ((r = sshkey_private_serialize(prv, encrypted)) != 0 ||
3010 (r = sshbuf_put_cstring(encrypted, comment)) != 0)
3011 goto out;
3012
3013 /* padding */
3014 i = 0;
3015 while (sshbuf_len(encrypted) % blocksize) {
3016 if ((r = sshbuf_put_u8(encrypted, ++i & 0xff)) != 0)
3017 goto out;
3018 }
3019
3020 /* length in destination buffer */
3021 if ((r = sshbuf_put_u32(encoded, sshbuf_len(encrypted))) != 0)
3022 goto out;
3023
3024 /* encrypt */
3025 if ((r = sshbuf_reserve(encoded,
3026 sshbuf_len(encrypted) + authlen, &cp)) != 0)
3027 goto out;
3028 if ((r = cipher_crypt(ciphercontext, 0, cp,
3029 sshbuf_ptr(encrypted), sshbuf_len(encrypted), 0, authlen)) != 0)
3030 goto out;
3031
3032 /* uuencode */
3033 if ((b64 = sshbuf_dtob64(encoded)) == NULL) {
3034 r = SSH_ERR_ALLOC_FAIL;
3035 goto out;
3036 }
3037
3038 sshbuf_reset(blob);
3039 if ((r = sshbuf_put(blob, MARK_BEGIN, MARK_BEGIN_LEN)) != 0)
3040 goto out;
3041 for (i = 0; i < strlen(b64); i++) {
3042 if ((r = sshbuf_put_u8(blob, b64[i])) != 0)
3043 goto out;
3044 /* insert line breaks */
3045 if (i % 70 == 69 && (r = sshbuf_put_u8(blob, '\n')) != 0)
3046 goto out;
3047 }
3048 if (i % 70 != 69 && (r = sshbuf_put_u8(blob, '\n')) != 0)
3049 goto out;
3050 if ((r = sshbuf_put(blob, MARK_END, MARK_END_LEN)) != 0)
3051 goto out;
3052
3053 /* success */
3054 r = 0;
3055
3056 out:
3057 sshbuf_free(kdf);
3058 sshbuf_free(encoded);
3059 sshbuf_free(encrypted);
3060 cipher_free(ciphercontext);
3061 explicit_bzero(salt, sizeof(salt));
3062 if (key != NULL) {
3063 explicit_bzero(key, keylen + ivlen);
3064 free(key);
3065 }
3066 if (pubkeyblob != NULL) {
3067 explicit_bzero(pubkeyblob, pubkeylen);
3068 free(pubkeyblob);
3069 }
3070 if (b64 != NULL) {
3071 explicit_bzero(b64, strlen(b64));
3072 free(b64);
3073 }
3074 return r;
3075 }
3076
3077 static int
3078 sshkey_parse_private2(struct sshbuf *blob, int type, const char *passphrase,
3079 struct sshkey **keyp, char **commentp)
3080 {
3081 char *comment = NULL, *ciphername = NULL, *kdfname = NULL;
3082 const struct sshcipher *cipher = NULL;
3083 const u_char *cp;
3084 int r = SSH_ERR_INTERNAL_ERROR;
3085 size_t encoded_len;
3086 size_t i, keylen = 0, ivlen = 0, authlen = 0, slen = 0;
3087 struct sshbuf *encoded = NULL, *decoded = NULL;
3088 struct sshbuf *kdf = NULL, *decrypted = NULL;
3089 struct sshcipher_ctx *ciphercontext = NULL;
3090 struct sshkey *k = NULL;
3091 u_char *key = NULL, *salt = NULL, *dp, pad, last;
3092 u_int blocksize, rounds, nkeys, encrypted_len, check1, check2;
3093
3094 if (keyp != NULL)
3095 *keyp = NULL;
3096 if (commentp != NULL)
3097 *commentp = NULL;
3098
3099 if ((encoded = sshbuf_new()) == NULL ||
3100 (decoded = sshbuf_new()) == NULL ||
3101 (decrypted = sshbuf_new()) == NULL) {
3102 r = SSH_ERR_ALLOC_FAIL;
3103 goto out;
3104 }
3105
3106 /* check preamble */
3107 cp = sshbuf_ptr(blob);
3108 encoded_len = sshbuf_len(blob);
3109 if (encoded_len < (MARK_BEGIN_LEN + MARK_END_LEN) ||
3110 memcmp(cp, MARK_BEGIN, MARK_BEGIN_LEN) != 0) {
3111 r = SSH_ERR_INVALID_FORMAT;
3112 goto out;
3113 }
3114 cp += MARK_BEGIN_LEN;
3115 encoded_len -= MARK_BEGIN_LEN;
3116
3117 /* Look for end marker, removing whitespace as we go */
3118 while (encoded_len > 0) {
3119 if (*cp != '\n' && *cp != '\r') {
3120 if ((r = sshbuf_put_u8(encoded, *cp)) != 0)
3121 goto out;
3122 }
3123 last = *cp;
3124 encoded_len--;
3125 cp++;
3126 if (last == '\n') {
3127 if (encoded_len >= MARK_END_LEN &&
3128 memcmp(cp, MARK_END, MARK_END_LEN) == 0) {
3129 /* \0 terminate */
3130 if ((r = sshbuf_put_u8(encoded, 0)) != 0)
3131 goto out;
3132 break;
3133 }
3134 }
3135 }
3136 if (encoded_len == 0) {
3137 r = SSH_ERR_INVALID_FORMAT;
3138 goto out;
3139 }
3140
3141 /* decode base64 */
3142 if ((r = sshbuf_b64tod(decoded, (char *)sshbuf_ptr(encoded))) != 0)
3143 goto out;
3144
3145 /* check magic */
3146 if (sshbuf_len(decoded) < sizeof(AUTH_MAGIC) ||
3147 memcmp(sshbuf_ptr(decoded), AUTH_MAGIC, sizeof(AUTH_MAGIC))) {
3148 r = SSH_ERR_INVALID_FORMAT;
3149 goto out;
3150 }
3151 /* parse public portion of key */
3152 if ((r = sshbuf_consume(decoded, sizeof(AUTH_MAGIC))) != 0 ||
3153 (r = sshbuf_get_cstring(decoded, &ciphername, NULL)) != 0 ||
3154 (r = sshbuf_get_cstring(decoded, &kdfname, NULL)) != 0 ||
3155 (r = sshbuf_froms(decoded, &kdf)) != 0 ||
3156 (r = sshbuf_get_u32(decoded, &nkeys)) != 0 ||
3157 (r = sshbuf_skip_string(decoded)) != 0 || /* pubkey */
3158 (r = sshbuf_get_u32(decoded, &encrypted_len)) != 0)
3159 goto out;
3160
3161 if ((cipher = cipher_by_name(ciphername)) == NULL) {
3162 r = SSH_ERR_KEY_UNKNOWN_CIPHER;
3163 goto out;
3164 }
3165 if ((passphrase == NULL || strlen(passphrase) == 0) &&
3166 strcmp(ciphername, "none") != 0) {
3167 /* passphrase required */
3168 r = SSH_ERR_KEY_WRONG_PASSPHRASE;
3169 goto out;
3170 }
3171 if (strcmp(kdfname, "none") != 0 && strcmp(kdfname, "bcrypt") != 0) {
3172 r = SSH_ERR_KEY_UNKNOWN_CIPHER;
3173 goto out;
3174 }
3175 if (!strcmp(kdfname, "none") && strcmp(ciphername, "none") != 0) {
3176 r = SSH_ERR_INVALID_FORMAT;
3177 goto out;
3178 }
3179 if (nkeys != 1) {
3180 /* XXX only one key supported */
3181 r = SSH_ERR_INVALID_FORMAT;
3182 goto out;
3183 }
3184
3185 /* check size of encrypted key blob */
3186 blocksize = cipher_blocksize(cipher);
3187 if (encrypted_len < blocksize || (encrypted_len % blocksize) != 0) {
3188 r = SSH_ERR_INVALID_FORMAT;
3189 goto out;
3190 }
3191
3192 /* setup key */
3193 keylen = cipher_keylen(cipher);
3194 ivlen = cipher_ivlen(cipher);
3195 authlen = cipher_authlen(cipher);
3196 if ((key = calloc(1, keylen + ivlen)) == NULL) {
3197 r = SSH_ERR_ALLOC_FAIL;
3198 goto out;
3199 }
3200 if (strcmp(kdfname, "bcrypt") == 0) {
3201 if ((r = sshbuf_get_string(kdf, &salt, &slen)) != 0 ||
3202 (r = sshbuf_get_u32(kdf, &rounds)) != 0)
3203 goto out;
3204 if (bcrypt_pbkdf(passphrase, strlen(passphrase), salt, slen,
3205 key, keylen + ivlen, rounds) < 0) {
3206 r = SSH_ERR_INVALID_FORMAT;
3207 goto out;
3208 }
3209 }
3210
3211 /* check that an appropriate amount of auth data is present */
3212 if (sshbuf_len(decoded) < encrypted_len + authlen) {
3213 r = SSH_ERR_INVALID_FORMAT;
3214 goto out;
3215 }
3216
3217 /* decrypt private portion of key */
3218 if ((r = sshbuf_reserve(decrypted, encrypted_len, &dp)) != 0 ||
3219 (r = cipher_init(&ciphercontext, cipher, key, keylen,
3220 key + keylen, ivlen, 0)) != 0)
3221 goto out;
3222 if ((r = cipher_crypt(ciphercontext, 0, dp, sshbuf_ptr(decoded),
3223 encrypted_len, 0, authlen)) != 0) {
3224 /* an integrity error here indicates an incorrect passphrase */
3225 if (r == SSH_ERR_MAC_INVALID)
3226 r = SSH_ERR_KEY_WRONG_PASSPHRASE;
3227 goto out;
3228 }
3229 if ((r = sshbuf_consume(decoded, encrypted_len + authlen)) != 0)
3230 goto out;
3231 /* there should be no trailing data */
3232 if (sshbuf_len(decoded) != 0) {
3233 r = SSH_ERR_INVALID_FORMAT;
3234 goto out;
3235 }
3236
3237 /* check check bytes */
3238 if ((r = sshbuf_get_u32(decrypted, &check1)) != 0 ||
3239 (r = sshbuf_get_u32(decrypted, &check2)) != 0)
3240 goto out;
3241 if (check1 != check2) {
3242 r = SSH_ERR_KEY_WRONG_PASSPHRASE;
3243 goto out;
3244 }
3245
3246 /* Load the private key and comment */
3247 if ((r = sshkey_private_deserialize(decrypted, &k)) != 0 ||
3248 (r = sshbuf_get_cstring(decrypted, &comment, NULL)) != 0)
3249 goto out;
3250
3251 /* Check deterministic padding */
3252 i = 0;
3253 while (sshbuf_len(decrypted)) {
3254 if ((r = sshbuf_get_u8(decrypted, &pad)) != 0)
3255 goto out;
3256 if (pad != (++i & 0xff)) {
3257 r = SSH_ERR_INVALID_FORMAT;
3258 goto out;
3259 }
3260 }
3261
3262 /* XXX decode pubkey and check against private */
3263
3264 /* success */
3265 r = 0;
3266 if (keyp != NULL) {
3267 *keyp = k;
3268 k = NULL;
3269 }
3270 if (commentp != NULL) {
3271 *commentp = comment;
3272 comment = NULL;
3273 }
3274 out:
3275 pad = 0;
3276 cipher_free(ciphercontext);
3277 free(ciphername);
3278 free(kdfname);
3279 free(comment);
3280 if (salt != NULL) {
3281 explicit_bzero(salt, slen);
3282 free(salt);
3283 }
3284 if (key != NULL) {
3285 explicit_bzero(key, keylen + ivlen);
3286 free(key);
3287 }
3288 sshbuf_free(encoded);
3289 sshbuf_free(decoded);
3290 sshbuf_free(kdf);
3291 sshbuf_free(decrypted);
3292 sshkey_free(k);
3293 return r;
3294 }
3295
3296
3297 #ifdef WITH_OPENSSL
3298 /* convert SSH v2 key in OpenSSL PEM format */
3299 static int
3300 sshkey_private_pem_to_blob(struct sshkey *key, struct sshbuf *blob,
3301 const char *_passphrase, const char *comment)
3302 {
3303 int success, r;
3304 int blen, len = strlen(_passphrase);
3305 u_char *passphrase = (len > 0) ? (u_char *)_passphrase : NULL;
3306 const EVP_CIPHER *cipher = (len > 0) ? EVP_aes_128_cbc() : NULL;
3307 const u_char *bptr;
3308 BIO *bio = NULL;
3309
3310 if (len > 0 && len <= 4)
3311 return SSH_ERR_PASSPHRASE_TOO_SHORT;
3312 if ((bio = BIO_new(BIO_s_mem())) == NULL)
3313 return SSH_ERR_ALLOC_FAIL;
3314
3315 switch (key->type) {
3316 case KEY_DSA:
3317 success = PEM_write_bio_DSAPrivateKey(bio, key->dsa,
3318 cipher, passphrase, len, NULL, NULL);
3319 break;
3320 #ifdef OPENSSL_HAS_ECC
3321 case KEY_ECDSA:
3322 success = PEM_write_bio_ECPrivateKey(bio, key->ecdsa,
3323 cipher, passphrase, len, NULL, NULL);
3324 break;
3325 #endif
3326 case KEY_RSA:
3327 success = PEM_write_bio_RSAPrivateKey(bio, key->rsa,
3328 cipher, passphrase, len, NULL, NULL);
3329 break;
3330 default:
3331 success = 0;
3332 break;
3333 }
3334 if (success == 0) {
3335 r = SSH_ERR_LIBCRYPTO_ERROR;
3336 goto out;
3337 }
3338 if ((blen = BIO_get_mem_data(bio, &bptr)) <= 0) {
3339 r = SSH_ERR_INTERNAL_ERROR;
3340 goto out;
3341 }
3342 if ((r = sshbuf_put(blob, bptr, blen)) != 0)
3343 goto out;
3344 r = 0;
3345 out:
3346 BIO_free(bio);
3347 return r;
3348 }
3349 #endif /* WITH_OPENSSL */
3350
3351 /* Serialise "key" to buffer "blob" */
3352 int
3353 sshkey_private_to_fileblob(struct sshkey *key, struct sshbuf *blob,
3354 const char *passphrase, const char *comment,
3355 int force_new_format, const char *new_format_cipher, int new_format_rounds)
3356 {
3357 switch (key->type) {
3358 #ifdef WITH_OPENSSL
3359 case KEY_DSA:
3360 case KEY_ECDSA:
3361 case KEY_RSA:
3362 if (force_new_format) {
3363 return sshkey_private_to_blob2(key, blob, passphrase,
3364 comment, new_format_cipher, new_format_rounds);
3365 }
3366 return sshkey_private_pem_to_blob(key, blob,
3367 passphrase, comment);
3368 #endif /* WITH_OPENSSL */
3369 case KEY_ED25519:
3370 return sshkey_private_to_blob2(key, blob, passphrase,
3371 comment, new_format_cipher, new_format_rounds);
3372 default:
3373 return SSH_ERR_KEY_TYPE_UNKNOWN;
3374 }
3375 }
3376
3377
3378 #ifdef WITH_OPENSSL
3379 static int
3380 translate_libcrypto_error(unsigned long pem_err)
3381 {
3382 int pem_reason = ERR_GET_REASON(pem_err);
3383
3384 switch (ERR_GET_LIB(pem_err)) {
3385 case ERR_LIB_PEM:
3386 switch (pem_reason) {
3387 case PEM_R_BAD_PASSWORD_READ:
3388 case PEM_R_PROBLEMS_GETTING_PASSWORD:
3389 case PEM_R_BAD_DECRYPT:
3390 return SSH_ERR_KEY_WRONG_PASSPHRASE;
3391 default:
3392 return SSH_ERR_INVALID_FORMAT;
3393 }
3394 case ERR_LIB_EVP:
3395 switch (pem_reason) {
3396 case EVP_R_BAD_DECRYPT:
3397 return SSH_ERR_KEY_WRONG_PASSPHRASE;
3398 case EVP_R_BN_DECODE_ERROR:
3399 case EVP_R_DECODE_ERROR:
3400 #ifdef EVP_R_PRIVATE_KEY_DECODE_ERROR
3401 case EVP_R_PRIVATE_KEY_DECODE_ERROR:
3402 #endif
3403 return SSH_ERR_INVALID_FORMAT;
3404 default:
3405 return SSH_ERR_LIBCRYPTO_ERROR;
3406 }
3407 case ERR_LIB_ASN1:
3408 return SSH_ERR_INVALID_FORMAT;
3409 }
3410 return SSH_ERR_LIBCRYPTO_ERROR;
3411 }
3412
3413 static void
3414 clear_libcrypto_errors(void)
3415 {
3416 while (ERR_get_error() != 0)
3417 ;
3418 }
3419
3420 /*
3421 * Translate OpenSSL error codes to determine whether
3422 * passphrase is required/incorrect.
3423 */
3424 static int
3425 convert_libcrypto_error(void)
3426 {
3427 /*
3428 * Some password errors are reported at the beginning
3429 * of the error queue.
3430 */
3431 if (translate_libcrypto_error(ERR_peek_error()) ==
3432 SSH_ERR_KEY_WRONG_PASSPHRASE)
3433 return SSH_ERR_KEY_WRONG_PASSPHRASE;
3434 return translate_libcrypto_error(ERR_peek_last_error());
3435 }
3436
3437 static int
3438 sshkey_parse_private_pem_fileblob(struct sshbuf *blob, int type,
3439 const char *passphrase, struct sshkey **keyp)
3440 {
3441 EVP_PKEY *pk = NULL;
3442 struct sshkey *prv = NULL;
3443 BIO *bio = NULL;
3444 int r;
3445
3446 if (keyp != NULL)
3447 *keyp = NULL;
3448
3449 if ((bio = BIO_new(BIO_s_mem())) == NULL || sshbuf_len(blob) > INT_MAX)
3450 return SSH_ERR_ALLOC_FAIL;
3451 if (BIO_write(bio, sshbuf_ptr(blob), sshbuf_len(blob)) !=
3452 (int)sshbuf_len(blob)) {
3453 r = SSH_ERR_ALLOC_FAIL;
3454 goto out;
3455 }
3456
3457 clear_libcrypto_errors();
3458 if ((pk = PEM_read_bio_PrivateKey(bio, NULL, NULL,
3459 (char *)passphrase)) == NULL) {
3460 r = convert_libcrypto_error();
3461 goto out;
3462 }
3463 if (pk->type == EVP_PKEY_RSA &&
3464 (type == KEY_UNSPEC || type == KEY_RSA)) {
3465 if ((prv = sshkey_new(KEY_UNSPEC)) == NULL) {
3466 r = SSH_ERR_ALLOC_FAIL;
3467 goto out;
3468 }
3469 prv->rsa = EVP_PKEY_get1_RSA(pk);
3470 prv->type = KEY_RSA;
3471 #ifdef DEBUG_PK
3472 RSA_print_fp(stderr, prv->rsa, 8);
3473 #endif
3474 if (RSA_blinding_on(prv->rsa, NULL) != 1) {
3475 r = SSH_ERR_LIBCRYPTO_ERROR;
3476 goto out;
3477 }
3478 if (BN_num_bits(prv->rsa->n) < SSH_RSA_MINIMUM_MODULUS_SIZE) {
3479 r = SSH_ERR_KEY_LENGTH;
3480 goto out;
3481 }
3482 } else if (pk->type == EVP_PKEY_DSA &&
3483 (type == KEY_UNSPEC || type == KEY_DSA)) {
3484 if ((prv = sshkey_new(KEY_UNSPEC)) == NULL) {
3485 r = SSH_ERR_ALLOC_FAIL;
3486 goto out;
3487 }
3488 prv->dsa = EVP_PKEY_get1_DSA(pk);
3489 prv->type = KEY_DSA;
3490 #ifdef DEBUG_PK
3491 DSA_print_fp(stderr, prv->dsa, 8);
3492 #endif
3493 #ifdef OPENSSL_HAS_ECC
3494 } else if (pk->type == EVP_PKEY_EC &&
3495 (type == KEY_UNSPEC || type == KEY_ECDSA)) {
3496 if ((prv = sshkey_new(KEY_UNSPEC)) == NULL) {
3497 r = SSH_ERR_ALLOC_FAIL;
3498 goto out;
3499 }
3500 prv->ecdsa = EVP_PKEY_get1_EC_KEY(pk);
3501 prv->type = KEY_ECDSA;
3502 prv->ecdsa_nid = sshkey_ecdsa_key_to_nid(prv->ecdsa);
3503 if (prv->ecdsa_nid == -1 ||
3504 sshkey_curve_nid_to_name(prv->ecdsa_nid) == NULL ||
3505 sshkey_ec_validate_public(EC_KEY_get0_group(prv->ecdsa),
3506 EC_KEY_get0_public_key(prv->ecdsa)) != 0 ||
3507 sshkey_ec_validate_private(prv->ecdsa) != 0) {
3508 r = SSH_ERR_INVALID_FORMAT;
3509 goto out;
3510 }
3511 # ifdef DEBUG_PK
3512 if (prv != NULL && prv->ecdsa != NULL)
3513 sshkey_dump_ec_key(prv->ecdsa);
3514 # endif
3515 #endif /* OPENSSL_HAS_ECC */
3516 } else {
3517 r = SSH_ERR_INVALID_FORMAT;
3518 goto out;
3519 }
3520 r = 0;
3521 if (keyp != NULL) {
3522 *keyp = prv;
3523 prv = NULL;
3524 }
3525 out:
3526 BIO_free(bio);
3527 if (pk != NULL)
3528 EVP_PKEY_free(pk);
3529 sshkey_free(prv);
3530 return r;
3531 }
3532 #endif /* WITH_OPENSSL */
3533
3534 int
3535 sshkey_parse_private_fileblob_type(struct sshbuf *blob, int type,
3536 const char *passphrase, struct sshkey **keyp, char **commentp)
3537 {
3538 int r = SSH_ERR_INTERNAL_ERROR;
3539
3540 if (keyp != NULL)
3541 *keyp = NULL;
3542 if (commentp != NULL)
3543 *commentp = NULL;
3544
3545 switch (type) {
3546 #ifdef WITH_OPENSSL
3547 case KEY_DSA:
3548 case KEY_ECDSA:
3549 case KEY_RSA:
3550 return sshkey_parse_private_pem_fileblob(blob, type,
3551 passphrase, keyp);
3552 #endif /* WITH_OPENSSL */
3553 case KEY_ED25519:
3554 return sshkey_parse_private2(blob, type, passphrase,
3555 keyp, commentp);
3556 case KEY_UNSPEC:
3557 r = sshkey_parse_private2(blob, type, passphrase, keyp,
3558 commentp);
3559 /* Do not fallback to PEM parser if only passphrase is wrong. */
3560 if (r == 0 || r == SSH_ERR_KEY_WRONG_PASSPHRASE)
3561 return r;
3562 #ifdef WITH_OPENSSL
3563 return sshkey_parse_private_pem_fileblob(blob, type,
3564 passphrase, keyp);
3565 #else
3566 return SSH_ERR_INVALID_FORMAT;
3567 #endif /* WITH_OPENSSL */
3568 default:
3569 return SSH_ERR_KEY_TYPE_UNKNOWN;
3570 }
3571 }
3572
3573 int
3574 sshkey_parse_private_fileblob(struct sshbuf *buffer, const char *passphrase,
3575 struct sshkey **keyp, char **commentp)
3576 {
3577 if (keyp != NULL)
3578 *keyp = NULL;
3579 if (commentp != NULL)
3580 *commentp = NULL;
3581
3582 return sshkey_parse_private_fileblob_type(buffer, KEY_UNSPEC,
3583 passphrase, keyp, commentp);
3584 }
DragonFly BSD