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