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