[BACK]Return to ssh-keygen.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/ssh-keygen.c between version 1.420 and 1.430

version 1.420, 2020/09/09 03:08:01 version 1.430, 2021/07/05 01:16:46
Line 26 
Line 26 
 #include <fcntl.h>  #include <fcntl.h>
 #include <netdb.h>  #include <netdb.h>
 #include <pwd.h>  #include <pwd.h>
   #include <stdarg.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #include <stdarg.h>  
 #include <unistd.h>  #include <unistd.h>
 #include <limits.h>  #include <limits.h>
 #include <locale.h>  #include <locale.h>
Line 55 
Line 55 
 #include "sshsig.h"  #include "sshsig.h"
 #include "ssh-sk.h"  #include "ssh-sk.h"
 #include "sk-api.h" /* XXX for SSH_SK_USER_PRESENCE_REQD; remove */  #include "sk-api.h" /* XXX for SSH_SK_USER_PRESENCE_REQD; remove */
   #include "cipher.h"
   
 #ifdef ENABLE_PKCS11  #ifdef ENABLE_PKCS11
 #include "ssh-pkcs11.h"  #include "ssh-pkcs11.h"
Line 178 
Line 179 
                 fatal("unknown key type %s", key_type_name);                  fatal("unknown key type %s", key_type_name);
         if (*bitsp == 0) {          if (*bitsp == 0) {
 #ifdef WITH_OPENSSL  #ifdef WITH_OPENSSL
                 u_int nid;                  int nid;
   
                 switch(type) {                  switch(type) {
                 case KEY_DSA:                  case KEY_DSA:
Line 309 
Line 310 
         if ((r = sshkey_load_private(filename, "", &prv, commentp)) == 0)          if ((r = sshkey_load_private(filename, "", &prv, commentp)) == 0)
                 return prv;                  return prv;
         if (r != SSH_ERR_KEY_WRONG_PASSPHRASE)          if (r != SSH_ERR_KEY_WRONG_PASSPHRASE)
                 fatal("Load key \"%s\": %s", filename, ssh_err(r));                  fatal_r(r, "Load key \"%s\"", filename);
         if (identity_passphrase)          if (identity_passphrase)
                 pass = xstrdup(identity_passphrase);                  pass = xstrdup(identity_passphrase);
         else          else
Line 317 
Line 318 
         r = sshkey_load_private(filename, pass, &prv, commentp);          r = sshkey_load_private(filename, pass, &prv, commentp);
         freezero(pass, strlen(pass));          freezero(pass, strlen(pass));
         if (r != 0)          if (r != 0)
                 fatal("Load key \"%s\": %s", filename, ssh_err(r));                  fatal_r(r, "Load key \"%s\"", filename);
         return prv;          return prv;
 }  }
   
Line 335 
Line 336 
         int r;          int r;
   
         if ((b = sshbuf_new()) == NULL)          if ((b = sshbuf_new()) == NULL)
                 fatal("%s: sshbuf_new failed", __func__);                  fatal_f("sshbuf_new failed");
         if ((r = sshkey_putb(k, b)) != 0)          if ((r = sshkey_putb(k, b)) != 0)
                 fatal("key_to_blob failed: %s", ssh_err(r));                  fatal_fr(r, "put key");
         if ((b64 = sshbuf_dtob64_string(b, 1)) == NULL)          if ((b64 = sshbuf_dtob64_string(b, 1)) == NULL)
                 fatal("%s: sshbuf_dtob64_string failed", __func__);                  fatal_f("sshbuf_dtob64_string failed");
   
         /* Comment + surrounds must fit into 72 chars (RFC 4716 sec 3.3) */          /* Comment + surrounds must fit into 72 chars (RFC 4716 sec 3.3) */
         snprintf(comment, sizeof(comment),          snprintf(comment, sizeof(comment),
Line 374 
Line 375 
                         fatal("PEM_write_EC_PUBKEY failed");                          fatal("PEM_write_EC_PUBKEY failed");
                 break;                  break;
         default:          default:
                 fatal("%s: unsupported key type %s", __func__, sshkey_type(k));                  fatal_f("unsupported key type %s", sshkey_type(k));
         }          }
         exit(0);          exit(0);
 }  }
Line 396 
Line 397 
                         fatal("PEM_write_EC_PUBKEY failed");                          fatal("PEM_write_EC_PUBKEY failed");
                 break;                  break;
         default:          default:
                 fatal("%s: unsupported key type %s", __func__, sshkey_type(k));                  fatal_f("unsupported key type %s", sshkey_type(k));
         }          }
         exit(0);          exit(0);
 }  }
Line 425 
Line 426 
                 do_convert_to_pem(k);                  do_convert_to_pem(k);
                 break;                  break;
         default:          default:
                 fatal("%s: unknown key format %d", __func__, convert_format);                  fatal_f("unknown key format %d", convert_format);
         }          }
         exit(0);          exit(0);
 }  }
Line 441 
Line 442 
         int r;          int r;
   
         if ((r = sshbuf_get_u32(b, &bignum_bits)) != 0)          if ((r = sshbuf_get_u32(b, &bignum_bits)) != 0)
                 fatal("%s: buffer error: %s", __func__, ssh_err(r));                  fatal_fr(r, "parse");
         bytes = (bignum_bits + 7) / 8;          bytes = (bignum_bits + 7) / 8;
         if (sshbuf_len(b) < bytes)          if (sshbuf_len(b) < bytes)
                 fatal("%s: input buffer too small: need %d have %zu",                  fatal_f("input buffer too small: need %d have %zu",
                     __func__, bytes, sshbuf_len(b));                      bytes, sshbuf_len(b));
         if (BN_bin2bn(sshbuf_ptr(b), bytes, value) == NULL)          if (BN_bin2bn(sshbuf_ptr(b), bytes, value) == NULL)
                 fatal("%s: BN_bin2bn failed", __func__);                  fatal_f("BN_bin2bn failed");
         if ((r = sshbuf_consume(b, bytes)) != 0)          if ((r = sshbuf_consume(b, bytes)) != 0)
                 fatal("%s: buffer error: %s", __func__, ssh_err(r));                  fatal_fr(r, "consume");
 }  }
   
 static struct sshkey *  static struct sshkey *
Line 468 
Line 469 
         BIGNUM *rsa_p = NULL, *rsa_q = NULL, *rsa_iqmp = NULL;          BIGNUM *rsa_p = NULL, *rsa_q = NULL, *rsa_iqmp = NULL;
   
         if ((r = sshbuf_get_u32(b, &magic)) != 0)          if ((r = sshbuf_get_u32(b, &magic)) != 0)
                 fatal("%s: buffer error: %s", __func__, ssh_err(r));                  fatal_fr(r, "parse magic");
   
         if (magic != SSH_COM_PRIVATE_KEY_MAGIC) {          if (magic != SSH_COM_PRIVATE_KEY_MAGIC) {
                 error("bad magic 0x%x != 0x%x", magic,                  error("bad magic 0x%x != 0x%x", magic,
Line 481 
Line 482 
             (r = sshbuf_get_u32(b, &i2)) != 0 ||              (r = sshbuf_get_u32(b, &i2)) != 0 ||
             (r = sshbuf_get_u32(b, &i3)) != 0 ||              (r = sshbuf_get_u32(b, &i3)) != 0 ||
             (r = sshbuf_get_u32(b, &i4)) != 0)              (r = sshbuf_get_u32(b, &i4)) != 0)
                 fatal("%s: buffer error: %s", __func__, ssh_err(r));                  fatal_fr(r, "parse");
         debug("ignore (%d %d %d %d)", i1, i2, i3, i4);          debug("ignore (%d %d %d %d)", i1, i2, i3, i4);
         if (strcmp(cipher, "none") != 0) {          if (strcmp(cipher, "none") != 0) {
                 error("unsupported cipher %s", cipher);                  error("unsupported cipher %s", cipher);
Line 510 
Line 511 
                     (dsa_g = BN_new()) == NULL ||                      (dsa_g = BN_new()) == NULL ||
                     (dsa_pub_key = BN_new()) == NULL ||                      (dsa_pub_key = BN_new()) == NULL ||
                     (dsa_priv_key = BN_new()) == NULL)                      (dsa_priv_key = BN_new()) == NULL)
                         fatal("%s: BN_new", __func__);                          fatal_f("BN_new");
                 buffer_get_bignum_bits(b, dsa_p);                  buffer_get_bignum_bits(b, dsa_p);
                 buffer_get_bignum_bits(b, dsa_g);                  buffer_get_bignum_bits(b, dsa_g);
                 buffer_get_bignum_bits(b, dsa_q);                  buffer_get_bignum_bits(b, dsa_q);
                 buffer_get_bignum_bits(b, dsa_pub_key);                  buffer_get_bignum_bits(b, dsa_pub_key);
                 buffer_get_bignum_bits(b, dsa_priv_key);                  buffer_get_bignum_bits(b, dsa_priv_key);
                 if (!DSA_set0_pqg(key->dsa, dsa_p, dsa_q, dsa_g))                  if (!DSA_set0_pqg(key->dsa, dsa_p, dsa_q, dsa_g))
                         fatal("%s: DSA_set0_pqg failed", __func__);                          fatal_f("DSA_set0_pqg failed");
                 dsa_p = dsa_q = dsa_g = NULL; /* transferred */                  dsa_p = dsa_q = dsa_g = NULL; /* transferred */
                 if (!DSA_set0_key(key->dsa, dsa_pub_key, dsa_priv_key))                  if (!DSA_set0_key(key->dsa, dsa_pub_key, dsa_priv_key))
                         fatal("%s: DSA_set0_key failed", __func__);                          fatal_f("DSA_set0_key failed");
                 dsa_pub_key = dsa_priv_key = NULL; /* transferred */                  dsa_pub_key = dsa_priv_key = NULL; /* transferred */
                 break;                  break;
         case KEY_RSA:          case KEY_RSA:
                 if ((r = sshbuf_get_u8(b, &e1)) != 0 ||                  if ((r = sshbuf_get_u8(b, &e1)) != 0 ||
                     (e1 < 30 && (r = sshbuf_get_u8(b, &e2)) != 0) ||                      (e1 < 30 && (r = sshbuf_get_u8(b, &e2)) != 0) ||
                     (e1 < 30 && (r = sshbuf_get_u8(b, &e3)) != 0))                      (e1 < 30 && (r = sshbuf_get_u8(b, &e3)) != 0))
                         fatal("%s: buffer error: %s", __func__, ssh_err(r));                          fatal_fr(r, "parse RSA");
                 e = e1;                  e = e1;
                 debug("e %lx", e);                  debug("e %lx", e);
                 if (e < 30) {                  if (e < 30) {
Line 539 
Line 540 
                         debug("e %lx", e);                          debug("e %lx", e);
                 }                  }
                 if ((rsa_e = BN_new()) == NULL)                  if ((rsa_e = BN_new()) == NULL)
                         fatal("%s: BN_new", __func__);                          fatal_f("BN_new");
                 if (!BN_set_word(rsa_e, e)) {                  if (!BN_set_word(rsa_e, e)) {
                         BN_clear_free(rsa_e);                          BN_clear_free(rsa_e);
                         sshkey_free(key);                          sshkey_free(key);
Line 550 
Line 551 
                     (rsa_p = BN_new()) == NULL ||                      (rsa_p = BN_new()) == NULL ||
                     (rsa_q = BN_new()) == NULL ||                      (rsa_q = BN_new()) == NULL ||
                     (rsa_iqmp = BN_new()) == NULL)                      (rsa_iqmp = BN_new()) == NULL)
                         fatal("%s: BN_new", __func__);                          fatal_f("BN_new");
                 buffer_get_bignum_bits(b, rsa_d);                  buffer_get_bignum_bits(b, rsa_d);
                 buffer_get_bignum_bits(b, rsa_n);                  buffer_get_bignum_bits(b, rsa_n);
                 buffer_get_bignum_bits(b, rsa_iqmp);                  buffer_get_bignum_bits(b, rsa_iqmp);
                 buffer_get_bignum_bits(b, rsa_q);                  buffer_get_bignum_bits(b, rsa_q);
                 buffer_get_bignum_bits(b, rsa_p);                  buffer_get_bignum_bits(b, rsa_p);
                 if (!RSA_set0_key(key->rsa, rsa_n, rsa_e, rsa_d))                  if (!RSA_set0_key(key->rsa, rsa_n, rsa_e, rsa_d))
                         fatal("%s: RSA_set0_key failed", __func__);                          fatal_f("RSA_set0_key failed");
                 rsa_n = rsa_e = rsa_d = NULL; /* transferred */                  rsa_n = rsa_e = rsa_d = NULL; /* transferred */
                 if (!RSA_set0_factors(key->rsa, rsa_p, rsa_q))                  if (!RSA_set0_factors(key->rsa, rsa_p, rsa_q))
                         fatal("%s: RSA_set0_factors failed", __func__);                          fatal_f("RSA_set0_factors failed");
                 rsa_p = rsa_q = NULL; /* transferred */                  rsa_p = rsa_q = NULL; /* transferred */
                 if ((r = ssh_rsa_complete_crt_parameters(key, rsa_iqmp)) != 0)                  if ((r = ssh_rsa_complete_crt_parameters(key, rsa_iqmp)) != 0)
                         fatal("generate RSA parameters failed: %s", ssh_err(r));                          fatal_fr(r, "generate RSA parameters");
                 BN_clear_free(rsa_iqmp);                  BN_clear_free(rsa_iqmp);
                 break;                  break;
         }          }
         rlen = sshbuf_len(b);          rlen = sshbuf_len(b);
         if (rlen != 0)          if (rlen != 0)
                 error("%s: remaining bytes in key blob %d", __func__, rlen);                  error_f("remaining bytes in key blob %d", rlen);
   
         /* try the key */          /* try the key */
         if (sshkey_sign(key, &sig, &slen, data, sizeof(data),          if (sshkey_sign(key, &sig, &slen, data, sizeof(data),
Line 652 
Line 653 
             (encoded[len-3] == '='))              (encoded[len-3] == '='))
                 encoded[len-3] = '\0';                  encoded[len-3] = '\0';
         if ((r = sshbuf_b64tod(buf, encoded)) != 0)          if ((r = sshbuf_b64tod(buf, encoded)) != 0)
                 fatal("%s: base64 decoding failed: %s", __func__, ssh_err(r));                  fatal_fr(r, "base64 decode");
         if (*private) {          if (*private) {
                 if ((*k = do_convert_private_ssh2(buf)) == NULL)                  if ((*k = do_convert_private_ssh2(buf)) == NULL)
                         fatal("%s: private key conversion failed", __func__);                          fatal_f("private key conversion failed");
         } else if ((r = sshkey_fromb(buf, k)) != 0)          } else if ((r = sshkey_fromb(buf, k)) != 0)
                 fatal("decode blob failed: %s", ssh_err(r));                  fatal_fr(r, "parse key");
         sshbuf_free(buf);          sshbuf_free(buf);
         fclose(fp);          fclose(fp);
 }  }
Line 671 
Line 672 
         if ((fp = fopen(identity_file, "r")) == NULL)          if ((fp = fopen(identity_file, "r")) == NULL)
                 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));                  fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
         if ((pubkey = PEM_read_PUBKEY(fp, NULL, NULL, NULL)) == NULL) {          if ((pubkey = PEM_read_PUBKEY(fp, NULL, NULL, NULL)) == NULL) {
                 fatal("%s: %s is not a recognised public key format", __func__,                  fatal_f("%s is not a recognised public key format",
                     identity_file);                      identity_file);
         }          }
         fclose(fp);          fclose(fp);
Line 696 
Line 697 
                 (*k)->ecdsa_nid = sshkey_ecdsa_key_to_nid((*k)->ecdsa);                  (*k)->ecdsa_nid = sshkey_ecdsa_key_to_nid((*k)->ecdsa);
                 break;                  break;
         default:          default:
                 fatal("%s: unsupported pubkey type %d", __func__,                  fatal_f("unsupported pubkey type %d",
                     EVP_PKEY_base_id(pubkey));                      EVP_PKEY_base_id(pubkey));
         }          }
         EVP_PKEY_free(pubkey);          EVP_PKEY_free(pubkey);
Line 719 
Line 720 
                 fclose(fp);                  fclose(fp);
                 return;                  return;
         }          }
         fatal("%s: unrecognised raw private key format", __func__);          fatal_f("unrecognised raw private key format");
 }  }
   
 static void  static void
Line 745 
Line 746 
                 do_convert_from_pem(&k, &private);                  do_convert_from_pem(&k, &private);
                 break;                  break;
         default:          default:
                 fatal("%s: unknown key format %d", __func__, convert_format);                  fatal_f("unknown key format %d", convert_format);
         }          }
   
         if (!private) {          if (!private) {
Line 768 
Line 769 
                             NULL, 0, NULL, NULL);                              NULL, 0, NULL, NULL);
                         break;                          break;
                 default:                  default:
                         fatal("%s: unsupported key type %s", __func__,                          fatal_f("unsupported key type %s", sshkey_type(k));
                             sshkey_type(k));  
                 }                  }
         }          }
   
Line 794 
Line 794 
                 fatal("%s: %s", identity_file, strerror(errno));                  fatal("%s: %s", identity_file, strerror(errno));
         prv = load_identity(identity_file, &comment);          prv = load_identity(identity_file, &comment);
         if ((r = sshkey_write(prv, stdout)) != 0)          if ((r = sshkey_write(prv, stdout)) != 0)
                 error("sshkey_write failed: %s", ssh_err(r));                  fatal_fr(r, "write key");
         if (comment != NULL && *comment != '\0')          if (comment != NULL && *comment != '\0')
                 fprintf(stdout, " %s", comment);                  fprintf(stdout, " %s", comment);
         fprintf(stdout, "\n");          fprintf(stdout, "\n");
Line 830 
Line 830 
                         ra = sshkey_fingerprint(keys[i], fingerprint_hash,                          ra = sshkey_fingerprint(keys[i], fingerprint_hash,
                             SSH_FP_RANDOMART);                              SSH_FP_RANDOMART);
                         if (fp == NULL || ra == NULL)                          if (fp == NULL || ra == NULL)
                                 fatal("%s: sshkey_fingerprint fail", __func__);                                  fatal_f("sshkey_fingerprint fail");
                         printf("%u %s %s (PKCS11 key)\n", sshkey_size(keys[i]),                          printf("%u %s %s (PKCS11 key)\n", sshkey_size(keys[i]),
                             fp, sshkey_type(keys[i]));                              fp, sshkey_type(keys[i]));
                         if (log_level_get() >= SYSLOG_LEVEL_VERBOSE)                          if (log_level_get() >= SYSLOG_LEVEL_VERBOSE)
Line 881 
Line 881 
         fp = sshkey_fingerprint(public, fptype, rep);          fp = sshkey_fingerprint(public, fptype, rep);
         ra = sshkey_fingerprint(public, fingerprint_hash, SSH_FP_RANDOMART);          ra = sshkey_fingerprint(public, fingerprint_hash, SSH_FP_RANDOMART);
         if (fp == NULL || ra == NULL)          if (fp == NULL || ra == NULL)
                 fatal("%s: sshkey_fingerprint failed", __func__);                  fatal_f("sshkey_fingerprint failed");
         mprintf("%u %s %s (%s)\n", sshkey_size(public), fp,          mprintf("%u %s %s (%s)\n", sshkey_size(public), fp,
             comment ? comment : "no comment", sshkey_type(public));              comment ? comment : "no comment", sshkey_type(public));
         if (log_level_get() >= SYSLOG_LEVEL_VERBOSE)          if (log_level_get() >= SYSLOG_LEVEL_VERBOSE)
Line 901 
Line 901 
         if (stat(identity_file, &st) == -1)          if (stat(identity_file, &st) == -1)
                 fatal("%s: %s", path, strerror(errno));                  fatal("%s: %s", path, strerror(errno));
         if ((r = sshkey_load_public(path, &pubkey, &comment)) != 0)          if ((r = sshkey_load_public(path, &pubkey, &comment)) != 0)
                 debug("load public \"%s\": %s", path, ssh_err(r));                  debug_r(r, "load public \"%s\"", path);
         if (pubkey == NULL || comment == NULL || *comment == '\0') {          if (pubkey == NULL || comment == NULL || *comment == '\0') {
                 free(comment);                  free(comment);
                 if ((r = sshkey_load_private(path, NULL,                  if ((r = sshkey_load_private(path, NULL,
                     &privkey, &comment)) != 0)                      &privkey, &comment)) != 0)
                         debug("load private \"%s\": %s", path, ssh_err(r));                          debug_r(r, "load private \"%s\"", path);
         }          }
         if (pubkey == NULL && privkey == NULL)          if (pubkey == NULL && privkey == NULL)
                 fatal("%s is not a key file.", path);                  fatal("%s is not a key file.", path);
Line 1084 
Line 1084 
                 bits = 0;                  bits = 0;
                 type_bits_valid(type, NULL, &bits);                  type_bits_valid(type, NULL, &bits);
                 if ((r = sshkey_generate(type, bits, &private)) != 0) {                  if ((r = sshkey_generate(type, bits, &private)) != 0) {
                         error("sshkey_generate failed: %s", ssh_err(r));                          error_r(r, "sshkey_generate failed");
                         goto failnext;                          goto failnext;
                 }                  }
                 if ((r = sshkey_from_private(private, &public)) != 0)                  if ((r = sshkey_from_private(private, &public)) != 0)
                         fatal("sshkey_from_private failed: %s", ssh_err(r));                          fatal_fr(r, "sshkey_from_private");
                 snprintf(comment, sizeof comment, "%s@%s", pw->pw_name,                  snprintf(comment, sizeof comment, "%s@%s", pw->pw_name,
                     hostname);                      hostname);
                 if ((r = sshkey_save_private(private, prv_tmp, "",                  if ((r = sshkey_save_private(private, prv_tmp, "",
                     comment, private_key_format, openssh_format_cipher,                      comment, private_key_format, openssh_format_cipher,
                     rounds)) != 0) {                      rounds)) != 0) {
                         error("Saving key \"%s\" failed: %s",                          error_r(r, "Saving key \"%s\" failed", prv_tmp);
                             prv_tmp, ssh_err(r));  
                         goto failnext;                          goto failnext;
                 }                  }
                 if ((fd = mkstemp(pub_tmp)) == -1) {                  if ((fd = mkstemp(pub_tmp)) == -1) {
Line 1106 
Line 1105 
                 (void)fchmod(fd, 0644);                  (void)fchmod(fd, 0644);
                 (void)close(fd);                  (void)close(fd);
                 if ((r = sshkey_save_public(public, pub_tmp, comment)) != 0) {                  if ((r = sshkey_save_public(public, pub_tmp, comment)) != 0) {
                         fatal("Unable to save public key to %s: %s",                          error_r(r, "Unable to save public key to %s",
                             identity_file, ssh_err(r));                              identity_file);
                         goto failnext;                          goto failnext;
                 }                  }
   
Line 1241 
Line 1240 
                                 ra = sshkey_fingerprint(l->key,                                  ra = sshkey_fingerprint(l->key,
                                     fingerprint_hash, SSH_FP_RANDOMART);                                      fingerprint_hash, SSH_FP_RANDOMART);
                                 if (fp == NULL || ra == NULL)                                  if (fp == NULL || ra == NULL)
                                         fatal("%s: sshkey_fingerprint failed",                                          fatal_f("sshkey_fingerprint failed");
                                             __func__);  
                                 mprintf("%s %s %s%s%s\n", ctx->host,                                  mprintf("%s %s %s%s%s\n", ctx->host,
                                     sshkey_type(l->key), fp,                                      sshkey_type(l->key), fp,
                                     l->comment[0] ? " " : "",                                      l->comment[0] ? " " : "",
Line 1320 
Line 1318 
         foreach_options |= print_fingerprint ? HKF_WANT_PARSE_KEY : 0;          foreach_options |= print_fingerprint ? HKF_WANT_PARSE_KEY : 0;
         if ((r = hostkeys_foreach(identity_file, (find_host || !hash_hosts) ?          if ((r = hostkeys_foreach(identity_file, (find_host || !hash_hosts) ?
             known_hosts_find_delete : known_hosts_hash, &ctx, name, NULL,              known_hosts_find_delete : known_hosts_hash, &ctx, name, NULL,
             foreach_options)) != 0) {              foreach_options, 0)) != 0) {
                 if (inplace)                  if (inplace)
                         unlink(tmp);                          unlink(tmp);
                 fatal("%s: hostkeys_foreach failed: %s", __func__, ssh_err(r));                  fatal_fr(r, "hostkeys_foreach");
         }          }
   
         if (inplace)          if (inplace)
Line 1402 
Line 1400 
                         goto badkey;                          goto badkey;
         } else if (r != 0) {          } else if (r != 0) {
  badkey:   badkey:
                 fatal("Failed to load key %s: %s", identity_file, ssh_err(r));                  fatal_r(r, "Failed to load key %s", identity_file);
         }          }
         if (comment)          if (comment)
                 mprintf("Key has comment '%s'\n", comment);                  mprintf("Key has comment '%s'\n", comment);
Line 1434 
Line 1432 
         /* Save the file using the new passphrase. */          /* Save the file using the new passphrase. */
         if ((r = sshkey_save_private(private, identity_file, passphrase1,          if ((r = sshkey_save_private(private, identity_file, passphrase1,
             comment, private_key_format, openssh_format_cipher, rounds)) != 0) {              comment, private_key_format, openssh_format_cipher, rounds)) != 0) {
                 error("Saving key \"%s\" failed: %s.",                  error_r(r, "Saving key \"%s\" failed", identity_file);
                     identity_file, ssh_err(r));  
                 freezero(passphrase1, strlen(passphrase1));                  freezero(passphrase1, strlen(passphrase1));
                 sshkey_free(private);                  sshkey_free(private);
                 free(comment);                  free(comment);
Line 1463 
Line 1460 
         int r;          int r;
   
         if (fname == NULL)          if (fname == NULL)
                 fatal("%s: no filename", __func__);                  fatal_f("no filename");
         if (stat(fname, &st) == -1) {          if (stat(fname, &st) == -1) {
                 if (errno == ENOENT)                  if (errno == ENOENT)
                         return 0;                          return 0;
                 fatal("%s: %s", fname, strerror(errno));                  fatal("%s: %s", fname, strerror(errno));
         }          }
         if ((r = sshkey_load_public(fname, &public, &comment)) != 0)          if ((r = sshkey_load_public(fname, &public, &comment)) != 0)
                 fatal("Failed to read v2 public key from \"%s\": %s.",                  fatal_r(r, "Failed to read v2 public key from \"%s\"", fname);
                     fname, ssh_err(r));  
         export_dns_rr(hname, public, stdout, print_generic);          export_dns_rr(hname, public, stdout, print_generic);
         sshkey_free(public);          sshkey_free(public);
         free(comment);          free(comment);
Line 1498 
Line 1494 
             &private, &comment)) == 0)              &private, &comment)) == 0)
                 passphrase = xstrdup("");                  passphrase = xstrdup("");
         else if (r != SSH_ERR_KEY_WRONG_PASSPHRASE)          else if (r != SSH_ERR_KEY_WRONG_PASSPHRASE)
                 fatal("Cannot load private key \"%s\": %s.",                  fatal_r(r, "Cannot load private key \"%s\"", identity_file);
                     identity_file, ssh_err(r));  
         else {          else {
                 if (identity_passphrase)                  if (identity_passphrase)
                         passphrase = xstrdup(identity_passphrase);                          passphrase = xstrdup(identity_passphrase);
Line 1512 
Line 1507 
                 if ((r = sshkey_load_private(identity_file, passphrase,                  if ((r = sshkey_load_private(identity_file, passphrase,
                     &private, &comment)) != 0) {                      &private, &comment)) != 0) {
                         freezero(passphrase, strlen(passphrase));                          freezero(passphrase, strlen(passphrase));
                         fatal("Cannot load private key \"%s\": %s.",                          fatal_r(r, "Cannot load private key \"%s\"",
                             identity_file, ssh_err(r));                              identity_file);
                 }                  }
         }          }
   
Line 1554 
Line 1549 
         if ((r = sshkey_save_private(private, identity_file, passphrase,          if ((r = sshkey_save_private(private, identity_file, passphrase,
             new_comment, private_key_format, openssh_format_cipher,              new_comment, private_key_format, openssh_format_cipher,
             rounds)) != 0) {              rounds)) != 0) {
                 error("Saving key \"%s\" failed: %s",                  error_r(r, "Saving key \"%s\" failed", identity_file);
                     identity_file, ssh_err(r));  
                 freezero(passphrase, strlen(passphrase));                  freezero(passphrase, strlen(passphrase));
                 sshkey_free(private);                  sshkey_free(private);
                 free(comment);                  free(comment);
Line 1563 
Line 1557 
         }          }
         freezero(passphrase, strlen(passphrase));          freezero(passphrase, strlen(passphrase));
         if ((r = sshkey_from_private(private, &public)) != 0)          if ((r = sshkey_from_private(private, &public)) != 0)
                 fatal("sshkey_from_private failed: %s", ssh_err(r));                  fatal_fr(r, "sshkey_from_private");
         sshkey_free(private);          sshkey_free(private);
   
         strlcat(identity_file, ".pub", sizeof(identity_file));          strlcat(identity_file, ".pub", sizeof(identity_file));
         if ((r = sshkey_save_public(public, identity_file, new_comment)) != 0) {          if ((r = sshkey_save_public(public, identity_file, new_comment)) != 0)
                 fatal("Unable to save public key to %s: %s",                  fatal_r(r, "Unable to save public key to %s", identity_file);
                     identity_file, ssh_err(r));  
         }  
         sshkey_free(public);          sshkey_free(public);
         free(comment);          free(comment);
   
Line 1622 
Line 1614 
         const struct cert_ext *ext;          const struct cert_ext *ext;
   
         if ((b = sshbuf_new()) == NULL)          if ((b = sshbuf_new()) == NULL)
                 fatal("%s: sshbuf_new failed", __func__);                  fatal_f("sshbuf_new failed");
         sshbuf_reset(c);          sshbuf_reset(c);
         for (i = 0; i < ncert_ext; i++) {          for (i = 0; i < ncert_ext; i++) {
                 ext = &cert_ext[i];                  ext = &cert_ext[i];
Line 1631 
Line 1623 
                         continue;                          continue;
                 if (ext->val == NULL) {                  if (ext->val == NULL) {
                         /* flag option */                          /* flag option */
                         debug3("%s: %s", __func__, ext->key);                          debug3_f("%s", ext->key);
                         if ((r = sshbuf_put_cstring(c, ext->key)) != 0 ||                          if ((r = sshbuf_put_cstring(c, ext->key)) != 0 ||
                             (r = sshbuf_put_string(c, NULL, 0)) != 0)                              (r = sshbuf_put_string(c, NULL, 0)) != 0)
                                 fatal("%s: buffer: %s", __func__, ssh_err(r));                                  fatal_fr(r, "prepare flag");
                 } else {                  } else {
                         /* key/value option */                          /* key/value option */
                         debug3("%s: %s=%s", __func__, ext->key, ext->val);                          debug3_f("%s=%s", ext->key, ext->val);
                         sshbuf_reset(b);                          sshbuf_reset(b);
                         if ((r = sshbuf_put_cstring(c, ext->key)) != 0 ||                          if ((r = sshbuf_put_cstring(c, ext->key)) != 0 ||
                             (r = sshbuf_put_cstring(b, ext->val)) != 0 ||                              (r = sshbuf_put_cstring(b, ext->val)) != 0 ||
                             (r = sshbuf_put_stringb(c, b)) != 0)                              (r = sshbuf_put_stringb(c, b)) != 0)
                                 fatal("%s: buffer: %s", __func__, ssh_err(r));                                  fatal_fr(r, "prepare k/v");
                 }                  }
         }          }
         sshbuf_free(b);          sshbuf_free(b);
Line 1682 
Line 1674 
         int r, i, nkeys;          int r, i, nkeys;
   
         if ((r = sshkey_load_public(path, &public, NULL)) != 0)          if ((r = sshkey_load_public(path, &public, NULL)) != 0)
                 fatal("Couldn't load CA public key \"%s\": %s",                  fatal_r(r, "Couldn't load CA public key \"%s\"", path);
                     path, ssh_err(r));  
   
         nkeys = pkcs11_add_provider(pkcs11provider, identity_passphrase,          nkeys = pkcs11_add_provider(pkcs11provider, identity_passphrase,
             &keys, NULL);              &keys, NULL);
         debug3("%s: %d keys", __func__, nkeys);          debug3_f("%d keys", nkeys);
         if (nkeys <= 0)          if (nkeys <= 0)
                 fatal("cannot read public key from pkcs11");                  fatal("cannot read public key from pkcs11");
         for (i = 0; i < nkeys; i++) {          for (i = 0; i < nkeys; i++) {
Line 1747 
Line 1738 
                  * agent.                   * agent.
                  */                   */
                 if ((r = sshkey_load_public(tmp, &ca, NULL)) != 0)                  if ((r = sshkey_load_public(tmp, &ca, NULL)) != 0)
                         fatal("Cannot load CA public key %s: %s",                          fatal_r(r, "Cannot load CA public key %s", tmp);
                             tmp, ssh_err(r));  
                 if ((r = ssh_get_authentication_socket(&agent_fd)) != 0)                  if ((r = ssh_get_authentication_socket(&agent_fd)) != 0)
                         fatal("Cannot use public key for CA signature: %s",                          fatal_r(r, "Cannot use public key for CA signature");
                             ssh_err(r));  
                 if ((r = ssh_fetch_identitylist(agent_fd, &agent_ids)) != 0)                  if ((r = ssh_fetch_identitylist(agent_fd, &agent_ids)) != 0)
                         fatal("Retrieve agent key list: %s", ssh_err(r));                          fatal_r(r, "Retrieve agent key list");
                 found = 0;                  found = 0;
                 for (j = 0; j < agent_ids->nkeys; j++) {                  for (j = 0; j < agent_ids->nkeys; j++) {
                         if (sshkey_equal(ca, agent_ids->keys[j])) {                          if (sshkey_equal(ca, agent_ids->keys[j])) {
Line 1772 
Line 1761 
                     (ca->sk_flags & SSH_SK_USER_VERIFICATION_REQD)) {                      (ca->sk_flags & SSH_SK_USER_VERIFICATION_REQD)) {
                         if ((pin = read_passphrase("Enter PIN for CA key: ",                          if ((pin = read_passphrase("Enter PIN for CA key: ",
                             RP_ALLOW_STDIN)) == NULL)                              RP_ALLOW_STDIN)) == NULL)
                                 fatal("%s: couldn't read PIN", __func__);                                  fatal_f("couldn't read PIN");
                 }                  }
         }          }
         free(tmp);          free(tmp);
Line 1807 
Line 1796 
   
                 tmp = tilde_expand_filename(argv[i], pw->pw_uid);                  tmp = tilde_expand_filename(argv[i], pw->pw_uid);
                 if ((r = sshkey_load_public(tmp, &public, &comment)) != 0)                  if ((r = sshkey_load_public(tmp, &public, &comment)) != 0)
                         fatal("%s: unable to open \"%s\": %s",                          fatal_r(r, "load pubkey \"%s\"", tmp);
                             __func__, tmp, ssh_err(r));  
                 if (sshkey_is_cert(public))                  if (sshkey_is_cert(public))
                         fatal("%s: key \"%s\" type %s cannot be certified",                          fatal_f("key \"%s\" type %s cannot be certified",
                             __func__, tmp, sshkey_type(public));                              tmp, sshkey_type(public));
   
                 /* Prepare certificate to sign */                  /* Prepare certificate to sign */
                 if ((r = sshkey_to_certified(public)) != 0)                  if ((r = sshkey_to_certified(public)) != 0)
                         fatal("Could not upgrade key %s to certificate: %s",                          fatal_r(r, "Could not upgrade key %s to certificate", tmp);
                             tmp, ssh_err(r));  
                 public->cert->type = cert_key_type;                  public->cert->type = cert_key_type;
                 public->cert->serial = (u_int64_t)cert_serial;                  public->cert->serial = (u_int64_t)cert_serial;
                 public->cert->key_id = xstrdup(cert_key_id);                  public->cert->key_id = xstrdup(cert_key_id);
Line 1829 
Line 1816 
                     OPTIONS_EXTENSIONS);                      OPTIONS_EXTENSIONS);
                 if ((r = sshkey_from_private(ca,                  if ((r = sshkey_from_private(ca,
                     &public->cert->signature_key)) != 0)                      &public->cert->signature_key)) != 0)
                         fatal("sshkey_from_private (ca key): %s", ssh_err(r));                          fatal_r(r, "sshkey_from_private (ca key)");
   
                 if (agent_fd != -1 && (ca->flags & SSHKEY_FLAG_EXT) != 0) {                  if (agent_fd != -1 && (ca->flags & SSHKEY_FLAG_EXT) != 0) {
                         if ((r = sshkey_certify_custom(public, ca,                          if ((r = sshkey_certify_custom(public, ca,
                             key_type_name, sk_provider, NULL, agent_signer,                              key_type_name, sk_provider, NULL, agent_signer,
                             &agent_fd)) != 0)                              &agent_fd)) != 0)
                                 fatal("Couldn't certify key %s via agent: %s",                                  fatal_r(r, "Couldn't certify %s via agent", tmp);
                                     tmp, ssh_err(r));  
                 } else {                  } else {
                         if (sshkey_is_sk(ca) &&                          if (sshkey_is_sk(ca) &&
                             (ca->sk_flags & SSH_SK_USER_PRESENCE_REQD)) {                              (ca->sk_flags & SSH_SK_USER_PRESENCE_REQD)) {
Line 1846 
Line 1832 
                         }                          }
                         r = sshkey_certify(public, ca, key_type_name,                          r = sshkey_certify(public, ca, key_type_name,
                             sk_provider, pin);                              sk_provider, pin);
                         notify_complete(notifier);                          notify_complete(notifier, "User presence confirmed");
                         if (r != 0)                          if (r != 0)
                                 fatal("Couldn't certify key %s: %s",                                  fatal_r(r, "Couldn't certify key %s", tmp);
                                     tmp, ssh_err(r));  
                 }                  }
   
                 if ((cp = strrchr(tmp, '.')) != NULL && strcmp(cp, ".pub") == 0)                  if ((cp = strrchr(tmp, '.')) != NULL && strcmp(cp, ".pub") == 0)
Line 1858 
Line 1843 
                 free(tmp);                  free(tmp);
   
                 if ((r = sshkey_save_public(public, out, comment)) != 0) {                  if ((r = sshkey_save_public(public, out, comment)) != 0) {
                         fatal("Unable to save public key to %s: %s",                          fatal_r(r, "Unable to save public key to %s",
                             identity_file, ssh_err(r));                              identity_file);
                 }                  }
   
                 if (!quiet) {                  if (!quiet) {
Line 2001 
Line 1986 
                         fatal("Invalid source-address list");                          fatal("Invalid source-address list");
                 certflags_src_addr = xstrdup(val);                  certflags_src_addr = xstrdup(val);
         } else if (strncasecmp(opt, "extension:", 10) == 0 ||          } else if (strncasecmp(opt, "extension:", 10) == 0 ||
                    (iscrit = (strncasecmp(opt, "critical:", 9) == 0))) {                      (iscrit = (strncasecmp(opt, "critical:", 9) == 0))) {
                 val = xstrdup(strchr(opt, ':') + 1);                  val = xstrdup(strchr(opt, ':') + 1);
                 if ((cp = strchr(val, '=')) != NULL)                  if ((cp = strchr(val, '=')) != NULL)
                         *cp++ = '\0';                          *cp++ = '\0';
Line 2019 
Line 2004 
         int r;          int r;
   
         if ((options = sshbuf_fromb(optbuf)) == NULL)          if ((options = sshbuf_fromb(optbuf)) == NULL)
                 fatal("%s: sshbuf_fromb failed", __func__);                  fatal_f("sshbuf_fromb failed");
         while (sshbuf_len(options) != 0) {          while (sshbuf_len(options) != 0) {
                 sshbuf_free(option);                  sshbuf_free(option);
                 option = NULL;                  option = NULL;
                 if ((r = sshbuf_get_cstring(options, &name, NULL)) != 0 ||                  if ((r = sshbuf_get_cstring(options, &name, NULL)) != 0 ||
                     (r = sshbuf_froms(options, &option)) != 0)                      (r = sshbuf_froms(options, &option)) != 0)
                         fatal("%s: buffer error: %s", __func__, ssh_err(r));                          fatal_fr(r, "parse option");
                 printf("                %s", name);                  printf("                %s", name);
                 if (!in_critical &&                  if (!in_critical &&
                     (strcmp(name, "permit-X11-forwarding") == 0 ||                      (strcmp(name, "permit-X11-forwarding") == 0 ||
Line 2039 
Line 2024 
                     (strcmp(name, "force-command") == 0 ||                      (strcmp(name, "force-command") == 0 ||
                     strcmp(name, "source-address") == 0)) {                      strcmp(name, "source-address") == 0)) {
                         if ((r = sshbuf_get_cstring(option, &arg, NULL)) != 0)                          if ((r = sshbuf_get_cstring(option, &arg, NULL)) != 0)
                                 fatal("%s: buffer error: %s",                                  fatal_fr(r, "parse critical");
                                     __func__, ssh_err(r));  
                         printf(" %s\n", arg);                          printf(" %s\n", arg);
                         free(arg);                          free(arg);
                 } else if (sshbuf_len(option) > 0) {                  } else if (sshbuf_len(option) > 0) {
Line 2069 
Line 2053 
         ca_fp = sshkey_fingerprint(key->cert->signature_key,          ca_fp = sshkey_fingerprint(key->cert->signature_key,
             fingerprint_hash, SSH_FP_DEFAULT);              fingerprint_hash, SSH_FP_DEFAULT);
         if (key_fp == NULL || ca_fp == NULL)          if (key_fp == NULL || ca_fp == NULL)
                 fatal("%s: sshkey_fingerprint fail", __func__);                  fatal_f("sshkey_fingerprint fail");
         sshkey_format_cert_validity(key->cert, valid, sizeof(valid));          sshkey_format_cert_validity(key->cert, valid, sizeof(valid));
   
         printf("        Type: %s %s certificate\n", sshkey_ssh_name(key),          printf("        Type: %s %s certificate\n", sshkey_ssh_name(key),
Line 2142 
Line 2126 
                 if ((key = sshkey_new(KEY_UNSPEC)) == NULL)                  if ((key = sshkey_new(KEY_UNSPEC)) == NULL)
                         fatal("sshkey_new");                          fatal("sshkey_new");
                 if ((r = sshkey_read(key, &cp)) != 0) {                  if ((r = sshkey_read(key, &cp)) != 0) {
                         error("%s:%lu: invalid key: %s", path,                          error_r(r, "%s:%lu: invalid key", path, lnum);
                             lnum, ssh_err(r));  
                         continue;                          continue;
                 }                  }
                 if (!sshkey_is_cert(key)) {                  if (!sshkey_is_cert(key)) {
Line 2170 
Line 2153 
         int r;          int r;
   
         if ((r = sshbuf_load_file(path, &krlbuf)) != 0)          if ((r = sshbuf_load_file(path, &krlbuf)) != 0)
                 fatal("Unable to load KRL: %s", ssh_err(r));                  fatal_r(r, "Unable to load KRL %s", path);
         /* XXX check sigs */          /* XXX check sigs */
         if ((r = ssh_krl_from_blob(krlbuf, krlp, NULL, 0)) != 0 ||          if ((r = ssh_krl_from_blob(krlbuf, krlp, NULL, 0)) != 0 ||
             *krlp == NULL)              *krlp == NULL)
                 fatal("Invalid KRL file: %s", ssh_err(r));                  fatal_r(r, "Invalid KRL file %s", path);
         sshbuf_free(krlbuf);          sshbuf_free(krlbuf);
 }  }
   
Line 2203 
Line 2186 
                 tmp[tlen] = '\0';                  tmp[tlen] = '\0';
         }          }
         if ((b = sshbuf_new()) == NULL)          if ((b = sshbuf_new()) == NULL)
                 fatal("%s: sshbuf_new failed", __func__);                  fatal_f("sshbuf_new failed");
         if ((r = sshbuf_b64tod(b, tmp)) != 0)          if ((r = sshbuf_b64tod(b, tmp)) != 0)
                 fatal("%s:%lu: decode hash failed: %s", file, lnum, ssh_err(r));                  fatal_r(r, "%s:%lu: decode hash failed", file, lnum);
         free(tmp);          free(tmp);
         *lenp = sshbuf_len(b);          *lenp = sshbuf_len(b);
         *blobp = xmalloc(*lenp);          *blobp = xmalloc(*lenp);
Line 2291 
Line 2274 
                         }                          }
                         if (ssh_krl_revoke_cert_by_serial_range(krl,                          if (ssh_krl_revoke_cert_by_serial_range(krl,
                             ca, serial, serial2) != 0) {                              ca, serial, serial2) != 0) {
                                 fatal("%s: revoke serial failed",                                  fatal_f("revoke serial failed");
                                     __func__);  
                         }                          }
                 } else if (strncasecmp(cp, "id:", 3) == 0) {                  } else if (strncasecmp(cp, "id:", 3) == 0) {
                         if (ca == NULL && !wild_ca) {                          if (ca == NULL && !wild_ca) {
Line 2302 
Line 2284 
                         cp += 3;                          cp += 3;
                         cp = cp + strspn(cp, " \t");                          cp = cp + strspn(cp, " \t");
                         if (ssh_krl_revoke_cert_by_key_id(krl, ca, cp) != 0)                          if (ssh_krl_revoke_cert_by_key_id(krl, ca, cp) != 0)
                                 fatal("%s: revoke key ID failed", __func__);                                  fatal_f("revoke key ID failed");
                 } else if (strncasecmp(cp, "hash:", 5) == 0) {                  } else if (strncasecmp(cp, "hash:", 5) == 0) {
                         cp += 5;                          cp += 5;
                         cp = cp + strspn(cp, " \t");                          cp = cp + strspn(cp, " \t");
                         hash_to_blob(cp, &blob, &blen, file, lnum);                          hash_to_blob(cp, &blob, &blen, file, lnum);
                         r = ssh_krl_revoke_key_sha256(krl, blob, blen);                          r = ssh_krl_revoke_key_sha256(krl, blob, blen);
                         if (r != 0)                          if (r != 0)
                                 fatal("%s: revoke key failed: %s",                                  fatal_fr(r, "revoke key failed");
                                     __func__, ssh_err(r));  
                 } else {                  } else {
                         if (strncasecmp(cp, "key:", 4) == 0) {                          if (strncasecmp(cp, "key:", 4) == 0) {
                                 cp += 4;                                  cp += 4;
Line 2332 
Line 2313 
                         if ((key = sshkey_new(KEY_UNSPEC)) == NULL)                          if ((key = sshkey_new(KEY_UNSPEC)) == NULL)
                                 fatal("sshkey_new");                                  fatal("sshkey_new");
                         if ((r = sshkey_read(key, &cp)) != 0)                          if ((r = sshkey_read(key, &cp)) != 0)
                                 fatal("%s:%lu: invalid key: %s",                                  fatal_r(r, "%s:%lu: invalid key", path, lnum);
                                     path, lnum, ssh_err(r));  
                         if (was_explicit_key)                          if (was_explicit_key)
                                 r = ssh_krl_revoke_key_explicit(krl, key);                                  r = ssh_krl_revoke_key_explicit(krl, key);
                         else if (was_sha1) {                          else if (was_sha1) {
Line 2353 
Line 2333 
                         } else                          } else
                                 r = ssh_krl_revoke_key(krl, key);                                  r = ssh_krl_revoke_key(krl, key);
                         if (r != 0)                          if (r != 0)
                                 fatal("%s: revoke key failed: %s",                                  fatal_fr(r, "revoke key failed");
                                     __func__, ssh_err(r));  
                         freezero(blob, blen);                          freezero(blob, blen);
                         blob = NULL;                          blob = NULL;
                         blen = 0;                          blen = 0;
Line 2394 
Line 2373 
                 else {                  else {
                         tmp = tilde_expand_filename(ca_key_path, pw->pw_uid);                          tmp = tilde_expand_filename(ca_key_path, pw->pw_uid);
                         if ((r = sshkey_load_public(tmp, &ca, NULL)) != 0)                          if ((r = sshkey_load_public(tmp, &ca, NULL)) != 0)
                                 fatal("Cannot load CA public key %s: %s",                                  fatal_r(r, "Cannot load CA public key %s", tmp);
                                     tmp, ssh_err(r));  
                         free(tmp);                          free(tmp);
                 }                  }
         }          }
Line 2439 
Line 2417 
                 krl_dump(krl, stdout);                  krl_dump(krl, stdout);
         for (i = 0; i < argc; i++) {          for (i = 0; i < argc; i++) {
                 if ((r = sshkey_load_public(argv[i], &k, &comment)) != 0)                  if ((r = sshkey_load_public(argv[i], &k, &comment)) != 0)
                         fatal("Cannot load public key %s: %s",                          fatal_r(r, "Cannot load public key %s", argv[i]);
                             argv[i], ssh_err(r));  
                 r = ssh_krl_check_key(krl, k);                  r = ssh_krl_check_key(krl, k);
                 printf("%s%s%s%s: %s\n", argv[i],                  printf("%s%s%s%s: %s\n", argv[i],
                     *comment ? " (" : "", comment, *comment ? ")" : "",                      *comment ? " (" : "", comment, *comment ? ")" : "",
Line 2474 
Line 2451 
                     strcmp(privpath + plen - slen, suffixes[i]) != 0)                      strcmp(privpath + plen - slen, suffixes[i]) != 0)
                         continue;                          continue;
                 privpath[plen - slen] = '\0';                  privpath[plen - slen] = '\0';
                 debug("%s: %s looks like a public key, using private key "                  debug_f("%s looks like a public key, using private key "
                     "path %s instead", __func__, keypath, privpath);                      "path %s instead", keypath, privpath);
         }          }
         if ((privkey = load_identity(privpath, NULL)) == NULL) {          if ((privkey = load_identity(privpath, NULL)) == NULL) {
                 error("Couldn't load identity %s", keypath);                  error("Couldn't load identity %s", keypath);
Line 2492 
Line 2469 
                  * it capable of signing.                   * it capable of signing.
                  */                   */
                 if ((r = sshkey_to_certified(privkey)) != 0) {                  if ((r = sshkey_to_certified(privkey)) != 0) {
                         error("%s: sshkey_to_certified: %s", __func__,                          error_fr(r, "sshkey_to_certified");
                             ssh_err(r));  
                         goto done;                          goto done;
                 }                  }
                 if ((r = sshkey_cert_copy(pubkey, privkey)) != 0) {                  if ((r = sshkey_cert_copy(pubkey, privkey)) != 0) {
                         error("%s: sshkey_cert_copy: %s", __func__, ssh_err(r));                          error_fr(r, "sshkey_cert_copy");
                         goto done;                          goto done;
                 }                  }
         }          }
Line 2531 
Line 2507 
                             sshkey_type(signkey));                              sshkey_type(signkey));
                         if ((pin = read_passphrase(prompt,                          if ((pin = read_passphrase(prompt,
                             RP_ALLOW_STDIN)) == NULL)                              RP_ALLOW_STDIN)) == NULL)
                                 fatal("%s: couldn't read PIN", __func__);                                  fatal_f("couldn't read PIN");
                 }                  }
                 if ((signkey->sk_flags & SSH_SK_USER_PRESENCE_REQD)) {                  if ((signkey->sk_flags & SSH_SK_USER_PRESENCE_REQD)) {
                         if ((fp = sshkey_fingerprint(signkey, fingerprint_hash,                          if ((fp = sshkey_fingerprint(signkey, fingerprint_hash,
                             SSH_FP_DEFAULT)) == NULL)                              SSH_FP_DEFAULT)) == NULL)
                                 fatal("%s: fingerprint failed", __func__);                                  fatal_f("fingerprint failed");
                         fprintf(stderr, "Confirm user presence for key %s %s\n",                          fprintf(stderr, "Confirm user presence for key %s %s\n",
                             sshkey_type(signkey), fp);                              sshkey_type(signkey), fp);
                         free(fp);                          free(fp);
Line 2544 
Line 2520 
         }          }
         if ((r = sshsig_sign_fd(signkey, NULL, sk_provider, pin,          if ((r = sshsig_sign_fd(signkey, NULL, sk_provider, pin,
             fd, sig_namespace, &sigbuf, signer, signer_ctx)) != 0) {              fd, sig_namespace, &sigbuf, signer, signer_ctx)) != 0) {
                 error("Signing %s failed: %s", filename, ssh_err(r));                  error_r(r, "Signing %s failed", filename);
                 goto out;                  goto out;
         }          }
         if ((r = sshsig_armor(sigbuf, &abuf)) != 0) {          if ((r = sshsig_armor(sigbuf, &abuf)) != 0) {
                 error("%s: sshsig_armor: %s", __func__, ssh_err(r));                  error_fr(r, "sshsig_armor");
                 goto out;                  goto out;
         }          }
         if ((asig = sshbuf_dup_string(abuf)) == NULL) {          if ((asig = sshbuf_dup_string(abuf)) == NULL) {
                 error("%s: buffer error", __func__);                  error_f("buffer error");
                 r = SSH_ERR_ALLOC_FAIL;                  r = SSH_ERR_ALLOC_FAIL;
                 goto out;                  goto out;
         }          }
Line 2619 
Line 2595 
         }          }
   
         if ((r = sshkey_load_public(keypath, &pubkey, NULL)) != 0) {          if ((r = sshkey_load_public(keypath, &pubkey, NULL)) != 0) {
                 error("Couldn't load public key %s: %s", keypath, ssh_err(r));                  error_r(r, "Couldn't load public key %s", keypath);
                 goto done;                  goto done;
         }          }
   
         if ((r = ssh_get_authentication_socket(&agent_fd)) != 0)          if ((r = ssh_get_authentication_socket(&agent_fd)) != 0)
                 debug("Couldn't get agent socket: %s", ssh_err(r));                  debug_r(r, "Couldn't get agent socket");
         else {          else {
                 if ((r = ssh_agent_has_key(agent_fd, pubkey)) == 0)                  if ((r = ssh_agent_has_key(agent_fd, pubkey)) == 0)
                         signer = agent_signer;                          signer = agent_signer;
                 else                  else
                         debug("Couldn't find key in agent: %s", ssh_err(r));                          debug_r(r, "Couldn't find key in agent");
         }          }
   
         if (signer == NULL) {          if (signer == NULL) {
Line 2685 
Line 2661 
   
         memset(&sig_details, 0, sizeof(sig_details));          memset(&sig_details, 0, sizeof(sig_details));
         if ((r = sshbuf_load_file(signature, &abuf)) != 0) {          if ((r = sshbuf_load_file(signature, &abuf)) != 0) {
                 error("Couldn't read signature file: %s", ssh_err(r));                  error_r(r, "Couldn't read signature file");
                 goto done;                  goto done;
         }          }
   
         if ((r = sshsig_dearmor(abuf, &sigbuf)) != 0) {          if ((r = sshsig_dearmor(abuf, &sigbuf)) != 0) {
                 error("%s: sshsig_armor: %s", __func__, ssh_err(r));                  error_fr(r, "sshsig_armor");
                 goto done;                  goto done;
         }          }
         if ((r = sshsig_verify_fd(sigbuf, STDIN_FILENO, sig_namespace,          if ((r = sshsig_verify_fd(sigbuf, STDIN_FILENO, sig_namespace,
Line 2699 
Line 2675 
   
         if ((fp = sshkey_fingerprint(sign_key, fingerprint_hash,          if ((fp = sshkey_fingerprint(sign_key, fingerprint_hash,
             SSH_FP_DEFAULT)) == NULL)              SSH_FP_DEFAULT)) == NULL)
                 fatal("%s: sshkey_fingerprint failed", __func__);                  fatal_f("sshkey_fingerprint failed");
         debug("Valid (unverified) signature from key %s", fp);          debug("Valid (unverified) signature from key %s", fp);
         if (sig_details != NULL) {          if (sig_details != NULL) {
                 debug2("%s: signature details: counter = %u, flags = 0x%02x",                  debug2_f("signature details: counter = %u, flags = 0x%02x",
                     __func__, sig_details->sk_counter, sig_details->sk_flags);                      sig_details->sk_counter, sig_details->sk_flags);
         }          }
         free(fp);          free(fp);
         fp = NULL;          fp = NULL;
   
         if (revoked_keys != NULL) {          if (revoked_keys != NULL) {
                 if ((r = sshkey_check_revoked(sign_key, revoked_keys)) != 0) {                  if ((r = sshkey_check_revoked(sign_key, revoked_keys)) != 0) {
                         debug3("sshkey_check_revoked failed: %s", ssh_err(r));                          debug3_fr(r, "sshkey_check_revoked");
                         goto done;                          goto done;
                 }                  }
         }          }
   
         if (allowed_keys != NULL &&          if (allowed_keys != NULL && (r = sshsig_check_allowed_keys(allowed_keys,
             (r = sshsig_check_allowed_keys(allowed_keys, sign_key,              sign_key, principal, sig_namespace)) != 0) {
                                            principal, sig_namespace)) != 0) {                  debug3_fr(r, "sshsig_check_allowed_keys");
                 debug3("sshsig_check_allowed_keys failed: %s", ssh_err(r));  
                 goto done;                  goto done;
         }          }
         /* success */          /* success */
Line 2727 
Line 2702 
         if (!quiet) {          if (!quiet) {
                 if (ret == 0) {                  if (ret == 0) {
                         if ((fp = sshkey_fingerprint(sign_key, fingerprint_hash,                          if ((fp = sshkey_fingerprint(sign_key, fingerprint_hash,
                             SSH_FP_DEFAULT)) == NULL) {                              SSH_FP_DEFAULT)) == NULL)
                                 fatal("%s: sshkey_fingerprint failed",                                  fatal_f("sshkey_fingerprint failed");
                                     __func__);  
                         }  
                         if (principal == NULL) {                          if (principal == NULL) {
                                 printf("Good \"%s\" signature with %s key %s\n",                                  printf("Good \"%s\" signature with %s key %s\n",
                                        sig_namespace, sshkey_type(sign_key), fp);                                      sig_namespace, sshkey_type(sign_key), fp);
   
                         } else {                          } else {
                                 printf("Good \"%s\" signature for %s with %s key %s\n",                                  printf("Good \"%s\" signature for %s with %s key %s\n",
                                        sig_namespace, principal,                                      sig_namespace, principal,
                                        sshkey_type(sign_key), fp);                                      sshkey_type(sign_key), fp);
                         }                          }
                 } else {                  } else {
                         printf("Could not verify signature.\n");                          printf("Could not verify signature.\n");
Line 2760 
Line 2733 
         char *principals = NULL, *cp, *tmp;          char *principals = NULL, *cp, *tmp;
   
         if ((r = sshbuf_load_file(signature, &abuf)) != 0) {          if ((r = sshbuf_load_file(signature, &abuf)) != 0) {
                 error("Couldn't read signature file: %s", ssh_err(r));                  error_r(r, "Couldn't read signature file");
                 goto done;                  goto done;
         }          }
         if ((r = sshsig_dearmor(abuf, &sigbuf)) != 0) {          if ((r = sshsig_dearmor(abuf, &sigbuf)) != 0) {
                 error("%s: sshsig_armor: %s", __func__, ssh_err(r));                  error_fr(r, "sshsig_armor");
                 goto done;                  goto done;
         }          }
         if ((r = sshsig_get_pubkey(sigbuf, &sign_key)) != 0) {          if ((r = sshsig_get_pubkey(sigbuf, &sign_key)) != 0) {
                 error("%s: sshsig_get_pubkey: %s",                  error_fr(r, "sshsig_get_pubkey");
                     __func__, ssh_err(r));  
                 goto done;                  goto done;
         }          }
         if ((r = sshsig_find_principals(allowed_keys, sign_key,          if ((r = sshsig_find_principals(allowed_keys, sign_key,
             &principals)) != 0) {              &principals)) != 0) {
                 error("%s: sshsig_get_principal: %s",                  error_fr(r, "sshsig_get_principal");
                       __func__, ssh_err(r));  
                 goto done;                  goto done;
         }          }
         ret = 0;          ret = 0;
Line 2975 
Line 2946 
             &keys, &nkeys)) != 0) {              &keys, &nkeys)) != 0) {
                 if (pin != NULL)                  if (pin != NULL)
                         freezero(pin, strlen(pin));                          freezero(pin, strlen(pin));
                 error("Unable to load resident keys: %s", ssh_err(r));                  error_r(r, "Unable to load resident keys");
                 return -1;                  return -1;
         }          }
         if (nkeys == 0)          if (nkeys == 0)
Line 2992 
Line 2963 
                 }                  }
                 if ((fp = sshkey_fingerprint(keys[i],                  if ((fp = sshkey_fingerprint(keys[i],
                     fingerprint_hash, SSH_FP_DEFAULT)) == NULL)                      fingerprint_hash, SSH_FP_DEFAULT)) == NULL)
                         fatal("%s: sshkey_fingerprint failed", __func__);                          fatal_f("sshkey_fingerprint failed");
                 debug("%s: key %zu: %s %s %s (flags 0x%02x)", __func__, i,                  debug_f("key %zu: %s %s %s (flags 0x%02x)", i,
                     sshkey_type(keys[i]), fp, keys[i]->sk_application,                      sshkey_type(keys[i]), fp, keys[i]->sk_application,
                     keys[i]->sk_flags);                      keys[i]->sk_flags);
                 ext = skip_ssh_url_preamble(keys[i]->sk_application);                  ext = skip_ssh_url_preamble(keys[i]->sk_application);
Line 3013 
Line 2984 
                 if ((r = sshkey_save_private(keys[i], path, pass,                  if ((r = sshkey_save_private(keys[i], path, pass,
                     keys[i]->sk_application, private_key_format,                      keys[i]->sk_application, private_key_format,
                     openssh_format_cipher, rounds)) != 0) {                      openssh_format_cipher, rounds)) != 0) {
                         error("Saving key \"%s\" failed: %s",                          error_r(r, "Saving key \"%s\" failed", path);
                             path, ssh_err(r));  
                         free(path);                          free(path);
                         break;                          break;
                 }                  }
Line 3031 
Line 3001 
                 free(path);                  free(path);
                 if ((r = sshkey_save_public(keys[i], pubpath,                  if ((r = sshkey_save_public(keys[i], pubpath,
                     keys[i]->sk_application)) != 0) {                      keys[i]->sk_application)) != 0) {
                         error("Saving public key \"%s\" failed: %s",                          error_r(r, "Saving public key \"%s\" failed", pubpath);
                             pubpath, ssh_err(r));  
                         free(pubpath);                          free(pubpath);
                         break;                          break;
                 }                  }
Line 3063 
Line 3032 
         r = sshbuf_write_file(path, attest);          r = sshbuf_write_file(path, attest);
         umask(omask);          umask(omask);
         if (r != 0)          if (r != 0)
                 fatal("Unable to write attestation data \"%s\": %s", path,                  fatal_r(r, "Unable to write attestation data \"%s\"", path);
                     ssh_err(r));  
         if (!quiet)          if (!quiet)
                 printf("Your FIDO attestation certificate has been saved in "                  printf("Your FIDO attestation certificate has been saved in "
                     "%s\n", path);                      "%s\n", path);
Line 3077 
Line 3045 
             "usage: ssh-keygen [-q] [-a rounds] [-b bits] [-C comment] [-f output_keyfile]\n"              "usage: ssh-keygen [-q] [-a rounds] [-b bits] [-C comment] [-f output_keyfile]\n"
             "                  [-m format] [-N new_passphrase] [-O option]\n"              "                  [-m format] [-N new_passphrase] [-O option]\n"
             "                  [-t dsa | ecdsa | ecdsa-sk | ed25519 | ed25519-sk | rsa]\n"              "                  [-t dsa | ecdsa | ecdsa-sk | ed25519 | ed25519-sk | rsa]\n"
             "                  [-w provider]\n"              "                  [-w provider] [-Z cipher]\n"
             "       ssh-keygen -p [-a rounds] [-f keyfile] [-m format] [-N new_passphrase]\n"              "       ssh-keygen -p [-a rounds] [-f keyfile] [-m format] [-N new_passphrase]\n"
             "                   [-P old_passphrase]\n"              "                   [-P old_passphrase] [-Z cipher]\n"
             "       ssh-keygen -i [-f input_keyfile] [-m key_format]\n"              "       ssh-keygen -i [-f input_keyfile] [-m key_format]\n"
             "       ssh-keygen -e [-f input_keyfile] [-m key_format]\n"              "       ssh-keygen -e [-f input_keyfile] [-m key_format]\n"
             "       ssh-keygen -y [-f input_keyfile]\n"              "       ssh-keygen -y [-f input_keyfile]\n"
Line 3112 
Line 3080 
             "       ssh-keygen -Y check-novalidate -n namespace -s signature_file\n"              "       ssh-keygen -Y check-novalidate -n namespace -s signature_file\n"
             "       ssh-keygen -Y sign -f key_file -n namespace file ...\n"              "       ssh-keygen -Y sign -f key_file -n namespace file ...\n"
             "       ssh-keygen -Y verify -f allowed_signers_file -I signer_identity\n"              "       ssh-keygen -Y verify -f allowed_signers_file -I signer_identity\n"
             "                   -n namespace -s signature_file [-r revocation_file]\n");              "                  -n namespace -s signature_file [-r revocation_file]\n");
         exit(1);          exit(1);
 }  }
   
Line 3162 
Line 3130 
         pw = getpwuid(getuid());          pw = getpwuid(getuid());
         if (!pw)          if (!pw)
                 fatal("No user exists for uid %lu", (u_long)getuid());                  fatal("No user exists for uid %lu", (u_long)getuid());
           pw = pwcopy(pw);
         if (gethostname(hostname, sizeof(hostname)) == -1)          if (gethostname(hostname, sizeof(hostname)) == -1)
                 fatal("gethostname: %s", strerror(errno));                  fatal("gethostname: %s", strerror(errno));
   
Line 3267 
Line 3236 
                         break;                          break;
                 case 'Z':                  case 'Z':
                         openssh_format_cipher = optarg;                          openssh_format_cipher = optarg;
                           if (cipher_by_name(openssh_format_cipher) == NULL)
                                   fatal("Invalid OpenSSH-format cipher '%s'",
                                       openssh_format_cipher);
                         break;                          break;
                 case 'C':                  case 'C':
                         identity_comment = optarg;                          identity_comment = optarg;
Line 3373 
Line 3345 
                 if (strncmp(sign_op, "find-principals", 15) == 0) {                  if (strncmp(sign_op, "find-principals", 15) == 0) {
                         if (ca_key_path == NULL) {                          if (ca_key_path == NULL) {
                                 error("Too few arguments for find-principals:"                                  error("Too few arguments for find-principals:"
                                       "missing signature file");                                      "missing signature file");
                                 exit(1);                                  exit(1);
                         }                          }
                         if (!have_identity) {                          if (!have_identity) {
                                 error("Too few arguments for find-principals:"                                  error("Too few arguments for find-principals:"
                                       "missing allowed keys file");                                      "missing allowed keys file");
                                 exit(1);                                  exit(1);
                         }                          }
                         return sig_find_principals(ca_key_path, identity_file);                          return sig_find_principals(ca_key_path, identity_file);
Line 3399 
Line 3371 
                 } else if (strncmp(sign_op, "check-novalidate", 16) == 0) {                  } else if (strncmp(sign_op, "check-novalidate", 16) == 0) {
                         if (ca_key_path == NULL) {                          if (ca_key_path == NULL) {
                                 error("Too few arguments for check-novalidate: "                                  error("Too few arguments for check-novalidate: "
                                       "missing signature file");                                      "missing signature file");
                                 exit(1);                                  exit(1);
                         }                          }
                         return sig_verify(ca_key_path, cert_principals,                          return sig_verify(ca_key_path, cert_principals,
Line 3583 
Line 3555 
                         } else if (strncasecmp(opts[i], "challenge=", 10) == 0) {                          } else if (strncasecmp(opts[i], "challenge=", 10) == 0) {
                                 if ((r = sshbuf_load_file(opts[i] + 10,                                  if ((r = sshbuf_load_file(opts[i] + 10,
                                     &challenge)) != 0) {                                      &challenge)) != 0) {
                                         fatal("Unable to load FIDO enrollment "                                          fatal_r(r, "Unable to load FIDO "
                                             "challenge \"%s\": %s",                                              "enrollment challenge \"%s\"",
                                             opts[i] + 10, ssh_err(r));                                              opts[i] + 10);
                                 }                                  }
                         } else if (strncasecmp(opts[i],                          } else if (strncasecmp(opts[i],
                             "write-attestation=", 18) == 0) {                              "write-attestation=", 18) == 0) {
Line 3624 
Line 3596 
                         if (r == 0)                          if (r == 0)
                                 break;                                  break;
                         if (r != SSH_ERR_KEY_WRONG_PASSPHRASE)                          if (r != SSH_ERR_KEY_WRONG_PASSPHRASE)
                                 fatal("Key enrollment failed: %s", ssh_err(r));                                  fatal_r(r, "Key enrollment failed");
                         else if (passphrase != NULL) {                          else if (passphrase != NULL) {
                                 error("PIN incorrect");                                  error("PIN incorrect");
                                 freezero(passphrase, strlen(passphrase));                                  freezero(passphrase, strlen(passphrase));
Line 3651 
Line 3623 
                 break;                  break;
         }          }
         if ((r = sshkey_from_private(private, &public)) != 0)          if ((r = sshkey_from_private(private, &public)) != 0)
                 fatal("sshkey_from_private failed: %s\n", ssh_err(r));                  fatal_r(r, "sshkey_from_private");
   
         if (!have_identity)          if (!have_identity)
                 ask_filename(pw, "Enter file in which to save the key");                  ask_filename(pw, "Enter file in which to save the key");
Line 3675 
Line 3647 
         /* Save the key with the given passphrase and comment. */          /* Save the key with the given passphrase and comment. */
         if ((r = sshkey_save_private(private, identity_file, passphrase,          if ((r = sshkey_save_private(private, identity_file, passphrase,
             comment, private_key_format, openssh_format_cipher, rounds)) != 0) {              comment, private_key_format, openssh_format_cipher, rounds)) != 0) {
                 error("Saving key \"%s\" failed: %s",                  error_r(r, "Saving key \"%s\" failed", identity_file);
                     identity_file, ssh_err(r));  
                 freezero(passphrase, strlen(passphrase));                  freezero(passphrase, strlen(passphrase));
                 exit(1);                  exit(1);
         }          }
Line 3689 
Line 3660 
         }          }
   
         strlcat(identity_file, ".pub", sizeof(identity_file));          strlcat(identity_file, ".pub", sizeof(identity_file));
         if ((r = sshkey_save_public(public, identity_file, comment)) != 0) {          if ((r = sshkey_save_public(public, identity_file, comment)) != 0)
                 fatal("Unable to save public key to %s: %s",                  fatal_r(r, "Unable to save public key to %s", identity_file);
                     identity_file, ssh_err(r));  
         }  
   
         if (!quiet) {          if (!quiet) {
                 fp = sshkey_fingerprint(public, fingerprint_hash,                  fp = sshkey_fingerprint(public, fingerprint_hash,
Legend:
Removed from v.1.420  
changed lines
  Added in v.1.430