src/usr.bin/ssh/ssh-keygen.c - diff

Return to ssh-keygen.c CVS log

Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/ssh-keygen.c between version 1.309 and 1.321

version 1.309, 2017/12/18 02:25:15

version 1.321, 2018/09/13 02:08:33

Line 172

char *pkcs11provider = NULL;

/* Use new OpenSSH private key format when writing SSH2 keys instead of PEM */

int use_new_format = 0;

int use_new_format = 1;

/* Cipher for new-format private keys */

char *new_format_cipher = NULL;

Line 267

case KEY_ED25519_CERT:

name = _PATH_SSH_CLIENT_ID_ED25519;

break;

case KEY_XMSS:

case KEY_XMSS_CERT:

name = _PATH_SSH_CLIENT_ID_XMSS;

break;

default:

fatal("bad key type");

}

Line 367

Line 371

if (!PEM_write_RSAPublicKey(stdout, k->rsa))

fatal("PEM_write_RSAPublicKey failed");

break;

#if notyet /* OpenSSH 0.9.8 lacks this function */

case KEY_DSA:

if (!PEM_write_DSAPublicKey(stdout, k->dsa))

fatal("PEM_write_DSAPublicKey failed");

break;

#endif

/* XXX ECDSA? */

default:

fatal("%s: unsupported key type %s", __func__, sshkey_type(k));

}

Line 442

Line 439

u_int magic, i1, i2, i3, i4;

size_t slen;

u_long e;

BIGNUM *dsa_p = NULL, *dsa_q = NULL, *dsa_g = NULL;

BIGNUM *dsa_pub_key = NULL, *dsa_priv_key = NULL;

BIGNUM *rsa_n = NULL, *rsa_e = NULL, *rsa_d = NULL;

BIGNUM *rsa_p = NULL, *rsa_q = NULL, *rsa_iqmp = NULL;

if ((b = sshbuf_from(blob, blen)) == NULL)

fatal("%s: sshbuf_from failed", __func__);

if ((r = sshbuf_get_u32(b, &magic)) != 0)

Line 486

switch (key->type) {

case KEY_DSA:

buffer_get_bignum_bits(b, key->dsa->p);

if ((dsa_p = BN_new()) == NULL ||

buffer_get_bignum_bits(b, key->dsa->g);

(dsa_q = BN_new()) == NULL ||

buffer_get_bignum_bits(b, key->dsa->q);

(dsa_g = BN_new()) == NULL ||

buffer_get_bignum_bits(b, key->dsa->pub_key);

(dsa_pub_key = BN_new()) == NULL ||

buffer_get_bignum_bits(b, key->dsa->priv_key);

(dsa_priv_key = BN_new()) == NULL)

fatal("%s: BN_new", __func__);

buffer_get_bignum_bits(b, dsa_p);

buffer_get_bignum_bits(b, dsa_g);

buffer_get_bignum_bits(b, dsa_q);

buffer_get_bignum_bits(b, dsa_pub_key);

buffer_get_bignum_bits(b, dsa_priv_key);

if (!DSA_set0_pqg(key->dsa, dsa_p, dsa_q, dsa_g))

fatal("%s: DSA_set0_pqg failed", __func__);

dsa_p = dsa_q = dsa_g = NULL; /* transferred */

if (!DSA_set0_key(key->dsa, dsa_pub_key, dsa_priv_key))

fatal("%s: DSA_set0_key failed", __func__);

dsa_pub_key = dsa_priv_key = NULL; /* transferred */

break;

case KEY_RSA:

if ((r = sshbuf_get_u8(b, &e1)) != 0 ||

Line 507

Line 519

e += e3;

debug("e %lx", e);

}

if (!BN_set_word(key->rsa->e, e)) {

if ((rsa_e = BN_new()) == NULL)

fatal("%s: BN_new", __func__);

if (!BN_set_word(rsa_e, e)) {

BN_clear_free(rsa_e);

sshbuf_free(b);

sshkey_free(key);

return NULL;

}

buffer_get_bignum_bits(b, key->rsa->d);

if ((rsa_n = BN_new()) == NULL ||

buffer_get_bignum_bits(b, key->rsa->n);

(rsa_d = BN_new()) == NULL ||

buffer_get_bignum_bits(b, key->rsa->iqmp);

(rsa_p = BN_new()) == NULL ||

buffer_get_bignum_bits(b, key->rsa->q);

(rsa_q = BN_new()) == NULL ||

buffer_get_bignum_bits(b, key->rsa->p);

(rsa_iqmp = BN_new()) == NULL)

if ((r = ssh_rsa_generate_additional_parameters(key)) != 0)

fatal("%s: BN_new", __func__);

buffer_get_bignum_bits(b, rsa_d);

buffer_get_bignum_bits(b, rsa_n);

buffer_get_bignum_bits(b, rsa_iqmp);

buffer_get_bignum_bits(b, rsa_q);

buffer_get_bignum_bits(b, rsa_p);

if (!RSA_set0_key(key->rsa, rsa_n, rsa_e, rsa_d))

fatal("%s: RSA_set0_key failed", __func__);

rsa_n = rsa_e = rsa_d = NULL; /* transferred */

if (!RSA_set0_factors(key->rsa, rsa_p, rsa_q))

fatal("%s: RSA_set0_factors failed", __func__);

rsa_p = rsa_q = NULL; /* transferred */

if ((r = ssh_rsa_complete_crt_parameters(key, rsa_iqmp)) != 0)

fatal("generate RSA parameters failed: %s", ssh_err(r));

BN_clear_free(rsa_iqmp);

break;

}

rlen = sshbuf_len(b);

Line 626

Line 654

identity_file);

}

fclose(fp);

switch (EVP_PKEY_type(pubkey->type)) {

switch (EVP_PKEY_base_id(pubkey)) {

case EVP_PKEY_RSA:

if ((*k = sshkey_new(KEY_UNSPEC)) == NULL)

fatal("sshkey_new failed");

Line 648

Line 676

break;

default:

fatal("%s: unsupported pubkey type %d", __func__,

EVP_PKEY_type(pubkey->type));

EVP_PKEY_base_id(pubkey));

}

EVP_PKEY_free(pubkey);

return;

Line 659

Line 687

{

FILE *fp;

RSA *rsa;

#ifdef notyet

DSA *dsa;

#endif

if ((fp = fopen(identity_file, "r")) == NULL)

fatal("%s: %s: %s", __progname, identity_file, strerror(errno));

Line 673

Line 698

fclose(fp);

return;

}

#if notyet /* OpenSSH 0.9.8 lacks this function */

rewind(fp);

if ((dsa = PEM_read_DSAPublicKey(fp, NULL, NULL, NULL)) != NULL) {

if ((*k = sshkey_new(KEY_UNSPEC)) == NULL)

fatal("sshkey_new failed");

(*k)->type = KEY_DSA;

(*k)->dsa = dsa;

fclose(fp);

return;

}

/* XXX ECDSA */

#endif

fatal("%s: unrecognised raw private key format", __func__);

}

Line 874

Line 887

{

FILE *f;

struct sshkey *public = NULL;

char *comment = NULL, *cp, *ep, line[SSH_MAX_PUBKEY_BYTES];

char *comment = NULL, *cp, *ep, *line = NULL;

size_t linesize = 0;

int i, invalid = 1;

const char *path;

u_long lnum = 0;

Line 889

Line 903

} else if ((f = fopen(path, "r")) == NULL)

fatal("%s: %s: %s", __progname, path, strerror(errno));

while (read_keyfile_line(f, path, line, sizeof(line), &lnum) == 0) {

while (getline(&line, &linesize, f) != -1) {

lnum++;

cp = line;

cp[strcspn(cp, "\n")] = '\0';

/* Trim leading space and comments */

Line 909

Line 924

if (lnum == 1 && strcmp(identity_file, "-") != 0 &&

strstr(cp, "PRIVATE KEY") != NULL) {

free(line);

fclose(f);

fingerprint_private(path);

exit(0);

Line 955

Line 971

invalid = 0; /* One good key in the file is sufficient */

}

fclose(f);

free(line);

if (invalid)

fatal("%s is not a public key file.", path);

Line 975

Line 992

{ "ecdsa", "ECDSA",_PATH_HOST_ECDSA_KEY_FILE },

#endif /* WITH_OPENSSL */

{ "ed25519", "ED25519",_PATH_HOST_ED25519_KEY_FILE },

#ifdef WITH_XMSS

{ "xmss", "XMSS",_PATH_HOST_XMSS_KEY_FILE },

#endif /* WITH_XMSS */

{ NULL, NULL, NULL }

};

Line 1253

Line 1273

}

inplace = 1;

}

/* XXX support identity_file == "-" for stdin */

foreach_options = find_host ? HKF_WANT_MATCH : 0;

foreach_options |= print_fingerprint ? HKF_WANT_PARSE_KEY : 0;

if ((r = hostkeys_foreach(identity_file,

if ((r = hostkeys_foreach(identity_file, (find_host || !hash_hosts) ?

hash_hosts ? known_hosts_hash : known_hosts_find_delete, &ctx,

known_hosts_find_delete : known_hosts_hash, &ctx, name, NULL,

name, NULL, foreach_options)) != 0) {

foreach_options)) != 0) {

if (inplace)

unlink(tmp);

fatal("%s: hostkeys_foreach failed: %s", __func__, ssh_err(r));

Line 1461

Line 1480

}

if (private->type != KEY_ED25519 && !use_new_format) {

if (private->type != KEY_ED25519 && private->type != KEY_XMSS &&

!use_new_format) {

error("Comments are only supported for keys stored in "

"the new format (-o).");

explicit_bzero(passphrase, strlen(passphrase));

Line 1703

Line 1723

}

free(otmp);

}

if (n > SSHKEY_CERT_MAX_PRINCIPALS)

fatal("Too many certificate principals specified");

tmp = tilde_expand_filename(argv[i], pw->pw_uid);

if ((r = sshkey_load_public(tmp, &public, &comment)) != 0)

fatal("%s: unable to open \"%s\": %s",

__func__, tmp, ssh_err(r));

if (public->type != KEY_RSA && public->type != KEY_DSA &&

public->type != KEY_ECDSA && public->type != KEY_ED25519)

public->type != KEY_ECDSA && public->type != KEY_ED25519 &&

public->type != KEY_XMSS)

fatal("%s: key \"%s\" type %s cannot be certified",

__func__, tmp, sshkey_type(public));

Line 1793

Line 1816

return now + (u_int64_t)(secs * mul);

}

static u_int64_t

parse_absolute_time(const char *s)

{

struct tm tm;

time_t tt;

char buf[32], *fmt;

* POSIX strptime says "The application shall ensure that there

* is white-space or other non-alphanumeric characters between

* any two conversion specifications" so arrange things this way.

switch (strlen(s)) {

case 8:

fmt = "%Y-%m-%d";

snprintf(buf, sizeof(buf), "%.4s-%.2s-%.2s", s, s + 4, s + 6);

break;

case 14:

fmt = "%Y-%m-%dT%H:%M:%S";

snprintf(buf, sizeof(buf), "%.4s-%.2s-%.2sT%.2s:%.2s:%.2s",

s, s + 4, s + 6, s + 8, s + 10, s + 12);

break;

default:

fatal("Invalid certificate time format \"%s\"", s);

}

memset(&tm, 0, sizeof(tm));

if (strptime(buf, fmt, &tm) == NULL)

fatal("Invalid certificate time %s", s);

if ((tt = mktime(&tm)) < 0)

fatal("Certificate time %s cannot be represented", s);

return (u_int64_t)tt;

}

static void

parse_cert_times(char *timespec)

{

Line 1862

Line 1851

cert_valid_from = parse_relative_time(from, now);

else if (strcmp(from, "always") == 0)

cert_valid_from = 0;

else

else if (parse_absolute_time(from, &cert_valid_from) != 0)

cert_valid_from = parse_absolute_time(from);

fatal("Invalid from time \"%s\"", from);

if (*to == '-' || *to == '+')

cert_valid_to = parse_relative_time(to, now);

else if (strcmp(to, "forever") == 0)

cert_valid_to = ~(u_int64_t)0;

else

else if (parse_absolute_time(to, &cert_valid_to) != 0)

cert_valid_to = parse_absolute_time(to);

fatal("Invalid to time \"%s\"", to);

if (cert_valid_to <= cert_valid_from)

fatal("Empty certificate validity interval");

Line 2034

Line 2023

struct stat st;

int r, is_stdin = 0, ok = 0;

FILE *f;

char *cp, line[SSH_MAX_PUBKEY_BYTES];

char *cp, *line = NULL;

const char *path;

size_t linesize = 0;

u_long lnum = 0;

if (!have_identity)

Line 2051

Line 2041

} else if ((f = fopen(identity_file, "r")) == NULL)

fatal("fopen %s: %s", identity_file, strerror(errno));

while (read_keyfile_line(f, path, line, sizeof(line), &lnum) == 0) {

while (getline(&line, &linesize, f) != -1) {

lnum++;

sshkey_free(key);

key = NULL;

/* Trim leading space and comments */

Line 2076

Line 2067

printf("%s:%lu:\n", path, lnum);

print_cert(key);

}

free(line);

sshkey_free(key);

fclose(f);

exit(ok ? 0 : 1);

Line 2103

Line 2095

}

static void

hash_to_blob(const char *cp, u_char **blobp, size_t *lenp,

const char *file, u_long lnum)

{

char *tmp;

size_t tlen;

struct sshbuf *b;

int r;

if (strncmp(cp, "SHA256:", 7) != 0)

fatal("%s:%lu: unsupported hash algorithm", file, lnum);

cp += 7;

* OpenSSH base64 hashes omit trailing '='

* characters; put them back for decode.

tlen = strlen(cp);

tmp = xmalloc(tlen + 4 + 1);

strlcpy(tmp, cp, tlen + 1);

while ((tlen % 4) != 0) {

tmp[tlen++] = '=';

tmp[tlen] = '\0';

}

if ((b = sshbuf_new()) == NULL)

fatal("%s: sshbuf_new failed", __func__);

if ((r = sshbuf_b64tod(b, tmp)) != 0)

fatal("%s:%lu: decode hash failed: %s", file, lnum, ssh_err(r));

free(tmp);

*lenp = sshbuf_len(b);

*blobp = xmalloc(*lenp);

memcpy(*blobp, sshbuf_ptr(b), *lenp);

sshbuf_free(b);

}

static void

update_krl_from_file(struct passwd *pw, const char *file, int wild_ca,

const struct sshkey *ca, struct ssh_krl *krl)

{

struct sshkey *key = NULL;

u_long lnum = 0;

char *path, *cp, *ep, line[SSH_MAX_PUBKEY_BYTES];

char *path, *cp, *ep, *line = NULL;

u_char *blob = NULL;

size_t blen = 0, linesize = 0;

unsigned long long serial, serial2;

int i, was_explicit_key, was_sha1, r;

int i, was_explicit_key, was_sha1, was_sha256, was_hash, r;

FILE *krl_spec;

path = tilde_expand_filename(file, pw->pw_uid);

Line 2123

Line 2152

if (!quiet)

printf("Revoking from %s\n", path);

while (read_keyfile_line(krl_spec, path, line, sizeof(line),

while (getline(&line, &linesize, krl_spec) != -1) {

&lnum) == 0) {

lnum++;

was_explicit_key = was_sha1 = 0;

was_explicit_key = was_sha1 = was_sha256 = was_hash = 0;

cp = line + strspn(line, " \t");

/* Trim trailing space, comments and strip \n */

for (i = 0, r = -1; cp[i] != '\0'; i++) {

Line 2190

Line 2219

cp = cp + strspn(cp, " \t");

if (ssh_krl_revoke_cert_by_key_id(krl, ca, cp) != 0)

fatal("%s: revoke key ID failed", __func__);

} else if (strncasecmp(cp, "hash:", 5) == 0) {

cp += 5;

cp = cp + strspn(cp, " \t");

hash_to_blob(cp, &blob, &blen, file, lnum);

r = ssh_krl_revoke_key_sha256(krl, blob, blen);

} else {

if (strncasecmp(cp, "key:", 4) == 0) {

cp += 4;

Line 2199

Line 2233

cp += 5;

cp = cp + strspn(cp, " \t");

was_sha1 = 1;

} else {

} else if (strncasecmp(cp, "sha256:", 7) == 0) {

cp += 7;

cp = cp + strspn(cp, " \t");

was_sha256 = 1;

* Just try to process the line as a key.

* Parsing will fail if it isn't.

Line 2212

Line 2249

path, lnum, ssh_err(r));

if (was_explicit_key)

r = ssh_krl_revoke_key_explicit(krl, key);

else if (was_sha1)

else if (was_sha1) {

r = ssh_krl_revoke_key_sha1(krl, key);

if (sshkey_fingerprint_raw(key,

else

SSH_DIGEST_SHA1, &blob, &blen) != 0) {

fatal("%s:%lu: fingerprint failed",

file, lnum);

}

r = ssh_krl_revoke_key_sha1(krl, blob, blen);

} else if (was_sha256) {

if (sshkey_fingerprint_raw(key,

SSH_DIGEST_SHA256, &blob, &blen) != 0) {

fatal("%s:%lu: fingerprint failed",

file, lnum);

}

r = ssh_krl_revoke_key_sha256(krl, blob, blen);

} else

r = ssh_krl_revoke_key(krl, key);

if (r != 0)

fatal("%s: revoke key failed: %s",

__func__, ssh_err(r));

freezero(blob, blen);

blob = NULL;

blen = 0;

sshkey_free(key);

}

if (strcmp(path, "-") != 0)

fclose(krl_spec);

free(line);

free(path);

}

Line 2277

Line 2330

fatal("Couldn't generate KRL");

if ((fd = open(identity_file, O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1)

fatal("open %s: %s", identity_file, strerror(errno));

if (atomicio(vwrite, fd, (void *)sshbuf_ptr(kbuf), sshbuf_len(kbuf)) !=

if (atomicio(vwrite, fd, sshbuf_mutable_ptr(kbuf), sshbuf_len(kbuf)) !=

sshbuf_len(kbuf))

fatal("write %s: %s", identity_file, strerror(errno));

close(fd);

Line 2405

Line 2458

gen_all_hostkeys = 1;

break;

case 'b':

bits = (u_int32_t)strtonum(optarg, 256, 32768, &errstr);

bits = (u_int32_t)strtonum(optarg, 10, 32768, &errstr);

if (errstr)

fatal("Bits has bad value %s (%s)",

optarg, errstr);

Line 2450

Line 2503

}

if (strcasecmp(optarg, "PEM") == 0) {

convert_format = FMT_PEM;

use_new_format = 0;

break;

}

fatal("Unsupported conversion format \"%s\"", optarg);

Line 2457

Line 2511

cert_principals = optarg;

break;

case 'o':

use_new_format = 1;

/* no-op; new format is already the default */

break;

case 'p':

change_passphrase = 1;

Line 2685

Line 2739

_PATH_HOST_ECDSA_KEY_FILE, rr_hostname);

n += do_print_resource_record(pw,

_PATH_HOST_ED25519_KEY_FILE, rr_hostname);

n += do_print_resource_record(pw,

_PATH_HOST_XMSS_KEY_FILE, rr_hostname);

if (n == 0)

fatal("no keys found.");

exit(0);

Line 2845

Line 2901

if ((r = sshkey_write(public, f)) != 0)

error("write key failed: %s", ssh_err(r));

fprintf(f, " %s\n", comment);

fclose(f);

if (ferror(f) || fclose(f) != 0)

fatal("write public failed: %s", strerror(errno));

if (!quiet) {

fp = sshkey_fingerprint(public, fingerprint_hash,