sshkey.c

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