version 1.326, 2019/01/23 04:51:02 |
version 1.338, 2019/07/19 03:38:01 |
|
|
#include "xmalloc.h" |
#include "xmalloc.h" |
#include "sshkey.h" |
#include "sshkey.h" |
#include "authfile.h" |
#include "authfile.h" |
#include "uuencode.h" |
|
#include "sshbuf.h" |
#include "sshbuf.h" |
#include "pathnames.h" |
#include "pathnames.h" |
#include "log.h" |
#include "log.h" |
|
|
# define DEFAULT_KEY_TYPE_NAME "ed25519" |
# define DEFAULT_KEY_TYPE_NAME "ed25519" |
#endif |
#endif |
|
|
/* Number of bits in the RSA/DSA key. This value can be set on the command line. */ |
/* |
#define DEFAULT_BITS 2048 |
* Default number of bits in the RSA, DSA and ECDSA keys. These value can be |
|
* overridden on the command line. |
|
* |
|
* These values, with the exception of DSA, provide security equivalent to at |
|
* least 128 bits of security according to NIST Special Publication 800-57: |
|
* Recommendation for Key Management Part 1 rev 4 section 5.6.1. |
|
* For DSA it (and FIPS-186-4 section 4.2) specifies that the only size for |
|
* which a 160bit hash is acceptable is 1kbit, and since ssh-dss specifies only |
|
* SHA1 we limit the DSA key size 1k bits. |
|
*/ |
|
#define DEFAULT_BITS 3072 |
#define DEFAULT_BITS_DSA 1024 |
#define DEFAULT_BITS_DSA 1024 |
#define DEFAULT_BITS_ECDSA 256 |
#define DEFAULT_BITS_ECDSA 256 |
|
|
|
|
/* Load key from this PKCS#11 provider */ |
/* Load key from this PKCS#11 provider */ |
static char *pkcs11provider = NULL; |
static char *pkcs11provider = NULL; |
|
|
/* Use new OpenSSH private key format when writing SSH2 keys instead of PEM */ |
/* Format for writing private keys */ |
static int use_new_format = 1; |
static int private_key_format = SSHKEY_PRIVATE_OPENSSH; |
|
|
/* Cipher for new-format private keys */ |
/* Cipher for new-format private keys */ |
static char *new_format_cipher = NULL; |
static char *openssh_format_cipher = NULL; |
|
|
/* |
/* |
* Number of KDF rounds to derive new format keys / |
* Number of KDF rounds to derive new format keys / |
|
|
static void |
static void |
do_convert_to_ssh2(struct passwd *pw, struct sshkey *k) |
do_convert_to_ssh2(struct passwd *pw, struct sshkey *k) |
{ |
{ |
size_t len; |
struct sshbuf *b; |
u_char *blob; |
char comment[61], *b64; |
char comment[61]; |
|
int r; |
int r; |
|
|
if ((r = sshkey_to_blob(k, &blob, &len)) != 0) |
if ((b = sshbuf_new()) == NULL) |
|
fatal("%s: sshbuf_new failed", __func__); |
|
if ((r = sshkey_putb(k, b)) != 0) |
fatal("key_to_blob failed: %s", ssh_err(r)); |
fatal("key_to_blob failed: %s", ssh_err(r)); |
|
if ((b64 = sshbuf_dtob64_string(b, 1)) == NULL) |
|
fatal("%s: sshbuf_dtob64_string failed", __func__); |
|
|
/* 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), |
"%u-bit %s, converted by %s@%s from OpenSSH", |
"%u-bit %s, converted by %s@%s from OpenSSH", |
sshkey_size(k), sshkey_type(k), |
sshkey_size(k), sshkey_type(k), |
pw->pw_name, hostname); |
pw->pw_name, hostname); |
|
|
|
sshkey_free(k); |
|
sshbuf_free(b); |
|
|
fprintf(stdout, "%s\n", SSH_COM_PUBLIC_BEGIN); |
fprintf(stdout, "%s\n", SSH_COM_PUBLIC_BEGIN); |
fprintf(stdout, "Comment: \"%s\"\n", comment); |
fprintf(stdout, "Comment: \"%s\"\n%s", comment, b64); |
dump_base64(stdout, blob, len); |
|
fprintf(stdout, "%s\n", SSH_COM_PUBLIC_END); |
fprintf(stdout, "%s\n", SSH_COM_PUBLIC_END); |
sshkey_free(k); |
free(b64); |
free(blob); |
|
exit(0); |
exit(0); |
} |
} |
|
|
|
|
|
|
if (!have_identity) |
if (!have_identity) |
ask_filename(pw, "Enter file in which the key is"); |
ask_filename(pw, "Enter file in which the key is"); |
if (stat(identity_file, &st) < 0) |
if (stat(identity_file, &st) == -1) |
fatal("%s: %s: %s", __progname, identity_file, strerror(errno)); |
fatal("%s: %s: %s", __progname, identity_file, strerror(errno)); |
if ((r = sshkey_load_public(identity_file, &k, NULL)) != 0) |
if ((r = sshkey_load_public(identity_file, &k, NULL)) != 0) |
k = load_identity(identity_file); |
k = load_identity(identity_file); |
|
|
} |
} |
|
|
static struct sshkey * |
static struct sshkey * |
do_convert_private_ssh2_from_blob(u_char *blob, u_int blen) |
do_convert_private_ssh2(struct sshbuf *b) |
{ |
{ |
struct sshbuf *b; |
|
struct sshkey *key = NULL; |
struct sshkey *key = NULL; |
char *type, *cipher; |
char *type, *cipher; |
u_char e1, e2, e3, *sig = NULL, data[] = "abcde12345"; |
u_char e1, e2, e3, *sig = NULL, data[] = "abcde12345"; |
|
|
BIGNUM *dsa_pub_key = NULL, *dsa_priv_key = NULL; |
BIGNUM *dsa_pub_key = NULL, *dsa_priv_key = NULL; |
BIGNUM *rsa_n = NULL, *rsa_e = NULL, *rsa_d = NULL; |
BIGNUM *rsa_n = NULL, *rsa_e = NULL, *rsa_d = NULL; |
BIGNUM *rsa_p = NULL, *rsa_q = NULL, *rsa_iqmp = 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) |
if ((r = sshbuf_get_u32(b, &magic)) != 0) |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
fatal("%s: buffer error: %s", __func__, ssh_err(r)); |
|
|
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, |
SSH_COM_PRIVATE_KEY_MAGIC); |
SSH_COM_PRIVATE_KEY_MAGIC); |
sshbuf_free(b); |
|
return NULL; |
return NULL; |
} |
} |
if ((r = sshbuf_get_u32(b, &i1)) != 0 || |
if ((r = sshbuf_get_u32(b, &i1)) != 0 || |
|
|
if (strcmp(cipher, "none") != 0) { |
if (strcmp(cipher, "none") != 0) { |
error("unsupported cipher %s", cipher); |
error("unsupported cipher %s", cipher); |
free(cipher); |
free(cipher); |
sshbuf_free(b); |
|
free(type); |
free(type); |
return NULL; |
return NULL; |
} |
} |
|
|
} else if (strstr(type, "rsa")) { |
} else if (strstr(type, "rsa")) { |
ktype = KEY_RSA; |
ktype = KEY_RSA; |
} else { |
} else { |
sshbuf_free(b); |
|
free(type); |
free(type); |
return NULL; |
return NULL; |
} |
} |
|
|
fatal("%s: BN_new", __func__); |
fatal("%s: BN_new", __func__); |
if (!BN_set_word(rsa_e, e)) { |
if (!BN_set_word(rsa_e, e)) { |
BN_clear_free(rsa_e); |
BN_clear_free(rsa_e); |
sshbuf_free(b); |
|
sshkey_free(key); |
sshkey_free(key); |
return NULL; |
return NULL; |
} |
} |
|
|
} |
} |
rlen = sshbuf_len(b); |
rlen = sshbuf_len(b); |
if (rlen != 0) |
if (rlen != 0) |
error("do_convert_private_ssh2_from_blob: " |
error("%s: remaining bytes in key blob %d", __func__, rlen); |
"remaining bytes in key blob %d", rlen); |
|
sshbuf_free(b); |
|
|
|
/* try the key */ |
/* try the key */ |
if (sshkey_sign(key, &sig, &slen, data, sizeof(data), NULL, 0) != 0 || |
if (sshkey_sign(key, &sig, &slen, data, sizeof(data), NULL, 0) != 0 || |
|
|
int r, blen, escaped = 0; |
int r, blen, escaped = 0; |
u_int len; |
u_int len; |
char line[1024]; |
char line[1024]; |
u_char blob[8096]; |
struct sshbuf *buf; |
char encoded[8096]; |
char encoded[8096]; |
FILE *fp; |
FILE *fp; |
|
|
|
if ((buf = sshbuf_new()) == NULL) |
|
fatal("sshbuf_new failed"); |
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)); |
encoded[0] = '\0'; |
encoded[0] = '\0'; |
|
|
(encoded[len-2] == '=') && |
(encoded[len-2] == '=') && |
(encoded[len-3] == '=')) |
(encoded[len-3] == '=')) |
encoded[len-3] = '\0'; |
encoded[len-3] = '\0'; |
blen = uudecode(encoded, blob, sizeof(blob)); |
if ((r = sshbuf_b64tod(buf, encoded)) != 0) |
if (blen < 0) |
fatal("%s: base64 decoding failed: %s", __func__, ssh_err(r)); |
fatal("uudecode failed."); |
|
if (*private) |
if (*private) |
*k = do_convert_private_ssh2_from_blob(blob, blen); |
*k = do_convert_private_ssh2(buf); |
else if ((r = sshkey_from_blob(blob, blen, k)) != 0) |
else if ((r = sshkey_fromb(buf, k)) != 0) |
fatal("decode blob failed: %s", ssh_err(r)); |
fatal("decode blob failed: %s", ssh_err(r)); |
fclose(fp); |
fclose(fp); |
} |
} |
|
|
|
|
if (!have_identity) |
if (!have_identity) |
ask_filename(pw, "Enter file in which the key is"); |
ask_filename(pw, "Enter file in which the key is"); |
if (stat(identity_file, &st) < 0) |
if (stat(identity_file, &st) == -1) |
fatal("%s: %s: %s", __progname, identity_file, strerror(errno)); |
fatal("%s: %s: %s", __progname, identity_file, strerror(errno)); |
|
|
switch (convert_format) { |
switch (convert_format) { |
|
|
|
|
if (!have_identity) |
if (!have_identity) |
ask_filename(pw, "Enter file in which the key is"); |
ask_filename(pw, "Enter file in which the key is"); |
if (stat(identity_file, &st) < 0) |
if (stat(identity_file, &st) == -1) |
fatal("%s: %s", identity_file, strerror(errno)); |
fatal("%s: %s", identity_file, strerror(errno)); |
prv = load_identity(identity_file); |
prv = load_identity(identity_file); |
if ((r = sshkey_write(prv, stdout)) != 0) |
if ((r = sshkey_write(prv, stdout)) != 0) |
|
|
fptype = print_bubblebabble ? SSH_DIGEST_SHA1 : fingerprint_hash; |
fptype = print_bubblebabble ? SSH_DIGEST_SHA1 : fingerprint_hash; |
rep = print_bubblebabble ? SSH_FP_BUBBLEBABBLE : SSH_FP_DEFAULT; |
rep = print_bubblebabble ? SSH_FP_BUBBLEBABBLE : SSH_FP_DEFAULT; |
|
|
pkcs11_init(0); |
pkcs11_init(1); |
nkeys = pkcs11_add_provider(pkcs11provider, NULL, &keys); |
nkeys = pkcs11_add_provider(pkcs11provider, NULL, &keys); |
if (nkeys <= 0) |
if (nkeys <= 0) |
fatal("cannot read public key from pkcs11"); |
fatal("cannot read public key from pkcs11"); |
|
|
struct sshkey *public = NULL; |
struct sshkey *public = NULL; |
int r; |
int r; |
|
|
if (stat(identity_file, &st) < 0) |
if (stat(identity_file, &st) == -1) |
fatal("%s: %s", path, strerror(errno)); |
fatal("%s: %s", path, strerror(errno)); |
if ((r = sshkey_load_public(path, &public, &comment)) != 0) { |
if ((r = sshkey_load_public(path, &public, &comment)) != 0) { |
debug("load public \"%s\": %s", path, ssh_err(r)); |
debug("load public \"%s\": %s", path, ssh_err(r)); |
|
|
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, use_new_format, new_format_cipher, rounds)) != 0) { |
comment, private_key_format, openssh_format_cipher, |
|
rounds)) != 0) { |
error("Saving key \"%s\" failed: %s", |
error("Saving key \"%s\" failed: %s", |
prv_tmp, ssh_err(r)); |
prv_tmp, ssh_err(r)); |
goto failnext; |
goto failnext; |
|
|
struct known_hosts_ctx *ctx = (struct known_hosts_ctx *)_ctx; |
struct known_hosts_ctx *ctx = (struct known_hosts_ctx *)_ctx; |
enum sshkey_fp_rep rep; |
enum sshkey_fp_rep rep; |
int fptype; |
int fptype; |
char *fp; |
char *fp = NULL, *ra = NULL; |
|
|
fptype = print_bubblebabble ? SSH_DIGEST_SHA1 : fingerprint_hash; |
fptype = print_bubblebabble ? SSH_DIGEST_SHA1 : fingerprint_hash; |
rep = print_bubblebabble ? SSH_FP_BUBBLEBABBLE : SSH_FP_DEFAULT; |
rep = print_bubblebabble ? SSH_FP_BUBBLEBABBLE : SSH_FP_DEFAULT; |
|
|
known_hosts_hash(l, ctx); |
known_hosts_hash(l, ctx); |
else if (print_fingerprint) { |
else if (print_fingerprint) { |
fp = sshkey_fingerprint(l->key, fptype, rep); |
fp = sshkey_fingerprint(l->key, fptype, rep); |
|
ra = sshkey_fingerprint(l->key, |
|
fingerprint_hash, SSH_FP_RANDOMART); |
|
if (fp == NULL || ra == NULL) |
|
fatal("%s: sshkey_fingerprint failed", |
|
__func__); |
mprintf("%s %s %s %s\n", ctx->host, |
mprintf("%s %s %s %s\n", ctx->host, |
sshkey_type(l->key), fp, l->comment); |
sshkey_type(l->key), fp, l->comment); |
|
if (log_level_get() >= SYSLOG_LEVEL_VERBOSE) |
|
printf("%s\n", ra); |
|
free(ra); |
free(fp); |
free(fp); |
} else |
} else |
fprintf(ctx->out, "%s\n", l->line); |
fprintf(ctx->out, "%s\n", l->line); |
|
|
|
|
if (!have_identity) |
if (!have_identity) |
ask_filename(pw, "Enter file in which the key is"); |
ask_filename(pw, "Enter file in which the key is"); |
if (stat(identity_file, &st) < 0) |
if (stat(identity_file, &st) == -1) |
fatal("%s: %s", identity_file, strerror(errno)); |
fatal("%s: %s", identity_file, strerror(errno)); |
/* Try to load the file with empty passphrase. */ |
/* Try to load the file with empty passphrase. */ |
r = sshkey_load_private(identity_file, "", &private, &comment); |
r = sshkey_load_private(identity_file, "", &private, &comment); |
|
|
|
|
/* 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, use_new_format, new_format_cipher, rounds)) != 0) { |
comment, private_key_format, openssh_format_cipher, rounds)) != 0) { |
error("Saving key \"%s\" failed: %s.", |
error("Saving key \"%s\" failed: %s.", |
identity_file, ssh_err(r)); |
identity_file, ssh_err(r)); |
explicit_bzero(passphrase1, strlen(passphrase1)); |
explicit_bzero(passphrase1, strlen(passphrase1)); |
|
|
|
|
if (fname == NULL) |
if (fname == NULL) |
fatal("%s: no filename", __func__); |
fatal("%s: no filename", __func__); |
if (stat(fname, &st) < 0) { |
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 (!have_identity) |
if (!have_identity) |
ask_filename(pw, "Enter file in which the key is"); |
ask_filename(pw, "Enter file in which the key is"); |
if (stat(identity_file, &st) < 0) |
if (stat(identity_file, &st) == -1) |
fatal("%s: %s", identity_file, strerror(errno)); |
fatal("%s: %s", identity_file, strerror(errno)); |
if ((r = sshkey_load_private(identity_file, "", |
if ((r = sshkey_load_private(identity_file, "", |
&private, &comment)) == 0) |
&private, &comment)) == 0) |
|
|
} |
} |
|
|
if (private->type != KEY_ED25519 && private->type != KEY_XMSS && |
if (private->type != KEY_ED25519 && private->type != KEY_XMSS && |
!use_new_format) { |
private_key_format != SSHKEY_PRIVATE_OPENSSH) { |
error("Comments are only supported for keys stored in " |
error("Comments are only supported for keys stored in " |
"the new format (-o)."); |
"the new format (-o)."); |
explicit_bzero(passphrase, strlen(passphrase)); |
explicit_bzero(passphrase, strlen(passphrase)); |
|
|
exit(1); |
exit(1); |
} |
} |
if (comment) |
if (comment) |
printf("Key now has comment '%s'\n", comment); |
printf("Old comment: %s\n", comment); |
else |
else |
printf("Key now has no comment\n"); |
printf("No existing comment\n"); |
|
|
if (identity_comment) { |
if (identity_comment) { |
strlcpy(new_comment, identity_comment, sizeof(new_comment)); |
strlcpy(new_comment, identity_comment, sizeof(new_comment)); |
} else { |
} else { |
printf("Enter new comment: "); |
printf("New comment: "); |
fflush(stdout); |
fflush(stdout); |
if (!fgets(new_comment, sizeof(new_comment), stdin)) { |
if (!fgets(new_comment, sizeof(new_comment), stdin)) { |
explicit_bzero(passphrase, strlen(passphrase)); |
explicit_bzero(passphrase, strlen(passphrase)); |
|
|
} |
} |
new_comment[strcspn(new_comment, "\n")] = '\0'; |
new_comment[strcspn(new_comment, "\n")] = '\0'; |
} |
} |
|
if (comment != NULL && strcmp(comment, new_comment) == 0) { |
|
printf("No change to comment\n"); |
|
free(passphrase); |
|
sshkey_free(private); |
|
free(comment); |
|
exit(0); |
|
} |
|
|
/* Save the file using the new passphrase. */ |
/* Save the file using the new passphrase. */ |
if ((r = sshkey_save_private(private, identity_file, passphrase, |
if ((r = sshkey_save_private(private, identity_file, passphrase, |
new_comment, use_new_format, new_format_cipher, rounds)) != 0) { |
new_comment, private_key_format, openssh_format_cipher, |
|
rounds)) != 0) { |
error("Saving key \"%s\" failed: %s", |
error("Saving key \"%s\" failed: %s", |
identity_file, ssh_err(r)); |
identity_file, ssh_err(r)); |
explicit_bzero(passphrase, strlen(passphrase)); |
explicit_bzero(passphrase, strlen(passphrase)); |
|
|
|
|
free(comment); |
free(comment); |
|
|
printf("The comment in your key file has been changed.\n"); |
if (strlen(new_comment) > 0) |
|
printf("Comment '%s' applied\n", new_comment); |
|
else |
|
printf("Comment removed\n"); |
|
|
exit(0); |
exit(0); |
} |
} |
|
|
|
|
|
|
/* Signer for sshkey_certify_custom that uses the agent */ |
/* Signer for sshkey_certify_custom that uses the agent */ |
static int |
static int |
agent_signer(const struct sshkey *key, u_char **sigp, size_t *lenp, |
agent_signer(struct sshkey *key, u_char **sigp, size_t *lenp, |
const u_char *data, size_t datalen, |
const u_char *data, size_t datalen, |
const char *alg, u_int compat, void *ctx) |
const char *alg, u_int compat, void *ctx) |
{ |
{ |
|
|
} |
} |
if (n > SSHKEY_CERT_MAX_PRINCIPALS) |
if (n > SSHKEY_CERT_MAX_PRINCIPALS) |
fatal("Too many certificate principals specified"); |
fatal("Too many certificate principals specified"); |
|
|
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("%s: unable to open \"%s\": %s", |
|
|
|
|
if (!have_identity) |
if (!have_identity) |
ask_filename(pw, "Enter file in which the key is"); |
ask_filename(pw, "Enter file in which the key is"); |
if (strcmp(identity_file, "-") != 0 && stat(identity_file, &st) < 0) |
if (strcmp(identity_file, "-") != 0 && stat(identity_file, &st) == -1) |
fatal("%s: %s: %s", __progname, identity_file, strerror(errno)); |
fatal("%s: %s: %s", __progname, identity_file, strerror(errno)); |
|
|
path = identity_file; |
path = identity_file; |
|
|
extern int optind; |
extern int optind; |
extern char *optarg; |
extern char *optarg; |
|
|
ssh_malloc_init(); /* must be called before any mallocs */ |
|
/* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */ |
/* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */ |
sanitise_stdfd(); |
sanitise_stdfd(); |
|
|
|
|
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()); |
if (gethostname(hostname, sizeof(hostname)) < 0) |
if (gethostname(hostname, sizeof(hostname)) == -1) |
fatal("gethostname: %s", strerror(errno)); |
fatal("gethostname: %s", strerror(errno)); |
|
|
/* Remaining characters: Ydw */ |
/* Remaining characters: Ydw */ |
|
|
} |
} |
if (strcasecmp(optarg, "PKCS8") == 0) { |
if (strcasecmp(optarg, "PKCS8") == 0) { |
convert_format = FMT_PKCS8; |
convert_format = FMT_PKCS8; |
|
private_key_format = SSHKEY_PRIVATE_PKCS8; |
break; |
break; |
} |
} |
if (strcasecmp(optarg, "PEM") == 0) { |
if (strcasecmp(optarg, "PEM") == 0) { |
convert_format = FMT_PEM; |
convert_format = FMT_PEM; |
use_new_format = 0; |
private_key_format = SSHKEY_PRIVATE_PEM; |
break; |
break; |
} |
} |
fatal("Unsupported conversion format \"%s\"", optarg); |
fatal("Unsupported conversion format \"%s\"", optarg); |
|
|
add_cert_option(optarg); |
add_cert_option(optarg); |
break; |
break; |
case 'Z': |
case 'Z': |
new_format_cipher = optarg; |
openssh_format_cipher = optarg; |
break; |
break; |
case 'C': |
case 'C': |
identity_comment = optarg; |
identity_comment = optarg; |
|
|
snprintf(dotsshdir, sizeof dotsshdir, "%s/%s", |
snprintf(dotsshdir, sizeof dotsshdir, "%s/%s", |
pw->pw_dir, _PATH_SSH_USER_DIR); |
pw->pw_dir, _PATH_SSH_USER_DIR); |
if (strstr(identity_file, dotsshdir) != NULL) { |
if (strstr(identity_file, dotsshdir) != NULL) { |
if (stat(dotsshdir, &st) < 0) { |
if (stat(dotsshdir, &st) == -1) { |
if (errno != ENOENT) { |
if (errno != ENOENT) { |
error("Could not stat %s: %s", dotsshdir, |
error("Could not stat %s: %s", dotsshdir, |
strerror(errno)); |
strerror(errno)); |
} else if (mkdir(dotsshdir, 0700) < 0) { |
} else if (mkdir(dotsshdir, 0700) == -1) { |
error("Could not create directory '%s': %s", |
error("Could not create directory '%s': %s", |
dotsshdir, strerror(errno)); |
dotsshdir, strerror(errno)); |
} else if (!quiet) |
} else if (!quiet) |
|
|
|
|
/* 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, passphrase1, |
if ((r = sshkey_save_private(private, identity_file, passphrase1, |
comment, use_new_format, new_format_cipher, rounds)) != 0) { |
comment, private_key_format, openssh_format_cipher, rounds)) != 0) { |
error("Saving key \"%s\" failed: %s", |
error("Saving key \"%s\" failed: %s", |
identity_file, ssh_err(r)); |
identity_file, ssh_err(r)); |
explicit_bzero(passphrase1, strlen(passphrase1)); |
explicit_bzero(passphrase1, strlen(passphrase1)); |