version 1.445, 2022/01/05 04:50:11 |
version 1.467, 2023/04/12 08:53:54 |
|
|
#define CERTOPT_PTY (1<<3) |
#define CERTOPT_PTY (1<<3) |
#define CERTOPT_USER_RC (1<<4) |
#define CERTOPT_USER_RC (1<<4) |
#define CERTOPT_NO_REQUIRE_USER_PRESENCE (1<<5) |
#define CERTOPT_NO_REQUIRE_USER_PRESENCE (1<<5) |
|
#define CERTOPT_REQUIRE_VERIFY (1<<6) |
#define CERTOPT_DEFAULT (CERTOPT_X_FWD|CERTOPT_AGENT_FWD| \ |
#define CERTOPT_DEFAULT (CERTOPT_X_FWD|CERTOPT_AGENT_FWD| \ |
CERTOPT_PORT_FWD|CERTOPT_PTY|CERTOPT_USER_RC) |
CERTOPT_PORT_FWD|CERTOPT_PTY|CERTOPT_USER_RC) |
static u_int32_t certflags_flags = CERTOPT_DEFAULT; |
static u_int32_t certflags_flags = CERTOPT_DEFAULT; |
|
|
{ |
{ |
struct sshkey *key = NULL; |
struct sshkey *key = NULL; |
char *type, *cipher; |
char *type, *cipher; |
|
const char *alg = NULL; |
u_char e1, e2, e3, *sig = NULL, data[] = "abcde12345"; |
u_char e1, e2, e3, *sig = NULL, data[] = "abcde12345"; |
int r, rlen, ktype; |
int r, rlen, ktype; |
u_int magic, i1, i2, i3, i4; |
u_int magic, i1, i2, i3, i4; |
|
|
if ((r = ssh_rsa_complete_crt_parameters(key, rsa_iqmp)) != 0) |
if ((r = ssh_rsa_complete_crt_parameters(key, rsa_iqmp)) != 0) |
fatal_fr(r, "generate RSA parameters"); |
fatal_fr(r, "generate RSA parameters"); |
BN_clear_free(rsa_iqmp); |
BN_clear_free(rsa_iqmp); |
|
alg = "rsa-sha2-256"; |
break; |
break; |
} |
} |
rlen = sshbuf_len(b); |
rlen = sshbuf_len(b); |
|
|
error_f("remaining bytes in key blob %d", 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 ((r = sshkey_sign(key, &sig, &slen, data, sizeof(data), |
NULL, NULL, NULL, 0) != 0 || |
alg, NULL, NULL, 0)) != 0) |
sshkey_verify(key, sig, slen, data, sizeof(data), |
error_fr(r, "signing with converted key failed"); |
NULL, 0, NULL) != 0) { |
else if ((r = sshkey_verify(key, sig, slen, data, sizeof(data), |
|
alg, 0, NULL)) != 0) |
|
error_fr(r, "verification with converted key failed"); |
|
if (r != 0) { |
sshkey_free(key); |
sshkey_free(key); |
free(sig); |
free(sig); |
return NULL; |
return NULL; |
|
|
} key_types[] = { |
} key_types[] = { |
#ifdef WITH_OPENSSL |
#ifdef WITH_OPENSSL |
{ "rsa", "RSA" ,_PATH_HOST_RSA_KEY_FILE }, |
{ "rsa", "RSA" ,_PATH_HOST_RSA_KEY_FILE }, |
{ "dsa", "DSA", _PATH_HOST_DSA_KEY_FILE }, |
|
{ "ecdsa", "ECDSA",_PATH_HOST_ECDSA_KEY_FILE }, |
{ "ecdsa", "ECDSA",_PATH_HOST_ECDSA_KEY_FILE }, |
#endif /* WITH_OPENSSL */ |
#endif /* WITH_OPENSSL */ |
{ "ed25519", "ED25519",_PATH_HOST_ED25519_KEY_FILE }, |
{ "ed25519", "ED25519",_PATH_HOST_ED25519_KEY_FILE }, |
|
|
case HKF_STATUS_OK: |
case HKF_STATUS_OK: |
case HKF_STATUS_MATCHED: |
case HKF_STATUS_MATCHED: |
/* |
/* |
* Don't hash hosts already already hashed, with wildcard |
* Don't hash hosts already hashed, with wildcard |
* characters or a CA/revocation marker. |
* characters or a CA/revocation marker. |
*/ |
*/ |
if (was_hashed || has_wild || l->marker != MRK_NONE) { |
if (was_hashed || has_wild || l->marker != MRK_NONE) { |
|
|
unlink(tmp); |
unlink(tmp); |
fatal("fdopen: %s", strerror(oerrno)); |
fatal("fdopen: %s", strerror(oerrno)); |
} |
} |
fchmod(fd, sb.st_mode & 0644); |
(void)fchmod(fd, sb.st_mode & 0644); |
inplace = 1; |
inplace = 1; |
} |
} |
/* XXX support identity_file == "-" for stdin */ |
/* XXX support identity_file == "-" for stdin */ |
|
|
*/ |
*/ |
static int |
static int |
do_print_resource_record(struct passwd *pw, char *fname, char *hname, |
do_print_resource_record(struct passwd *pw, char *fname, char *hname, |
int print_generic) |
int print_generic, char * const *opts, size_t nopts) |
{ |
{ |
struct sshkey *public; |
struct sshkey *public; |
char *comment = NULL; |
char *comment = NULL; |
struct stat st; |
struct stat st; |
int r; |
int r, hash = -1; |
|
size_t i; |
|
|
|
for (i = 0; i < nopts; i++) { |
|
if (strncasecmp(opts[i], "hashalg=", 8) == 0) { |
|
if ((hash = ssh_digest_alg_by_name(opts[i] + 8)) == -1) |
|
fatal("Unsupported hash algorithm"); |
|
} else { |
|
error("Invalid option \"%s\"", opts[i]); |
|
return SSH_ERR_INVALID_ARGUMENT; |
|
} |
|
} |
if (fname == NULL) |
if (fname == NULL) |
fatal_f("no filename"); |
fatal_f("no filename"); |
if (stat(fname, &st) == -1) { |
if (stat(fname, &st) == -1) { |
|
|
} |
} |
if ((r = sshkey_load_public(fname, &public, &comment)) != 0) |
if ((r = sshkey_load_public(fname, &public, &comment)) != 0) |
fatal_r(r, "Failed to read v2 public key from \"%s\"", fname); |
fatal_r(r, "Failed to read v2 public key from \"%s\"", fname); |
export_dns_rr(hname, public, stdout, print_generic); |
export_dns_rr(hname, public, stdout, print_generic, hash); |
sshkey_free(public); |
sshkey_free(public); |
free(comment); |
free(comment); |
return 1; |
return 1; |
|
|
cert_ext_add("force-command", certflags_command, 1); |
cert_ext_add("force-command", certflags_command, 1); |
if (certflags_src_addr != NULL) |
if (certflags_src_addr != NULL) |
cert_ext_add("source-address", certflags_src_addr, 1); |
cert_ext_add("source-address", certflags_src_addr, 1); |
|
if ((certflags_flags & CERTOPT_REQUIRE_VERIFY) != 0) |
|
cert_ext_add("verify-required", NULL, 1); |
/* extensions */ |
/* extensions */ |
if ((certflags_flags & CERTOPT_X_FWD) != 0) |
if ((certflags_flags & CERTOPT_X_FWD) != 0) |
cert_ext_add("permit-X11-forwarding", NULL, 0); |
cert_ext_add("permit-X11-forwarding", NULL, 0); |
|
|
} |
} |
|
|
static void |
static void |
|
parse_hex_u64(const char *s, uint64_t *up) |
|
{ |
|
char *ep; |
|
unsigned long long ull; |
|
|
|
errno = 0; |
|
ull = strtoull(s, &ep, 16); |
|
if (*s == '\0' || *ep != '\0') |
|
fatal("Invalid certificate time: not a number"); |
|
if (errno == ERANGE && ull == ULONG_MAX) |
|
fatal_fr(SSH_ERR_SYSTEM_ERROR, "Invalid certificate time"); |
|
*up = (uint64_t)ull; |
|
} |
|
|
|
static void |
parse_cert_times(char *timespec) |
parse_cert_times(char *timespec) |
{ |
{ |
char *from, *to; |
char *from, *to; |
|
|
|
|
/* |
/* |
* from:to, where |
* from:to, where |
* from := [+-]timespec | YYYYMMDD | YYYYMMDDHHMMSS | "always" |
* from := [+-]timespec | YYYYMMDD | YYYYMMDDHHMMSS | 0x... | "always" |
* to := [+-]timespec | YYYYMMDD | YYYYMMDDHHMMSS | "forever" |
* to := [+-]timespec | YYYYMMDD | YYYYMMDDHHMMSS | 0x... | "forever" |
*/ |
*/ |
from = xstrdup(timespec); |
from = xstrdup(timespec); |
to = strchr(from, ':'); |
to = strchr(from, ':'); |
|
|
cert_valid_from = parse_relative_time(from, now); |
cert_valid_from = parse_relative_time(from, now); |
else if (strcmp(from, "always") == 0) |
else if (strcmp(from, "always") == 0) |
cert_valid_from = 0; |
cert_valid_from = 0; |
|
else if (strncmp(from, "0x", 2) == 0) |
|
parse_hex_u64(from, &cert_valid_from); |
else if (parse_absolute_time(from, &cert_valid_from) != 0) |
else if (parse_absolute_time(from, &cert_valid_from) != 0) |
fatal("Invalid from time \"%s\"", from); |
fatal("Invalid from time \"%s\"", from); |
|
|
|
|
cert_valid_to = parse_relative_time(to, now); |
cert_valid_to = parse_relative_time(to, now); |
else if (strcmp(to, "forever") == 0) |
else if (strcmp(to, "forever") == 0) |
cert_valid_to = ~(u_int64_t)0; |
cert_valid_to = ~(u_int64_t)0; |
|
else if (strncmp(to, "0x", 2) == 0) |
|
parse_hex_u64(to, &cert_valid_to); |
else if (parse_absolute_time(to, &cert_valid_to) != 0) |
else if (parse_absolute_time(to, &cert_valid_to) != 0) |
fatal("Invalid to time \"%s\"", to); |
fatal("Invalid to time \"%s\"", to); |
|
|
|
|
certflags_flags &= ~CERTOPT_NO_REQUIRE_USER_PRESENCE; |
certflags_flags &= ~CERTOPT_NO_REQUIRE_USER_PRESENCE; |
else if (strcasecmp(opt, "no-touch-required") == 0) |
else if (strcasecmp(opt, "no-touch-required") == 0) |
certflags_flags |= CERTOPT_NO_REQUIRE_USER_PRESENCE; |
certflags_flags |= CERTOPT_NO_REQUIRE_USER_PRESENCE; |
|
else if (strcasecmp(opt, "no-verify-required") == 0) |
|
certflags_flags &= ~CERTOPT_REQUIRE_VERIFY; |
|
else if (strcasecmp(opt, "verify-required") == 0) |
|
certflags_flags |= CERTOPT_REQUIRE_VERIFY; |
else if (strncasecmp(opt, "force-command=", 14) == 0) { |
else if (strncasecmp(opt, "force-command=", 14) == 0) { |
val = opt + 14; |
val = opt + 14; |
if (*val == '\0') |
if (*val == '\0') |
|
|
fatal_fr(r, "parse critical"); |
fatal_fr(r, "parse critical"); |
printf(" %s\n", arg); |
printf(" %s\n", arg); |
free(arg); |
free(arg); |
|
} else if (in_critical && |
|
strcmp(name, "verify-required") == 0) { |
|
printf("\n"); |
} else if (sshbuf_len(option) > 0) { |
} else if (sshbuf_len(option) > 0) { |
hex = sshbuf_dtob16(option); |
hex = sshbuf_dtob16(option); |
printf(" UNKNOWN OPTION: %s (len %zu)\n", |
printf(" UNKNOWN OPTION: %s (len %zu)\n", |
|
|
{ |
{ |
size_t i, slen, plen = strlen(keypath); |
size_t i, slen, plen = strlen(keypath); |
char *privpath = xstrdup(keypath); |
char *privpath = xstrdup(keypath); |
const char *suffixes[] = { "-cert.pub", ".pub", NULL }; |
static const char * const suffixes[] = { "-cert.pub", ".pub", NULL }; |
struct sshkey *ret = NULL, *privkey = NULL; |
struct sshkey *ret = NULL, *privkey = NULL; |
int r; |
int r, waspub = 0; |
|
struct stat st; |
|
|
/* |
/* |
* If passed a public key filename, then try to locate the corresponding |
* If passed a public key filename, then try to locate the corresponding |
|
|
privpath[plen - slen] = '\0'; |
privpath[plen - slen] = '\0'; |
debug_f("%s looks like a public key, using private key " |
debug_f("%s looks like a public key, using private key " |
"path %s instead", keypath, privpath); |
"path %s instead", keypath, privpath); |
|
waspub = 1; |
} |
} |
if ((privkey = load_identity(privpath, NULL)) == NULL) { |
if (waspub && stat(privpath, &st) != 0 && errno == ENOENT) |
error("Couldn't load identity %s", keypath); |
fatal("No private key found for public key \"%s\"", keypath); |
goto done; |
if ((r = sshkey_load_private(privpath, "", &privkey, NULL)) != 0 && |
} |
(r != SSH_ERR_KEY_WRONG_PASSPHRASE)) { |
|
debug_fr(r, "load private key \"%s\"", privpath); |
|
fatal("No private key found for \"%s\"", privpath); |
|
} else if (privkey == NULL) |
|
privkey = load_identity(privpath, NULL); |
|
|
if (!sshkey_equal_public(pubkey, privkey)) { |
if (!sshkey_equal_public(pubkey, privkey)) { |
error("Public key %s doesn't match private %s", |
error("Public key %s doesn't match private %s", |
keypath, privpath); |
keypath, privpath); |
|
|
|
|
|
|
static int |
static int |
sig_sign(const char *keypath, const char *sig_namespace, int argc, char **argv, |
sig_sign(const char *keypath, const char *sig_namespace, int require_agent, |
char * const *opts, size_t nopts) |
int argc, char **argv, char * const *opts, size_t nopts) |
{ |
{ |
int i, fd = -1, r, ret = -1; |
int i, fd = -1, r, ret = -1; |
int agent_fd = -1; |
int agent_fd = -1; |
|
|
goto done; |
goto done; |
} |
} |
|
|
if ((r = ssh_get_authentication_socket(&agent_fd)) != 0) |
if ((r = ssh_get_authentication_socket(&agent_fd)) != 0) { |
|
if (require_agent) |
|
fatal("Couldn't get agent socket"); |
debug_r(r, "Couldn't get agent socket"); |
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 { |
|
if (require_agent) |
|
fatal("Couldn't find key in agent"); |
debug_r(r, "Couldn't find key in agent"); |
debug_r(r, "Couldn't find key in agent"); |
|
} |
} |
} |
|
|
if (signer == NULL) { |
if (signer == NULL) { |
|
|
} else if (strncmp(opts[i], "start-line=", 11) == 0) { |
} else if (strncmp(opts[i], "start-line=", 11) == 0) { |
start_lineno = strtoul(opts[i]+11, NULL, 10); |
start_lineno = strtoul(opts[i]+11, NULL, 10); |
} else if (strncmp(opts[i], "checkpoint=", 11) == 0) { |
} else if (strncmp(opts[i], "checkpoint=", 11) == 0) { |
|
free(checkpoint); |
checkpoint = xstrdup(opts[i]+11); |
checkpoint = xstrdup(opts[i]+11); |
} else if (strncmp(opts[i], "generator=", 10) == 0) { |
} else if (strncmp(opts[i], "generator=", 10) == 0) { |
generator_wanted = (u_int32_t)strtonum( |
generator_wanted = (u_int32_t)strtonum( |
|
|
generator_wanted, checkpoint, |
generator_wanted, checkpoint, |
start_lineno, lines_to_process) != 0) |
start_lineno, lines_to_process) != 0) |
fatal("modulus screening failed"); |
fatal("modulus screening failed"); |
|
if (in != stdin) |
|
(void)fclose(in); |
|
free(checkpoint); |
#else /* WITH_OPENSSL */ |
#else /* WITH_OPENSSL */ |
fatal("Moduli screening is not supported"); |
fatal("Moduli screening is not supported"); |
#endif /* WITH_OPENSSL */ |
#endif /* WITH_OPENSSL */ |
} |
} |
|
|
|
/* Read and confirm a passphrase */ |
static char * |
static char * |
private_key_passphrase(void) |
read_check_passphrase(const char *prompt1, const char *prompt2, |
|
const char *retry_prompt) |
{ |
{ |
char *passphrase1, *passphrase2; |
char *passphrase1, *passphrase2; |
|
|
/* Ask for a passphrase (twice). */ |
for (;;) { |
if (identity_passphrase) |
passphrase1 = read_passphrase(prompt1, RP_ALLOW_STDIN); |
passphrase1 = xstrdup(identity_passphrase); |
passphrase2 = read_passphrase(prompt2, RP_ALLOW_STDIN); |
else if (identity_new_passphrase) |
if (strcmp(passphrase1, passphrase2) == 0) { |
passphrase1 = xstrdup(identity_new_passphrase); |
|
else { |
|
passphrase_again: |
|
passphrase1 = |
|
read_passphrase("Enter passphrase (empty for no " |
|
"passphrase): ", RP_ALLOW_STDIN); |
|
passphrase2 = read_passphrase("Enter same passphrase again: ", |
|
RP_ALLOW_STDIN); |
|
if (strcmp(passphrase1, passphrase2) != 0) { |
|
/* |
|
* The passphrases do not match. Clear them and |
|
* retry. |
|
*/ |
|
freezero(passphrase1, strlen(passphrase1)); |
|
freezero(passphrase2, strlen(passphrase2)); |
freezero(passphrase2, strlen(passphrase2)); |
printf("Passphrases do not match. Try again.\n"); |
return passphrase1; |
goto passphrase_again; |
|
} |
} |
/* Clear the other copy of the passphrase. */ |
/* The passphrases do not match. Clear them and retry. */ |
|
freezero(passphrase1, strlen(passphrase1)); |
freezero(passphrase2, strlen(passphrase2)); |
freezero(passphrase2, strlen(passphrase2)); |
|
fputs(retry_prompt, stdout); |
|
fputc('\n', stdout); |
|
fflush(stdout); |
} |
} |
return passphrase1; |
/* NOTREACHED */ |
|
return NULL; |
} |
} |
|
|
static char * |
static char * |
|
private_key_passphrase(void) |
|
{ |
|
if (identity_passphrase) |
|
return xstrdup(identity_passphrase); |
|
if (identity_new_passphrase) |
|
return xstrdup(identity_new_passphrase); |
|
|
|
return read_check_passphrase( |
|
"Enter passphrase (empty for no passphrase): ", |
|
"Enter same passphrase again: ", |
|
"Passphrases do not match. Try again."); |
|
} |
|
|
|
static char * |
sk_suffix(const char *application, const uint8_t *user, size_t userlen) |
sk_suffix(const char *application, const uint8_t *user, size_t userlen) |
{ |
{ |
char *ret, *cp; |
char *ret, *cp; |
|
|
"%s\n", path); |
"%s\n", path); |
} |
} |
|
|
|
static int |
|
confirm_sk_overwrite(const char *application, const char *user) |
|
{ |
|
char yesno[3]; |
|
|
|
printf("A resident key scoped to '%s' with user id '%s' already " |
|
"exists.\n", application == NULL ? "ssh:" : application, |
|
user == NULL ? "null" : user); |
|
printf("Overwrite key in token (y/n)? "); |
|
fflush(stdout); |
|
if (fgets(yesno, sizeof(yesno), stdin) == NULL) |
|
return 0; |
|
if (yesno[0] != 'y' && yesno[0] != 'Y') |
|
return 0; |
|
return 1; |
|
} |
|
|
static void |
static void |
usage(void) |
usage(void) |
{ |
{ |
|
|
int |
int |
main(int argc, char **argv) |
main(int argc, char **argv) |
{ |
{ |
char comment[1024], *passphrase; |
char comment[1024], *passphrase = NULL; |
char *rr_hostname = NULL, *ep, *fp, *ra; |
char *rr_hostname = NULL, *ep, *fp, *ra; |
struct sshkey *private, *public; |
struct sshkey *private, *public; |
struct passwd *pw; |
struct passwd *pw; |
|
|
else |
else |
fatal("Unsupported moduli option %s", optarg); |
fatal("Unsupported moduli option %s", optarg); |
break; |
break; |
case '?': |
|
default: |
default: |
usage(); |
usage(); |
} |
} |
|
|
return sig_match_principals(identity_file, cert_key_id, |
return sig_match_principals(identity_file, cert_key_id, |
opts, nopts); |
opts, nopts); |
} else if (strncmp(sign_op, "sign", 4) == 0) { |
} else if (strncmp(sign_op, "sign", 4) == 0) { |
|
/* NB. cert_principals is actually namespace, via -n */ |
if (cert_principals == NULL || |
if (cert_principals == NULL || |
*cert_principals == '\0') { |
*cert_principals == '\0') { |
error("Too few arguments for sign: " |
error("Too few arguments for sign: " |
|
|
exit(1); |
exit(1); |
} |
} |
return sig_sign(identity_file, cert_principals, |
return sig_sign(identity_file, cert_principals, |
argc, argv, opts, nopts); |
prefer_agent, argc, argv, opts, nopts); |
} else if (strncmp(sign_op, "check-novalidate", 16) == 0) { |
} else if (strncmp(sign_op, "check-novalidate", 16) == 0) { |
|
/* NB. cert_principals is actually namespace, via -n */ |
|
if (cert_principals == NULL || |
|
*cert_principals == '\0') { |
|
error("Too few arguments for check-novalidate: " |
|
"missing namespace"); |
|
exit(1); |
|
} |
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"); |
|
|
return sig_verify(ca_key_path, cert_principals, |
return sig_verify(ca_key_path, cert_principals, |
NULL, NULL, NULL, opts, nopts); |
NULL, NULL, NULL, opts, nopts); |
} else if (strncmp(sign_op, "verify", 6) == 0) { |
} else if (strncmp(sign_op, "verify", 6) == 0) { |
|
/* NB. cert_principals is actually namespace, via -n */ |
if (cert_principals == NULL || |
if (cert_principals == NULL || |
*cert_principals == '\0') { |
*cert_principals == '\0') { |
error("Too few arguments for verify: " |
error("Too few arguments for verify: " |
|
|
} |
} |
if (cert_key_id == NULL) { |
if (cert_key_id == NULL) { |
error("Too few arguments for verify: " |
error("Too few arguments for verify: " |
"missing principal ID"); |
"missing principal identity"); |
exit(1); |
exit(1); |
} |
} |
return sig_verify(ca_key_path, cert_principals, |
return sig_verify(ca_key_path, cert_principals, |
|
|
|
|
if (have_identity) { |
if (have_identity) { |
n = do_print_resource_record(pw, identity_file, |
n = do_print_resource_record(pw, identity_file, |
rr_hostname, print_generic); |
rr_hostname, print_generic, opts, nopts); |
if (n == 0) |
if (n == 0) |
fatal("%s: %s", identity_file, strerror(errno)); |
fatal("%s: %s", identity_file, strerror(errno)); |
exit(0); |
exit(0); |
|
|
|
|
n += do_print_resource_record(pw, |
n += do_print_resource_record(pw, |
_PATH_HOST_RSA_KEY_FILE, rr_hostname, |
_PATH_HOST_RSA_KEY_FILE, rr_hostname, |
print_generic); |
print_generic, opts, nopts); |
n += do_print_resource_record(pw, |
n += do_print_resource_record(pw, |
_PATH_HOST_DSA_KEY_FILE, rr_hostname, |
_PATH_HOST_DSA_KEY_FILE, rr_hostname, |
print_generic); |
print_generic, opts, nopts); |
n += do_print_resource_record(pw, |
n += do_print_resource_record(pw, |
_PATH_HOST_ECDSA_KEY_FILE, rr_hostname, |
_PATH_HOST_ECDSA_KEY_FILE, rr_hostname, |
print_generic); |
print_generic, opts, nopts); |
n += do_print_resource_record(pw, |
n += do_print_resource_record(pw, |
_PATH_HOST_ED25519_KEY_FILE, rr_hostname, |
_PATH_HOST_ED25519_KEY_FILE, rr_hostname, |
print_generic); |
print_generic, opts, nopts); |
n += do_print_resource_record(pw, |
n += do_print_resource_record(pw, |
_PATH_HOST_XMSS_KEY_FILE, rr_hostname, |
_PATH_HOST_XMSS_KEY_FILE, rr_hostname, |
print_generic); |
print_generic, opts, nopts); |
if (n == 0) |
if (n == 0) |
fatal("no keys found."); |
fatal("no keys found."); |
exit(0); |
exit(0); |
|
|
"FIDO authenticator enrollment", opts[i]); |
"FIDO authenticator enrollment", opts[i]); |
} |
} |
} |
} |
if (!quiet) { |
|
printf("You may need to touch your authenticator " |
|
"to authorize key generation.\n"); |
|
} |
|
if ((attest = sshbuf_new()) == NULL) |
if ((attest = sshbuf_new()) == NULL) |
fatal("sshbuf_new failed"); |
fatal("sshbuf_new failed"); |
if ((sk_flags & |
r = 0; |
(SSH_SK_USER_VERIFICATION_REQD|SSH_SK_RESIDENT_KEY))) { |
for (i = 0 ;;) { |
passphrase = read_passphrase("Enter PIN for " |
if (!quiet) { |
"authenticator: ", RP_ALLOW_STDIN); |
printf("You may need to touch your " |
} else { |
"authenticator%s to authorize key " |
passphrase = NULL; |
"generation.\n", |
} |
r == 0 ? "" : " again"); |
for (i = 0 ; ; i++) { |
} |
fflush(stdout); |
fflush(stdout); |
r = sshsk_enroll(type, sk_provider, sk_device, |
r = sshsk_enroll(type, sk_provider, sk_device, |
sk_application == NULL ? "ssh:" : sk_application, |
sk_application == NULL ? "ssh:" : sk_application, |
|
|
&private, attest); |
&private, attest); |
if (r == 0) |
if (r == 0) |
break; |
break; |
|
if (r == SSH_ERR_KEY_BAD_PERMISSIONS && |
|
(sk_flags & SSH_SK_RESIDENT_KEY) != 0 && |
|
(sk_flags & SSH_SK_FORCE_OPERATION) == 0 && |
|
confirm_sk_overwrite(sk_application, sk_user)) { |
|
sk_flags |= SSH_SK_FORCE_OPERATION; |
|
continue; |
|
} |
if (r != SSH_ERR_KEY_WRONG_PASSPHRASE) |
if (r != SSH_ERR_KEY_WRONG_PASSPHRASE) |
fatal_r(r, "Key enrollment failed"); |
fatal_r(r, "Key enrollment failed"); |
else if (passphrase != NULL) { |
else if (passphrase != NULL) { |
|
|
freezero(passphrase, strlen(passphrase)); |
freezero(passphrase, strlen(passphrase)); |
passphrase = NULL; |
passphrase = NULL; |
} |
} |
if (i >= 3) |
if (++i >= 3) |
fatal("Too many incorrect PINs"); |
fatal("Too many incorrect PINs"); |
passphrase = read_passphrase("Enter PIN for " |
passphrase = read_passphrase("Enter PIN for " |
"authenticator: ", RP_ALLOW_STDIN); |
"authenticator: ", RP_ALLOW_STDIN); |
if (!quiet) { |
|
printf("You may need to touch your " |
|
"authenticator (again) to authorize " |
|
"key generation.\n"); |
|
} |
|
} |
} |
if (passphrase != NULL) { |
if (passphrase != NULL) { |
freezero(passphrase, strlen(passphrase)); |
freezero(passphrase, strlen(passphrase)); |