/*
* Generic SSH public-key handling operations. In particular,
* reading of SSH public-key files, and also the generic `sign'
- * operation for ssh2 (which checks the type of the key and
+ * operation for SSH-2 (which checks the type of the key and
* dispatches to the appropriate key-type specific function).
*/
#include "ssh.h"
#include "misc.h"
-#define PUT_32BIT(cp, value) do { \
- (cp)[3] = (value); \
- (cp)[2] = (value) >> 8; \
- (cp)[1] = (value) >> 16; \
- (cp)[0] = (value) >> 24; } while (0)
-
-#define GET_32BIT(cp) \
- (((unsigned long)(unsigned char)(cp)[0] << 24) | \
- ((unsigned long)(unsigned char)(cp)[1] << 16) | \
- ((unsigned long)(unsigned char)(cp)[2] << 8) | \
- ((unsigned long)(unsigned char)(cp)[3]))
-
#define rsa_signature "SSH PRIVATE KEY FILE FORMAT 1.1\n"
#define BASE64_TOINT(x) ( (x)-'A'<26 ? (x)-'A'+0 :\
|| buf[i + 3] != 0) goto end; /* reserved field nonzero, panic! */
i += 4;
- /* Now the serious stuff. An ordinary SSH 1 public key. */
+ /* Now the serious stuff. An ordinary SSH-1 public key. */
i += makekey(buf + i, len, key, NULL, 1);
if (i < 0)
goto end; /* overran */
- if (pub_only) {
- ret = 1;
- goto end;
- }
-
/* Next, the comment field. */
j = GET_32BIT(buf + i);
i += 4;
}
i += j;
if (commentptr)
- *commentptr = comment;
+ *commentptr = dupstr(comment);
if (key)
key->comment = comment;
+ else
+ sfree(comment);
+
+ if (pub_only) {
+ ret = 1;
+ goto end;
+ }
+
if (!key) {
ret = ciphertype != 0;
*error = NULL;
MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
MD5Final(keybuf, &md5c);
des3_decrypt_pubkey(keybuf, buf + i, (len - i + 7) & ~7);
- memset(keybuf, 0, sizeof(keybuf)); /* burn the evidence */
+ smemclr(keybuf, sizeof(keybuf)); /* burn the evidence */
}
/*
ret = 1;
end:
- memset(buf, 0, sizeof(buf)); /* burn the evidence */
+ smemclr(buf, sizeof(buf)); /* burn the evidence */
return ret;
}
int ret = 0;
const char *error = NULL;
- fp = f_open(*filename, "rb");
+ fp = f_open(filename, "rb", FALSE);
if (!fp) {
error = "can't open file";
goto end;
FILE *fp;
char buf[64];
- fp = f_open(*filename, "rb");
+ fp = f_open(filename, "rb", FALSE);
if (!fp)
return 0; /* doesn't even exist */
* exponent, modulus).
*/
int rsakey_pubblob(const Filename *filename, void **blob, int *bloblen,
- const char **errorstr)
+ char **commentptr, const char **errorstr)
{
FILE *fp;
char buf[64];
*bloblen = 0;
ret = 0;
- fp = f_open(*filename, "rb");
+ fp = f_open(filename, "rb", FALSE);
if (!fp) {
error = "can't open file";
goto end;
*/
if (fgets(buf, sizeof(buf), fp) && !strcmp(buf, rsa_signature)) {
memset(&key, 0, sizeof(key));
- if (loadrsakey_main(fp, &key, TRUE, NULL, NULL, &error)) {
+ if (loadrsakey_main(fp, &key, TRUE, commentptr, NULL, &error)) {
*blob = rsa_public_blob(&key, bloblen);
freersakey(&key);
ret = 1;
p += 4;
/*
- * An ordinary SSH 1 public key consists of: a uint32
+ * An ordinary SSH-1 public key consists of: a uint32
* containing the bit count, then two bignums containing the
* modulus and exponent respectively.
*/
MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
MD5Final(keybuf, &md5c);
des3_encrypt_pubkey(keybuf, estart, p - estart);
- memset(keybuf, 0, sizeof(keybuf)); /* burn the evidence */
+ smemclr(keybuf, sizeof(keybuf)); /* burn the evidence */
}
/*
* Done. Write the result to the file.
*/
- fp = f_open(*filename, "wb");
+ fp = f_open(filename, "wb", TRUE);
if (fp) {
int ret = (fwrite(buf, 1, p - buf, fp) == (size_t) (p - buf));
- ret = ret && (fclose(fp) == 0);
+ if (fclose(fp))
+ ret = 0;
return ret;
} else
return 0;
}
/* ----------------------------------------------------------------------
- * SSH2 private key load/store functions.
+ * SSH-2 private key load/store functions.
*/
/*
- * PuTTY's own format for SSH2 keys is as follows:
+ * PuTTY's own format for SSH-2 keys is as follows:
*
* The file is text. Lines are terminated by CRLF, although CR-only
* and LF-only are tolerated on input.
*
* Next there is a line saying "Public-Lines: " plus a number N.
* The following N lines contain a base64 encoding of the public
- * part of the key. This is encoded as the standard SSH2 public key
+ * part of the key. This is encoded as the standard SSH-2 public key
* blob (with no initial length): so for RSA, for example, it will
* read
*
* with "PuTTY-User-Key-File-1" (version number differs). In this
* format the Private-MAC: field only covers the private-plaintext
* field and nothing else (and without the 4-byte string length on
- * the front too). Moreover, for RSA keys the Private-MAC: field
- * can be replaced with a Private-Hash: field which is a plain
- * SHA-1 hash instead of an HMAC. This is not allowable in DSA
- * keys. (Yes, the old format was a mess. Guess why it changed :-)
+ * the front too). Moreover, the Private-MAC: field can be replaced
+ * with a Private-Hash: field which is a plain SHA-1 hash instead of
+ * an HMAC (this was generated for unencrypted keys).
*/
static int read_header(FILE * fp, char *header)
while (1) {
c = fgetc(fp);
- if (c == '\r' || c == '\n') {
- c = fgetc(fp);
- if (c != '\r' && c != '\n' && c != EOF)
- ungetc(c, fp);
+ if (c == '\r' || c == '\n' || c == EOF) {
+ if (c != EOF) {
+ c = fgetc(fp);
+ if (c != '\r' && c != '\n')
+ ungetc(c, fp);
+ }
return text;
}
- if (c == EOF) {
- sfree(text);
- return NULL;
- }
- if (len + 1 > size) {
+ if (len + 1 >= size) {
size += 128;
text = sresize(text, size, char);
}
encryption = comment = mac = NULL;
public_blob = private_blob = NULL;
- fp = f_open(*filename, "rb");
+ fp = f_open(filename, "rb", FALSE);
if (!fp) {
error = "can't open file";
goto error;
if ((mac = read_body(fp)) == NULL)
goto error;
is_mac = 1;
- } else if (0 == strcmp(header, "Private-Hash") &&
- alg == &ssh_rsa && old_fmt) {
+ } else if (0 == strcmp(header, "Private-Hash") && old_fmt) {
if ((mac = read_body(fp)) == NULL)
goto error;
is_mac = 0;
hmac_sha1_simple(mackey, 20, macdata, maclen, binary);
- memset(mackey, 0, sizeof(mackey));
- memset(&s, 0, sizeof(s));
+ smemclr(mackey, sizeof(mackey));
+ smemclr(&s, sizeof(s));
} else {
SHA_Simple(macdata, maclen, binary);
}
if (free_macdata) {
- memset(macdata, 0, maclen);
+ smemclr(macdata, maclen);
sfree(macdata);
}
return ret;
}
-char *ssh2_userkey_loadpub(const Filename *filename, char **algorithm,
- int *pub_blob_len, const char **errorstr)
+unsigned char *ssh2_userkey_loadpub(const Filename *filename, char **algorithm,
+ int *pub_blob_len, char **commentptr,
+ const char **errorstr)
{
FILE *fp;
char header[40], *b;
int public_blob_len;
int i;
const char *error = NULL;
+ char *comment;
public_blob = NULL;
- fp = f_open(*filename, "rb");
+ fp = f_open(filename, "rb", FALSE);
if (!fp) {
error = "can't open file";
goto error;
error = "file format error";
if ((b = read_body(fp)) == NULL)
goto error;
- /* Select key algorithm structure. Currently only ssh-rsa. */
+ /* Select key algorithm structure. */
alg = find_pubkey_alg(b);
if (!alg) {
sfree(b);
/* Read the Comment header line. */
if (!read_header(fp, header) || 0 != strcmp(header, "Comment"))
goto error;
- if ((b = read_body(fp)) == NULL)
+ if ((comment = read_body(fp)) == NULL)
goto error;
- sfree(b); /* we don't care */
+
+ if (commentptr)
+ *commentptr = comment;
+ else
+ sfree(comment);
/* Read the Public-Lines header line and the public blob. */
if (!read_header(fp, header) || 0 != strcmp(header, "Public-Lines"))
*pub_blob_len = public_blob_len;
if (algorithm)
*algorithm = alg->name;
- return (char *)public_blob;
+ return public_blob;
/*
* Error processing.
if (commentptr)
*commentptr = NULL;
- fp = f_open(*filename, "rb");
+ fp = f_open(filename, "rb", FALSE);
if (!fp)
return 0;
if (!read_header(fp, header)
SHA_Bytes(&s, passphrase, strlen(passphrase));
SHA_Final(&s, mackey);
hmac_sha1_simple(mackey, 20, macdata, maclen, priv_mac);
- memset(macdata, 0, maclen);
+ smemclr(macdata, maclen);
sfree(macdata);
- memset(mackey, 0, sizeof(mackey));
- memset(&s, 0, sizeof(s));
+ smemclr(mackey, sizeof(mackey));
+ smemclr(&s, sizeof(s));
}
if (passphrase) {
aes256_encrypt_pubkey(key, priv_blob_encrypted,
priv_encrypted_len);
- memset(key, 0, sizeof(key));
- memset(&s, 0, sizeof(s));
+ smemclr(key, sizeof(key));
+ smemclr(&s, sizeof(s));
}
- fp = f_open(*filename, "w");
+ fp = f_open(filename, "w", TRUE);
if (!fp)
return 0;
fprintf(fp, "PuTTY-User-Key-File-2: %s\n", key->alg->name);
fclose(fp);
sfree(pub_blob);
- memset(priv_blob, 0, priv_blob_len);
+ smemclr(priv_blob, priv_blob_len);
sfree(priv_blob);
sfree(priv_blob_encrypted);
return 1;
const char openssh_sig[] = "-----BEGIN ";
int i;
- fp = f_open(*filename, "r");
+ fp = f_open(filename, "r", FALSE);
if (!fp)
return SSH_KEYTYPE_UNOPENABLE;
i = fread(buf, 1, sizeof(buf), fp);
switch (type) {
case SSH_KEYTYPE_UNOPENABLE: return "unable to open file"; break;
case SSH_KEYTYPE_UNKNOWN: return "not a private key"; break;
- case SSH_KEYTYPE_SSH1: return "SSH1 private key"; break;
- case SSH_KEYTYPE_SSH2: return "PuTTY SSH2 private key"; break;
- case SSH_KEYTYPE_OPENSSH: return "OpenSSH SSH2 private key"; break;
- case SSH_KEYTYPE_SSHCOM: return "ssh.com SSH2 private key"; break;
+ case SSH_KEYTYPE_SSH1: return "SSH-1 private key"; break;
+ case SSH_KEYTYPE_SSH2: return "PuTTY SSH-2 private key"; break;
+ case SSH_KEYTYPE_OPENSSH: return "OpenSSH SSH-2 private key"; break;
+ case SSH_KEYTYPE_SSHCOM: return "ssh.com SSH-2 private key"; break;
default: return "INTERNAL ERROR"; break;
}
}