dropbear: keyimport.c comparison

comparison keyimport.c @ 1306:34e6127ef02e

merge fixes from PuTTY import.c toint() from misc.c (revids are from hggit conversion) changeset: 4620:60a336a6c85c user: Simon Tatham <[email protected]> date: Thu Feb 25 20:26:33 2016 +0000 files: import.c description: Fix potential segfaults in reading OpenSSH's ASN.1 key format. The length coming back from ber_read_id_len might have overflowed, so treat it as potentially negative. Also, while I'm here, accumulate it inside ber_read_id_len as an unsigned, so as to avoid undefined behaviour on integer overflow, and toint() it before return. Thanks to Hanno Böck for spotting this, with the aid of AFL. (cherry picked from commit 5b7833cd474a24ec098654dcba8cb9509f3bf2c1) Conflicts: import.c (cherry-picker's note: resolving the conflict involved removing an entire section of the original commit which fixed ECDSA code not present on this branch) changeset: 4619:9c6c638d98d8 user: Simon Tatham <[email protected]> date: Sun Jul 14 10:45:54 2013 +0000 files: import.c ssh.c sshdss.c sshpubk.c sshrsa.c description: Tighten up a lot of casts from unsigned to int which are read by one of the GET_32BIT macros and then used as length fields. Missing bounds checks against zero have been added, and also I've introduced a helper function toint() which casts from unsigned to int in such a way as to avoid C undefined behaviour, since I'm not sure I trust compilers any more to do the obviously sensible thing. [originally from svn r9918] changeset: 4618:3957829f24d3 user: Simon Tatham <[email protected]> date: Mon Jul 08 22:36:04 2013 +0000 files: import.c sshdss.c sshrsa.c description: Add an assortment of extra safety checks. [originally from svn r9896] changeset: 4617:2cddee0bce12 user: Jacob Nevins <[email protected]> date: Wed Dec 07 00:24:45 2005 +0000 files: import.c description: Institutional failure to memset() things pointed at rather than pointers. Things should now be zeroed and memory not leaked. Spotted by Brant Thomsen. [originally from svn r6476] changeset: 4616:24ac78a9c71d user: Simon Tatham <[email protected]> date: Wed Feb 11 13:58:27 2004 +0000 files: import.c description: Jacob's last-minute testing found a couple of trivial bugs in import.c, and my attempts to reproduce them in cmdgen found another one there :-) [originally from svn r3847] changeset: 4615:088d39a73db0 user: Simon Tatham <[email protected]> date: Thu Jan 22 18:52:49 2004 +0000 files: import.c description: Placate some gcc warnings. [originally from svn r3761] changeset: 4614:e4288bad4d93 parent: 1758:108b8924593d user: Simon Tatham <[email protected]> date: Fri Oct 03 21:21:23 2003 +0000 files: import.c description: My ASN.1 decoder returned wrong IDs for anything above 0x1E! Good job it's never had to yet. Ahem. [originally from svn r3479]

author	Matt Johnston <matt@ucc.asn.au>
date	Tue, 12 Jul 2016 23:00:01 +0800
parents	2bb4c662d1c2
children	ad9c40aca3bc

comparison

equal deleted inserted replaced

-:6914eedb1072
+:34e6127ef02e
 (cp)[2] = (unsigned char)((value) >> 8); \
 (cp)[1] = (unsigned char)((value) >> 16); \
 (cp)[0] = (unsigned char)((value) >> 24); } while (0)
 #define GET_32BIT(cp) \
-	(((unsigned long)(unsigned char)(cp)[0] << 24) | \
+(((unsigned long)(unsigned char)(cp)[0] << 24) | \
-	((unsigned long)(unsigned char)(cp)[1] << 16) | \
+((unsigned long)(unsigned char)(cp)[1] << 16) | \
-	((unsigned long)(unsigned char)(cp)[2] << 8) | \
+((unsigned long)(unsigned char)(cp)[2] << 8) | \
-	((unsigned long)(unsigned char)(cp)[3]))
+((unsigned long)(unsigned char)(cp)[3]))
 static int openssh_encrypted(const char *filename);
 static sign_key *openssh_read(const char *filename, char *passphrase);
 static int openssh_write(const char *filename, sign_key *key,
-				  char *passphrase);
+		  char *passphrase);
 static int dropbear_write(const char*filename, sign_key * key);
 static sign_key *dropbear_read(const char* filename);
+static int toint(unsigned u);
 #if 0
 static int sshcom_encrypted(const char *filename, char **comment);
 static struct ssh2_userkey *sshcom_read(const char *filename, char *passphrase);
 static int sshcom_write(const char *filename, struct ssh2_userkey *key,
-				 char *passphrase);
+		 char *passphrase);
 #endif
 int import_encrypted(const char* filename, int filetype) {
 	if (filetype == KEYFILE_OPENSSH) {
-		return openssh_encrypted(filename);
+	return openssh_encrypted(filename);
 #if 0
 	} else if (filetype == KEYFILE_SSHCOM) {
 		return sshcom_encrypted(filename, NULL);
 #endif
-	}
+}
-	return 0;
+return 0;
 }
 sign_key *import_read(const char *filename, char *passphrase, int filetype) {
 	if (filetype == KEYFILE_OPENSSH) {
-		return openssh_read(filename, passphrase);
+	return openssh_read(filename, passphrase);
 	} else if (filetype == KEYFILE_DROPBEAR) {
 		return dropbear_read(filename);
 #if 0
 	} else if (filetype == KEYFILE_SSHCOM) {
-		return sshcom_read(filename, passphrase);
+	return sshcom_read(filename, passphrase);
 #endif
 	}
-	return NULL;
+return NULL;
 }
 int import_write(const char *filename, sign_key *key, char *passphrase,
 		int filetype) {
 	if (filetype == KEYFILE_OPENSSH) {
-		return openssh_write(filename, key, passphrase);
+	return openssh_write(filename, key, passphrase);
 	} else if (filetype == KEYFILE_DROPBEAR) {
 		return dropbear_write(filename, key);
 #if 0
 	} else if (filetype == KEYFILE_SSHCOM) {
-		return sshcom_write(filename, key, passphrase);
+	return sshcom_write(filename, key, passphrase);
 #endif
 	}
-	return 0;
+return 0;
 }
 static sign_key *dropbear_read(const char* filename) {
 	buffer * buf = NULL;
 /* ----------------------------------------------------------------------
 * Helper routines. (The base64 ones are defined in sshpubk.c.)
 */
-#define isbase64(c) (	((c) >= 'A' && (c) <= 'Z') || \
+#define isbase64(c) (    ((c) >= 'A' && (c) <= 'Z') || \
-						 ((c) >= 'a' && (c) <= 'z') || \
+((c) >= 'a' && (c) <= 'z') || \
-						 ((c) >= '0' && (c) <= '9') || \
+((c) >= '0' && (c) <= '9') || \
-						 (c) == '+' || (c) == '/' || (c) == '=' \
+(c) == '+' || (c) == '/' || (c) == '=' \
-						 )
+)
 /* cpl has to be less than 100 */
 static void base64_encode_fp(FILE * fp, unsigned char *data,
 		int datalen, int cpl)
 {
 * Returns -1 if unsuccessful; otherwise returns the number of
 * bytes used out of the source data.
 */
 /* ASN.1 tag classes. */
-#define ASN1_CLASS_UNIVERSAL		(0 << 6)
+#define ASN1_CLASS_UNIVERSAL        (0 << 6)
-#define ASN1_CLASS_APPLICATION	  (1 << 6)
+#define ASN1_CLASS_APPLICATION      (1 << 6)
 #define ASN1_CLASS_CONTEXT_SPECIFIC (2 << 6)
-#define ASN1_CLASS_PRIVATE		  (3 << 6)
+#define ASN1_CLASS_PRIVATE          (3 << 6)
-#define ASN1_CLASS_MASK			 (3 << 6)
+#define ASN1_CLASS_MASK             (3 << 6)
 /* Primitive versus constructed bit. */
-#define ASN1_CONSTRUCTED			(1 << 5)
+#define ASN1_CONSTRUCTED            (1 << 5)
 static int ber_read_id_len(void *source, int sourcelen,
-						   int *id, int *length, int *flags)
+			   int *id, int *length, int *flags)
 {
-	unsigned char *p = (unsigned char *) source;
+unsigned char *p = (unsigned char *) source;
-	if (sourcelen == 0)
+if (sourcelen == 0)
+	return -1;
+*flags = (*p & 0xE0);
+if ((*p & 0x1F) == 0x1F) {
+	*id = 0;
+	while (*p & 0x80) {
+	    p++, sourcelen--;
+	    if (sourcelen == 0)
 		return -1;
+	    *id = (*id << 7) | (*p & 0x7F);
-	*flags = (*p & 0xE0);
+	}
-	if ((*p & 0x1F) == 0x1F) {
+	p++, sourcelen--;
-		*id = 0;
+} else {
-		while (*p & 0x80) {
+	*id = *p & 0x1F;
-			*id = (*id << 7) | (*p & 0x7F);
+	p++, sourcelen--;
-			p++, sourcelen--;
+}
-			if (sourcelen == 0)
-				return -1;
+if (sourcelen == 0)
-		}
+	return -1;
-		*id = (*id << 7) | (*p & 0x7F);
-		p++, sourcelen--;
+if (*p & 0x80) {
-	} else {
+unsigned len;
-		*id = *p & 0x1F;
+	int n = *p & 0x7F;
-		p++, sourcelen--;
+	p++, sourcelen--;
-	}
+	if (sourcelen < n)
+	    return -1;
-	if (sourcelen == 0)
+	len = 0;
-		return -1;
+	while (n--)
+	    len = (len << 8) | (*p++);
-	if (*p & 0x80) {
+	sourcelen -= n;
-		int n = *p & 0x7F;
+*length = toint(len);
-		p++, sourcelen--;
+} else {
-		if (sourcelen < n)
+	*length = *p;
-			return -1;
+	p++, sourcelen--;
-		*length = 0;
+}
-		while (n--)
-			*length = (*length << 8) | (*p++);
+return p - (unsigned char *) source;
-		sourcelen -= n;
-	} else {
-		*length = *p;
-		p++, sourcelen--;
-	}
-	return p - (unsigned char *) source;
 }
 /*
 * Write an ASN.1/BER identifier and length pair. Returns the
 * number of bytes consumed. Assumes dest contains enough space.
 * Will avoid writing anything if dest is NULL, but still return
 * amount of space required.
 */
 static int ber_write_id_len(void *dest, int id, int length, int flags)
 {
-	unsigned char *d = (unsigned char *)dest;
+unsigned char *d = (unsigned char *)dest;
-	int len = 0;
+int len = 0;
-	if (id <= 30) {
+if (id <= 30) {
-		/*
+	/*
-		 * Identifier is one byte.
+	 * Identifier is one byte.
-		 */
+	 */
-		len++;
+	len++;
-		if (d) *d++ = id | flags;
+	if (d) *d++ = id | flags;
-	} else {
+} else {
-		int n;
+	int n;
-		/*
+	/*
-		 * Identifier is multiple bytes: the first byte is 11111
+	 * Identifier is multiple bytes: the first byte is 11111
-		 * plus the flags, and subsequent bytes encode the value of
+	 * plus the flags, and subsequent bytes encode the value of
-		 * the identifier, 7 bits at a time, with the top bit of
+	 * the identifier, 7 bits at a time, with the top bit of
-		 * each byte 1 except the last one which is 0.
+	 * each byte 1 except the last one which is 0.
-		 */
+	 */
-		len++;
+	len++;
-		if (d) *d++ = 0x1F | flags;
+	if (d) *d++ = 0x1F | flags;
-		for (n = 1; (id >> (7*n)) > 0; n++)
+	for (n = 1; (id >> (7*n)) > 0; n++)
-			continue;					   /* count the bytes */
+	    continue;		       /* count the bytes */
-		while (n--) {
+	while (n--) {
-			len++;
+	    len++;
-			if (d) *d++ = (n ? 0x80 : 0) | ((id >> (7*n)) & 0x7F);
+	    if (d) *d++ = (n ? 0x80 : 0) | ((id >> (7*n)) & 0x7F);
-		}
+	}
-	}
+}
-	if (length < 128) {
+if (length < 128) {
-		/*
+	/*
-		 * Length is one byte.
+	 * Length is one byte.
-		 */
+	 */
-		len++;
+	len++;
-		if (d) *d++ = length;
+	if (d) *d++ = length;
-	} else {
+} else {
-		int n;
+	int n;
-		/*
+	/*
-		 * Length is multiple bytes. The first is 0x80 plus the
+	 * Length is multiple bytes. The first is 0x80 plus the
-		 * number of subsequent bytes, and the subsequent bytes
+	 * number of subsequent bytes, and the subsequent bytes
-		 * encode the actual length.
+	 * encode the actual length.
-		 */
+	 */
-		for (n = 1; (length >> (8*n)) > 0; n++)
+	for (n = 1; (length >> (8*n)) > 0; n++)
-			continue;					   /* count the bytes */
+	    continue;		       /* count the bytes */
-		len++;
+	len++;
-		if (d) *d++ = 0x80 | n;
+	if (d) *d++ = 0x80 | n;
-		while (n--) {
+	while (n--) {
-			len++;
+	    len++;
-			if (d) *d++ = (length >> (8*n)) & 0xFF;
+	    if (d) *d++ = (length >> (8*n)) & 0xFF;
-		}
+	}
-	}
+}
-	return len;
+return len;
 }
 /* Simple structure to point to an mp-int within a blob. */
 struct mpint_pos { void *start; int bytes; };
 * Code to read and write OpenSSH private keys.
 */
 enum { OSSH_DSA, OSSH_RSA, OSSH_EC };
 struct openssh_key {
-	int type;
+int type;
-	int encrypted;
+int encrypted;
-	char iv[32];
+char iv[32];
-	unsigned char *keyblob;
+unsigned char *keyblob;
 	unsigned int keyblob_len, keyblob_size;
 };
 static struct openssh_key *load_openssh_key(const char *filename)
 {
-	struct openssh_key *ret;
+struct openssh_key *ret;
 	FILE *fp = NULL;
-	char buffer[256];
+char buffer[256];
 	char *errmsg = NULL, *p = NULL;
-	int headers_done;
+int headers_done;
 	unsigned long len, outlen;
 	ret = (struct openssh_key*)m_malloc(sizeof(struct openssh_key));
-	ret->keyblob = NULL;
+ret->keyblob = NULL;
-	ret->keyblob_len = ret->keyblob_size = 0;
+ret->keyblob_len = ret->keyblob_size = 0;
-	ret->encrypted = 0;
+ret->encrypted = 0;
-	memset(ret->iv, 0, sizeof(ret->iv));
+memset(ret->iv, 0, sizeof(ret->iv));
 	if (strlen(filename) == 1 && filename[0] == '-') {
 		fp = stdin;
 	} else {
 		fp = fopen(filename, "r");
 	}
-	if (!fp) {
+if (!fp) {
-		errmsg = "Unable to open key file";
+	errmsg = "Unable to open key file";
-		goto error;
+	goto error;
-	}
+}
-	if (!fgets(buffer, sizeof(buffer), fp) ||
+if (!fgets(buffer, sizeof(buffer), fp) ||
-		0 != strncmp(buffer, "-----BEGIN ", 11) ||
+	0 != strncmp(buffer, "-----BEGIN ", 11) ||
-		0 != strcmp(buffer+strlen(buffer)-17, "PRIVATE KEY-----\n")) {
+	0 != strcmp(buffer+strlen(buffer)-17, "PRIVATE KEY-----\n")) {
-		errmsg = "File does not begin with OpenSSH key header";
+	errmsg = "File does not begin with OpenSSH key header";
-		goto error;
+	goto error;
-	}
+}
-	if (!strcmp(buffer, "-----BEGIN RSA PRIVATE KEY-----\n"))
+if (!strcmp(buffer, "-----BEGIN RSA PRIVATE KEY-----\n"))
-		ret->type = OSSH_RSA;
+	ret->type = OSSH_RSA;
-	else if (!strcmp(buffer, "-----BEGIN DSA PRIVATE KEY-----\n"))
+else if (!strcmp(buffer, "-----BEGIN DSA PRIVATE KEY-----\n"))
-		ret->type = OSSH_DSA;
+	ret->type = OSSH_DSA;
 	else if (!strcmp(buffer, "-----BEGIN EC PRIVATE KEY-----\n"))
 		ret->type = OSSH_EC;
-	else {
+else {
-		errmsg = "Unrecognised key type";
+	errmsg = "Unrecognised key type";
+	goto error;
+}
+headers_done = 0;
+while (1) {
+	if (!fgets(buffer, sizeof(buffer), fp)) {
+	    errmsg = "Unexpected end of file";
+	    goto error;
+	}
+	if (0 == strncmp(buffer, "-----END ", 9) &&
+	    0 == strcmp(buffer+strlen(buffer)-17, "PRIVATE KEY-----\n"))
+	    break;		       /* done */
+	if ((p = strchr(buffer, ':')) != NULL) {
+	    if (headers_done) {
+		errmsg = "Header found in body of key data";
 		goto error;
-	}
+	    }
+	    *p++ = '\0';
-	headers_done = 0;
+	    while (*p && isspace((unsigned char)*p)) p++;
-	while (1) {
+	    if (!strcmp(buffer, "Proc-Type")) {
-		if (!fgets(buffer, sizeof(buffer), fp)) {
+		if (p[0] != '4' || p[1] != ',') {
-			errmsg = "Unexpected end of file";
+		    errmsg = "Proc-Type is not 4 (only 4 is supported)";
-			goto error;
+		    goto error;
 		}
-		if (0 == strncmp(buffer, "-----END ", 9) &&
+		p += 2;
-			0 == strcmp(buffer+strlen(buffer)-17, "PRIVATE KEY-----\n"))
+		if (!strcmp(p, "ENCRYPTED\n"))
-			break;					   /* done */
+		    ret->encrypted = 1;
-		if ((p = strchr(buffer, ':')) != NULL) {
+	    } else if (!strcmp(buffer, "DEK-Info")) {
-			if (headers_done) {
+		int i, j;
-				errmsg = "Header found in body of key data";
-				goto error;
+		if (strncmp(p, "DES-EDE3-CBC,", 13)) {
-			}
+		    errmsg = "Ciphers other than DES-EDE3-CBC not supported";
-			*p++ = '\0';
+		    goto error;
-			while (*p && isspace((unsigned char)*p)) p++;
+		}
-			if (!strcmp(buffer, "Proc-Type")) {
+		p += 13;
-				if (p[0] != '4' || p[1] != ',') {
+		for (i = 0; i < 8; i++) {
-					errmsg = "Proc-Type is not 4 (only 4 is supported)";
+		    if (1 != sscanf(p, "%2x", &j))
-					goto error;
+			break;
-				}
+		    ret->iv[i] = j;
-				p += 2;
+		    p += 2;
-				if (!strcmp(p, "ENCRYPTED\n"))
+		}
-					ret->encrypted = 1;
+		if (i < 8) {
-			} else if (!strcmp(buffer, "DEK-Info")) {
+		    errmsg = "Expected 16-digit iv in DEK-Info";
-				int i, j;
+		    goto error;
+		}
-				if (strncmp(p, "DES-EDE3-CBC,", 13)) {
+	    }
-					errmsg = "Ciphers other than DES-EDE3-CBC not supported";
+	} else {
-					goto error;
+	    headers_done = 1;
-				}
-				p += 13;
-				for (i = 0; i < 8; i++) {
-					if (1 != sscanf(p, "%2x", &j))
-						break;
-					ret->iv[i] = j;
-					p += 2;
-				}
-				if (i < 8) {
-					errmsg = "Expected 16-digit iv in DEK-Info";
-					goto error;
-				}
-			}
-		} else {
-			headers_done = 1;
 			len = strlen(buffer);
 			outlen = len*4/3;
 			if (ret->keyblob_len + outlen > ret->keyblob_size) {
 				ret->keyblob_size = ret->keyblob_len + outlen + 256;
 				ret->keyblob = (unsigned char*)m_realloc(ret->keyblob,
 			}
 			outlen = ret->keyblob_size - ret->keyblob_len;
 			if (base64_decode((const unsigned char *)buffer, len,
 						ret->keyblob + ret->keyblob_len, &outlen) != CRYPT_OK){
 				errmsg = "Error decoding base64";
-				goto error;
+goto error;
-			}
+}
 			ret->keyblob_len += outlen;
-		}
+}
 	}
-	if (ret->keyblob_len == 0 || !ret->keyblob) {
+if (ret->keyblob_len == 0 || !ret->keyblob) {
-		errmsg = "Key body not present";
+	errmsg = "Key body not present";
-		goto error;
+	goto error;
-	}
+}
-	if (ret->encrypted && ret->keyblob_len % 8 != 0) {
+if (ret->encrypted && ret->keyblob_len % 8 != 0) {
-		errmsg = "Encrypted key blob is not a multiple of cipher block size";
+	errmsg = "Encrypted key blob is not a multiple of cipher block size";
-		goto error;
+	goto error;
-	}
+}
 	m_burn(buffer, sizeof(buffer));
-	return ret;
+return ret;
-	error:
+error:
 	m_burn(buffer, sizeof(buffer));
-	if (ret) {
+if (ret) {
-		if (ret->keyblob) {
+	if (ret->keyblob) {
 			m_burn(ret->keyblob, ret->keyblob_size);
 			m_free(ret->keyblob);
-		}
+}
 		m_free(ret);
 	}
 	if (fp) {
 		fclose(fp);
-	}
+}
 	if (errmsg) {
 		fprintf(stderr, "Error: %s\n", errmsg);
 	}
-	return NULL;
+return NULL;
 }
 static int openssh_encrypted(const char *filename)
 {
-	struct openssh_key *key = load_openssh_key(filename);
+struct openssh_key *key = load_openssh_key(filename);
-	int ret;
+int ret;
-	if (!key)
+if (!key)
-		return 0;
+	return 0;
-	ret = key->encrypted;
+ret = key->encrypted;
 	m_burn(key->keyblob, key->keyblob_size);
 	m_free(key->keyblob);
 	m_free(key);
-	return ret;
+return ret;
 }
 static sign_key *openssh_read(const char *filename, char * UNUSED(passphrase))
 {
 	struct openssh_key *key;
-	unsigned char *p;
+unsigned char *p;
-	int ret, id, len, flags;
+int ret, id, len, flags;
 	int i, num_integers = 0;
 	sign_key *retval = NULL;
-	char *errmsg;
+char *errmsg;
 	unsigned char *modptr = NULL;
 	int modlen = -9999;
 	enum signkey_type type;
 	sign_key *retkey;
 	retkey = new_sign_key();
 	key = load_openssh_key(filename);
-	if (!key)
+if (!key)
-		return NULL;
+	return NULL;
-	if (key->encrypted) {
+if (key->encrypted) {
 		errmsg = "encrypted keys not supported currently";
 		goto error;
 #if 0
 		/* matt TODO */
-		/*
+	/*
-		 * Derive encryption key from passphrase and iv/salt:
+	 * Derive encryption key from passphrase and iv/salt:
-		 *
+	 *
-		 *  - let block A equal MD5(passphrase || iv)
+	 *  - let block A equal MD5(passphrase || iv)
-		 *  - let block B equal MD5(A || passphrase || iv)
+	 *  - let block B equal MD5(A || passphrase || iv)
-		 *  - block C would be MD5(B || passphrase || iv) and so on
+	 *  - block C would be MD5(B || passphrase || iv) and so on
-		 *  - encryption key is the first N bytes of A || B
+	 *  - encryption key is the first N bytes of A || B
-		 */
+	 */
-		struct MD5Context md5c;
+	struct MD5Context md5c;
-		unsigned char keybuf[32];
+	unsigned char keybuf[32];
-		MD5Init(&md5c);
+	MD5Init(&md5c);
-		MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
+	MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
-		MD5Update(&md5c, (unsigned char *)key->iv, 8);
+	MD5Update(&md5c, (unsigned char *)key->iv, 8);
-		MD5Final(keybuf, &md5c);
+	MD5Final(keybuf, &md5c);
-		MD5Init(&md5c);
+	MD5Init(&md5c);
-		MD5Update(&md5c, keybuf, 16);
+	MD5Update(&md5c, keybuf, 16);
-		MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
+	MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
-		MD5Update(&md5c, (unsigned char *)key->iv, 8);
+	MD5Update(&md5c, (unsigned char *)key->iv, 8);
-		MD5Final(keybuf+16, &md5c);
+	MD5Final(keybuf+16, &md5c);
-		/*
+	/*
-		 * Now decrypt the key blob.
+	 * Now decrypt the key blob.
-		 */
+	 */
-		des3_decrypt_pubkey_ossh(keybuf, (unsigned char *)key->iv,
+	des3_decrypt_pubkey_ossh(keybuf, (unsigned char *)key->iv,
-								 key->keyblob, key->keyblob_len);
+				 key->keyblob, key->keyblob_len);
-		memset(&md5c, 0, sizeof(md5c));
+memset(&md5c, 0, sizeof(md5c));
-		memset(keybuf, 0, sizeof(keybuf));
+memset(keybuf, 0, sizeof(keybuf));
 #endif
-	}
+}
-	/*
+/*
-	 * Now we have a decrypted key blob, which contains an ASN.1
+* Now we have a decrypted key blob, which contains an ASN.1
-	 * encoded private key. We must now untangle the ASN.1.
+* encoded private key. We must now untangle the ASN.1.
-	 *
+*
-	 * We expect the whole key blob to be formatted as a SEQUENCE
+* We expect the whole key blob to be formatted as a SEQUENCE
-	 * (0x30 followed by a length code indicating that the rest of
+* (0x30 followed by a length code indicating that the rest of
-	 * the blob is part of the sequence). Within that SEQUENCE we
+* the blob is part of the sequence). Within that SEQUENCE we
-	 * expect to see a bunch of INTEGERs. What those integers mean
+* expect to see a bunch of INTEGERs. What those integers mean
-	 * depends on the key type:
+* depends on the key type:
-	 *
+*
-	 *  - For RSA, we expect the integers to be 0, n, e, d, p, q,
+*  - For RSA, we expect the integers to be 0, n, e, d, p, q,
-	 *	dmp1, dmq1, iqmp in that order. (The last three are d mod
+*    dmp1, dmq1, iqmp in that order. (The last three are d mod
-	 *	(p-1), d mod (q-1), inverse of q mod p respectively.)
+*    (p-1), d mod (q-1), inverse of q mod p respectively.)
-	 *
+*
-	 *  - For DSA, we expect them to be 0, p, q, g, y, x in that
+*  - For DSA, we expect them to be 0, p, q, g, y, x in that
-	 *	order.
+*    order.
-	 */
+*/
-	p = key->keyblob;
+p = key->keyblob;
-	/* Expect the SEQUENCE header. Take its absence as a failure to decrypt. */
+/* Expect the SEQUENCE header. Take its absence as a failure to decrypt. */
-	ret = ber_read_id_len(p, key->keyblob_len, &id, &len, &flags);
+ret = ber_read_id_len(p, key->keyblob_len, &id, &len, &flags);
-	p += ret;
+p += ret;
-	if (ret < 0 || id != 16) {
+if (ret < 0 || id != 16 || len < 0 ||
+key->keyblob+key->keyblob_len-p < len) {
 		errmsg = "ASN.1 decoding failure - wrong password?";
-		goto error;
+	goto error;
-	}
+}
-	/* Expect a load of INTEGERs. */
+/* Expect a load of INTEGERs. */
-	if (key->type == OSSH_RSA)
+if (key->type == OSSH_RSA)
-		num_integers = 9;
+	num_integers = 9;
-	else if (key->type == OSSH_DSA)
+else if (key->type == OSSH_DSA)
-		num_integers = 6;
+	num_integers = 6;
 	else if (key->type == OSSH_EC)
 		num_integers = 1;
-	/*
+/*
-	 * Space to create key blob in.
+* Space to create key blob in.
-	 */
+*/
 	blobbuf = buf_new(3000);
 #ifdef DROPBEAR_DSS
 	if (key->type == OSSH_DSA) {
 		buf_putstring(blobbuf, "ssh-dss", 7);
 		buf_putstring(blobbuf, "ssh-rsa", 7);
 		retkey->type = DROPBEAR_SIGNKEY_RSA;
 	}
 #endif
-	for (i = 0; i < num_integers; i++) {
+for (i = 0; i < num_integers; i++) {
-		ret = ber_read_id_len(p, key->keyblob+key->keyblob_len-p,
+	ret = ber_read_id_len(p, key->keyblob+key->keyblob_len-p,
-							  &id, &len, &flags);
+			      &id, &len, &flags);
-		p += ret;
+	p += ret;
-		if (ret < 0 || id != 2 ||
+	if (ret < 0 || id != 2 || len < 0 ||
-			key->keyblob+key->keyblob_len-p < len) {
+	    key->keyblob+key->keyblob_len-p < len) {
-			errmsg = "ASN.1 decoding failure";
+	    errmsg = "ASN.1 decoding failure";
-			goto error;
+	    goto error;
-		}
+	}
-		if (i == 0) {
+	if (i == 0) {
 			/* First integer is a version indicator */
 			int expected = -1;
 			switch (key->type) {
 				case OSSH_RSA:
 				case OSSH_DSA:
 				case OSSH_EC:
 					expected = 1;
 					break;
 			}
 			if (len != 1 || p[0] != expected) {
-				errmsg = "Version number mismatch";
+		errmsg = "Version number mismatch";
-				goto error;
+		goto error;
-			}
+	    }
-		} else if (key->type == OSSH_RSA) {
+	} else if (key->type == OSSH_RSA) {
-			/*
+	    /*
 			 * OpenSSH key order is n, e, d, p, q, dmp1, dmq1, iqmp
 			 * but we want e, n, d, p, q
-			 */
+	     */
-			if (i == 1) {
+	    if (i == 1) {
-				/* Save the details for after we deal with number 2. */
+		/* Save the details for after we deal with number 2. */
 				modptr = p;
-				modlen = len;
+		modlen = len;
 			} else if (i >= 2 && i <= 5) {
 				buf_putstring(blobbuf, (const char*)p, len);
-				if (i == 2) {
+		if (i == 2) {
 					buf_putstring(blobbuf, (const char*)modptr, modlen);
-				}
+		}
-			}
+	    }
-		} else if (key->type == OSSH_DSA) {
+	} else if (key->type == OSSH_DSA) {
-			/*
+	    /*
 			 * OpenSSH key order is p, q, g, y, x,
 			 * we want the same.
-			 */
+	     */
 			buf_putstring(blobbuf, (const char*)p, len);
-		}
+	}
-		/* Skip past the number. */
+	/* Skip past the number. */
-		p += len;
+	p += len;
-	}
+}
 #ifdef DROPBEAR_ECDSA
 	if (key->type == OSSH_EC) {
 		unsigned char* private_key_bytes = NULL;
 		int private_key_len = 0;
 		*signkey_key_ptr(retkey, retkey->type) = ecc;
 	}
 #endif /* DROPBEAR_ECDSA */
-	/*
+/*
-	 * Now put together the actual key. Simplest way to do this is
+* Now put together the actual key. Simplest way to do this is
-	 * to assemble our own key blobs and feed them to the createkey
+* to assemble our own key blobs and feed them to the createkey
-	 * functions; this is a bit faffy but it does mean we get all
+* functions; this is a bit faffy but it does mean we get all
-	 * the sanity checks for free.
+* the sanity checks for free.
-	 */
+*/
 	if (key->type == OSSH_RSA || key->type == OSSH_DSA) {
 		buf_setpos(blobbuf, 0);
 		type = DROPBEAR_SIGNKEY_ANY;
 		if (buf_get_priv_key(blobbuf, retkey, &type)
 				!= DROPBEAR_SUCCESS) {
 			errmsg = "unable to create key structure";
 			sign_key_free(retkey);
 			retkey = NULL;
-			goto error;
+	goto error;
-		}
+}
 	}
-	errmsg = NULL;					 /* no error */
+errmsg = NULL;                     /* no error */
-	retval = retkey;
+retval = retkey;
-	error:
+error:
 	if (blobbuf) {
 		buf_burn(blobbuf);
 		buf_free(blobbuf);
-	}
+}
 	m_burn(key->keyblob, key->keyblob_size);
 	m_free(key->keyblob);
 	m_burn(key, sizeof(*key));
 	m_free(key);
 	if (errmsg) {
 		fprintf(stderr, "Error: %s\n", errmsg);
 	}
-	return retval;
+return retval;
 }
 static int openssh_write(const char *filename, sign_key *key,
-				  char *passphrase)
+		  char *passphrase)
 {
 	buffer * keyblob = NULL;
 	buffer * extrablob = NULL; /* used for calculated values to write */
 	unsigned char *outblob = NULL;
 	int outlen = -9999;
-	struct mpint_pos numbers[9];
+struct mpint_pos numbers[9];
 	int nnumbers = -1, pos = 0, len = 0, seqlen, i;
 	char *header = NULL, *footer = NULL;
-	char zero[1];
+char zero[1];
-	int ret = 0;
+int ret = 0;
-	FILE *fp;
+FILE *fp;
 #ifdef DROPBEAR_RSA
 	mp_int dmp1, dmq1, iqmp, tmpval; /* for rsa */
 #endif
 #ifdef DROPBEAR_DSS
 			key->type == DROPBEAR_SIGNKEY_DSS ||
 #endif
 			0)
 	{
-		/*
+/*
-		 * Fetch the key blobs.
+* Fetch the key blobs.
-		 */
+*/
 		keyblob = buf_new(3000);
 		buf_put_priv_key(keyblob, key, key->type);
 		buf_setpos(keyblob, 0);
 		/* skip the "ssh-rsa" or "ssh-dss" header */
 		buf_incrpos(keyblob, buf_getint(keyblob));
-		/*
+/*
-		 * Find the sequence of integers to be encoded into the OpenSSH
+* Find the sequence of integers to be encoded into the OpenSSH
-		 * key blob, and also decide on the header line.
+* key blob, and also decide on the header line.
-		 */
+*/
 		numbers[0].start = zero; numbers[0].bytes = 1; zero[0] = '\0';
 	#ifdef DROPBEAR_RSA
 		if (key->type == DROPBEAR_SIGNKEY_RSA) {
 			/* e */
 			numbers[2].bytes = buf_getint(keyblob);
 			numbers[2].start = buf_getptr(keyblob, numbers[2].bytes);
 			buf_incrpos(keyblob, numbers[2].bytes);
 			/* n */
 			numbers[1].bytes = buf_getint(keyblob);
 			numbers[1].start = buf_getptr(keyblob, numbers[1].bytes);
 			buf_incrpos(keyblob, numbers[1].bytes);
 			/* d */
 			numbers[3].bytes = buf_getint(keyblob);
 			numbers[3].start = buf_getptr(keyblob, numbers[3].bytes);
 			buf_incrpos(keyblob, numbers[3].bytes);
 			/* p */
 			numbers[4].bytes = buf_getint(keyblob);
 			numbers[4].start = buf_getptr(keyblob, numbers[4].bytes);
 			buf_incrpos(keyblob, numbers[4].bytes);
 			/* iqmp */
 			numbers[8].bytes = buf_getint(extrablob);
 			numbers[8].start = buf_getptr(extrablob, numbers[8].bytes);
 			buf_incrpos(extrablob, numbers[8].bytes);
-			nnumbers = 9;
+nnumbers = 9;
-			header = "-----BEGIN RSA PRIVATE KEY-----\n";
+header = "-----BEGIN RSA PRIVATE KEY-----\n";
-			footer = "-----END RSA PRIVATE KEY-----\n";
+footer = "-----END RSA PRIVATE KEY-----\n";
 		}
 	#endif /* DROPBEAR_RSA */
 	#ifdef DROPBEAR_DSS
 		if (key->type == DROPBEAR_SIGNKEY_DSS) {
 			/* x */
 			numbers[5].bytes = buf_getint(keyblob);
 			numbers[5].start = buf_getptr(keyblob, numbers[5].bytes);
 			buf_incrpos(keyblob, numbers[5].bytes);
-			nnumbers = 6;
+nnumbers = 6;
-			header = "-----BEGIN DSA PRIVATE KEY-----\n";
+header = "-----BEGIN DSA PRIVATE KEY-----\n";
-			footer = "-----END DSA PRIVATE KEY-----\n";
+footer = "-----END DSA PRIVATE KEY-----\n";
-		}
+}
 	#endif /* DROPBEAR_DSS */
-		/*
+/*
-		 * Now count up the total size of the ASN.1 encoded integers,
+* Now count up the total size of the ASN.1 encoded integers,
-		 * so as to determine the length of the containing SEQUENCE.
+* so as to determine the length of the containing SEQUENCE.
-		 */
+*/
-		len = 0;
+len = 0;
-		for (i = 0; i < nnumbers; i++) {
+for (i = 0; i < nnumbers; i++) {
-			len += ber_write_id_len(NULL, 2, numbers[i].bytes, 0);
+	len += ber_write_id_len(NULL, 2, numbers[i].bytes, 0);
-			len += numbers[i].bytes;
+	len += numbers[i].bytes;
-		}
+}
-		seqlen = len;
+seqlen = len;
-		/* Now add on the SEQUENCE header. */
+/* Now add on the SEQUENCE header. */
-		len += ber_write_id_len(NULL, 16, seqlen, ASN1_CONSTRUCTED);
+len += ber_write_id_len(NULL, 16, seqlen, ASN1_CONSTRUCTED);
-		/* Round up to the cipher block size, ensuring we have at least one
+/* Round up to the cipher block size, ensuring we have at least one
-		 * byte of padding (see below). */
+* byte of padding (see below). */
-		outlen = len;
+outlen = len;
-		if (passphrase)
+if (passphrase)
-			outlen = (outlen+8) &~ 7;
+	outlen = (outlen+8) &~ 7;
-		/*
+/*
-		 * Now we know how big outblob needs to be. Allocate it.
+* Now we know how big outblob needs to be. Allocate it.
-		 */
+*/
 		outblob = (unsigned char*)m_malloc(outlen);
-		/*
+/*
-		 * And write the data into it.
+* And write the data into it.
-		 */
+*/
-		pos = 0;
+pos = 0;
-		pos += ber_write_id_len(outblob+pos, 16, seqlen, ASN1_CONSTRUCTED);
+pos += ber_write_id_len(outblob+pos, 16, seqlen, ASN1_CONSTRUCTED);
-		for (i = 0; i < nnumbers; i++) {
+for (i = 0; i < nnumbers; i++) {
-			pos += ber_write_id_len(outblob+pos, 2, numbers[i].bytes, 0);
+	pos += ber_write_id_len(outblob+pos, 2, numbers[i].bytes, 0);
-			memcpy(outblob+pos, numbers[i].start, numbers[i].bytes);
+	memcpy(outblob+pos, numbers[i].start, numbers[i].bytes);
-			pos += numbers[i].bytes;
+	pos += numbers[i].bytes;
-		}
+}
 	} /* end RSA and DSS handling */
 #ifdef DROPBEAR_ECDSA
 	if (key->type == DROPBEAR_SIGNKEY_ECDSA_NISTP256
 		|| key->type == DROPBEAR_SIGNKEY_ECDSA_NISTP384
 		header = "-----BEGIN EC PRIVATE KEY-----\n";
 		footer = "-----END EC PRIVATE KEY-----\n";
 	}
 #endif
-	/*
+/*
-	 * Padding on OpenSSH keys is deterministic. The number of
+* Padding on OpenSSH keys is deterministic. The number of
-	 * padding bytes is always more than zero, and always at most
+* padding bytes is always more than zero, and always at most
-	 * the cipher block length. The value of each padding byte is
+* the cipher block length. The value of each padding byte is
-	 * equal to the number of padding bytes. So a plaintext that's
+* equal to the number of padding bytes. So a plaintext that's
-	 * an exact multiple of the block size will be padded with 08
+* an exact multiple of the block size will be padded with 08
-	 * 08 08 08 08 08 08 08 (assuming a 64-bit block cipher); a
+* 08 08 08 08 08 08 08 (assuming a 64-bit block cipher); a
-	 * plaintext one byte less than a multiple of the block size
+* plaintext one byte less than a multiple of the block size
-	 * will be padded with just 01.
+* will be padded with just 01.
-	 *
+*
-	 * This enables the OpenSSL key decryption function to strip
+* This enables the OpenSSL key decryption function to strip
-	 * off the padding algorithmically and return the unpadded
+* off the padding algorithmically and return the unpadded
-	 * plaintext to the next layer: it looks at the final byte, and
+* plaintext to the next layer: it looks at the final byte, and
-	 * then expects to find that many bytes at the end of the data
+* then expects to find that many bytes at the end of the data
-	 * with the same value. Those are all removed and the rest is
+* with the same value. Those are all removed and the rest is
-	 * returned.
+* returned.
-	 */
+*/
 	dropbear_assert(pos == len);
-	while (pos < outlen) {
+while (pos < outlen) {
-		outblob[pos++] = outlen - len;
+outblob[pos++] = outlen - len;
-	}
+}
-	/*
+/*
-	 * Encrypt the key.
+* Encrypt the key.
-	 */
+*/
-	if (passphrase) {
+if (passphrase) {
 		fprintf(stderr, "Encrypted keys aren't supported currently\n");
 		goto error;
-	}
+}
-	/*
+/*
-	 * And save it. We'll use Unix line endings just in case it's
+* And save it. We'll use Unix line endings just in case it's
-	 * subsequently transferred in binary mode.
+* subsequently transferred in binary mode.
-	 */
+*/
 	if (strlen(filename) == 1 && filename[0] == '-') {
 		fp = stdout;
 	} else {
 		fp = fopen(filename, "wb");	  /* ensure Unix line endings */
 	}
 	if (!fp) {
 		fprintf(stderr, "Failed opening output file\n");
-		goto error;
+	goto error;
 	}
-	fputs(header, fp);
+fputs(header, fp);
 	base64_encode_fp(fp, outblob, outlen, 64);
-	fputs(footer, fp);
+fputs(footer, fp);
-	fclose(fp);
+fclose(fp);
-	ret = 1;
+ret = 1;
-	error:
+error:
-	if (outblob) {
+if (outblob) {
-		memset(outblob, 0, outlen);
+memset(outblob, 0, outlen);
 		m_free(outblob);
-	}
+}
 	if (keyblob) {
 		buf_burn(keyblob);
 		buf_free(keyblob);
-	}
+}
 	if (extrablob) {
 		buf_burn(extrablob);
 		buf_free(extrablob);
-	}
+}
-	return ret;
+return ret;
 }
 #if 0
 /* XXX TODO ssh.com stuff isn't going yet */
 * old ssh1 mpint. You have a 32-bit bit count N, followed by
 * (N+7)/8 bytes of data.
 *
 * So. The blob contains:
 *
-*  - uint32 0x3f6ff9eb	   (magic number)
+*  - uint32 0x3f6ff9eb       (magic number)
-*  - uint32 size			 (total blob size)
+*  - uint32 size             (total blob size)
-*  - string key-type		 (see below)
+*  - string key-type         (see below)
-*  - string cipher-type	  (tells you if key is encrypted)
+*  - string cipher-type      (tells you if key is encrypted)
 *  - string encrypted-blob
 *
 * (The first size field includes the size field itself and the
 * magic number before it. All other size fields are ordinary ssh2
 * strings, so the size field indicates how much data is to
 * from the passphrase by means of yet another hashing faff:
 *
 *  - first 16 bytes are MD5(passphrase)
 *  - next 16 bytes are MD5(passphrase || first 16 bytes)
 *  - if there were more, they'd be MD5(passphrase || first 32),
-*	and so on.
+*    and so on.
 */
 #define SSHCOM_MAGIC_NUMBER 0x3f6ff9eb
 struct sshcom_key {
-	char comment[256];				 /* allowing any length is overkill */
+char comment[256];                 /* allowing any length is overkill */
-	unsigned char *keyblob;
+unsigned char *keyblob;
-	int keyblob_len, keyblob_size;
+int keyblob_len, keyblob_size;
 };
 static struct sshcom_key *load_sshcom_key(const char *filename)
 {
-	struct sshcom_key *ret;
+struct sshcom_key *ret;
-	FILE *fp;
+FILE *fp;
-	char buffer[256];
+char buffer[256];
-	int len;
+int len;
-	char *errmsg, *p;
+char *errmsg, *p;
-	int headers_done;
+int headers_done;
-	char base64_bit[4];
+char base64_bit[4];
-	int base64_chars = 0;
+int base64_chars = 0;
-	ret = snew(struct sshcom_key);
+ret = snew(struct sshcom_key);
-	ret->comment[0] = '\0';
+ret->comment[0] = '\0';
-	ret->keyblob = NULL;
+ret->keyblob = NULL;
-	ret->keyblob_len = ret->keyblob_size = 0;
+ret->keyblob_len = ret->keyblob_size = 0;
 	fp = fopen(filename, "r");
-	if (!fp) {
+if (!fp) {
-		errmsg = "Unable to open key file";
+	errmsg = "Unable to open key file";
+	goto error;
+}
+if (!fgets(buffer, sizeof(buffer), fp) ||
+	0 != strcmp(buffer, "---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----\n")) {
+	errmsg = "File does not begin with ssh.com key header";
+	goto error;
+}
+headers_done = 0;
+while (1) {
+	if (!fgets(buffer, sizeof(buffer), fp)) {
+	    errmsg = "Unexpected end of file";
+	    goto error;
+	}
+if (!strcmp(buffer, "---- END SSH2 ENCRYPTED PRIVATE KEY ----\n"))
+break;                     /* done */
+	if ((p = strchr(buffer, ':')) != NULL) {
+	    if (headers_done) {
+		errmsg = "Header found in body of key data";
 		goto error;
-	}
+	    }
-	if (!fgets(buffer, sizeof(buffer), fp) ||
+	    *p++ = '\0';
-		0 != strcmp(buffer, "---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----\n")) {
+	    while (*p && isspace((unsigned char)*p)) p++;
-		errmsg = "File does not begin with ssh.com key header";
+/*
-		goto error;
+* Header lines can end in a trailing backslash for
-	}
+* continuation.
+*/
-	headers_done = 0;
+while ((len = strlen(p)) > (int)(sizeof(buffer) - (p-buffer) -1) ||
-	while (1) {
+p[len-1] != '\n' || p[len-2] == '\\') {
-		if (!fgets(buffer, sizeof(buffer), fp)) {
+if (len > (int)((p-buffer) + sizeof(buffer)-2)) {
-			errmsg = "Unexpected end of file";
+errmsg = "Header line too long to deal with";
-			goto error;
+goto error;
-		}
+}
-		if (!strcmp(buffer, "---- END SSH2 ENCRYPTED PRIVATE KEY ----\n"))
+if (!fgets(p+len-2, sizeof(buffer)-(p-buffer)-(len-2), fp)) {
-			break;					 /* done */
+errmsg = "Unexpected end of file";
-		if ((p = strchr(buffer, ':')) != NULL) {
+goto error;
-			if (headers_done) {
+}
-				errmsg = "Header found in body of key data";
+}
-				goto error;
+p[strcspn(p, "\n")] = '\0';
-			}
+if (!strcmp(buffer, "Comment")) {
-			*p++ = '\0';
+/* Strip quotes in comment if present. */
-			while (*p && isspace((unsigned char)*p)) p++;
+if (p[0] == '"' && p[strlen(p)-1] == '"') {
-			/*
+p++;
-			 * Header lines can end in a trailing backslash for
+p[strlen(p)-1] = '\0';
-			 * continuation.
+}
-			 */
+strncpy(ret->comment, p, sizeof(ret->comment));
-			while ((len = strlen(p)) > (int)(sizeof(buffer) - (p-buffer) -1) ||
+ret->comment[sizeof(ret->comment)-1] = '\0';
-				   p[len-1] != '\n' || p[len-2] == '\\') {
+}
-				if (len > (int)((p-buffer) + sizeof(buffer)-2)) {
+	} else {
-					errmsg = "Header line too long to deal with";
+	    headers_done = 1;
-					goto error;
-				}
+	    p = buffer;
-				if (!fgets(p+len-2, sizeof(buffer)-(p-buffer)-(len-2), fp)) {
+	    while (isbase64(*p)) {
-					errmsg = "Unexpected end of file";
+base64_bit[base64_chars++] = *p;
-					goto error;
+if (base64_chars == 4) {
-				}
+unsigned char out[3];
-			}
-			p[strcspn(p, "\n")] = '\0';
+base64_chars = 0;
-			if (!strcmp(buffer, "Comment")) {
-				/* Strip quotes in comment if present. */
+len = base64_decode_atom(base64_bit, out);
-				if (p[0] == '"' && p[strlen(p)-1] == '"') {
-					p++;
+if (len <= 0) {
-					p[strlen(p)-1] = '\0';
+errmsg = "Invalid base64 encoding";
-				}
+goto error;
-				strncpy(ret->comment, p, sizeof(ret->comment));
+}
-				ret->comment[sizeof(ret->comment)-1] = '\0';
-			}
+if (ret->keyblob_len + len > ret->keyblob_size) {
-		} else {
+ret->keyblob_size = ret->keyblob_len + len + 256;
-			headers_done = 1;
+ret->keyblob = sresize(ret->keyblob, ret->keyblob_size,
+					       unsigned char);
-			p = buffer;
+}
-			while (isbase64(*p)) {
-				base64_bit[base64_chars++] = *p;
+memcpy(ret->keyblob + ret->keyblob_len, out, len);
-				if (base64_chars == 4) {
+ret->keyblob_len += len;
-					unsigned char out[3];
+}
-					base64_chars = 0;
+		p++;
+	    }
-					len = base64_decode_atom(base64_bit, out);
+	}
+}
-					if (len <= 0) {
-						errmsg = "Invalid base64 encoding";
+if (ret->keyblob_len == 0 || !ret->keyblob) {
-						goto error;
+	errmsg = "Key body not present";
-					}
+	goto error;
+}
-					if (ret->keyblob_len + len > ret->keyblob_size) {
-						ret->keyblob_size = ret->keyblob_len + len + 256;
+return ret;
-						ret->keyblob = sresize(ret->keyblob, ret->keyblob_size,
-											   unsigned char);
+error:
-					}
+if (ret) {
+	if (ret->keyblob) {
-					memcpy(ret->keyblob + ret->keyblob_len, out, len);
+memset(ret->keyblob, 0, ret->keyblob_size);
-					ret->keyblob_len += len;
-				}
-				p++;
-			}
-		}
-	}
-	if (ret->keyblob_len == 0 || !ret->keyblob) {
-		errmsg = "Key body not present";
-		goto error;
-	}
-	return ret;
-	error:
-	if (ret) {
-		if (ret->keyblob) {
-			memset(ret->keyblob, 0, ret->keyblob_size);
 			m_free(ret->keyblob);
-		}
+}
-		memset(&ret, 0, sizeof(ret));
+memset(ret, 0, sizeof(*ret));
 		m_free(ret);
-	}
+}
-	return NULL;
+return NULL;
 }
 int sshcom_encrypted(const char *filename, char **comment)
 {
-	struct sshcom_key *key = load_sshcom_key(filename);
+struct sshcom_key *key = load_sshcom_key(filename);
-	int pos, len, answer;
+int pos, len, answer;
-	*comment = NULL;
+*comment = NULL;
-	if (!key)
+if (!key)
-		return 0;
+return 0;
-	/*
+/*
-	 * Check magic number.
+* Check magic number.
-	 */
+*/
-	if (GET_32BIT(key->keyblob) != 0x3f6ff9eb)
+if (GET_32BIT(key->keyblob) != 0x3f6ff9eb)
-		return 0;					  /* key is invalid */
+return 0;                      /* key is invalid */
-	/*
+/*
-	 * Find the cipher-type string.
+* Find the cipher-type string.
-	 */
+*/
-	answer = 0;
+answer = 0;
-	pos = 8;
+pos = 8;
-	if (key->keyblob_len < pos+4)
+if (key->keyblob_len < pos+4)
-		goto done;					 /* key is far too short */
+goto done;                     /* key is far too short */
-	pos += 4 + GET_32BIT(key->keyblob + pos);   /* skip key type */
+len = toint(GET_32BIT(key->keyblob + pos));
-	if (key->keyblob_len < pos+4)
+if (len < 0 || len > key->keyblob_len - pos - 4)
-		goto done;					 /* key is far too short */
+goto done;                     /* key is far too short */
-	len = GET_32BIT(key->keyblob + pos);   /* find cipher-type length */
+pos += 4 + len;                    /* skip key type */
-	if (key->keyblob_len < pos+4+len)
+len = toint(GET_32BIT(key->keyblob + pos)); /* find cipher-type length */
-		goto done;					 /* cipher type string is incomplete */
+if (len < 0 || len > key->keyblob_len - pos - 4)
-	if (len != 4 || 0 != memcmp(key->keyblob + pos + 4, "none", 4))
+goto done;                     /* cipher type string is incomplete */
-		answer = 1;
+if (len != 4 || 0 != memcmp(key->keyblob + pos + 4, "none", 4))
+answer = 1;
-	done:
-	*comment = dupstr(key->comment);
+done:
-	memset(key->keyblob, 0, key->keyblob_size);
+*comment = dupstr(key->comment);
+memset(key->keyblob, 0, key->keyblob_size);
 	m_free(key->keyblob);
-	memset(&key, 0, sizeof(key));
+memset(key, 0, sizeof(*key));
 	m_free(key);
-	return answer;
+return answer;
 }
 static int sshcom_read_mpint(void *data, int len, struct mpint_pos *ret)
 {
-	int bits;
+unsigned bits, bytes;
-	int bytes;
+unsigned char *d = (unsigned char *) data;
-	unsigned char *d = (unsigned char *) data;
+if (len < 4)
-	if (len < 4)
+goto error;
-		goto error;
+bits = GET_32BIT(d);
-	bits = GET_32BIT(d);
+bytes = (bits + 7) / 8;
-	bytes = (bits + 7) / 8;
+if (len < 4+bytes)
-	if (len < 4+bytes)
+goto error;
-		goto error;
+ret->start = d + 4;
-	ret->start = d + 4;
+ret->bytes = bytes;
-	ret->bytes = bytes;
+return bytes+4;
-	return bytes+4;
+error:
-	error:
+ret->start = NULL;
-	ret->start = NULL;
+ret->bytes = -1;
-	ret->bytes = -1;
+return len;                        /* ensure further calls fail as well */
-	return len;						/* ensure further calls fail as well */
 }
 static int sshcom_put_mpint(void *target, void *data, int len)
 {
-	unsigned char *d = (unsigned char *)target;
+unsigned char *d = (unsigned char *)target;
-	unsigned char *i = (unsigned char *)data;
+unsigned char *i = (unsigned char *)data;
-	int bits = len * 8 - 1;
+int bits = len * 8 - 1;
-	while (bits > 0) {
+while (bits > 0) {
-		if (*i & (1 << (bits & 7)))
+	if (*i & (1 << (bits & 7)))
-			break;
+	    break;
-		if (!(bits-- & 7))
+	if (!(bits-- & 7))
-			i++, len--;
+	    i++, len--;
-	}
+}
-	PUT_32BIT(d, bits+1);
+PUT_32BIT(d, bits+1);
-	memcpy(d+4, i, len);
+memcpy(d+4, i, len);
-	return len+4;
+return len+4;
 }
 sign_key *sshcom_read(const char *filename, char *passphrase)
 {
-	struct sshcom_key *key = load_sshcom_key(filename);
+struct sshcom_key *key = load_sshcom_key(filename);
-	char *errmsg;
+char *errmsg;
-	int pos, len;
+int pos, len;
-	const char prefix_rsa[] = "if-modn{sign{rsa";
+const char prefix_rsa[] = "if-modn{sign{rsa";
-	const char prefix_dsa[] = "dl-modp{sign{dsa";
+const char prefix_dsa[] = "dl-modp{sign{dsa";
-	enum { RSA, DSA } type;
+enum { RSA, DSA } type;
-	int encrypted;
+int encrypted;
-	char *ciphertext;
+char *ciphertext;
-	int cipherlen;
+int cipherlen;
-	struct ssh2_userkey *ret = NULL, *retkey;
+struct ssh2_userkey *ret = NULL, *retkey;
-	const struct ssh_signkey *alg;
+const struct ssh_signkey *alg;
-	unsigned char *blob = NULL;
+unsigned char *blob = NULL;
-	int blobsize, publen, privlen;
+int blobsize = 0, publen, privlen;
-	if (!key)
+if (!key)
-		return NULL;
+return NULL;
+/*
+* Check magic number.
+*/
+if (GET_32BIT(key->keyblob) != SSHCOM_MAGIC_NUMBER) {
+errmsg = "Key does not begin with magic number";
+goto error;
+}
+/*
+* Determine the key type.
+*/
+pos = 8;
+if (key->keyblob_len < pos+4 ||
+(len = GET_32BIT(key->keyblob + pos)) > key->keyblob_len - pos - 4) {
+errmsg = "Key blob does not contain a key type string";
+goto error;
+}
+if (len > sizeof(prefix_rsa) - 1 &&
+!memcmp(key->keyblob+pos+4, prefix_rsa, sizeof(prefix_rsa) - 1)) {
+type = RSA;
+} else if (len > sizeof(prefix_dsa) - 1 &&
+!memcmp(key->keyblob+pos+4, prefix_dsa, sizeof(prefix_dsa) - 1)) {
+type = DSA;
+} else {
+errmsg = "Key is of unknown type";
+goto error;
+}
+pos += 4+len;
+/*
+* Determine the cipher type.
+*/
+if (key->keyblob_len < pos+4 ||
+(len = GET_32BIT(key->keyblob + pos)) > key->keyblob_len - pos - 4) {
+errmsg = "Key blob does not contain a cipher type string";
+goto error;
+}
+if (len == 4 && !memcmp(key->keyblob+pos+4, "none", 4))
+encrypted = 0;
+else if (len == 8 && !memcmp(key->keyblob+pos+4, "3des-cbc", 8))
+encrypted = 1;
+else {
+errmsg = "Key encryption is of unknown type";
+goto error;
+}
+pos += 4+len;
+/*
+* Get hold of the encrypted part of the key.
+*/
+if (key->keyblob_len < pos+4 ||
+(len = GET_32BIT(key->keyblob + pos)) > key->keyblob_len - pos - 4) {
+errmsg = "Key blob does not contain actual key data";
+goto error;
+}
+ciphertext = (char *)key->keyblob + pos + 4;
+cipherlen = len;
+if (cipherlen == 0) {
+errmsg = "Length of key data is zero";
+goto error;
+}
+/*
+* Decrypt it if necessary.
+*/
+if (encrypted) {
 	/*
-	 * Check magic number.
+	 * Derive encryption key from passphrase and iv/salt:
+	 *
+	 *  - let block A equal MD5(passphrase)
+	 *  - let block B equal MD5(passphrase || A)
+	 *  - block C would be MD5(passphrase || A || B) and so on
+	 *  - encryption key is the first N bytes of A || B
 	 */
-	if (GET_32BIT(key->keyblob) != SSHCOM_MAGIC_NUMBER) {
+	struct MD5Context md5c;
-		errmsg = "Key does not begin with magic number";
+	unsigned char keybuf[32], iv[8];
-		goto error;
-	}
+if (cipherlen % 8 != 0) {
+errmsg = "Encrypted part of key is not a multiple of cipher block"
+" size";
+goto error;
+}
+	MD5Init(&md5c);
+	MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
+	MD5Final(keybuf, &md5c);
+	MD5Init(&md5c);
+	MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
+	MD5Update(&md5c, keybuf, 16);
+	MD5Final(keybuf+16, &md5c);
 	/*
-	 * Determine the key type.
+	 * Now decrypt the key blob.
 	 */
-	pos = 8;
+memset(iv, 0, sizeof(iv));
-	if (key->keyblob_len < pos+4 ||
+	des3_decrypt_pubkey_ossh(keybuf, iv, (unsigned char *)ciphertext,
-		(len = GET_32BIT(key->keyblob + pos)) > key->keyblob_len - pos - 4) {
+				 cipherlen);
-		errmsg = "Key blob does not contain a key type string";
-		goto error;
+memset(&md5c, 0, sizeof(md5c));
-	}
+memset(keybuf, 0, sizeof(keybuf));
-	if (len > sizeof(prefix_rsa) - 1 &&
-		!memcmp(key->keyblob+pos+4, prefix_rsa, sizeof(prefix_rsa) - 1)) {
+/*
-		type = RSA;
+* Hereafter we return WRONG_PASSPHRASE for any parsing
-	} else if (len > sizeof(prefix_dsa) - 1 &&
+* error. (But only if we've just tried to decrypt it!
-		!memcmp(key->keyblob+pos+4, prefix_dsa, sizeof(prefix_dsa) - 1)) {
+* Returning WRONG_PASSPHRASE for an unencrypted key is
-		type = DSA;
+* automatic doom.)
-	} else {
+*/
-		errmsg = "Key is of unknown type";
+if (encrypted)
-		goto error;
+ret = SSH2_WRONG_PASSPHRASE;
-	}
+}
-	pos += 4+len;
+/*
+* Strip away the containing string to get to the real meat.
+*/
+len = toint(GET_32BIT(ciphertext));
+if (len < 0 || len > cipherlen-4) {
+errmsg = "containing string was ill-formed";
+goto error;
+}
+ciphertext += 4;
+cipherlen = len;
+/*
+* Now we break down into RSA versus DSA. In either case we'll
+* construct public and private blobs in our own format, and
+* end up feeding them to alg->createkey().
+*/
+blobsize = cipherlen + 256;
+blob = snewn(blobsize, unsigned char);
+privlen = 0;
+if (type == RSA) {
+struct mpint_pos n, e, d, u, p, q;
+int pos = 0;
+pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &e);
+pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &d);
+pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &n);
+pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &u);
+pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &p);
+pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &q);
+if (!q.start) {
+errmsg = "key data did not contain six integers";
+goto error;
+}
+alg = &ssh_rsa;
+pos = 0;
+pos += put_string(blob+pos, "ssh-rsa", 7);
+pos += put_mp(blob+pos, e.start, e.bytes);
+pos += put_mp(blob+pos, n.start, n.bytes);
+publen = pos;
+pos += put_string(blob+pos, d.start, d.bytes);
+pos += put_mp(blob+pos, q.start, q.bytes);
+pos += put_mp(blob+pos, p.start, p.bytes);
+pos += put_mp(blob+pos, u.start, u.bytes);
+privlen = pos - publen;
+} else if (type == DSA) {
+struct mpint_pos p, q, g, x, y;
+int pos = 4;
+if (GET_32BIT(ciphertext) != 0) {
+errmsg = "predefined DSA parameters not supported";
+goto error;
+}
+pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &p);
+pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &g);
+pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &q);
+pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &y);
+pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &x);
+if (!x.start) {
+errmsg = "key data did not contain five integers";
+goto error;
+}
+alg = &ssh_dss;
+pos = 0;
+pos += put_string(blob+pos, "ssh-dss", 7);
+pos += put_mp(blob+pos, p.start, p.bytes);
+pos += put_mp(blob+pos, q.start, q.bytes);
+pos += put_mp(blob+pos, g.start, g.bytes);
+pos += put_mp(blob+pos, y.start, y.bytes);
+publen = pos;
+pos += put_mp(blob+pos, x.start, x.bytes);
+privlen = pos - publen;
+} else
+	return NULL;
+	dropbear_assert(privlen > 0);			   /* should have bombed by now if not */
+retkey = snew(struct ssh2_userkey);
+retkey->alg = alg;
+retkey->data = alg->createkey(blob, publen, blob+publen, privlen);
+if (!retkey->data) {
+		m_free(retkey);
+	errmsg = "unable to create key data structure";
+	goto error;
+}
+retkey->comment = dupstr(key->comment);
+errmsg = NULL; /* no error */
+ret = retkey;
+error:
+if (blob) {
+memset(blob, 0, blobsize);
+		m_free(blob);
+}
+memset(key->keyblob, 0, key->keyblob_size);
+	m_free(key->keyblob);
+memset(key, 0, sizeof(*key));
+	m_free(key);
+return ret;
+}
+int sshcom_write(const char *filename, sign_key *key,
+		 char *passphrase)
+{
+unsigned char *pubblob, *privblob;
+int publen, privlen;
+unsigned char *outblob;
+int outlen;
+struct mpint_pos numbers[6];
+int nnumbers, initial_zero, pos, lenpos, i;
+char *type;
+char *ciphertext;
+int cipherlen;
+int ret = 0;
+FILE *fp;
+/*
+* Fetch the key blobs.
+*/
+pubblob = key->alg->public_blob(key->data, &publen);
+privblob = key->alg->private_blob(key->data, &privlen);
+outblob = NULL;
+/*
+* Find the sequence of integers to be encoded into the OpenSSH
+* key blob, and also decide on the header line.
+*/
+if (key->alg == &ssh_rsa) {
+int pos;
+struct mpint_pos n, e, d, p, q, iqmp;
+pos = 4 + GET_32BIT(pubblob);
+pos += ssh2_read_mpint(pubblob+pos, publen-pos, &e);
+pos += ssh2_read_mpint(pubblob+pos, publen-pos, &n);
+pos = 0;
+pos += ssh2_read_mpint(privblob+pos, privlen-pos, &d);
+pos += ssh2_read_mpint(privblob+pos, privlen-pos, &p);
+pos += ssh2_read_mpint(privblob+pos, privlen-pos, &q);
+pos += ssh2_read_mpint(privblob+pos, privlen-pos, &iqmp);
+		dropbear_assert(e.start && iqmp.start); /* can't go wrong */
+numbers[0] = e;
+numbers[1] = d;
+numbers[2] = n;
+numbers[3] = iqmp;
+numbers[4] = q;
+numbers[5] = p;
+nnumbers = 6;
+	initial_zero = 0;
+	type = "if-modn{sign{rsa-pkcs1-sha1},encrypt{rsa-pkcs1v2-oaep}}";
+} else if (key->alg == &ssh_dss) {
+int pos;
+struct mpint_pos p, q, g, y, x;
+pos = 4 + GET_32BIT(pubblob);
+pos += ssh2_read_mpint(pubblob+pos, publen-pos, &p);
+pos += ssh2_read_mpint(pubblob+pos, publen-pos, &q);
+pos += ssh2_read_mpint(pubblob+pos, publen-pos, &g);
+pos += ssh2_read_mpint(pubblob+pos, publen-pos, &y);
+pos = 0;
+pos += ssh2_read_mpint(privblob+pos, privlen-pos, &x);
+		dropbear_assert(y.start && x.start); /* can't go wrong */
+numbers[0] = p;
+numbers[1] = g;
+numbers[2] = q;
+numbers[3] = y;
+numbers[4] = x;
+nnumbers = 5;
+	initial_zero = 1;
+	type = "dl-modp{sign{dsa-nist-sha1},dh{plain}}";
+} else {
+		dropbear_assert(0);					 /* zoinks! */
+}
+/*
+* Total size of key blob will be somewhere under 512 plus
+* combined length of integers. We'll calculate the more
+* precise size as we construct the blob.
+*/
+outlen = 512;
+for (i = 0; i < nnumbers; i++)
+	outlen += 4 + numbers[i].bytes;
+outblob = snewn(outlen, unsigned char);
+/*
+* Create the unencrypted key blob.
+*/
+pos = 0;
+PUT_32BIT(outblob+pos, SSHCOM_MAGIC_NUMBER); pos += 4;
+pos += 4;			       /* length field, fill in later */
+pos += put_string(outblob+pos, type, strlen(type));
+{
+	char *ciphertype = passphrase ? "3des-cbc" : "none";
+	pos += put_string(outblob+pos, ciphertype, strlen(ciphertype));
+}
+lenpos = pos;		       /* remember this position */
+pos += 4;			       /* encrypted-blob size */
+pos += 4;			       /* encrypted-payload size */
+if (initial_zero) {
+	PUT_32BIT(outblob+pos, 0);
+	pos += 4;
+}
+for (i = 0; i < nnumbers; i++)
+	pos += sshcom_put_mpint(outblob+pos,
+				numbers[i].start, numbers[i].bytes);
+/* Now wrap up the encrypted payload. */
+PUT_32BIT(outblob+lenpos+4, pos - (lenpos+8));
+/* Pad encrypted blob to a multiple of cipher block size. */
+if (passphrase) {
+	int padding = -(pos - (lenpos+4)) & 7;
+	while (padding--)
+	    outblob[pos++] = random_byte();
+}
+ciphertext = (char *)outblob+lenpos+4;
+cipherlen = pos - (lenpos+4);
+	dropbear_assert(!passphrase || cipherlen % 8 == 0);
+/* Wrap up the encrypted blob string. */
+PUT_32BIT(outblob+lenpos, cipherlen);
+/* And finally fill in the total length field. */
+PUT_32BIT(outblob+4, pos);
+	dropbear_assert(pos < outlen);
+/*
+* Encrypt the key.
+*/
+if (passphrase) {
 	/*
-	 * Determine the cipher type.
+	 * Derive encryption key from passphrase and iv/salt:
+	 *
+	 *  - let block A equal MD5(passphrase)
+	 *  - let block B equal MD5(passphrase || A)
+	 *  - block C would be MD5(passphrase || A || B) and so on
+	 *  - encryption key is the first N bytes of A || B
 	 */
-	if (key->keyblob_len < pos+4 ||
+	struct MD5Context md5c;
-		(len = GET_32BIT(key->keyblob + pos)) > key->keyblob_len - pos - 4) {
+	unsigned char keybuf[32], iv[8];
-		errmsg = "Key blob does not contain a cipher type string";
-		goto error;
+	MD5Init(&md5c);
-	}
+	MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
-	if (len == 4 && !memcmp(key->keyblob+pos+4, "none", 4))
+	MD5Final(keybuf, &md5c);
-		encrypted = 0;
-	else if (len == 8 && !memcmp(key->keyblob+pos+4, "3des-cbc", 8))
+	MD5Init(&md5c);
-		encrypted = 1;
+	MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
-	else {
+	MD5Update(&md5c, keybuf, 16);
-		errmsg = "Key encryption is of unknown type";
+	MD5Final(keybuf+16, &md5c);
-		goto error;
-	}
-	pos += 4+len;
 	/*
-	 * Get hold of the encrypted part of the key.
+	 * Now decrypt the key blob.
 	 */
-	if (key->keyblob_len < pos+4 ||
+memset(iv, 0, sizeof(iv));
-		(len = GET_32BIT(key->keyblob + pos)) > key->keyblob_len - pos - 4) {
+	des3_encrypt_pubkey_ossh(keybuf, iv, (unsigned char *)ciphertext,
-		errmsg = "Key blob does not contain actual key data";
+				 cipherlen);
-		goto error;
-	}
+memset(&md5c, 0, sizeof(md5c));
-	ciphertext = (char *)key->keyblob + pos + 4;
+memset(keybuf, 0, sizeof(keybuf));
-	cipherlen = len;
+}
-	if (cipherlen == 0) {
-		errmsg = "Length of key data is zero";
+/*
-		goto error;
+* And save it. We'll use Unix line endings just in case it's
-	}
+* subsequently transferred in binary mode.
+*/
-	/*
-	 * Decrypt it if necessary.
-	 */
-	if (encrypted) {
-		/*
-		 * Derive encryption key from passphrase and iv/salt:
-		 *
-		 *  - let block A equal MD5(passphrase)
-		 *  - let block B equal MD5(passphrase || A)
-		 *  - block C would be MD5(passphrase || A || B) and so on
-		 *  - encryption key is the first N bytes of A || B
-		 */
-		struct MD5Context md5c;
-		unsigned char keybuf[32], iv[8];
-		if (cipherlen % 8 != 0) {
-			errmsg = "Encrypted part of key is not a multiple of cipher block"
-				" size";
-			goto error;
-		}
-		MD5Init(&md5c);
-		MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
-		MD5Final(keybuf, &md5c);
-		MD5Init(&md5c);
-		MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
-		MD5Update(&md5c, keybuf, 16);
-		MD5Final(keybuf+16, &md5c);
-		/*
-		 * Now decrypt the key blob.
-		 */
-		memset(iv, 0, sizeof(iv));
-		des3_decrypt_pubkey_ossh(keybuf, iv, (unsigned char *)ciphertext,
-								 cipherlen);
-		memset(&md5c, 0, sizeof(md5c));
-		memset(keybuf, 0, sizeof(keybuf));
-		/*
-		 * Hereafter we return WRONG_PASSPHRASE for any parsing
-		 * error. (But only if we've just tried to decrypt it!
-		 * Returning WRONG_PASSPHRASE for an unencrypted key is
-		 * automatic doom.)
-		 */
-		if (encrypted)
-			ret = SSH2_WRONG_PASSPHRASE;
-	}
-	/*
-	 * Strip away the containing string to get to the real meat.
-	 */
-	len = GET_32BIT(ciphertext);
-	if (len > cipherlen-4) {
-		errmsg = "containing string was ill-formed";
-		goto error;
-	}
-	ciphertext += 4;
-	cipherlen = len;
-	/*
-	 * Now we break down into RSA versus DSA. In either case we'll
-	 * construct public and private blobs in our own format, and
-	 * end up feeding them to alg->createkey().
-	 */
-	blobsize = cipherlen + 256;
-	blob = snewn(blobsize, unsigned char);
-	privlen = 0;
-	if (type == RSA) {
-		struct mpint_pos n, e, d, u, p, q;
-		int pos = 0;
-		pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &e);
-		pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &d);
-		pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &n);
-		pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &u);
-		pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &p);
-		pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &q);
-		if (!q.start) {
-			errmsg = "key data did not contain six integers";
-			goto error;
-		}
-		alg = &ssh_rsa;
-		pos = 0;
-		pos += put_string(blob+pos, "ssh-rsa", 7);
-		pos += put_mp(blob+pos, e.start, e.bytes);
-		pos += put_mp(blob+pos, n.start, n.bytes);
-		publen = pos;
-		pos += put_string(blob+pos, d.start, d.bytes);
-		pos += put_mp(blob+pos, q.start, q.bytes);
-		pos += put_mp(blob+pos, p.start, p.bytes);
-		pos += put_mp(blob+pos, u.start, u.bytes);
-		privlen = pos - publen;
-	} else if (type == DSA) {
-		struct mpint_pos p, q, g, x, y;
-		int pos = 4;
-		if (GET_32BIT(ciphertext) != 0) {
-			errmsg = "predefined DSA parameters not supported";
-			goto error;
-		}
-		pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &p);
-		pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &g);
-		pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &q);
-		pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &y);
-		pos += sshcom_read_mpint(ciphertext+pos, cipherlen-pos, &x);
-		if (!x.start) {
-			errmsg = "key data did not contain five integers";
-			goto error;
-		}
-		alg = &ssh_dss;
-		pos = 0;
-		pos += put_string(blob+pos, "ssh-dss", 7);
-		pos += put_mp(blob+pos, p.start, p.bytes);
-		pos += put_mp(blob+pos, q.start, q.bytes);
-		pos += put_mp(blob+pos, g.start, g.bytes);
-		pos += put_mp(blob+pos, y.start, y.bytes);
-		publen = pos;
-		pos += put_mp(blob+pos, x.start, x.bytes);
-		privlen = pos - publen;
-	}
-	dropbear_assert(privlen > 0);			   /* should have bombed by now if not */
-	retkey = snew(struct ssh2_userkey);
-	retkey->alg = alg;
-	retkey->data = alg->createkey(blob, publen, blob+publen, privlen);
-	if (!retkey->data) {
-		m_free(retkey);
-		errmsg = "unable to create key data structure";
-		goto error;
-	}
-	retkey->comment = dupstr(key->comment);
-	errmsg = NULL; /* no error */
-	ret = retkey;
-	error:
-	if (blob) {
-		memset(blob, 0, blobsize);
-		m_free(blob);
-	}
-	memset(key->keyblob, 0, key->keyblob_size);
-	m_free(key->keyblob);
-	memset(&key, 0, sizeof(key));
-	m_free(key);
-	return ret;
-}
-int sshcom_write(const char *filename, sign_key *key,
-				 char *passphrase)
-{
-	unsigned char *pubblob, *privblob;
-	int publen, privlen;
-	unsigned char *outblob;
-	int outlen;
-	struct mpint_pos numbers[6];
-	int nnumbers, initial_zero, pos, lenpos, i;
-	char *type;
-	char *ciphertext;
-	int cipherlen;
-	int ret = 0;
-	FILE *fp;
-	/*
-	 * Fetch the key blobs.
-	 */
-	pubblob = key->alg->public_blob(key->data, &publen);
-	privblob = key->alg->private_blob(key->data, &privlen);
-	outblob = NULL;
-	/*
-	 * Find the sequence of integers to be encoded into the OpenSSH
-	 * key blob, and also decide on the header line.
-	 */
-	if (key->alg == &ssh_rsa) {
-		int pos;
-		struct mpint_pos n, e, d, p, q, iqmp;
-		pos = 4 + GET_32BIT(pubblob);
-		pos += ssh2_read_mpint(pubblob+pos, publen-pos, &e);
-		pos += ssh2_read_mpint(pubblob+pos, publen-pos, &n);
-		pos = 0;
-		pos += ssh2_read_mpint(privblob+pos, privlen-pos, &d);
-		pos += ssh2_read_mpint(privblob+pos, privlen-pos, &p);
-		pos += ssh2_read_mpint(privblob+pos, privlen-pos, &q);
-		pos += ssh2_read_mpint(privblob+pos, privlen-pos, &iqmp);
-		dropbear_assert(e.start && iqmp.start); /* can't go wrong */
-		numbers[0] = e;
-		numbers[1] = d;
-		numbers[2] = n;
-		numbers[3] = iqmp;
-		numbers[4] = q;
-		numbers[5] = p;
-		nnumbers = 6;
-		initial_zero = 0;
-		type = "if-modn{sign{rsa-pkcs1-sha1},encrypt{rsa-pkcs1v2-oaep}}";
-	} else if (key->alg == &ssh_dss) {
-		int pos;
-		struct mpint_pos p, q, g, y, x;
-		pos = 4 + GET_32BIT(pubblob);
-		pos += ssh2_read_mpint(pubblob+pos, publen-pos, &p);
-		pos += ssh2_read_mpint(pubblob+pos, publen-pos, &q);
-		pos += ssh2_read_mpint(pubblob+pos, publen-pos, &g);
-		pos += ssh2_read_mpint(pubblob+pos, publen-pos, &y);
-		pos = 0;
-		pos += ssh2_read_mpint(privblob+pos, privlen-pos, &x);
-		dropbear_assert(y.start && x.start); /* can't go wrong */
-		numbers[0] = p;
-		numbers[1] = g;
-		numbers[2] = q;
-		numbers[3] = y;
-		numbers[4] = x;
-		nnumbers = 5;
-		initial_zero = 1;
-		type = "dl-modp{sign{dsa-nist-sha1},dh{plain}}";
-	} else {
-		dropbear_assert(0);					 /* zoinks! */
-	}
-	/*
-	 * Total size of key blob will be somewhere under 512 plus
-	 * combined length of integers. We'll calculate the more
-	 * precise size as we construct the blob.
-	 */
-	outlen = 512;
-	for (i = 0; i < nnumbers; i++)
-		outlen += 4 + numbers[i].bytes;
-	outblob = snewn(outlen, unsigned char);
-	/*
-	 * Create the unencrypted key blob.
-	 */
-	pos = 0;
-	PUT_32BIT(outblob+pos, SSHCOM_MAGIC_NUMBER); pos += 4;
-	pos += 4;							   /* length field, fill in later */
-	pos += put_string(outblob+pos, type, strlen(type));
-	{
-		char *ciphertype = passphrase ? "3des-cbc" : "none";
-		pos += put_string(outblob+pos, ciphertype, strlen(ciphertype));
-	}
-	lenpos = pos;					   /* remember this position */
-	pos += 4;							   /* encrypted-blob size */
-	pos += 4;							   /* encrypted-payload size */
-	if (initial_zero) {
-		PUT_32BIT(outblob+pos, 0);
-		pos += 4;
-	}
-	for (i = 0; i < nnumbers; i++)
-		pos += sshcom_put_mpint(outblob+pos,
-								numbers[i].start, numbers[i].bytes);
-	/* Now wrap up the encrypted payload. */
-	PUT_32BIT(outblob+lenpos+4, pos - (lenpos+8));
-	/* Pad encrypted blob to a multiple of cipher block size. */
-	if (passphrase) {
-		int padding = -(pos - (lenpos+4)) & 7;
-		while (padding--)
-			outblob[pos++] = random_byte();
-	}
-	ciphertext = (char *)outblob+lenpos+4;
-	cipherlen = pos - (lenpos+4);
-	dropbear_assert(!passphrase || cipherlen % 8 == 0);
-	/* Wrap up the encrypted blob string. */
-	PUT_32BIT(outblob+lenpos, cipherlen);
-	/* And finally fill in the total length field. */
-	PUT_32BIT(outblob+4, pos);
-	dropbear_assert(pos < outlen);
-	/*
-	 * Encrypt the key.
-	 */
-	if (passphrase) {
-		/*
-		 * Derive encryption key from passphrase and iv/salt:
-		 *
-		 *  - let block A equal MD5(passphrase)
-		 *  - let block B equal MD5(passphrase || A)
-		 *  - block C would be MD5(passphrase || A || B) and so on
-		 *  - encryption key is the first N bytes of A || B
-		 */
-		struct MD5Context md5c;
-		unsigned char keybuf[32], iv[8];
-		MD5Init(&md5c);
-		MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
-		MD5Final(keybuf, &md5c);
-		MD5Init(&md5c);
-		MD5Update(&md5c, (unsigned char *)passphrase, strlen(passphrase));
-		MD5Update(&md5c, keybuf, 16);
-		MD5Final(keybuf+16, &md5c);
-		/*
-		 * Now decrypt the key blob.
-		 */
-		memset(iv, 0, sizeof(iv));
-		des3_encrypt_pubkey_ossh(keybuf, iv, (unsigned char *)ciphertext,
-								 cipherlen);
-		memset(&md5c, 0, sizeof(md5c));
-		memset(keybuf, 0, sizeof(keybuf));
-	}
-	/*
-	 * And save it. We'll use Unix line endings just in case it's
-	 * subsequently transferred in binary mode.
-	 */
 	fp = fopen(filename, "wb");	  /* ensure Unix line endings */
-	if (!fp)
+if (!fp)
-		goto error;
+	goto error;
-	fputs("---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----\n", fp);
+fputs("---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----\n", fp);
-	fprintf(fp, "Comment: \"");
+fprintf(fp, "Comment: \"");
-	/*
+/*
-	 * Comment header is broken with backslash-newline if it goes
+* Comment header is broken with backslash-newline if it goes
-	 * over 70 chars. Although it's surrounded by quotes, it
+* over 70 chars. Although it's surrounded by quotes, it
-	 * _doesn't_ escape backslashes or quotes within the string.
+* _doesn't_ escape backslashes or quotes within the string.
-	 * Don't ask me, I didn't design it.
+* Don't ask me, I didn't design it.
-	 */
+*/
-	{
+{
-		int slen = 60;					   /* starts at 60 due to "Comment: " */
+	int slen = 60;		       /* starts at 60 due to "Comment: " */
-		char *c = key->comment;
+	char *c = key->comment;
-		while ((int)strlen(c) > slen) {
+	while ((int)strlen(c) > slen) {
-			fprintf(fp, "%.*s\\\n", slen, c);
+	    fprintf(fp, "%.*s\\\n", slen, c);
-			c += slen;
+	    c += slen;
-			slen = 70;					   /* allow 70 chars on subsequent lines */
+	    slen = 70;		       /* allow 70 chars on subsequent lines */
-		}
+	}
-		fprintf(fp, "%s\"\n", c);
+	fprintf(fp, "%s\"\n", c);
-	}
+}
 	base64_encode_fp(fp, outblob, pos, 70);
-	fputs("---- END SSH2 ENCRYPTED PRIVATE KEY ----\n", fp);
+fputs("---- END SSH2 ENCRYPTED PRIVATE KEY ----\n", fp);
-	fclose(fp);
+fclose(fp);
-	ret = 1;
+ret = 1;
-	error:
+error:
-	if (outblob) {
+if (outblob) {
-		memset(outblob, 0, outlen);
+memset(outblob, 0, outlen);
 		m_free(outblob);
-	}
+}
-	if (privblob) {
+if (privblob) {
-		memset(privblob, 0, privlen);
+memset(privblob, 0, privlen);
 		m_free(privblob);
-	}
+}
-	if (pubblob) {
+if (pubblob) {
-		memset(pubblob, 0, publen);
+memset(pubblob, 0, publen);
 		m_free(pubblob);
-	}
+}
-	return ret;
+return ret;
 }
 #endif /* ssh.com stuff disabled */
+/* From PuTTY misc.c */
+static int toint(unsigned u)
+{
+/*
+* Convert an unsigned to an int, without running into the
+* undefined behaviour which happens by the strict C standard if
+* the value overflows. You'd hope that sensible compilers would
+* do the sensible thing in response to a cast, but actually I
+* don't trust modern compilers not to do silly things like
+* assuming that _obviously_ you wouldn't have caused an overflow
+* and so they can elide an 'if (i < 0)' test immediately after
+* the cast.
+*
+* Sensible compilers ought of course to optimise this entire
+* function into 'just return the input value'!
+*/
+if (u <= (unsigned)INT_MAX)
+return (int)u;
+else if (u >= (unsigned)INT_MIN)   /* wrap in cast _to_ unsigned is OK */
+return INT_MIN + (int)(u - (unsigned)INT_MIN);
+else
+return INT_MIN; /* fallback; should never occur on binary machines */
+}

Mercurial > dropbear

comparison keyimport.c @ 1306:34e6127ef02e