" -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, unsigned 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 = NULL, *outfilename = NULL;
- enum { NOKEYGEN, RSA1, RSA2, DSA, ECDSA } keytype = NOKEYGEN;
+ enum { NOKEYGEN, RSA1, RSA2, DSA, ECDSA, ED25519 } keytype = NOKEYGEN;
char *outfile = NULL, *outfiletmp = NULL;
- enum { PRIVATE, PUBLIC, PUBLICO, FP, OPENSSH, SSHCOM } outtype = PRIVATE;
- int bits = 2048;
+ 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;
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;
* We must save the private part when generating a new key.
*/
if (keytype != NOKEYGEN &&
- (outtype != PRIVATE && outtype != OPENSSH && outtype != SSHCOM)) {
+ (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;
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 SSH-1 to SSH-2 keys"
" not supported\n");
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 SSH-2 to SSH-1 keys"
}
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.
*/
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);
ssh2key->alg = &ssh_ecdsa_nistp521;
}
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);
int ret;
case SSH_KEYTYPE_SSH1:
+ case SSH_KEYTYPE_SSH1_PUBLIC:
ssh1key = snew(struct RSAKey);
if (!load_encrypted) {
void *vblob;
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, NULL, &error);
+ &ssh2bloblen, &origcomment,
+ &error);
if (ssh2blob) {
ssh2algf = find_pubkey_alg(ssh2alg);
if (ssh2algf)
else
bits = -1;
}
+ sfree(ssh2alg);
} else {
ssh2key = ssh2_load_userkey(infilename, passphrase, &error);
}
}
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, &error);
if (ssh2key) {
outfilename = filename_from_str(outfile ? outfile : "");
switch (outtype) {
- int ret;
+ int ret, real_outtype;
case PRIVATE:
if (sshver == 1) {
case PUBLIC:
case PUBLICO:
- if (sshver == 1) {
- FILE *fp;
- char *dec1, *dec2;
+ {
+ FILE *fp;
- assert(ssh1key);
+ if (outfile)
+ fp = f_open(outfilename, "w", FALSE);
+ else
+ fp = stdout;
- if (outfile)
- fp = f_open(outfilename, "w", FALSE);
- 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 (sshver == 1) {
+ ssh1_write_pubkey(fp, ssh1key);
+ } else {
+ if (!ssh2blob) {
+ assert(ssh2key);
+ ssh2blob = ssh2key->alg->public_blob(ssh2key->data,
+ &ssh2bloblen);
+ }
- 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';
+ 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", FALSE);
- 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);
}
}
}
break;
- case OPENSSH:
+ case OPENSSH_AUTO:
+ case OPENSSH_NEW:
case SSHCOM:
assert(sshver == 2);
assert(ssh2key);
random_ref(); /* both foreign key types require randomness,
* for IV or padding */
- ret = export_ssh2(outfilename, outtype, ssh2key, passphrase);
+ 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;
projects / PuTTY.git / blobdiff