* order to avoid depleting the test system's /dev/random
* unnecessarily.
*
- * - Calls to console_get_line() are replaced with the diagnostic
- * function below, so that I can run tests in an automated
- * manner and provide their interactive passphrase inputs.
+ * - Calls to console_get_userpass_input() are replaced with the
+ * diagnostic function below, so that I can run tests in an
+ * automated manner and provide their interactive passphrase
+ * inputs.
*
* - main() is renamed to cmdgen_main(); at the bottom of the file
* I define another main() which calls the former repeatedly to
memset(buf, 'x', len);
return buf;
}
-#define console_get_line console_get_line_diagnostic
+#define console_get_userpass_input console_get_userpass_input_diagnostic
int nprompts, promptsgot;
const char *prompts[3];
-int console_get_line(const char *prompt, char *str, int maxlen, int is_pw)
+int console_get_userpass_input(prompts_t *p, unsigned char *in, int inlen)
{
- if (promptsgot < nprompts) {
- assert(strlen(prompts[promptsgot]) < maxlen);
- strcpy(str, prompts[promptsgot++]);
- return TRUE;
- } else {
- promptsgot++; /* track number of requests anyway */
- return FALSE;
+ size_t i;
+ int ret = 1;
+ for (i = 0; i < p->n_prompts; i++) {
+ if (promptsgot < nprompts) {
+ assert(strlen(prompts[promptsgot]) < p->prompts[i]->result_len);
+ strcpy(p->prompts[i]->result, prompts[promptsgot++]);
+ } else {
+ promptsgot++; /* track number of requests anyway */
+ ret = 0;
+ }
}
+ return ret;
}
#define main cmdgen_main
#endif
{
}
-void modalfatalbox(char *p, ...)
+void modalfatalbox(const char *p, ...)
{
va_list ap;
fprintf(stderr, "FATAL ERROR: ");
cleanup_exit(1);
}
+void nonfatal(const char *p, ...)
+{
+ va_list ap;
+ fprintf(stderr, "ERROR: ");
+ va_start(ap, p);
+ vfprintf(stderr, p, ap);
+ va_end(ap);
+ fputc('\n', stderr);
+}
+
/*
* Stubs to let everything else link sensibly.
*/
void showversion(void)
{
- char *verstr = dupstr(ver);
- verstr[0] = tolower(verstr[0]);
- printf("PuTTYgen %s\n", verstr);
- sfree(verstr);
+ printf("puttygen: %s\n", ver);
}
-void usage(void)
+void usage(int standalone)
{
fprintf(stderr,
"Usage: puttygen ( keyfile | -t type [ -b bits ] )\n"
- " [ -C comment ] [ -P ]\n"
+ " [ -C comment ] [ -P ] [ -q ]\n"
" [ -o output-keyfile ] [ -O type | -l | -L"
" | -p ]\n");
+ if (standalone)
+ fprintf(stderr,
+ "Use \"puttygen --help\" for more detail.\n");
}
void help(void)
* start with that, plus a version heading.
*/
showversion();
- usage();
+ usage(FALSE);
fprintf(stderr,
" -t specify key type when generating (rsa, dsa, rsa1)\n"
" -b specify number of bits when generating key\n"
" -C change or specify key comment\n"
" -P change key passphrase\n"
+ " -q quiet: do not display progress bar\n"
" -O specify output type:\n"
" private output PuTTY private key format\n"
" private-openssh export OpenSSH private key\n"
+ " private-openssh-new export OpenSSH private key "
+ "(force new file format)\n"
" private-sshcom export ssh.com private key\n"
- " public standard / ssh.com public key\n"
+ " public RFC 4716 / ssh.com public key\n"
" public-openssh OpenSSH public key\n"
" fingerprint output the key fingerprint\n"
" -o specify output file\n"
);
}
-static int save_ssh2_pubkey(char *filename, char *comment,
- void *v_pub_blob, int pub_len)
-{
- unsigned char *pub_blob = (unsigned char *)v_pub_blob;
- char *p;
- int i, column;
- FILE *fp;
-
- if (filename) {
- fp = fopen(filename, "wb");
- if (!fp)
- return 0;
- } else
- fp = stdout;
-
- fprintf(fp, "---- BEGIN SSH2 PUBLIC KEY ----\n");
-
- if (comment) {
- fprintf(fp, "Comment: \"");
- for (p = comment; *p; p++) {
- if (*p == '\\' || *p == '\"')
- fputc('\\', fp);
- fputc(*p, fp);
- }
- fprintf(fp, "\"\n");
- }
-
- i = 0;
- column = 0;
- while (i < pub_len) {
- char buf[5];
- int n = (pub_len - i < 3 ? pub_len - i : 3);
- base64_encode_atom(pub_blob + i, n, buf);
- i += n;
- buf[4] = '\0';
- fputs(buf, fp);
- if (++column >= 16) {
- fputc('\n', fp);
- column = 0;
- }
- }
- if (column > 0)
- fputc('\n', fp);
-
- fprintf(fp, "---- END SSH2 PUBLIC KEY ----\n");
- if (filename)
- fclose(fp);
- return 1;
-}
-
static int move(char *from, char *to)
{
int ret;
return TRUE;
}
-static char *blobfp(char *alg, int bits, char *blob, int bloblen)
-{
- char buffer[128];
- unsigned char digest[16];
- struct MD5Context md5c;
- int i;
-
- MD5Init(&md5c);
- MD5Update(&md5c, blob, bloblen);
- MD5Final(digest, &md5c);
-
- sprintf(buffer, "%s ", alg);
- if (bits > 0)
- sprintf(buffer + strlen(buffer), "%d ", bits);
- for (i = 0; i < 16; i++)
- sprintf(buffer + strlen(buffer), "%s%02x", i ? ":" : "",
- digest[i]);
-
- return dupstr(buffer);
-}
-
int main(int argc, char **argv)
{
char *infile = NULL;
- Filename infilename;
- enum { NOKEYGEN, RSA1, RSA2, DSA } keytype = NOKEYGEN;
+ Filename *infilename = NULL, *outfilename = NULL;
+ enum { NOKEYGEN, RSA1, RSA2, DSA, ECDSA, ED25519 } keytype = NOKEYGEN;
char *outfile = NULL, *outfiletmp = NULL;
- Filename outfilename;
- enum { PRIVATE, PUBLIC, PUBLICO, FP, OPENSSH, SSHCOM } outtype = PRIVATE;
- int bits = 1024;
+ enum { PRIVATE, PUBLIC, PUBLICO, FP, OPENSSH_AUTO,
+ OPENSSH_NEW, SSHCOM } outtype = PRIVATE;
+ int bits = -1;
char *comment = NULL, *origcomment = NULL;
int change_passphrase = FALSE;
int errs = FALSE, nogo = FALSE;
int sshver = 0;
struct ssh2_userkey *ssh2key = NULL;
struct RSAKey *ssh1key = NULL;
- char *ssh2blob = NULL, *ssh2alg = NULL;
+ unsigned char *ssh2blob = NULL;
+ char *ssh2alg = NULL;
const struct ssh_signkey *ssh2algf = NULL;
int ssh2bloblen;
char *passphrase = NULL;
* return success.
*/
if (argc <= 1) {
- usage();
+ usage(TRUE);
return 0;
}
*p++ = '\0';
val = p;
} else
- val = NULL;
+ val = NULL;
+
if (!strcmp(opt, "-help")) {
- help();
- nogo = TRUE;
+ if (val) {
+ errs = TRUE;
+ fprintf(stderr, "puttygen: option `-%s'"
+ " expects no argument\n", opt);
+ } else {
+ help();
+ nogo = TRUE;
+ }
} else if (!strcmp(opt, "-version")) {
- showversion();
- nogo = TRUE;
- }
+ if (val) {
+ errs = TRUE;
+ fprintf(stderr, "puttygen: option `-%s'"
+ " expects no argument\n", opt);
+ } else {
+ showversion();
+ nogo = TRUE;
+ }
+ } else if (!strcmp(opt, "-pgpfp")) {
+ if (val) {
+ errs = TRUE;
+ fprintf(stderr, "puttygen: option `-%s'"
+ " expects no argument\n", opt);
+ } else {
+ /* support --pgpfp for consistency */
+ pgp_fingerprints();
+ nogo = TRUE;
+ }
+ }
/*
- * A sample option requiring an argument:
+ * For long options requiring an argument, add
+ * code along the lines of
*
* else if (!strcmp(opt, "-output")) {
- * if (!val)
- * errs = TRUE, error(err_optnoarg, opt);
- * else
+ * if (!val) {
+ * errs = TRUE;
+ * fprintf(stderr, "puttygen: option `-%s'"
+ * " expects an argument\n", opt);
+ * } else
* ofile = val;
* }
*/
else {
errs = TRUE;
fprintf(stderr,
- "puttygen: no such option `--%s'\n", opt);
+ "puttygen: no such option `-%s'\n", opt);
}
}
p = NULL;
keytype = RSA1, sshver = 1;
else if (!strcmp(p, "dsa") || !strcmp(p, "dss"))
keytype = DSA, sshver = 2;
+ else if (!strcmp(p, "ecdsa"))
+ keytype = ECDSA, sshver = 2;
+ else if (!strcmp(p, "ed25519"))
+ keytype = ED25519, sshver = 2;
else {
fprintf(stderr,
"puttygen: unknown key type `%s'\n", p);
else if (!strcmp(p, "fingerprint"))
outtype = FP;
else if (!strcmp(p, "private-openssh"))
- outtype = OPENSSH, sshver = 2;
+ outtype = OPENSSH_AUTO, sshver = 2;
+ else if (!strcmp(p, "private-openssh-new"))
+ outtype = OPENSSH_NEW, sshver = 2;
else if (!strcmp(p, "private-sshcom"))
outtype = SSHCOM, sshver = 2;
else {
}
}
+ if (bits == -1) {
+ /*
+ * No explicit key size was specified. Default varies
+ * depending on key type.
+ */
+ switch (keytype) {
+ case ECDSA:
+ bits = 384;
+ break;
+ case ED25519:
+ bits = 256;
+ break;
+ default:
+ bits = 2048;
+ break;
+ }
+ }
+
+ if (keytype == ECDSA && (bits != 256 && bits != 384 && bits != 521)) {
+ fprintf(stderr, "puttygen: invalid bits for ECDSA, choose 256, 384 or 521\n");
+ errs = TRUE;
+ }
+
+ if (keytype == ED25519 && (bits != 256)) {
+ fprintf(stderr, "puttygen: invalid bits for ED25519, choose 256\n");
+ errs = TRUE;
+ }
+
if (errs)
return 1;
* ones, print the usage message and return failure.
*/
if (!infile && keytype == NOKEYGEN) {
- usage();
+ usage(TRUE);
return 1;
}
* Bomb out if we've been asked to both load and generate a
* key.
*/
- if (keytype != NOKEYGEN && intype) {
+ if (keytype != NOKEYGEN && infile) {
fprintf(stderr, "puttygen: cannot both load and generate a key\n");
return 1;
}
+ /*
+ * We must save the private part when generating a new key.
+ */
+ if (keytype != NOKEYGEN &&
+ (outtype != PRIVATE && outtype != OPENSSH_AUTO &&
+ outtype != OPENSSH_NEW && outtype != SSHCOM)) {
+ fprintf(stderr, "puttygen: this would generate a new key but "
+ "discard the private part\n");
+ return 1;
+ }
+
/*
* Analyse the type of the input file, in case this affects our
* course of action.
if (infile) {
infilename = filename_from_str(infile);
- intype = key_type(&infilename);
+ intype = key_type(infilename);
switch (intype) {
- /*
- * It would be nice here to be able to load _public_
- * key files, in any of a number of forms, and (a)
- * convert them to other public key types, (b) print
- * out their fingerprints. Or, I suppose, for real
- * orthogonality, (c) change their comment!
- *
- * In fact this opens some interesting possibilities.
- * Suppose ssh2_userkey_loadpub() were able to load
- * public key files as well as extracting the public
- * key from private ones. And suppose I did the thing
- * I've been wanting to do, where specifying a
- * particular private key file for authentication
- * causes any _other_ key in the agent to be discarded.
- * Then, if you had an agent forwarded to the machine
- * you were running Unix PuTTY or Plink on, and you
- * needed to specify which of the keys in the agent it
- * should use, you could do that by supplying a
- * _public_ key file, thus not needing to trust even
- * your encrypted private key file to the network. Ooh!
- */
-
case SSH_KEYTYPE_UNOPENABLE:
case SSH_KEYTYPE_UNKNOWN:
fprintf(stderr, "puttygen: unable to load file `%s': %s\n",
return 1;
case SSH_KEYTYPE_SSH1:
+ case SSH_KEYTYPE_SSH1_PUBLIC:
if (sshver == 2) {
- fprintf(stderr, "puttygen: conversion from SSH1 to SSH2 keys"
+ fprintf(stderr, "puttygen: conversion from SSH-1 to SSH-2 keys"
" not supported\n");
return 1;
}
break;
case SSH_KEYTYPE_SSH2:
- case SSH_KEYTYPE_OPENSSH:
+ case SSH_KEYTYPE_SSH2_PUBLIC_RFC4716:
+ case SSH_KEYTYPE_SSH2_PUBLIC_OPENSSH:
+ case SSH_KEYTYPE_OPENSSH_PEM:
+ case SSH_KEYTYPE_OPENSSH_NEW:
case SSH_KEYTYPE_SSHCOM:
if (sshver == 1) {
- fprintf(stderr, "puttygen: conversion from SSH2 to SSH1 keys"
+ fprintf(stderr, "puttygen: conversion from SSH-2 to SSH-1 keys"
" not supported\n");
return 1;
}
sshver = 2;
break;
+
+ case SSH_KEYTYPE_OPENSSH_AUTO:
+ default:
+ assert(0 && "Should never see these types on an input file");
}
}
*/
if ((intype == SSH_KEYTYPE_SSH1 && outtype == PRIVATE) ||
(intype == SSH_KEYTYPE_SSH2 && outtype == PRIVATE) ||
- (intype == SSH_KEYTYPE_OPENSSH && outtype == OPENSSH) ||
+ (intype == SSH_KEYTYPE_OPENSSH_PEM && outtype == OPENSSH_AUTO) ||
+ (intype == SSH_KEYTYPE_OPENSSH_NEW && outtype == OPENSSH_NEW) ||
(intype == SSH_KEYTYPE_SSHCOM && outtype == SSHCOM)) {
if (!outfile) {
outfile = infile;
* Bomb out rather than automatically choosing to write
* a private key file to stdout.
*/
- if (outtype==PRIVATE || outtype==OPENSSH || outtype==SSHCOM) {
+ if (outtype == PRIVATE || outtype == OPENSSH_AUTO ||
+ outtype == OPENSSH_NEW || outtype == SSHCOM) {
fprintf(stderr, "puttygen: need to specify an output file\n");
return 1;
}
* out a private key format, or (b) the entire input key file
* is encrypted.
*/
- if (outtype == PRIVATE || outtype == OPENSSH || outtype == SSHCOM ||
- intype == SSH_KEYTYPE_OPENSSH || intype == SSH_KEYTYPE_SSHCOM)
+ if (outtype == PRIVATE || outtype == OPENSSH_AUTO ||
+ outtype == OPENSSH_NEW || outtype == SSHCOM ||
+ intype == SSH_KEYTYPE_OPENSSH_PEM ||
+ intype == SSH_KEYTYPE_OPENSSH_NEW ||
+ intype == SSH_KEYTYPE_SSHCOM)
load_encrypted = TRUE;
else
load_encrypted = FALSE;
+ if (load_encrypted && (intype == SSH_KEYTYPE_SSH1_PUBLIC ||
+ intype == SSH_KEYTYPE_SSH2_PUBLIC_RFC4716 ||
+ intype == SSH_KEYTYPE_SSH2_PUBLIC_OPENSSH)) {
+ fprintf(stderr, "puttygen: cannot perform this action on a "
+ "public-key-only input file\n");
+ return 1;
+ }
+
/* ------------------------------------------------------------------
* Now we're ready to actually do some stuff.
*/
if (keytype != NOKEYGEN) {
char *entropy;
char default_comment[80];
- time_t t;
- struct tm *tm;
+ struct tm tm;
struct progress prog;
prog.phase = -1;
prog.current = -1;
- time(&t);
- tm = localtime(&t);
+ tm = ltime();
if (keytype == DSA)
- strftime(default_comment, 30, "dsa-key-%Y%m%d", tm);
+ strftime(default_comment, 30, "dsa-key-%Y%m%d", &tm);
+ else if (keytype == ECDSA)
+ strftime(default_comment, 30, "ecdsa-key-%Y%m%d", &tm);
+ else if (keytype == ED25519)
+ strftime(default_comment, 30, "ed25519-key-%Y%m%d", &tm);
else
- strftime(default_comment, 30, "rsa-key-%Y%m%d", tm);
+ strftime(default_comment, 30, "rsa-key-%Y%m%d", &tm);
- random_init();
+ random_ref();
entropy = get_random_data(bits / 8);
+ if (!entropy) {
+ fprintf(stderr, "puttygen: failed to collect entropy, "
+ "could not generate key\n");
+ return 1;
+ }
random_add_heavynoise(entropy, bits / 8);
- memset(entropy, 0, bits/8);
+ smemclr(entropy, bits/8);
sfree(entropy);
if (keytype == DSA) {
ssh2key->data = dsskey;
ssh2key->alg = &ssh_dss;
ssh1key = NULL;
+ } else if (keytype == ECDSA) {
+ struct ec_key *ec = snew(struct ec_key);
+ ec_generate(ec, bits, progressfn, &prog);
+ ssh2key = snew(struct ssh2_userkey);
+ ssh2key->data = ec;
+ ssh2key->alg = ec->signalg;
+ ssh1key = NULL;
+ } else if (keytype == ED25519) {
+ struct ec_key *ec = snew(struct ec_key);
+ ec_edgenerate(ec, bits, progressfn, &prog);
+ ssh2key = snew(struct ssh2_userkey);
+ ssh2key->data = ec;
+ ssh2key->alg = &ssh_ecdsa_ed25519;
+ ssh1key = NULL;
} else {
struct RSAKey *rsakey = snew(struct RSAKey);
rsa_generate(rsakey, bits, progressfn, &prog);
* Find out whether the input key is encrypted.
*/
if (intype == SSH_KEYTYPE_SSH1)
- encrypted = rsakey_encrypted(&infilename, &origcomment);
+ encrypted = rsakey_encrypted(infilename, &origcomment);
else if (intype == SSH_KEYTYPE_SSH2)
- encrypted = ssh2_userkey_encrypted(&infilename, &origcomment);
+ encrypted = ssh2_userkey_encrypted(infilename, &origcomment);
else
- encrypted = import_encrypted(&infilename, intype, &origcomment);
+ encrypted = import_encrypted(infilename, intype, &origcomment);
/*
* If so, ask for a passphrase.
*/
if (encrypted && load_encrypted) {
- passphrase = snewn(512, char);
- if (!console_get_line("Enter passphrase to load key: ",
- passphrase, 512, TRUE)) {
+ prompts_t *p = new_prompts(NULL);
+ int ret;
+ p->to_server = FALSE;
+ p->name = dupstr("SSH key passphrase");
+ add_prompt(p, dupstr("Enter passphrase to load key: "), FALSE);
+ ret = console_get_userpass_input(p, NULL, 0);
+ assert(ret >= 0);
+ if (!ret) {
+ free_prompts(p);
perror("puttygen: unable to read passphrase");
return 1;
+ } else {
+ passphrase = dupstr(p->prompts[0]->result);
+ free_prompts(p);
}
} else {
passphrase = NULL;
int ret;
case SSH_KEYTYPE_SSH1:
+ case SSH_KEYTYPE_SSH1_PUBLIC:
ssh1key = snew(struct RSAKey);
if (!load_encrypted) {
void *vblob;
- char *blob;
+ unsigned char *blob;
int n, l, bloblen;
- ret = rsakey_pubblob(&infilename, &vblob, &bloblen, &error);
- blob = (char *)vblob;
+ ret = rsakey_pubblob(infilename, &vblob, &bloblen,
+ &origcomment, &error);
+ blob = (unsigned char *)vblob;
n = 4; /* skip modulus bits */
l = ssh1_read_bignum(blob + n, bloblen - n,
&ssh1key->exponent);
if (l < 0) {
- error = "SSH1 public key blob was too short";
+ error = "SSH-1 public key blob was too short";
} else {
n += l;
l = ssh1_read_bignum(blob + n, bloblen - n,
&ssh1key->modulus);
if (l < 0) {
- error = "SSH1 public key blob was too short";
+ error = "SSH-1 public key blob was too short";
} else
n += l;
}
- ssh1key->comment = NULL;
+ ssh1key->comment = dupstr(origcomment);
ssh1key->private_exponent = NULL;
+ ssh1key->p = NULL;
+ ssh1key->q = NULL;
+ ssh1key->iqmp = NULL;
} else {
- ret = loadrsakey(&infilename, ssh1key, passphrase, &error);
+ ret = loadrsakey(infilename, ssh1key, passphrase, &error);
}
if (ret > 0)
error = NULL;
break;
case SSH_KEYTYPE_SSH2:
+ case SSH_KEYTYPE_SSH2_PUBLIC_RFC4716:
+ case SSH_KEYTYPE_SSH2_PUBLIC_OPENSSH:
if (!load_encrypted) {
- ssh2blob = ssh2_userkey_loadpub(&infilename, &ssh2alg,
- &ssh2bloblen, &error);
- ssh2algf = find_pubkey_alg(ssh2alg);
- if (ssh2algf)
- bits = ssh2algf->pubkey_bits(ssh2blob, ssh2bloblen);
- else
- bits = -1;
+ ssh2blob = ssh2_userkey_loadpub(infilename, &ssh2alg,
+ &ssh2bloblen, &origcomment,
+ &error);
+ if (ssh2blob) {
+ ssh2algf = find_pubkey_alg(ssh2alg);
+ if (ssh2algf)
+ bits = ssh2algf->pubkey_bits(ssh2algf,
+ ssh2blob, ssh2bloblen);
+ else
+ bits = -1;
+ }
+ sfree(ssh2alg);
} else {
- ssh2key = ssh2_load_userkey(&infilename, passphrase, &error);
+ ssh2key = ssh2_load_userkey(infilename, passphrase, &error);
}
if ((ssh2key && ssh2key != SSH2_WRONG_PASSPHRASE) || ssh2blob)
error = NULL;
}
break;
- case SSH_KEYTYPE_OPENSSH:
+ case SSH_KEYTYPE_OPENSSH_PEM:
+ case SSH_KEYTYPE_OPENSSH_NEW:
case SSH_KEYTYPE_SSHCOM:
- ssh2key = import_ssh2(&infilename, intype, passphrase);
- if (ssh2key && ssh2key != SSH2_WRONG_PASSPHRASE)
- error = NULL;
- else if (!error) {
- if (ssh2key == SSH2_WRONG_PASSPHRASE)
- error = "wrong passphrase";
+ ssh2key = import_ssh2(infilename, intype, passphrase, &error);
+ if (ssh2key) {
+ if (ssh2key != SSH2_WRONG_PASSPHRASE)
+ error = NULL;
else
- error = "unknown error";
- }
+ error = "wrong passphrase";
+ } else if (!error)
+ error = "unknown error";
break;
default:
* we have just generated a key.
*/
if (change_passphrase || keytype != NOKEYGEN) {
- char *passphrase2;
-
- if (passphrase) {
- memset(passphrase, 0, strlen(passphrase));
- sfree(passphrase);
- }
+ prompts_t *p = new_prompts(NULL);
+ int ret;
- passphrase = snewn(512, char);
- passphrase2 = snewn(512, char);
- if (!console_get_line("Enter passphrase to save key: ",
- passphrase, 512, TRUE) ||
- !console_get_line("Re-enter passphrase to verify: ",
- passphrase2, 512, TRUE)) {
+ p->to_server = FALSE;
+ p->name = dupstr("New SSH key passphrase");
+ add_prompt(p, dupstr("Enter passphrase to save key: "), FALSE);
+ add_prompt(p, dupstr("Re-enter passphrase to verify: "), FALSE);
+ ret = console_get_userpass_input(p, NULL, 0);
+ assert(ret >= 0);
+ if (!ret) {
+ free_prompts(p);
perror("puttygen: unable to read new passphrase");
return 1;
- }
- if (strcmp(passphrase, passphrase2)) {
- fprintf(stderr, "puttygen: passphrases do not match\n");
- return 1;
- }
- memset(passphrase2, 0, strlen(passphrase2));
- sfree(passphrase2);
- if (!*passphrase) {
- sfree(passphrase);
- passphrase = NULL;
+ } else {
+ if (strcmp(p->prompts[0]->result, p->prompts[1]->result)) {
+ free_prompts(p);
+ fprintf(stderr, "puttygen: passphrases do not match\n");
+ return 1;
+ }
+ if (passphrase) {
+ smemclr(passphrase, strlen(passphrase));
+ sfree(passphrase);
+ }
+ passphrase = dupstr(p->prompts[0]->result);
+ free_prompts(p);
+ if (!*passphrase) {
+ sfree(passphrase);
+ passphrase = NULL;
+ }
}
}
outfilename = filename_from_str(outfile ? outfile : "");
switch (outtype) {
- int ret;
+ int ret, real_outtype;
case PRIVATE:
if (sshver == 1) {
assert(ssh1key);
- ret = saversakey(&outfilename, ssh1key, passphrase);
+ ret = saversakey(outfilename, ssh1key, passphrase);
if (!ret) {
- fprintf(stderr, "puttygen: unable to save SSH1 private key\n");
+ fprintf(stderr, "puttygen: unable to save SSH-1 private key\n");
return 1;
}
} else {
assert(ssh2key);
- ret = ssh2_save_userkey(&outfilename, ssh2key, passphrase);
+ ret = ssh2_save_userkey(outfilename, ssh2key, passphrase);
if (!ret) {
- fprintf(stderr, "puttygen: unable to save SSH2 private key\n");
+ fprintf(stderr, "puttygen: unable to save SSH-2 private key\n");
return 1;
}
}
case PUBLIC:
case PUBLICO:
- if (sshver == 1) {
- FILE *fp;
- char *dec1, *dec2;
-
- assert(ssh1key);
+ {
+ FILE *fp;
+
+ if (outfile)
+ fp = f_open(outfilename, "w", FALSE);
+ else
+ fp = stdout;
+
+ if (sshver == 1) {
+ ssh1_write_pubkey(fp, ssh1key);
+ } else {
+ if (!ssh2blob) {
+ assert(ssh2key);
+ ssh2blob = ssh2key->alg->public_blob(ssh2key->data,
+ &ssh2bloblen);
+ }
+
+ ssh2_write_pubkey(fp, ssh2key ? ssh2key->comment : origcomment,
+ ssh2blob, ssh2bloblen,
+ (outtype == PUBLIC ?
+ SSH_KEYTYPE_SSH2_PUBLIC_RFC4716 :
+ SSH_KEYTYPE_SSH2_PUBLIC_OPENSSH));
+ }
- if (outfile)
- fp = f_open(outfilename, "w");
- else
- fp = stdout;
- dec1 = bignum_decimal(ssh1key->exponent);
- dec2 = bignum_decimal(ssh1key->modulus);
- fprintf(fp, "%d %s %s %s\n", bignum_bitcount(ssh1key->modulus),
- dec1, dec2, ssh1key->comment);
- sfree(dec1);
- sfree(dec2);
if (outfile)
fclose(fp);
- } else if (outtype == PUBLIC) {
- if (!ssh2blob) {
- assert(ssh2key);
- ssh2blob = ssh2key->alg->public_blob(ssh2key->data,
- &ssh2bloblen);
- }
- save_ssh2_pubkey(outfile, ssh2key ? ssh2key->comment : origcomment,
- ssh2blob, ssh2bloblen);
- } else if (outtype == PUBLICO) {
- char *buffer, *p;
- int i;
- FILE *fp;
-
- if (!ssh2blob) {
- assert(ssh2key);
- ssh2blob = ssh2key->alg->public_blob(ssh2key->data,
- &ssh2bloblen);
- }
- if (!ssh2alg) {
- assert(ssh2key);
- ssh2alg = ssh2key->alg->name;
- }
- if (ssh2key)
- comment = ssh2key->comment;
- else
- comment = origcomment;
-
- buffer = snewn(strlen(ssh2alg) +
- 4 * ((ssh2bloblen+2) / 3) +
- strlen(comment) + 3, char);
- strcpy(buffer, ssh2alg);
- p = buffer + strlen(buffer);
- *p++ = ' ';
- i = 0;
- while (i < ssh2bloblen) {
- int n = (ssh2bloblen - i < 3 ? ssh2bloblen - i : 3);
- base64_encode_atom(ssh2blob + i, n, p);
- i += n;
- p += 4;
- }
- if (*comment) {
- *p++ = ' ';
- strcpy(p, comment);
- } else
- *p++ = '\0';
-
- if (outfile)
- fp = f_open(outfilename, "w");
- else
- fp = stdout;
- fprintf(fp, "%s\n", buffer);
- if (outfile)
- fclose(fp);
-
- sfree(buffer);
- }
+ }
break;
case FP:
rsa_fingerprint(fingerprint, 128, ssh1key);
} else {
if (ssh2key) {
- fingerprint = ssh2key->alg->fingerprint(ssh2key->data);
+ fingerprint = ssh2_fingerprint(ssh2key->alg,
+ ssh2key->data);
} else {
assert(ssh2blob);
- fingerprint = blobfp(ssh2alg, bits, ssh2blob, ssh2bloblen);
+ fingerprint = ssh2_fingerprint_blob(ssh2blob, ssh2bloblen);
}
}
if (outfile)
- fp = f_open(outfilename, "w");
+ fp = f_open(outfilename, "w", FALSE);
else
fp = stdout;
fprintf(fp, "%s\n", fingerprint);
}
break;
- case OPENSSH:
+ case OPENSSH_AUTO:
+ case OPENSSH_NEW:
case SSHCOM:
assert(sshver == 2);
assert(ssh2key);
- ret = export_ssh2(&outfilename, outtype, ssh2key, passphrase);
+ random_ref(); /* both foreign key types require randomness,
+ * for IV or padding */
+ switch (outtype) {
+ case OPENSSH_AUTO:
+ real_outtype = SSH_KEYTYPE_OPENSSH_AUTO;
+ break;
+ case OPENSSH_NEW:
+ real_outtype = SSH_KEYTYPE_OPENSSH_NEW;
+ break;
+ case SSHCOM:
+ real_outtype = SSH_KEYTYPE_SSHCOM;
+ break;
+ default:
+ assert(0 && "control flow goof");
+ }
+ ret = export_ssh2(outfilename, real_outtype, ssh2key, passphrase);
if (!ret) {
fprintf(stderr, "puttygen: unable to export key\n");
return 1;
}
if (passphrase) {
- memset(passphrase, 0, strlen(passphrase));
+ smemclr(passphrase, strlen(passphrase));
sfree(passphrase);
}
* Change the comment of the key; this _does_ require a
* passphrase owing to the tamperproofing.
*
- * NOTE: In SSH1, this only requires a passphrase because
+ * NOTE: In SSH-1, this only requires a passphrase because
* of inadequacies of the loading and saving mechanisms. In
* _principle_, it should be perfectly possible to modify
- * the comment on an SSH1 key without requiring a
+ * the comment on an SSH-1 key without requiring a
* passphrase; the only reason I can't do it is because my
* loading and saving mechanisms don't include a method of
* loading all the key data without also trying to decrypt
*
* I don't consider this to be a problem worth solving,
* because (a) to fix it would probably end up bloating
- * PuTTY proper, and (b) SSH1 is on the way out anyway so
+ * PuTTY proper, and (b) SSH-1 is on the way out anyway so
* it shouldn't be highly significant. If it seriously
* bothers anyone then perhaps I _might_ be persuadable.
*/
projects / PuTTY.git / blobdiff