1 /* $OpenBSD: sshkey.c,v 1.73 2019/01/21 09:54:11 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 (sshbuf_get_bignum2(b, &rsa_e) != 0 || 2014 sshbuf_get_bignum2(b, &rsa_n) != 0) { 2015 ret = SSH_ERR_INVALID_FORMAT; 2016 goto out; 2017 } 2018 if (!RSA_set0_key(key->rsa, rsa_n, rsa_e, NULL)) { 2019 ret = SSH_ERR_LIBCRYPTO_ERROR; 2020 goto out; 2021 } 2022 rsa_n = rsa_e = NULL; /* transferred */ 2023 if ((ret = check_rsa_length(key->rsa)) != 0) 2024 goto out; 2025 #ifdef DEBUG_PK 2026 RSA_print_fp(stderr, key->rsa, 8); 2027 #endif 2028 break; 2029 case KEY_DSA_CERT: 2030 /* Skip nonce */ 2031 if (sshbuf_get_string_direct(b, NULL, NULL) != 0) { 2032 ret = SSH_ERR_INVALID_FORMAT; 2033 goto out; 2034 } 2035 /* FALLTHROUGH */ 2036 case KEY_DSA: 2037 if ((key = sshkey_new(type)) == NULL) { 2038 ret = SSH_ERR_ALLOC_FAIL; 2039 goto out; 2040 } 2041 if (sshbuf_get_bignum2(b, &dsa_p) != 0 || 2042 sshbuf_get_bignum2(b, &dsa_q) != 0 || 2043 sshbuf_get_bignum2(b, &dsa_g) != 0 || 2044 sshbuf_get_bignum2(b, &dsa_pub_key) != 0) { 2045 ret = SSH_ERR_INVALID_FORMAT; 2046 goto out; 2047 } 2048 if (!DSA_set0_pqg(key->dsa, dsa_p, dsa_q, dsa_g)) { 2049 ret = SSH_ERR_LIBCRYPTO_ERROR; 2050 goto out; 2051 } 2052 dsa_p = dsa_q = dsa_g = NULL; /* transferred */ 2053 if (!DSA_set0_key(key->dsa, dsa_pub_key, NULL)) { 2054 ret = SSH_ERR_LIBCRYPTO_ERROR; 2055 goto out; 2056 } 2057 dsa_pub_key = NULL; /* transferred */ 2058 #ifdef DEBUG_PK 2059 DSA_print_fp(stderr, key->dsa, 8); 2060 #endif 2061 break; 2062 case KEY_ECDSA_CERT: 2063 /* Skip nonce */ 2064 if (sshbuf_get_string_direct(b, NULL, NULL) != 0) { 2065 ret = SSH_ERR_INVALID_FORMAT; 2066 goto out; 2067 } 2068 /* FALLTHROUGH */ 2069 case KEY_ECDSA: 2070 if ((key = sshkey_new(type)) == NULL) { 2071 ret = SSH_ERR_ALLOC_FAIL; 2072 goto out; 2073 } 2074 key->ecdsa_nid = sshkey_ecdsa_nid_from_name(ktype); 2075 if (sshbuf_get_cstring(b, &curve, NULL) != 0) { 2076 ret = SSH_ERR_INVALID_FORMAT; 2077 goto out; 2078 } 2079 if (key->ecdsa_nid != sshkey_curve_name_to_nid(curve)) { 2080 ret = SSH_ERR_EC_CURVE_MISMATCH; 2081 goto out; 2082 } 2083 EC_KEY_free(key->ecdsa); 2084 if ((key->ecdsa = EC_KEY_new_by_curve_name(key->ecdsa_nid)) 2085 == NULL) { 2086 ret = SSH_ERR_EC_CURVE_INVALID; 2087 goto out; 2088 } 2089 if ((q = EC_POINT_new(EC_KEY_get0_group(key->ecdsa))) == NULL) { 2090 ret = SSH_ERR_ALLOC_FAIL; 2091 goto out; 2092 } 2093 if (sshbuf_get_ec(b, q, EC_KEY_get0_group(key->ecdsa)) != 0) { 2094 ret = SSH_ERR_INVALID_FORMAT; 2095 goto out; 2096 } 2097 if (sshkey_ec_validate_public(EC_KEY_get0_group(key->ecdsa), 2098 q) != 0) { 2099 ret = SSH_ERR_KEY_INVALID_EC_VALUE; 2100 goto out; 2101 } 2102 if (EC_KEY_set_public_key(key->ecdsa, q) != 1) { 2103 /* XXX assume it is a allocation error */ 2104 ret = SSH_ERR_ALLOC_FAIL; 2105 goto out; 2106 } 2107 #ifdef DEBUG_PK 2108 sshkey_dump_ec_point(EC_KEY_get0_group(key->ecdsa), q); 2109 #endif 2110 break; 2111 #endif /* WITH_OPENSSL */ 2112 case KEY_ED25519_CERT: 2113 /* Skip nonce */ 2114 if (sshbuf_get_string_direct(b, NULL, NULL) != 0) { 2115 ret = SSH_ERR_INVALID_FORMAT; 2116 goto out; 2117 } 2118 /* FALLTHROUGH */ 2119 case KEY_ED25519: 2120 if ((ret = sshbuf_get_string(b, &pk, &len)) != 0) 2121 goto out; 2122 if (len != ED25519_PK_SZ) { 2123 ret = SSH_ERR_INVALID_FORMAT; 2124 goto out; 2125 } 2126 if ((key = sshkey_new(type)) == NULL) { 2127 ret = SSH_ERR_ALLOC_FAIL; 2128 goto out; 2129 } 2130 key->ed25519_pk = pk; 2131 pk = NULL; 2132 break; 2133 #ifdef WITH_XMSS 2134 case KEY_XMSS_CERT: 2135 /* Skip nonce */ 2136 if (sshbuf_get_string_direct(b, NULL, NULL) != 0) { 2137 ret = SSH_ERR_INVALID_FORMAT; 2138 goto out; 2139 } 2140 /* FALLTHROUGH */ 2141 case KEY_XMSS: 2142 if ((ret = sshbuf_get_cstring(b, &xmss_name, NULL)) != 0) 2143 goto out; 2144 if ((key = sshkey_new(type)) == NULL) { 2145 ret = SSH_ERR_ALLOC_FAIL; 2146 goto out; 2147 } 2148 if ((ret = sshkey_xmss_init(key, xmss_name)) != 0) 2149 goto out; 2150 if ((ret = sshbuf_get_string(b, &pk, &len)) != 0) 2151 goto out; 2152 if (len == 0 || len != sshkey_xmss_pklen(key)) { 2153 ret = SSH_ERR_INVALID_FORMAT; 2154 goto out; 2155 } 2156 key->xmss_pk = pk; 2157 pk = NULL; 2158 if (type != KEY_XMSS_CERT && 2159 (ret = sshkey_xmss_deserialize_pk_info(key, b)) != 0) 2160 goto out; 2161 break; 2162 #endif /* WITH_XMSS */ 2163 case KEY_UNSPEC: 2164 default: 2165 ret = SSH_ERR_KEY_TYPE_UNKNOWN; 2166 goto out; 2167 } 2168 2169 /* Parse certificate potion */ 2170 if (sshkey_is_cert(key) && (ret = cert_parse(b, key, copy)) != 0) 2171 goto out; 2172 2173 if (key != NULL && sshbuf_len(b) != 0) { 2174 ret = SSH_ERR_INVALID_FORMAT; 2175 goto out; 2176 } 2177 ret = 0; 2178 if (keyp != NULL) { 2179 *keyp = key; 2180 key = NULL; 2181 } 2182 out: 2183 sshbuf_free(copy); 2184 sshkey_free(key); 2185 free(xmss_name); 2186 free(ktype); 2187 free(curve); 2188 free(pk); 2189 #ifdef WITH_OPENSSL 2190 EC_POINT_free(q); 2191 BN_clear_free(rsa_n); 2192 BN_clear_free(rsa_e); 2193 BN_clear_free(dsa_p); 2194 BN_clear_free(dsa_q); 2195 BN_clear_free(dsa_g); 2196 BN_clear_free(dsa_pub_key); 2197 #endif /* WITH_OPENSSL */ 2198 return ret; 2199 } 2200 2201 int 2202 sshkey_from_blob(const u_char *blob, size_t blen, struct sshkey **keyp) 2203 { 2204 struct sshbuf *b; 2205 int r; 2206 2207 if ((b = sshbuf_from(blob, blen)) == NULL) 2208 return SSH_ERR_ALLOC_FAIL; 2209 r = sshkey_from_blob_internal(b, keyp, 1); 2210 sshbuf_free(b); 2211 return r; 2212 } 2213 2214 int 2215 sshkey_fromb(struct sshbuf *b, struct sshkey **keyp) 2216 { 2217 return sshkey_from_blob_internal(b, keyp, 1); 2218 } 2219 2220 int 2221 sshkey_froms(struct sshbuf *buf, struct sshkey **keyp) 2222 { 2223 struct sshbuf *b; 2224 int r; 2225 2226 if ((r = sshbuf_froms(buf, &b)) != 0) 2227 return r; 2228 r = sshkey_from_blob_internal(b, keyp, 1); 2229 sshbuf_free(b); 2230 return r; 2231 } 2232 2233 static int 2234 get_sigtype(const u_char *sig, size_t siglen, char **sigtypep) 2235 { 2236 int r; 2237 struct sshbuf *b = NULL; 2238 char *sigtype = NULL; 2239 2240 if (sigtypep != NULL) 2241 *sigtypep = NULL; 2242 if ((b = sshbuf_from(sig, siglen)) == NULL) 2243 return SSH_ERR_ALLOC_FAIL; 2244 if ((r = sshbuf_get_cstring(b, &sigtype, NULL)) != 0) 2245 goto out; 2246 /* success */ 2247 if (sigtypep != NULL) { 2248 *sigtypep = sigtype; 2249 sigtype = NULL; 2250 } 2251 r = 0; 2252 out: 2253 free(sigtype); 2254 sshbuf_free(b); 2255 return r; 2256 } 2257 2258 /* 2259 * 2260 * Checks whether a certificate's signature type is allowed. 2261 * Returns 0 (success) if the certificate signature type appears in the 2262 * "allowed" pattern-list, or the key is not a certificate to begin with. 2263 * Otherwise returns a ssherr.h code. 2264 */ 2265 int 2266 sshkey_check_cert_sigtype(const struct sshkey *key, const char *allowed) 2267 { 2268 if (key == NULL || allowed == NULL) 2269 return SSH_ERR_INVALID_ARGUMENT; 2270 if (!sshkey_type_is_cert(key->type)) 2271 return 0; 2272 if (key->cert == NULL || key->cert->signature_type == NULL) 2273 return SSH_ERR_INVALID_ARGUMENT; 2274 if (match_pattern_list(key->cert->signature_type, allowed, 0) != 1) 2275 return SSH_ERR_SIGN_ALG_UNSUPPORTED; 2276 return 0; 2277 } 2278 2279 /* 2280 * Returns the expected signature algorithm for a given public key algorithm. 2281 */ 2282 const char * 2283 sshkey_sigalg_by_name(const char *name) 2284 { 2285 const struct keytype *kt; 2286 2287 for (kt = keytypes; kt->type != -1; kt++) { 2288 if (strcmp(kt->name, name) != 0) 2289 continue; 2290 if (kt->sigalg != NULL) 2291 return kt->sigalg; 2292 if (!kt->cert) 2293 return kt->name; 2294 return sshkey_ssh_name_from_type_nid( 2295 sshkey_type_plain(kt->type), kt->nid); 2296 } 2297 return NULL; 2298 } 2299 2300 /* 2301 * Verifies that the signature algorithm appearing inside the signature blob 2302 * matches that which was requested. 2303 */ 2304 int 2305 sshkey_check_sigtype(const u_char *sig, size_t siglen, 2306 const char *requested_alg) 2307 { 2308 const char *expected_alg; 2309 char *sigtype = NULL; 2310 int r; 2311 2312 if (requested_alg == NULL) 2313 return 0; 2314 if ((expected_alg = sshkey_sigalg_by_name(requested_alg)) == NULL) 2315 return SSH_ERR_INVALID_ARGUMENT; 2316 if ((r = get_sigtype(sig, siglen, &sigtype)) != 0) 2317 return r; 2318 r = strcmp(expected_alg, sigtype) == 0; 2319 free(sigtype); 2320 return r ? 0 : SSH_ERR_SIGN_ALG_UNSUPPORTED; 2321 } 2322 2323 int 2324 sshkey_sign(const struct sshkey *key, 2325 u_char **sigp, size_t *lenp, 2326 const u_char *data, size_t datalen, const char *alg, u_int compat) 2327 { 2328 if (sigp != NULL) 2329 *sigp = NULL; 2330 if (lenp != NULL) 2331 *lenp = 0; 2332 if (datalen > SSH_KEY_MAX_SIGN_DATA_SIZE) 2333 return SSH_ERR_INVALID_ARGUMENT; 2334 switch (key->type) { 2335 #ifdef WITH_OPENSSL 2336 case KEY_DSA_CERT: 2337 case KEY_DSA: 2338 return ssh_dss_sign(key, sigp, lenp, data, datalen, compat); 2339 case KEY_ECDSA_CERT: 2340 case KEY_ECDSA: 2341 return ssh_ecdsa_sign(key, sigp, lenp, data, datalen, compat); 2342 case KEY_RSA_CERT: 2343 case KEY_RSA: 2344 return ssh_rsa_sign(key, sigp, lenp, data, datalen, alg); 2345 #endif /* WITH_OPENSSL */ 2346 case KEY_ED25519: 2347 case KEY_ED25519_CERT: 2348 return ssh_ed25519_sign(key, sigp, lenp, data, datalen, compat); 2349 #ifdef WITH_XMSS 2350 case KEY_XMSS: 2351 case KEY_XMSS_CERT: 2352 return ssh_xmss_sign(key, sigp, lenp, data, datalen, compat); 2353 #endif /* WITH_XMSS */ 2354 default: 2355 return SSH_ERR_KEY_TYPE_UNKNOWN; 2356 } 2357 } 2358 2359 /* 2360 * ssh_key_verify returns 0 for a correct signature and < 0 on error. 2361 * If "alg" specified, then the signature must use that algorithm. 2362 */ 2363 int 2364 sshkey_verify(const struct sshkey *key, 2365 const u_char *sig, size_t siglen, 2366 const u_char *data, size_t dlen, const char *alg, u_int compat) 2367 { 2368 if (siglen == 0 || dlen > SSH_KEY_MAX_SIGN_DATA_SIZE) 2369 return SSH_ERR_INVALID_ARGUMENT; 2370 switch (key->type) { 2371 #ifdef WITH_OPENSSL 2372 case KEY_DSA_CERT: 2373 case KEY_DSA: 2374 return ssh_dss_verify(key, sig, siglen, data, dlen, compat); 2375 case KEY_ECDSA_CERT: 2376 case KEY_ECDSA: 2377 return ssh_ecdsa_verify(key, sig, siglen, data, dlen, compat); 2378 case KEY_RSA_CERT: 2379 case KEY_RSA: 2380 return ssh_rsa_verify(key, sig, siglen, data, dlen, alg); 2381 #endif /* WITH_OPENSSL */ 2382 case KEY_ED25519: 2383 case KEY_ED25519_CERT: 2384 return ssh_ed25519_verify(key, sig, siglen, data, dlen, compat); 2385 #ifdef WITH_XMSS 2386 case KEY_XMSS: 2387 case KEY_XMSS_CERT: 2388 return ssh_xmss_verify(key, sig, siglen, data, dlen, compat); 2389 #endif /* WITH_XMSS */ 2390 default: 2391 return SSH_ERR_KEY_TYPE_UNKNOWN; 2392 } 2393 } 2394 2395 /* Convert a plain key to their _CERT equivalent */ 2396 int 2397 sshkey_to_certified(struct sshkey *k) 2398 { 2399 int newtype; 2400 2401 switch (k->type) { 2402 #ifdef WITH_OPENSSL 2403 case KEY_RSA: 2404 newtype = KEY_RSA_CERT; 2405 break; 2406 case KEY_DSA: 2407 newtype = KEY_DSA_CERT; 2408 break; 2409 case KEY_ECDSA: 2410 newtype = KEY_ECDSA_CERT; 2411 break; 2412 #endif /* WITH_OPENSSL */ 2413 case KEY_ED25519: 2414 newtype = KEY_ED25519_CERT; 2415 break; 2416 #ifdef WITH_XMSS 2417 case KEY_XMSS: 2418 newtype = KEY_XMSS_CERT; 2419 break; 2420 #endif /* WITH_XMSS */ 2421 default: 2422 return SSH_ERR_INVALID_ARGUMENT; 2423 } 2424 if ((k->cert = cert_new()) == NULL) 2425 return SSH_ERR_ALLOC_FAIL; 2426 k->type = newtype; 2427 return 0; 2428 } 2429 2430 /* Convert a certificate to its raw key equivalent */ 2431 int 2432 sshkey_drop_cert(struct sshkey *k) 2433 { 2434 if (!sshkey_type_is_cert(k->type)) 2435 return SSH_ERR_KEY_TYPE_UNKNOWN; 2436 cert_free(k->cert); 2437 k->cert = NULL; 2438 k->type = sshkey_type_plain(k->type); 2439 return 0; 2440 } 2441 2442 /* Sign a certified key, (re-)generating the signed certblob. */ 2443 int 2444 sshkey_certify_custom(struct sshkey *k, struct sshkey *ca, const char *alg, 2445 sshkey_certify_signer *signer, void *signer_ctx) 2446 { 2447 struct sshbuf *principals = NULL; 2448 u_char *ca_blob = NULL, *sig_blob = NULL, nonce[32]; 2449 size_t i, ca_len, sig_len; 2450 int ret = SSH_ERR_INTERNAL_ERROR; 2451 struct sshbuf *cert = NULL; 2452 char *sigtype = NULL; 2453 #ifdef WITH_OPENSSL 2454 const BIGNUM *rsa_n, *rsa_e, *dsa_p, *dsa_q, *dsa_g, *dsa_pub_key; 2455 #endif /* WITH_OPENSSL */ 2456 2457 if (k == NULL || k->cert == NULL || 2458 k->cert->certblob == NULL || ca == NULL) 2459 return SSH_ERR_INVALID_ARGUMENT; 2460 if (!sshkey_is_cert(k)) 2461 return SSH_ERR_KEY_TYPE_UNKNOWN; 2462 if (!sshkey_type_is_valid_ca(ca->type)) 2463 return SSH_ERR_KEY_CERT_INVALID_SIGN_KEY; 2464 2465 /* 2466 * If no alg specified as argument but a signature_type was set, 2467 * then prefer that. If both were specified, then they must match. 2468 */ 2469 if (alg == NULL) 2470 alg = k->cert->signature_type; 2471 else if (k->cert->signature_type != NULL && 2472 strcmp(alg, k->cert->signature_type) != 0) 2473 return SSH_ERR_INVALID_ARGUMENT; 2474 2475 if ((ret = sshkey_to_blob(ca, &ca_blob, &ca_len)) != 0) 2476 return SSH_ERR_KEY_CERT_INVALID_SIGN_KEY; 2477 2478 cert = k->cert->certblob; /* for readability */ 2479 sshbuf_reset(cert); 2480 if ((ret = sshbuf_put_cstring(cert, sshkey_ssh_name(k))) != 0) 2481 goto out; 2482 2483 /* -v01 certs put nonce first */ 2484 arc4random_buf(&nonce, sizeof(nonce)); 2485 if ((ret = sshbuf_put_string(cert, nonce, sizeof(nonce))) != 0) 2486 goto out; 2487 2488 /* XXX this substantially duplicates to_blob(); refactor */ 2489 switch (k->type) { 2490 #ifdef WITH_OPENSSL 2491 case KEY_DSA_CERT: 2492 DSA_get0_pqg(k->dsa, &dsa_p, &dsa_q, &dsa_g); 2493 DSA_get0_key(k->dsa, &dsa_pub_key, NULL); 2494 if ((ret = sshbuf_put_bignum2(cert, dsa_p)) != 0 || 2495 (ret = sshbuf_put_bignum2(cert, dsa_q)) != 0 || 2496 (ret = sshbuf_put_bignum2(cert, dsa_g)) != 0 || 2497 (ret = sshbuf_put_bignum2(cert, dsa_pub_key)) != 0) 2498 goto out; 2499 break; 2500 case KEY_ECDSA_CERT: 2501 if ((ret = sshbuf_put_cstring(cert, 2502 sshkey_curve_nid_to_name(k->ecdsa_nid))) != 0 || 2503 (ret = sshbuf_put_ec(cert, 2504 EC_KEY_get0_public_key(k->ecdsa), 2505 EC_KEY_get0_group(k->ecdsa))) != 0) 2506 goto out; 2507 break; 2508 case KEY_RSA_CERT: 2509 RSA_get0_key(k->rsa, &rsa_n, &rsa_e, NULL); 2510 if ((ret = sshbuf_put_bignum2(cert, rsa_e)) != 0 || 2511 (ret = sshbuf_put_bignum2(cert, rsa_n)) != 0) 2512 goto out; 2513 break; 2514 #endif /* WITH_OPENSSL */ 2515 case KEY_ED25519_CERT: 2516 if ((ret = sshbuf_put_string(cert, 2517 k->ed25519_pk, ED25519_PK_SZ)) != 0) 2518 goto out; 2519 break; 2520 #ifdef WITH_XMSS 2521 case KEY_XMSS_CERT: 2522 if (k->xmss_name == NULL) { 2523 ret = SSH_ERR_INVALID_ARGUMENT; 2524 goto out; 2525 } 2526 if ((ret = sshbuf_put_cstring(cert, k->xmss_name)) || 2527 (ret = sshbuf_put_string(cert, 2528 k->xmss_pk, sshkey_xmss_pklen(k))) != 0) 2529 goto out; 2530 break; 2531 #endif /* WITH_XMSS */ 2532 default: 2533 ret = SSH_ERR_INVALID_ARGUMENT; 2534 goto out; 2535 } 2536 2537 if ((ret = sshbuf_put_u64(cert, k->cert->serial)) != 0 || 2538 (ret = sshbuf_put_u32(cert, k->cert->type)) != 0 || 2539 (ret = sshbuf_put_cstring(cert, k->cert->key_id)) != 0) 2540 goto out; 2541 2542 if ((principals = sshbuf_new()) == NULL) { 2543 ret = SSH_ERR_ALLOC_FAIL; 2544 goto out; 2545 } 2546 for (i = 0; i < k->cert->nprincipals; i++) { 2547 if ((ret = sshbuf_put_cstring(principals, 2548 k->cert->principals[i])) != 0) 2549 goto out; 2550 } 2551 if ((ret = sshbuf_put_stringb(cert, principals)) != 0 || 2552 (ret = sshbuf_put_u64(cert, k->cert->valid_after)) != 0 || 2553 (ret = sshbuf_put_u64(cert, k->cert->valid_before)) != 0 || 2554 (ret = sshbuf_put_stringb(cert, k->cert->critical)) != 0 || 2555 (ret = sshbuf_put_stringb(cert, k->cert->extensions)) != 0 || 2556 (ret = sshbuf_put_string(cert, NULL, 0)) != 0 || /* Reserved */ 2557 (ret = sshbuf_put_string(cert, ca_blob, ca_len)) != 0) 2558 goto out; 2559 2560 /* Sign the whole mess */ 2561 if ((ret = signer(ca, &sig_blob, &sig_len, sshbuf_ptr(cert), 2562 sshbuf_len(cert), alg, 0, signer_ctx)) != 0) 2563 goto out; 2564 /* Check and update signature_type against what was actually used */ 2565 if ((ret = get_sigtype(sig_blob, sig_len, &sigtype)) != 0) 2566 goto out; 2567 if (alg != NULL && strcmp(alg, sigtype) != 0) { 2568 ret = SSH_ERR_SIGN_ALG_UNSUPPORTED; 2569 goto out; 2570 } 2571 if (k->cert->signature_type == NULL) { 2572 k->cert->signature_type = sigtype; 2573 sigtype = NULL; 2574 } 2575 /* Append signature and we are done */ 2576 if ((ret = sshbuf_put_string(cert, sig_blob, sig_len)) != 0) 2577 goto out; 2578 ret = 0; 2579 out: 2580 if (ret != 0) 2581 sshbuf_reset(cert); 2582 free(sig_blob); 2583 free(ca_blob); 2584 free(sigtype); 2585 sshbuf_free(principals); 2586 return ret; 2587 } 2588 2589 static int 2590 default_key_sign(const struct sshkey *key, u_char **sigp, size_t *lenp, 2591 const u_char *data, size_t datalen, 2592 const char *alg, u_int compat, void *ctx) 2593 { 2594 if (ctx != NULL) 2595 return SSH_ERR_INVALID_ARGUMENT; 2596 return sshkey_sign(key, sigp, lenp, data, datalen, alg, compat); 2597 } 2598 2599 int 2600 sshkey_certify(struct sshkey *k, struct sshkey *ca, const char *alg) 2601 { 2602 return sshkey_certify_custom(k, ca, alg, default_key_sign, NULL); 2603 } 2604 2605 int 2606 sshkey_cert_check_authority(const struct sshkey *k, 2607 int want_host, int require_principal, 2608 const char *name, const char **reason) 2609 { 2610 u_int i, principal_matches; 2611 time_t now = time(NULL); 2612 2613 if (reason != NULL) 2614 *reason = NULL; 2615 2616 if (want_host) { 2617 if (k->cert->type != SSH2_CERT_TYPE_HOST) { 2618 *reason = "Certificate invalid: not a host certificate"; 2619 return SSH_ERR_KEY_CERT_INVALID; 2620 } 2621 } else { 2622 if (k->cert->type != SSH2_CERT_TYPE_USER) { 2623 *reason = "Certificate invalid: not a user certificate"; 2624 return SSH_ERR_KEY_CERT_INVALID; 2625 } 2626 } 2627 if (now < 0) { 2628 /* yikes - system clock before epoch! */ 2629 *reason = "Certificate invalid: not yet valid"; 2630 return SSH_ERR_KEY_CERT_INVALID; 2631 } 2632 if ((u_int64_t)now < k->cert->valid_after) { 2633 *reason = "Certificate invalid: not yet valid"; 2634 return SSH_ERR_KEY_CERT_INVALID; 2635 } 2636 if ((u_int64_t)now >= k->cert->valid_before) { 2637 *reason = "Certificate invalid: expired"; 2638 return SSH_ERR_KEY_CERT_INVALID; 2639 } 2640 if (k->cert->nprincipals == 0) { 2641 if (require_principal) { 2642 *reason = "Certificate lacks principal list"; 2643 return SSH_ERR_KEY_CERT_INVALID; 2644 } 2645 } else if (name != NULL) { 2646 principal_matches = 0; 2647 for (i = 0; i < k->cert->nprincipals; i++) { 2648 if (strcmp(name, k->cert->principals[i]) == 0) { 2649 principal_matches = 1; 2650 break; 2651 } 2652 } 2653 if (!principal_matches) { 2654 *reason = "Certificate invalid: name is not a listed " 2655 "principal"; 2656 return SSH_ERR_KEY_CERT_INVALID; 2657 } 2658 } 2659 return 0; 2660 } 2661 2662 size_t 2663 sshkey_format_cert_validity(const struct sshkey_cert *cert, char *s, size_t l) 2664 { 2665 char from[32], to[32], ret[64]; 2666 time_t tt; 2667 struct tm *tm; 2668 2669 *from = *to = '\0'; 2670 if (cert->valid_after == 0 && 2671 cert->valid_before == 0xffffffffffffffffULL) 2672 return strlcpy(s, "forever", l); 2673 2674 if (cert->valid_after != 0) { 2675 /* XXX revisit INT_MAX in 2038 :) */ 2676 tt = cert->valid_after > INT_MAX ? 2677 INT_MAX : cert->valid_after; 2678 tm = localtime(&tt); 2679 strftime(from, sizeof(from), "%Y-%m-%dT%H:%M:%S", tm); 2680 } 2681 if (cert->valid_before != 0xffffffffffffffffULL) { 2682 /* XXX revisit INT_MAX in 2038 :) */ 2683 tt = cert->valid_before > INT_MAX ? 2684 INT_MAX : cert->valid_before; 2685 tm = localtime(&tt); 2686 strftime(to, sizeof(to), "%Y-%m-%dT%H:%M:%S", tm); 2687 } 2688 2689 if (cert->valid_after == 0) 2690 snprintf(ret, sizeof(ret), "before %s", to); 2691 else if (cert->valid_before == 0xffffffffffffffffULL) 2692 snprintf(ret, sizeof(ret), "after %s", from); 2693 else 2694 snprintf(ret, sizeof(ret), "from %s to %s", from, to); 2695 2696 return strlcpy(s, ret, l); 2697 } 2698 2699 int 2700 sshkey_private_serialize_opt(const struct sshkey *key, struct sshbuf *b, 2701 enum sshkey_serialize_rep opts) 2702 { 2703 int r = SSH_ERR_INTERNAL_ERROR; 2704 #ifdef WITH_OPENSSL 2705 const BIGNUM *rsa_n, *rsa_e, *rsa_d, *rsa_iqmp, *rsa_p, *rsa_q; 2706 const BIGNUM *dsa_p, *dsa_q, *dsa_g, *dsa_pub_key, *dsa_priv_key; 2707 #endif /* WITH_OPENSSL */ 2708 2709 if ((r = sshbuf_put_cstring(b, sshkey_ssh_name(key))) != 0) 2710 goto out; 2711 switch (key->type) { 2712 #ifdef WITH_OPENSSL 2713 case KEY_RSA: 2714 RSA_get0_key(key->rsa, &rsa_n, &rsa_e, &rsa_d); 2715 RSA_get0_factors(key->rsa, &rsa_p, &rsa_q); 2716 RSA_get0_crt_params(key->rsa, NULL, NULL, &rsa_iqmp); 2717 if ((r = sshbuf_put_bignum2(b, rsa_n)) != 0 || 2718 (r = sshbuf_put_bignum2(b, rsa_e)) != 0 || 2719 (r = sshbuf_put_bignum2(b, rsa_d)) != 0 || 2720 (r = sshbuf_put_bignum2(b, rsa_iqmp)) != 0 || 2721 (r = sshbuf_put_bignum2(b, rsa_p)) != 0 || 2722 (r = sshbuf_put_bignum2(b, rsa_q)) != 0) 2723 goto out; 2724 break; 2725 case KEY_RSA_CERT: 2726 if (key->cert == NULL || sshbuf_len(key->cert->certblob) == 0) { 2727 r = SSH_ERR_INVALID_ARGUMENT; 2728 goto out; 2729 } 2730 RSA_get0_key(key->rsa, NULL, NULL, &rsa_d); 2731 RSA_get0_factors(key->rsa, &rsa_p, &rsa_q); 2732 RSA_get0_crt_params(key->rsa, NULL, NULL, &rsa_iqmp); 2733 if ((r = sshbuf_put_stringb(b, key->cert->certblob)) != 0 || 2734 (r = sshbuf_put_bignum2(b, rsa_d)) != 0 || 2735 (r = sshbuf_put_bignum2(b, rsa_iqmp)) != 0 || 2736 (r = sshbuf_put_bignum2(b, rsa_p)) != 0 || 2737 (r = sshbuf_put_bignum2(b, rsa_q)) != 0) 2738 goto out; 2739 break; 2740 case KEY_DSA: 2741 DSA_get0_pqg(key->dsa, &dsa_p, &dsa_q, &dsa_g); 2742 DSA_get0_key(key->dsa, &dsa_pub_key, &dsa_priv_key); 2743 if ((r = sshbuf_put_bignum2(b, dsa_p)) != 0 || 2744 (r = sshbuf_put_bignum2(b, dsa_q)) != 0 || 2745 (r = sshbuf_put_bignum2(b, dsa_g)) != 0 || 2746 (r = sshbuf_put_bignum2(b, dsa_pub_key)) != 0 || 2747 (r = sshbuf_put_bignum2(b, dsa_priv_key)) != 0) 2748 goto out; 2749 break; 2750 case KEY_DSA_CERT: 2751 if (key->cert == NULL || sshbuf_len(key->cert->certblob) == 0) { 2752 r = SSH_ERR_INVALID_ARGUMENT; 2753 goto out; 2754 } 2755 DSA_get0_key(key->dsa, NULL, &dsa_priv_key); 2756 if ((r = sshbuf_put_stringb(b, key->cert->certblob)) != 0 || 2757 (r = sshbuf_put_bignum2(b, dsa_priv_key)) != 0) 2758 goto out; 2759 break; 2760 case KEY_ECDSA: 2761 if ((r = sshbuf_put_cstring(b, 2762 sshkey_curve_nid_to_name(key->ecdsa_nid))) != 0 || 2763 (r = sshbuf_put_eckey(b, key->ecdsa)) != 0 || 2764 (r = sshbuf_put_bignum2(b, 2765 EC_KEY_get0_private_key(key->ecdsa))) != 0) 2766 goto out; 2767 break; 2768 case KEY_ECDSA_CERT: 2769 if (key->cert == NULL || sshbuf_len(key->cert->certblob) == 0) { 2770 r = SSH_ERR_INVALID_ARGUMENT; 2771 goto out; 2772 } 2773 if ((r = sshbuf_put_stringb(b, key->cert->certblob)) != 0 || 2774 (r = sshbuf_put_bignum2(b, 2775 EC_KEY_get0_private_key(key->ecdsa))) != 0) 2776 goto out; 2777 break; 2778 #endif /* WITH_OPENSSL */ 2779 case KEY_ED25519: 2780 if ((r = sshbuf_put_string(b, key->ed25519_pk, 2781 ED25519_PK_SZ)) != 0 || 2782 (r = sshbuf_put_string(b, key->ed25519_sk, 2783 ED25519_SK_SZ)) != 0) 2784 goto out; 2785 break; 2786 case KEY_ED25519_CERT: 2787 if (key->cert == NULL || sshbuf_len(key->cert->certblob) == 0) { 2788 r = SSH_ERR_INVALID_ARGUMENT; 2789 goto out; 2790 } 2791 if ((r = sshbuf_put_stringb(b, key->cert->certblob)) != 0 || 2792 (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 #ifdef WITH_XMSS 2799 case KEY_XMSS: 2800 if (key->xmss_name == NULL) { 2801 r = SSH_ERR_INVALID_ARGUMENT; 2802 goto out; 2803 } 2804 if ((r = sshbuf_put_cstring(b, key->xmss_name)) != 0 || 2805 (r = sshbuf_put_string(b, key->xmss_pk, 2806 sshkey_xmss_pklen(key))) != 0 || 2807 (r = sshbuf_put_string(b, key->xmss_sk, 2808 sshkey_xmss_sklen(key))) != 0 || 2809 (r = sshkey_xmss_serialize_state_opt(key, b, opts)) != 0) 2810 goto out; 2811 break; 2812 case KEY_XMSS_CERT: 2813 if (key->cert == NULL || sshbuf_len(key->cert->certblob) == 0 || 2814 key->xmss_name == NULL) { 2815 r = SSH_ERR_INVALID_ARGUMENT; 2816 goto out; 2817 } 2818 if ((r = sshbuf_put_stringb(b, key->cert->certblob)) != 0 || 2819 (r = sshbuf_put_cstring(b, key->xmss_name)) != 0 || 2820 (r = sshbuf_put_string(b, key->xmss_pk, 2821 sshkey_xmss_pklen(key))) != 0 || 2822 (r = sshbuf_put_string(b, key->xmss_sk, 2823 sshkey_xmss_sklen(key))) != 0 || 2824 (r = sshkey_xmss_serialize_state_opt(key, b, opts)) != 0) 2825 goto out; 2826 break; 2827 #endif /* WITH_XMSS */ 2828 default: 2829 r = SSH_ERR_INVALID_ARGUMENT; 2830 goto out; 2831 } 2832 /* success */ 2833 r = 0; 2834 out: 2835 return r; 2836 } 2837 2838 int 2839 sshkey_private_serialize(const struct sshkey *key, struct sshbuf *b) 2840 { 2841 return sshkey_private_serialize_opt(key, b, 2842 SSHKEY_SERIALIZE_DEFAULT); 2843 } 2844 2845 int 2846 sshkey_private_deserialize(struct sshbuf *buf, struct sshkey **kp) 2847 { 2848 char *tname = NULL, *curve = NULL, *xmss_name = NULL; 2849 struct sshkey *k = NULL; 2850 size_t pklen = 0, sklen = 0; 2851 int type, r = SSH_ERR_INTERNAL_ERROR; 2852 u_char *ed25519_pk = NULL, *ed25519_sk = NULL; 2853 u_char *xmss_pk = NULL, *xmss_sk = NULL; 2854 #ifdef WITH_OPENSSL 2855 BIGNUM *exponent = NULL; 2856 BIGNUM *rsa_n = NULL, *rsa_e = NULL, *rsa_d = NULL; 2857 BIGNUM *rsa_iqmp = NULL, *rsa_p = NULL, *rsa_q = NULL; 2858 BIGNUM *dsa_p = NULL, *dsa_q = NULL, *dsa_g = NULL; 2859 BIGNUM *dsa_pub_key = NULL, *dsa_priv_key = NULL; 2860 #endif /* WITH_OPENSSL */ 2861 2862 if (kp != NULL) 2863 *kp = NULL; 2864 if ((r = sshbuf_get_cstring(buf, &tname, NULL)) != 0) 2865 goto out; 2866 type = sshkey_type_from_name(tname); 2867 switch (type) { 2868 #ifdef WITH_OPENSSL 2869 case KEY_DSA: 2870 if ((k = sshkey_new(type)) == NULL) { 2871 r = SSH_ERR_ALLOC_FAIL; 2872 goto out; 2873 } 2874 if ((r = sshbuf_get_bignum2(buf, &dsa_p)) != 0 || 2875 (r = sshbuf_get_bignum2(buf, &dsa_q)) != 0 || 2876 (r = sshbuf_get_bignum2(buf, &dsa_g)) != 0 || 2877 (r = sshbuf_get_bignum2(buf, &dsa_pub_key)) != 0 || 2878 (r = sshbuf_get_bignum2(buf, &dsa_priv_key)) != 0) 2879 goto out; 2880 if (!DSA_set0_pqg(k->dsa, dsa_p, dsa_q, dsa_g)) { 2881 r = SSH_ERR_LIBCRYPTO_ERROR; 2882 goto out; 2883 } 2884 dsa_p = dsa_q = dsa_g = NULL; /* transferred */ 2885 if (!DSA_set0_key(k->dsa, dsa_pub_key, dsa_priv_key)) { 2886 r = SSH_ERR_LIBCRYPTO_ERROR; 2887 goto out; 2888 } 2889 dsa_pub_key = dsa_priv_key = NULL; /* transferred */ 2890 break; 2891 case KEY_DSA_CERT: 2892 if ((r = sshkey_froms(buf, &k)) != 0 || 2893 (r = sshbuf_get_bignum2(buf, &dsa_priv_key)) != 0) 2894 goto out; 2895 if (!DSA_set0_key(k->dsa, NULL, dsa_priv_key)) { 2896 r = SSH_ERR_LIBCRYPTO_ERROR; 2897 goto out; 2898 } 2899 dsa_priv_key = NULL; /* transferred */ 2900 break; 2901 case KEY_ECDSA: 2902 if ((k = sshkey_new(type)) == NULL) { 2903 r = SSH_ERR_ALLOC_FAIL; 2904 goto out; 2905 } 2906 if ((k->ecdsa_nid = sshkey_ecdsa_nid_from_name(tname)) == -1) { 2907 r = SSH_ERR_INVALID_ARGUMENT; 2908 goto out; 2909 } 2910 if ((r = sshbuf_get_cstring(buf, &curve, NULL)) != 0) 2911 goto out; 2912 if (k->ecdsa_nid != sshkey_curve_name_to_nid(curve)) { 2913 r = SSH_ERR_EC_CURVE_MISMATCH; 2914 goto out; 2915 } 2916 k->ecdsa = EC_KEY_new_by_curve_name(k->ecdsa_nid); 2917 if (k->ecdsa == NULL) { 2918 r = SSH_ERR_LIBCRYPTO_ERROR; 2919 goto out; 2920 } 2921 if ((r = sshbuf_get_eckey(buf, k->ecdsa)) != 0 || 2922 (r = sshbuf_get_bignum2(buf, &exponent))) 2923 goto out; 2924 if (EC_KEY_set_private_key(k->ecdsa, exponent) != 1) { 2925 r = SSH_ERR_LIBCRYPTO_ERROR; 2926 goto out; 2927 } 2928 if ((r = sshkey_ec_validate_public(EC_KEY_get0_group(k->ecdsa), 2929 EC_KEY_get0_public_key(k->ecdsa))) != 0 || 2930 (r = sshkey_ec_validate_private(k->ecdsa)) != 0) 2931 goto out; 2932 break; 2933 case KEY_ECDSA_CERT: 2934 if ((r = sshkey_froms(buf, &k)) != 0 || 2935 (r = sshbuf_get_bignum2(buf, &exponent)) != 0) 2936 goto out; 2937 if (EC_KEY_set_private_key(k->ecdsa, exponent) != 1) { 2938 r = SSH_ERR_LIBCRYPTO_ERROR; 2939 goto out; 2940 } 2941 if ((r = sshkey_ec_validate_public(EC_KEY_get0_group(k->ecdsa), 2942 EC_KEY_get0_public_key(k->ecdsa))) != 0 || 2943 (r = sshkey_ec_validate_private(k->ecdsa)) != 0) 2944 goto out; 2945 break; 2946 case KEY_RSA: 2947 if ((k = sshkey_new(type)) == NULL) { 2948 r = SSH_ERR_ALLOC_FAIL; 2949 goto out; 2950 } 2951 if ((r = sshbuf_get_bignum2(buf, &rsa_n)) != 0 || 2952 (r = sshbuf_get_bignum2(buf, &rsa_e)) != 0 || 2953 (r = sshbuf_get_bignum2(buf, &rsa_d)) != 0 || 2954 (r = sshbuf_get_bignum2(buf, &rsa_iqmp)) != 0 || 2955 (r = sshbuf_get_bignum2(buf, &rsa_p)) != 0 || 2956 (r = sshbuf_get_bignum2(buf, &rsa_q)) != 0) 2957 goto out; 2958 if (!RSA_set0_key(k->rsa, rsa_n, rsa_e, rsa_d)) { 2959 r = SSH_ERR_LIBCRYPTO_ERROR; 2960 goto out; 2961 } 2962 rsa_n = rsa_e = rsa_d = NULL; /* transferred */ 2963 if (!RSA_set0_factors(k->rsa, rsa_p, rsa_q)) { 2964 r = SSH_ERR_LIBCRYPTO_ERROR; 2965 goto out; 2966 } 2967 rsa_p = rsa_q = NULL; /* transferred */ 2968 if ((r = check_rsa_length(k->rsa)) != 0) 2969 goto out; 2970 if ((r = ssh_rsa_complete_crt_parameters(k, rsa_iqmp)) != 0) 2971 goto out; 2972 break; 2973 case KEY_RSA_CERT: 2974 if ((r = sshkey_froms(buf, &k)) != 0 || 2975 (r = sshbuf_get_bignum2(buf, &rsa_d)) != 0 || 2976 (r = sshbuf_get_bignum2(buf, &rsa_iqmp)) != 0 || 2977 (r = sshbuf_get_bignum2(buf, &rsa_p)) != 0 || 2978 (r = sshbuf_get_bignum2(buf, &rsa_q)) != 0) 2979 goto out; 2980 if (!RSA_set0_key(k->rsa, NULL, NULL, rsa_d)) { 2981 r = SSH_ERR_LIBCRYPTO_ERROR; 2982 goto out; 2983 } 2984 rsa_d = NULL; /* transferred */ 2985 if (!RSA_set0_factors(k->rsa, rsa_p, rsa_q)) { 2986 r = SSH_ERR_LIBCRYPTO_ERROR; 2987 goto out; 2988 } 2989 rsa_p = rsa_q = NULL; /* transferred */ 2990 if ((r = check_rsa_length(k->rsa)) != 0) 2991 goto out; 2992 if ((r = ssh_rsa_complete_crt_parameters(k, rsa_iqmp)) != 0) 2993 goto out; 2994 break; 2995 #endif /* WITH_OPENSSL */ 2996 case KEY_ED25519: 2997 if ((k = sshkey_new(type)) == NULL) { 2998 r = SSH_ERR_ALLOC_FAIL; 2999 goto out; 3000 } 3001 if ((r = sshbuf_get_string(buf, &ed25519_pk, &pklen)) != 0 || 3002 (r = sshbuf_get_string(buf, &ed25519_sk, &sklen)) != 0) 3003 goto out; 3004 if (pklen != ED25519_PK_SZ || sklen != ED25519_SK_SZ) { 3005 r = SSH_ERR_INVALID_FORMAT; 3006 goto out; 3007 } 3008 k->ed25519_pk = ed25519_pk; 3009 k->ed25519_sk = ed25519_sk; 3010 ed25519_pk = ed25519_sk = NULL; 3011 break; 3012 case KEY_ED25519_CERT: 3013 if ((r = sshkey_froms(buf, &k)) != 0 || 3014 (r = sshbuf_get_string(buf, &ed25519_pk, &pklen)) != 0 || 3015 (r = sshbuf_get_string(buf, &ed25519_sk, &sklen)) != 0) 3016 goto out; 3017 if (pklen != ED25519_PK_SZ || sklen != ED25519_SK_SZ) { 3018 r = SSH_ERR_INVALID_FORMAT; 3019 goto out; 3020 } 3021 k->ed25519_pk = ed25519_pk; 3022 k->ed25519_sk = ed25519_sk; 3023 ed25519_pk = ed25519_sk = NULL; 3024 break; 3025 #ifdef WITH_XMSS 3026 case KEY_XMSS: 3027 if ((k = sshkey_new(type)) == NULL) { 3028 r = SSH_ERR_ALLOC_FAIL; 3029 goto out; 3030 } 3031 if ((r = sshbuf_get_cstring(buf, &xmss_name, NULL)) != 0 || 3032 (r = sshkey_xmss_init(k, xmss_name)) != 0 || 3033 (r = sshbuf_get_string(buf, &xmss_pk, &pklen)) != 0 || 3034 (r = sshbuf_get_string(buf, &xmss_sk, &sklen)) != 0) 3035 goto out; 3036 if (pklen != sshkey_xmss_pklen(k) || 3037 sklen != sshkey_xmss_sklen(k)) { 3038 r = SSH_ERR_INVALID_FORMAT; 3039 goto out; 3040 } 3041 k->xmss_pk = xmss_pk; 3042 k->xmss_sk = xmss_sk; 3043 xmss_pk = xmss_sk = NULL; 3044 /* optional internal state */ 3045 if ((r = sshkey_xmss_deserialize_state_opt(k, buf)) != 0) 3046 goto out; 3047 break; 3048 case KEY_XMSS_CERT: 3049 if ((r = sshkey_froms(buf, &k)) != 0 || 3050 (r = sshbuf_get_cstring(buf, &xmss_name, NULL)) != 0 || 3051 (r = sshbuf_get_string(buf, &xmss_pk, &pklen)) != 0 || 3052 (r = sshbuf_get_string(buf, &xmss_sk, &sklen)) != 0) 3053 goto out; 3054 if (strcmp(xmss_name, k->xmss_name)) { 3055 r = SSH_ERR_INVALID_FORMAT; 3056 goto out; 3057 } 3058 if (pklen != sshkey_xmss_pklen(k) || 3059 sklen != sshkey_xmss_sklen(k)) { 3060 r = SSH_ERR_INVALID_FORMAT; 3061 goto out; 3062 } 3063 k->xmss_pk = xmss_pk; 3064 k->xmss_sk = xmss_sk; 3065 xmss_pk = xmss_sk = NULL; 3066 /* optional internal state */ 3067 if ((r = sshkey_xmss_deserialize_state_opt(k, buf)) != 0) 3068 goto out; 3069 break; 3070 #endif /* WITH_XMSS */ 3071 default: 3072 r = SSH_ERR_KEY_TYPE_UNKNOWN; 3073 goto out; 3074 } 3075 #ifdef WITH_OPENSSL 3076 /* enable blinding */ 3077 switch (k->type) { 3078 case KEY_RSA: 3079 case KEY_RSA_CERT: 3080 if (RSA_blinding_on(k->rsa, NULL) != 1) { 3081 r = SSH_ERR_LIBCRYPTO_ERROR; 3082 goto out; 3083 } 3084 break; 3085 } 3086 #endif /* WITH_OPENSSL */ 3087 /* success */ 3088 r = 0; 3089 if (kp != NULL) { 3090 *kp = k; 3091 k = NULL; 3092 } 3093 out: 3094 free(tname); 3095 free(curve); 3096 #ifdef WITH_OPENSSL 3097 BN_clear_free(exponent); 3098 BN_clear_free(dsa_p); 3099 BN_clear_free(dsa_q); 3100 BN_clear_free(dsa_g); 3101 BN_clear_free(dsa_pub_key); 3102 BN_clear_free(dsa_priv_key); 3103 BN_clear_free(rsa_n); 3104 BN_clear_free(rsa_e); 3105 BN_clear_free(rsa_d); 3106 BN_clear_free(rsa_p); 3107 BN_clear_free(rsa_q); 3108 BN_clear_free(rsa_iqmp); 3109 #endif /* WITH_OPENSSL */ 3110 sshkey_free(k); 3111 freezero(ed25519_pk, pklen); 3112 freezero(ed25519_sk, sklen); 3113 free(xmss_name); 3114 freezero(xmss_pk, pklen); 3115 freezero(xmss_sk, sklen); 3116 return r; 3117 } 3118 3119 #ifdef WITH_OPENSSL 3120 int 3121 sshkey_ec_validate_public(const EC_GROUP *group, const EC_POINT *public) 3122 { 3123 BN_CTX *bnctx; 3124 EC_POINT *nq = NULL; 3125 BIGNUM *order, *x, *y, *tmp; 3126 int ret = SSH_ERR_KEY_INVALID_EC_VALUE; 3127 3128 /* 3129 * NB. This assumes OpenSSL has already verified that the public 3130 * point lies on the curve. This is done by EC_POINT_oct2point() 3131 * implicitly calling EC_POINT_is_on_curve(). If this code is ever 3132 * reachable with public points not unmarshalled using 3133 * EC_POINT_oct2point then the caller will need to explicitly check. 3134 */ 3135 3136 if ((bnctx = BN_CTX_new()) == NULL) 3137 return SSH_ERR_ALLOC_FAIL; 3138 BN_CTX_start(bnctx); 3139 3140 /* 3141 * We shouldn't ever hit this case because bignum_get_ecpoint() 3142 * refuses to load GF2m points. 3143 */ 3144 if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) != 3145 NID_X9_62_prime_field) 3146 goto out; 3147 3148 /* Q != infinity */ 3149 if (EC_POINT_is_at_infinity(group, public)) 3150 goto out; 3151 3152 if ((x = BN_CTX_get(bnctx)) == NULL || 3153 (y = BN_CTX_get(bnctx)) == NULL || 3154 (order = BN_CTX_get(bnctx)) == NULL || 3155 (tmp = BN_CTX_get(bnctx)) == NULL) { 3156 ret = SSH_ERR_ALLOC_FAIL; 3157 goto out; 3158 } 3159 3160 /* log2(x) > log2(order)/2, log2(y) > log2(order)/2 */ 3161 if (EC_GROUP_get_order(group, order, bnctx) != 1 || 3162 EC_POINT_get_affine_coordinates_GFp(group, public, 3163 x, y, bnctx) != 1) { 3164 ret = SSH_ERR_LIBCRYPTO_ERROR; 3165 goto out; 3166 } 3167 if (BN_num_bits(x) <= BN_num_bits(order) / 2 || 3168 BN_num_bits(y) <= BN_num_bits(order) / 2) 3169 goto out; 3170 3171 /* nQ == infinity (n == order of subgroup) */ 3172 if ((nq = EC_POINT_new(group)) == NULL) { 3173 ret = SSH_ERR_ALLOC_FAIL; 3174 goto out; 3175 } 3176 if (EC_POINT_mul(group, nq, NULL, public, order, bnctx) != 1) { 3177 ret = SSH_ERR_LIBCRYPTO_ERROR; 3178 goto out; 3179 } 3180 if (EC_POINT_is_at_infinity(group, nq) != 1) 3181 goto out; 3182 3183 /* x < order - 1, y < order - 1 */ 3184 if (!BN_sub(tmp, order, BN_value_one())) { 3185 ret = SSH_ERR_LIBCRYPTO_ERROR; 3186 goto out; 3187 } 3188 if (BN_cmp(x, tmp) >= 0 || BN_cmp(y, tmp) >= 0) 3189 goto out; 3190 ret = 0; 3191 out: 3192 BN_CTX_free(bnctx); 3193 EC_POINT_free(nq); 3194 return ret; 3195 } 3196 3197 int 3198 sshkey_ec_validate_private(const EC_KEY *key) 3199 { 3200 BN_CTX *bnctx; 3201 BIGNUM *order, *tmp; 3202 int ret = SSH_ERR_KEY_INVALID_EC_VALUE; 3203 3204 if ((bnctx = BN_CTX_new()) == NULL) 3205 return SSH_ERR_ALLOC_FAIL; 3206 BN_CTX_start(bnctx); 3207 3208 if ((order = BN_CTX_get(bnctx)) == NULL || 3209 (tmp = BN_CTX_get(bnctx)) == NULL) { 3210 ret = SSH_ERR_ALLOC_FAIL; 3211 goto out; 3212 } 3213 3214 /* log2(private) > log2(order)/2 */ 3215 if (EC_GROUP_get_order(EC_KEY_get0_group(key), order, bnctx) != 1) { 3216 ret = SSH_ERR_LIBCRYPTO_ERROR; 3217 goto out; 3218 } 3219 if (BN_num_bits(EC_KEY_get0_private_key(key)) <= 3220 BN_num_bits(order) / 2) 3221 goto out; 3222 3223 /* private < order - 1 */ 3224 if (!BN_sub(tmp, order, BN_value_one())) { 3225 ret = SSH_ERR_LIBCRYPTO_ERROR; 3226 goto out; 3227 } 3228 if (BN_cmp(EC_KEY_get0_private_key(key), tmp) >= 0) 3229 goto out; 3230 ret = 0; 3231 out: 3232 BN_CTX_free(bnctx); 3233 return ret; 3234 } 3235 3236 void 3237 sshkey_dump_ec_point(const EC_GROUP *group, const EC_POINT *point) 3238 { 3239 BIGNUM *x, *y; 3240 BN_CTX *bnctx; 3241 3242 if (point == NULL) { 3243 fputs("point=(NULL)\n", stderr); 3244 return; 3245 } 3246 if ((bnctx = BN_CTX_new()) == NULL) { 3247 fprintf(stderr, "%s: BN_CTX_new failed\n", __func__); 3248 return; 3249 } 3250 BN_CTX_start(bnctx); 3251 if ((x = BN_CTX_get(bnctx)) == NULL || 3252 (y = BN_CTX_get(bnctx)) == NULL) { 3253 fprintf(stderr, "%s: BN_CTX_get failed\n", __func__); 3254 return; 3255 } 3256 if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) != 3257 NID_X9_62_prime_field) { 3258 fprintf(stderr, "%s: group is not a prime field\n", __func__); 3259 return; 3260 } 3261 if (EC_POINT_get_affine_coordinates_GFp(group, point, x, y, 3262 bnctx) != 1) { 3263 fprintf(stderr, "%s: EC_POINT_get_affine_coordinates_GFp\n", 3264 __func__); 3265 return; 3266 } 3267 fputs("x=", stderr); 3268 BN_print_fp(stderr, x); 3269 fputs("\ny=", stderr); 3270 BN_print_fp(stderr, y); 3271 fputs("\n", stderr); 3272 BN_CTX_free(bnctx); 3273 } 3274 3275 void 3276 sshkey_dump_ec_key(const EC_KEY *key) 3277 { 3278 const BIGNUM *exponent; 3279 3280 sshkey_dump_ec_point(EC_KEY_get0_group(key), 3281 EC_KEY_get0_public_key(key)); 3282 fputs("exponent=", stderr); 3283 if ((exponent = EC_KEY_get0_private_key(key)) == NULL) 3284 fputs("(NULL)", stderr); 3285 else 3286 BN_print_fp(stderr, EC_KEY_get0_private_key(key)); 3287 fputs("\n", stderr); 3288 } 3289 #endif /* WITH_OPENSSL */ 3290 3291 static int 3292 sshkey_private_to_blob2(const struct sshkey *prv, struct sshbuf *blob, 3293 const char *passphrase, const char *comment, const char *ciphername, 3294 int rounds) 3295 { 3296 u_char *cp, *key = NULL, *pubkeyblob = NULL; 3297 u_char salt[SALT_LEN]; 3298 char *b64 = NULL; 3299 size_t i, pubkeylen, keylen, ivlen, blocksize, authlen; 3300 u_int check; 3301 int r = SSH_ERR_INTERNAL_ERROR; 3302 struct sshcipher_ctx *ciphercontext = NULL; 3303 const struct sshcipher *cipher; 3304 const char *kdfname = KDFNAME; 3305 struct sshbuf *encoded = NULL, *encrypted = NULL, *kdf = NULL; 3306 3307 if (rounds <= 0) 3308 rounds = DEFAULT_ROUNDS; 3309 if (passphrase == NULL || !strlen(passphrase)) { 3310 ciphername = "none"; 3311 kdfname = "none"; 3312 } else if (ciphername == NULL) 3313 ciphername = DEFAULT_CIPHERNAME; 3314 if ((cipher = cipher_by_name(ciphername)) == NULL) { 3315 r = SSH_ERR_INVALID_ARGUMENT; 3316 goto out; 3317 } 3318 3319 if ((kdf = sshbuf_new()) == NULL || 3320 (encoded = sshbuf_new()) == NULL || 3321 (encrypted = sshbuf_new()) == NULL) { 3322 r = SSH_ERR_ALLOC_FAIL; 3323 goto out; 3324 } 3325 blocksize = cipher_blocksize(cipher); 3326 keylen = cipher_keylen(cipher); 3327 ivlen = cipher_ivlen(cipher); 3328 authlen = cipher_authlen(cipher); 3329 if ((key = calloc(1, keylen + ivlen)) == NULL) { 3330 r = SSH_ERR_ALLOC_FAIL; 3331 goto out; 3332 } 3333 if (strcmp(kdfname, "bcrypt") == 0) { 3334 arc4random_buf(salt, SALT_LEN); 3335 if (bcrypt_pbkdf(passphrase, strlen(passphrase), 3336 salt, SALT_LEN, key, keylen + ivlen, rounds) < 0) { 3337 r = SSH_ERR_INVALID_ARGUMENT; 3338 goto out; 3339 } 3340 if ((r = sshbuf_put_string(kdf, salt, SALT_LEN)) != 0 || 3341 (r = sshbuf_put_u32(kdf, rounds)) != 0) 3342 goto out; 3343 } else if (strcmp(kdfname, "none") != 0) { 3344 /* Unsupported KDF type */ 3345 r = SSH_ERR_KEY_UNKNOWN_CIPHER; 3346 goto out; 3347 } 3348 if ((r = cipher_init(&ciphercontext, cipher, key, keylen, 3349 key + keylen, ivlen, 1)) != 0) 3350 goto out; 3351 3352 if ((r = sshbuf_put(encoded, AUTH_MAGIC, sizeof(AUTH_MAGIC))) != 0 || 3353 (r = sshbuf_put_cstring(encoded, ciphername)) != 0 || 3354 (r = sshbuf_put_cstring(encoded, kdfname)) != 0 || 3355 (r = sshbuf_put_stringb(encoded, kdf)) != 0 || 3356 (r = sshbuf_put_u32(encoded, 1)) != 0 || /* number of keys */ 3357 (r = sshkey_to_blob(prv, &pubkeyblob, &pubkeylen)) != 0 || 3358 (r = sshbuf_put_string(encoded, pubkeyblob, pubkeylen)) != 0) 3359 goto out; 3360 3361 /* set up the buffer that will be encrypted */ 3362 3363 /* Random check bytes */ 3364 check = arc4random(); 3365 if ((r = sshbuf_put_u32(encrypted, check)) != 0 || 3366 (r = sshbuf_put_u32(encrypted, check)) != 0) 3367 goto out; 3368 3369 /* append private key and comment*/ 3370 if ((r = sshkey_private_serialize_opt(prv, encrypted, 3371 SSHKEY_SERIALIZE_FULL)) != 0 || 3372 (r = sshbuf_put_cstring(encrypted, comment)) != 0) 3373 goto out; 3374 3375 /* padding */ 3376 i = 0; 3377 while (sshbuf_len(encrypted) % blocksize) { 3378 if ((r = sshbuf_put_u8(encrypted, ++i & 0xff)) != 0) 3379 goto out; 3380 } 3381 3382 /* length in destination buffer */ 3383 if ((r = sshbuf_put_u32(encoded, sshbuf_len(encrypted))) != 0) 3384 goto out; 3385 3386 /* encrypt */ 3387 if ((r = sshbuf_reserve(encoded, 3388 sshbuf_len(encrypted) + authlen, &cp)) != 0) 3389 goto out; 3390 if ((r = cipher_crypt(ciphercontext, 0, cp, 3391 sshbuf_ptr(encrypted), sshbuf_len(encrypted), 0, authlen)) != 0) 3392 goto out; 3393 3394 /* uuencode */ 3395 if ((b64 = sshbuf_dtob64(encoded)) == NULL) { 3396 r = SSH_ERR_ALLOC_FAIL; 3397 goto out; 3398 } 3399 3400 sshbuf_reset(blob); 3401 if ((r = sshbuf_put(blob, MARK_BEGIN, MARK_BEGIN_LEN)) != 0) 3402 goto out; 3403 for (i = 0; i < strlen(b64); i++) { 3404 if ((r = sshbuf_put_u8(blob, b64[i])) != 0) 3405 goto out; 3406 /* insert line breaks */ 3407 if (i % 70 == 69 && (r = sshbuf_put_u8(blob, '\n')) != 0) 3408 goto out; 3409 } 3410 if (i % 70 != 69 && (r = sshbuf_put_u8(blob, '\n')) != 0) 3411 goto out; 3412 if ((r = sshbuf_put(blob, MARK_END, MARK_END_LEN)) != 0) 3413 goto out; 3414 3415 /* success */ 3416 r = 0; 3417 3418 out: 3419 sshbuf_free(kdf); 3420 sshbuf_free(encoded); 3421 sshbuf_free(encrypted); 3422 cipher_free(ciphercontext); 3423 explicit_bzero(salt, sizeof(salt)); 3424 if (key != NULL) { 3425 explicit_bzero(key, keylen + ivlen); 3426 free(key); 3427 } 3428 if (pubkeyblob != NULL) { 3429 explicit_bzero(pubkeyblob, pubkeylen); 3430 free(pubkeyblob); 3431 } 3432 if (b64 != NULL) { 3433 explicit_bzero(b64, strlen(b64)); 3434 free(b64); 3435 } 3436 return r; 3437 } 3438 3439 static int 3440 sshkey_parse_private2(struct sshbuf *blob, int type, const char *passphrase, 3441 struct sshkey **keyp, char **commentp) 3442 { 3443 char *comment = NULL, *ciphername = NULL, *kdfname = NULL; 3444 const struct sshcipher *cipher = NULL; 3445 const u_char *cp; 3446 int r = SSH_ERR_INTERNAL_ERROR; 3447 size_t encoded_len; 3448 size_t i, keylen = 0, ivlen = 0, authlen = 0, slen = 0; 3449 struct sshbuf *encoded = NULL, *decoded = NULL; 3450 struct sshbuf *kdf = NULL, *decrypted = NULL; 3451 struct sshcipher_ctx *ciphercontext = NULL; 3452 struct sshkey *k = NULL; 3453 u_char *key = NULL, *salt = NULL, *dp, pad, last; 3454 u_int blocksize, rounds, nkeys, encrypted_len, check1, check2; 3455 3456 if (keyp != NULL) 3457 *keyp = NULL; 3458 if (commentp != NULL) 3459 *commentp = NULL; 3460 3461 if ((encoded = sshbuf_new()) == NULL || 3462 (decoded = sshbuf_new()) == NULL || 3463 (decrypted = sshbuf_new()) == NULL) { 3464 r = SSH_ERR_ALLOC_FAIL; 3465 goto out; 3466 } 3467 3468 /* check preamble */ 3469 cp = sshbuf_ptr(blob); 3470 encoded_len = sshbuf_len(blob); 3471 if (encoded_len < (MARK_BEGIN_LEN + MARK_END_LEN) || 3472 memcmp(cp, MARK_BEGIN, MARK_BEGIN_LEN) != 0) { 3473 r = SSH_ERR_INVALID_FORMAT; 3474 goto out; 3475 } 3476 cp += MARK_BEGIN_LEN; 3477 encoded_len -= MARK_BEGIN_LEN; 3478 3479 /* Look for end marker, removing whitespace as we go */ 3480 while (encoded_len > 0) { 3481 if (*cp != '\n' && *cp != '\r') { 3482 if ((r = sshbuf_put_u8(encoded, *cp)) != 0) 3483 goto out; 3484 } 3485 last = *cp; 3486 encoded_len--; 3487 cp++; 3488 if (last == '\n') { 3489 if (encoded_len >= MARK_END_LEN && 3490 memcmp(cp, MARK_END, MARK_END_LEN) == 0) { 3491 /* \0 terminate */ 3492 if ((r = sshbuf_put_u8(encoded, 0)) != 0) 3493 goto out; 3494 break; 3495 } 3496 } 3497 } 3498 if (encoded_len == 0) { 3499 r = SSH_ERR_INVALID_FORMAT; 3500 goto out; 3501 } 3502 3503 /* decode base64 */ 3504 if ((r = sshbuf_b64tod(decoded, (char *)sshbuf_ptr(encoded))) != 0) 3505 goto out; 3506 3507 /* check magic */ 3508 if (sshbuf_len(decoded) < sizeof(AUTH_MAGIC) || 3509 memcmp(sshbuf_ptr(decoded), AUTH_MAGIC, sizeof(AUTH_MAGIC))) { 3510 r = SSH_ERR_INVALID_FORMAT; 3511 goto out; 3512 } 3513 /* parse public portion of key */ 3514 if ((r = sshbuf_consume(decoded, sizeof(AUTH_MAGIC))) != 0 || 3515 (r = sshbuf_get_cstring(decoded, &ciphername, NULL)) != 0 || 3516 (r = sshbuf_get_cstring(decoded, &kdfname, NULL)) != 0 || 3517 (r = sshbuf_froms(decoded, &kdf)) != 0 || 3518 (r = sshbuf_get_u32(decoded, &nkeys)) != 0 || 3519 (r = sshbuf_skip_string(decoded)) != 0 || /* pubkey */ 3520 (r = sshbuf_get_u32(decoded, &encrypted_len)) != 0) 3521 goto out; 3522 3523 if ((cipher = cipher_by_name(ciphername)) == NULL) { 3524 r = SSH_ERR_KEY_UNKNOWN_CIPHER; 3525 goto out; 3526 } 3527 if ((passphrase == NULL || strlen(passphrase) == 0) && 3528 strcmp(ciphername, "none") != 0) { 3529 /* passphrase required */ 3530 r = SSH_ERR_KEY_WRONG_PASSPHRASE; 3531 goto out; 3532 } 3533 if (strcmp(kdfname, "none") != 0 && strcmp(kdfname, "bcrypt") != 0) { 3534 r = SSH_ERR_KEY_UNKNOWN_CIPHER; 3535 goto out; 3536 } 3537 if (!strcmp(kdfname, "none") && strcmp(ciphername, "none") != 0) { 3538 r = SSH_ERR_INVALID_FORMAT; 3539 goto out; 3540 } 3541 if (nkeys != 1) { 3542 /* XXX only one key supported */ 3543 r = SSH_ERR_INVALID_FORMAT; 3544 goto out; 3545 } 3546 3547 /* check size of encrypted key blob */ 3548 blocksize = cipher_blocksize(cipher); 3549 if (encrypted_len < blocksize || (encrypted_len % blocksize) != 0) { 3550 r = SSH_ERR_INVALID_FORMAT; 3551 goto out; 3552 } 3553 3554 /* setup key */ 3555 keylen = cipher_keylen(cipher); 3556 ivlen = cipher_ivlen(cipher); 3557 authlen = cipher_authlen(cipher); 3558 if ((key = calloc(1, keylen + ivlen)) == NULL) { 3559 r = SSH_ERR_ALLOC_FAIL; 3560 goto out; 3561 } 3562 if (strcmp(kdfname, "bcrypt") == 0) { 3563 if ((r = sshbuf_get_string(kdf, &salt, &slen)) != 0 || 3564 (r = sshbuf_get_u32(kdf, &rounds)) != 0) 3565 goto out; 3566 if (bcrypt_pbkdf(passphrase, strlen(passphrase), salt, slen, 3567 key, keylen + ivlen, rounds) < 0) { 3568 r = SSH_ERR_INVALID_FORMAT; 3569 goto out; 3570 } 3571 } 3572 3573 /* check that an appropriate amount of auth data is present */ 3574 if (sshbuf_len(decoded) < encrypted_len + authlen) { 3575 r = SSH_ERR_INVALID_FORMAT; 3576 goto out; 3577 } 3578 3579 /* decrypt private portion of key */ 3580 if ((r = sshbuf_reserve(decrypted, encrypted_len, &dp)) != 0 || 3581 (r = cipher_init(&ciphercontext, cipher, key, keylen, 3582 key + keylen, ivlen, 0)) != 0) 3583 goto out; 3584 if ((r = cipher_crypt(ciphercontext, 0, dp, sshbuf_ptr(decoded), 3585 encrypted_len, 0, authlen)) != 0) { 3586 /* an integrity error here indicates an incorrect passphrase */ 3587 if (r == SSH_ERR_MAC_INVALID) 3588 r = SSH_ERR_KEY_WRONG_PASSPHRASE; 3589 goto out; 3590 } 3591 if ((r = sshbuf_consume(decoded, encrypted_len + authlen)) != 0) 3592 goto out; 3593 /* there should be no trailing data */ 3594 if (sshbuf_len(decoded) != 0) { 3595 r = SSH_ERR_INVALID_FORMAT; 3596 goto out; 3597 } 3598 3599 /* check check bytes */ 3600 if ((r = sshbuf_get_u32(decrypted, &check1)) != 0 || 3601 (r = sshbuf_get_u32(decrypted, &check2)) != 0) 3602 goto out; 3603 if (check1 != check2) { 3604 r = SSH_ERR_KEY_WRONG_PASSPHRASE; 3605 goto out; 3606 } 3607 3608 /* Load the private key and comment */ 3609 if ((r = sshkey_private_deserialize(decrypted, &k)) != 0 || 3610 (r = sshbuf_get_cstring(decrypted, &comment, NULL)) != 0) 3611 goto out; 3612 3613 /* Check deterministic padding */ 3614 i = 0; 3615 while (sshbuf_len(decrypted)) { 3616 if ((r = sshbuf_get_u8(decrypted, &pad)) != 0) 3617 goto out; 3618 if (pad != (++i & 0xff)) { 3619 r = SSH_ERR_INVALID_FORMAT; 3620 goto out; 3621 } 3622 } 3623 3624 /* XXX decode pubkey and check against private */ 3625 3626 /* success */ 3627 r = 0; 3628 if (keyp != NULL) { 3629 *keyp = k; 3630 k = NULL; 3631 } 3632 if (commentp != NULL) { 3633 *commentp = comment; 3634 comment = NULL; 3635 } 3636 out: 3637 pad = 0; 3638 cipher_free(ciphercontext); 3639 free(ciphername); 3640 free(kdfname); 3641 free(comment); 3642 if (salt != NULL) { 3643 explicit_bzero(salt, slen); 3644 free(salt); 3645 } 3646 if (key != NULL) { 3647 explicit_bzero(key, keylen + ivlen); 3648 free(key); 3649 } 3650 sshbuf_free(encoded); 3651 sshbuf_free(decoded); 3652 sshbuf_free(kdf); 3653 sshbuf_free(decrypted); 3654 sshkey_free(k); 3655 return r; 3656 } 3657 3658 3659 #ifdef WITH_OPENSSL 3660 /* convert SSH v2 key in OpenSSL PEM format */ 3661 static int 3662 sshkey_private_pem_to_blob(struct sshkey *key, struct sshbuf *blob, 3663 const char *_passphrase, const char *comment) 3664 { 3665 int success, r; 3666 int blen, len = strlen(_passphrase); 3667 u_char *passphrase = (len > 0) ? (u_char *)_passphrase : NULL; 3668 const EVP_CIPHER *cipher = (len > 0) ? EVP_aes_128_cbc() : NULL; 3669 char *bptr; 3670 BIO *bio = NULL; 3671 3672 if (len > 0 && len <= 4) 3673 return SSH_ERR_PASSPHRASE_TOO_SHORT; 3674 if ((bio = BIO_new(BIO_s_mem())) == NULL) 3675 return SSH_ERR_ALLOC_FAIL; 3676 3677 switch (key->type) { 3678 case KEY_DSA: 3679 success = PEM_write_bio_DSAPrivateKey(bio, key->dsa, 3680 cipher, passphrase, len, NULL, NULL); 3681 break; 3682 case KEY_ECDSA: 3683 success = PEM_write_bio_ECPrivateKey(bio, key->ecdsa, 3684 cipher, passphrase, len, NULL, NULL); 3685 break; 3686 case KEY_RSA: 3687 success = PEM_write_bio_RSAPrivateKey(bio, key->rsa, 3688 cipher, passphrase, len, NULL, NULL); 3689 break; 3690 default: 3691 success = 0; 3692 break; 3693 } 3694 if (success == 0) { 3695 r = SSH_ERR_LIBCRYPTO_ERROR; 3696 goto out; 3697 } 3698 if ((blen = BIO_get_mem_data(bio, &bptr)) <= 0) { 3699 r = SSH_ERR_INTERNAL_ERROR; 3700 goto out; 3701 } 3702 if ((r = sshbuf_put(blob, bptr, blen)) != 0) 3703 goto out; 3704 r = 0; 3705 out: 3706 BIO_free(bio); 3707 return r; 3708 } 3709 #endif /* WITH_OPENSSL */ 3710 3711 /* Serialise "key" to buffer "blob" */ 3712 int 3713 sshkey_private_to_fileblob(struct sshkey *key, struct sshbuf *blob, 3714 const char *passphrase, const char *comment, 3715 int force_new_format, const char *new_format_cipher, int new_format_rounds) 3716 { 3717 switch (key->type) { 3718 #ifdef WITH_OPENSSL 3719 case KEY_DSA: 3720 case KEY_ECDSA: 3721 case KEY_RSA: 3722 if (force_new_format) { 3723 return sshkey_private_to_blob2(key, blob, passphrase, 3724 comment, new_format_cipher, new_format_rounds); 3725 } 3726 return sshkey_private_pem_to_blob(key, blob, 3727 passphrase, comment); 3728 #endif /* WITH_OPENSSL */ 3729 case KEY_ED25519: 3730 #ifdef WITH_XMSS 3731 case KEY_XMSS: 3732 #endif /* WITH_XMSS */ 3733 return sshkey_private_to_blob2(key, blob, passphrase, 3734 comment, new_format_cipher, new_format_rounds); 3735 default: 3736 return SSH_ERR_KEY_TYPE_UNKNOWN; 3737 } 3738 } 3739 3740 3741 #ifdef WITH_OPENSSL 3742 static int 3743 translate_libcrypto_error(unsigned long pem_err) 3744 { 3745 int pem_reason = ERR_GET_REASON(pem_err); 3746 3747 switch (ERR_GET_LIB(pem_err)) { 3748 case ERR_LIB_PEM: 3749 switch (pem_reason) { 3750 case PEM_R_BAD_PASSWORD_READ: 3751 case PEM_R_PROBLEMS_GETTING_PASSWORD: 3752 case PEM_R_BAD_DECRYPT: 3753 return SSH_ERR_KEY_WRONG_PASSPHRASE; 3754 default: 3755 return SSH_ERR_INVALID_FORMAT; 3756 } 3757 case ERR_LIB_EVP: 3758 switch (pem_reason) { 3759 case EVP_R_BAD_DECRYPT: 3760 return SSH_ERR_KEY_WRONG_PASSPHRASE; 3761 #ifdef EVP_R_BN_DECODE_ERROR 3762 case EVP_R_BN_DECODE_ERROR: 3763 #endif 3764 case EVP_R_DECODE_ERROR: 3765 #ifdef EVP_R_PRIVATE_KEY_DECODE_ERROR 3766 case EVP_R_PRIVATE_KEY_DECODE_ERROR: 3767 #endif 3768 return SSH_ERR_INVALID_FORMAT; 3769 default: 3770 return SSH_ERR_LIBCRYPTO_ERROR; 3771 } 3772 case ERR_LIB_ASN1: 3773 return SSH_ERR_INVALID_FORMAT; 3774 } 3775 return SSH_ERR_LIBCRYPTO_ERROR; 3776 } 3777 3778 static void 3779 clear_libcrypto_errors(void) 3780 { 3781 while (ERR_get_error() != 0) 3782 ; 3783 } 3784 3785 /* 3786 * Translate OpenSSL error codes to determine whether 3787 * passphrase is required/incorrect. 3788 */ 3789 static int 3790 convert_libcrypto_error(void) 3791 { 3792 /* 3793 * Some password errors are reported at the beginning 3794 * of the error queue. 3795 */ 3796 if (translate_libcrypto_error(ERR_peek_error()) == 3797 SSH_ERR_KEY_WRONG_PASSPHRASE) 3798 return SSH_ERR_KEY_WRONG_PASSPHRASE; 3799 return translate_libcrypto_error(ERR_peek_last_error()); 3800 } 3801 3802 static int 3803 sshkey_parse_private_pem_fileblob(struct sshbuf *blob, int type, 3804 const char *passphrase, struct sshkey **keyp) 3805 { 3806 EVP_PKEY *pk = NULL; 3807 struct sshkey *prv = NULL; 3808 BIO *bio = NULL; 3809 int r; 3810 3811 if (keyp != NULL) 3812 *keyp = NULL; 3813 3814 if ((bio = BIO_new(BIO_s_mem())) == NULL || sshbuf_len(blob) > INT_MAX) 3815 return SSH_ERR_ALLOC_FAIL; 3816 if (BIO_write(bio, sshbuf_ptr(blob), sshbuf_len(blob)) != 3817 (int)sshbuf_len(blob)) { 3818 r = SSH_ERR_ALLOC_FAIL; 3819 goto out; 3820 } 3821 3822 clear_libcrypto_errors(); 3823 if ((pk = PEM_read_bio_PrivateKey(bio, NULL, NULL, 3824 (char *)passphrase)) == NULL) { 3825 /* 3826 * libcrypto may return various ASN.1 errors when attempting 3827 * to parse a key with an incorrect passphrase. 3828 * Treat all format errors as "incorrect passphrase" if a 3829 * passphrase was supplied. 3830 */ 3831 if (passphrase != NULL && *passphrase != '\0') 3832 r = SSH_ERR_KEY_WRONG_PASSPHRASE; 3833 else 3834 r = convert_libcrypto_error(); 3835 goto out; 3836 } 3837 if (EVP_PKEY_base_id(pk) == EVP_PKEY_RSA && 3838 (type == KEY_UNSPEC || type == KEY_RSA)) { 3839 if ((prv = sshkey_new(KEY_UNSPEC)) == NULL) { 3840 r = SSH_ERR_ALLOC_FAIL; 3841 goto out; 3842 } 3843 prv->rsa = EVP_PKEY_get1_RSA(pk); 3844 prv->type = KEY_RSA; 3845 #ifdef DEBUG_PK 3846 RSA_print_fp(stderr, prv->rsa, 8); 3847 #endif 3848 if (RSA_blinding_on(prv->rsa, NULL) != 1) { 3849 r = SSH_ERR_LIBCRYPTO_ERROR; 3850 goto out; 3851 } 3852 if ((r = check_rsa_length(prv->rsa)) != 0) 3853 goto out; 3854 } else if (EVP_PKEY_base_id(pk) == EVP_PKEY_DSA && 3855 (type == KEY_UNSPEC || type == KEY_DSA)) { 3856 if ((prv = sshkey_new(KEY_UNSPEC)) == NULL) { 3857 r = SSH_ERR_ALLOC_FAIL; 3858 goto out; 3859 } 3860 prv->dsa = EVP_PKEY_get1_DSA(pk); 3861 prv->type = KEY_DSA; 3862 #ifdef DEBUG_PK 3863 DSA_print_fp(stderr, prv->dsa, 8); 3864 #endif 3865 } else if (EVP_PKEY_base_id(pk) == EVP_PKEY_EC && 3866 (type == KEY_UNSPEC || type == KEY_ECDSA)) { 3867 if ((prv = sshkey_new(KEY_UNSPEC)) == NULL) { 3868 r = SSH_ERR_ALLOC_FAIL; 3869 goto out; 3870 } 3871 prv->ecdsa = EVP_PKEY_get1_EC_KEY(pk); 3872 prv->type = KEY_ECDSA; 3873 prv->ecdsa_nid = sshkey_ecdsa_key_to_nid(prv->ecdsa); 3874 if (prv->ecdsa_nid == -1 || 3875 sshkey_curve_nid_to_name(prv->ecdsa_nid) == NULL || 3876 sshkey_ec_validate_public(EC_KEY_get0_group(prv->ecdsa), 3877 EC_KEY_get0_public_key(prv->ecdsa)) != 0 || 3878 sshkey_ec_validate_private(prv->ecdsa) != 0) { 3879 r = SSH_ERR_INVALID_FORMAT; 3880 goto out; 3881 } 3882 #ifdef DEBUG_PK 3883 if (prv != NULL && prv->ecdsa != NULL) 3884 sshkey_dump_ec_key(prv->ecdsa); 3885 #endif 3886 } else { 3887 r = SSH_ERR_INVALID_FORMAT; 3888 goto out; 3889 } 3890 r = 0; 3891 if (keyp != NULL) { 3892 *keyp = prv; 3893 prv = NULL; 3894 } 3895 out: 3896 BIO_free(bio); 3897 EVP_PKEY_free(pk); 3898 sshkey_free(prv); 3899 return r; 3900 } 3901 #endif /* WITH_OPENSSL */ 3902 3903 int 3904 sshkey_parse_private_fileblob_type(struct sshbuf *blob, int type, 3905 const char *passphrase, struct sshkey **keyp, char **commentp) 3906 { 3907 int r = SSH_ERR_INTERNAL_ERROR; 3908 3909 if (keyp != NULL) 3910 *keyp = NULL; 3911 if (commentp != NULL) 3912 *commentp = NULL; 3913 3914 switch (type) { 3915 #ifdef WITH_OPENSSL 3916 case KEY_DSA: 3917 case KEY_ECDSA: 3918 case KEY_RSA: 3919 return sshkey_parse_private_pem_fileblob(blob, type, 3920 passphrase, keyp); 3921 #endif /* WITH_OPENSSL */ 3922 case KEY_ED25519: 3923 #ifdef WITH_XMSS 3924 case KEY_XMSS: 3925 #endif /* WITH_XMSS */ 3926 return sshkey_parse_private2(blob, type, passphrase, 3927 keyp, commentp); 3928 case KEY_UNSPEC: 3929 r = sshkey_parse_private2(blob, type, passphrase, keyp, 3930 commentp); 3931 /* Do not fallback to PEM parser if only passphrase is wrong. */ 3932 if (r == 0 || r == SSH_ERR_KEY_WRONG_PASSPHRASE) 3933 return r; 3934 #ifdef WITH_OPENSSL 3935 return sshkey_parse_private_pem_fileblob(blob, type, 3936 passphrase, keyp); 3937 #else 3938 return SSH_ERR_INVALID_FORMAT; 3939 #endif /* WITH_OPENSSL */ 3940 default: 3941 return SSH_ERR_KEY_TYPE_UNKNOWN; 3942 } 3943 } 3944 3945 int 3946 sshkey_parse_private_fileblob(struct sshbuf *buffer, const char *passphrase, 3947 struct sshkey **keyp, char **commentp) 3948 { 3949 if (keyp != NULL) 3950 *keyp = NULL; 3951 if (commentp != NULL) 3952 *commentp = NULL; 3953 3954 return sshkey_parse_private_fileblob_type(buffer, KEY_UNSPEC, 3955 passphrase, keyp, commentp); 3956 } 3957 3958 #ifdef WITH_XMSS 3959 /* 3960 * serialize the key with the current state and forward the state 3961 * maxsign times. 3962 */ 3963 int 3964 sshkey_private_serialize_maxsign(const struct sshkey *k, struct sshbuf *b, 3965 u_int32_t maxsign, sshkey_printfn *pr) 3966 { 3967 int r, rupdate; 3968 3969 if (maxsign == 0 || 3970 sshkey_type_plain(k->type) != KEY_XMSS) 3971 return sshkey_private_serialize_opt(k, b, 3972 SSHKEY_SERIALIZE_DEFAULT); 3973 if ((r = sshkey_xmss_get_state(k, pr)) != 0 || 3974 (r = sshkey_private_serialize_opt(k, b, 3975 SSHKEY_SERIALIZE_STATE)) != 0 || 3976 (r = sshkey_xmss_forward_state(k, maxsign)) != 0) 3977 goto out; 3978 r = 0; 3979 out: 3980 if ((rupdate = sshkey_xmss_update_state(k, pr)) != 0) { 3981 if (r == 0) 3982 r = rupdate; 3983 } 3984 return r; 3985 } 3986 3987 u_int32_t 3988 sshkey_signatures_left(const struct sshkey *k) 3989 { 3990 if (sshkey_type_plain(k->type) == KEY_XMSS) 3991 return sshkey_xmss_signatures_left(k); 3992 return 0; 3993 } 3994 3995 int 3996 sshkey_enable_maxsign(struct sshkey *k, u_int32_t maxsign) 3997 { 3998 if (sshkey_type_plain(k->type) != KEY_XMSS) 3999 return SSH_ERR_INVALID_ARGUMENT; 4000 return sshkey_xmss_enable_maxsign(k, maxsign); 4001 } 4002 4003 int 4004 sshkey_set_filename(struct sshkey *k, const char *filename) 4005 { 4006 if (k == NULL) 4007 return SSH_ERR_INVALID_ARGUMENT; 4008 if (sshkey_type_plain(k->type) != KEY_XMSS) 4009 return 0; 4010 if (filename == NULL) 4011 return SSH_ERR_INVALID_ARGUMENT; 4012 if ((k->xmss_filename = strdup(filename)) == NULL) 4013 return SSH_ERR_ALLOC_FAIL; 4014 return 0; 4015 } 4016 #else 4017 int 4018 sshkey_private_serialize_maxsign(const struct sshkey *k, struct sshbuf *b, 4019 u_int32_t maxsign, sshkey_printfn *pr) 4020 { 4021 return sshkey_private_serialize_opt(k, b, SSHKEY_SERIALIZE_DEFAULT); 4022 } 4023 4024 u_int32_t 4025 sshkey_signatures_left(const struct sshkey *k) 4026 { 4027 return 0; 4028 } 4029 4030 int 4031 sshkey_enable_maxsign(struct sshkey *k, u_int32_t maxsign) 4032 { 4033 return SSH_ERR_INVALID_ARGUMENT; 4034 } 4035 4036 int 4037 sshkey_set_filename(struct sshkey *k, const char *filename) 4038 { 4039 if (k == NULL) 4040 return SSH_ERR_INVALID_ARGUMENT; 4041 return 0; 4042 } 4043 #endif /* WITH_XMSS */ 4044