Following the recent advisory about attacks on PGP keys based on

[u/mdw/putty] / sshrsa.c

diff --git a/sshrsa.c b/sshrsa.c
index c933862..1938623 100644 (file)
--- a/sshrsa.c
+++ b/sshrsa.c
@@ -9,8 +9,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
-#include <windows.h> // FIXME
-#include "putty.h" // FIXME
 
 #include "ssh.h"
 
@@ -153,6 +151,37 @@ void rsa_fingerprint(char *str, int len, struct RSAKey *key) {
     }
 }
 
+/*
+ * Verify that the public data in an RSA key matches the private
+ * data.
+ */
+int rsa_verify(struct RSAKey *key) {
+    Bignum n, ed, pm1, qm1, pm1qm1;
+    int cmp;
+
+    /* n must equal pq. */
+    n = bigmul(key->p, key->q);
+    cmp = bignum_cmp(n, key->modulus);
+    freebn(n);
+    if (cmp != 0)
+       return 0;
+
+    /* e * d must be congruent to 1, modulo (p-1)(q-1). */
+    pm1 = copybn(key->p);
+    decbn(pm1);
+    qm1 = copybn(key->q);
+    decbn(qm1);
+    pm1qm1 = bigmul(pm1, qm1);
+    freebn(pm1);
+    freebn(qm1);
+    ed = modmul(key->exponent, key->private_exponent, pm1qm1);
+    sfree(pm1qm1);
+    cmp = bignum_cmp(ed, One);
+    sfree(ed);
+    if (cmp != 0)
+       return 0;
+}
+
 void freersakey(struct RSAKey *key) {
     if (key->modulus) freebn(key->modulus);
     if (key->exponent) freebn(key->exponent);
@@ -208,7 +237,7 @@ static void *rsa2_newkey(char *data, int len) {
     if (!rsa) return NULL;
     getstring(&data, &len, &p, &slen);
 
-    if (!p || memcmp(p, "ssh-rsa", 7)) {
+    if (!p || slen != 7 || memcmp(p, "ssh-rsa", 7)) {
        sfree(rsa);
        return NULL;
     }
@@ -233,7 +262,7 @@ static char *rsa2_fmtkey(void *key) {
     
     len = rsastr_len(rsa);
     p = smalloc(len);
-    rsastr_fmt(p, rsa);
+     rsastr_fmt(p, rsa);
     return p;
 }
 
@@ -306,6 +335,41 @@ static void *rsa2_createkey(unsigned char *pub_blob, int pub_len,
     rsa->q = getmp(&pb, &priv_len);
     rsa->iqmp = getmp(&pb, &priv_len);
 
+    if (!rsa_verify(rsa)) {
+       rsa2_freekey(rsa);
+       return NULL;
+    }
+
+    return rsa;
+}
+
+static void *rsa2_openssh_createkey(unsigned char **blob, int *len) {
+    char **b = (char **)blob;
+    struct RSAKey *rsa;
+
+    rsa = smalloc(sizeof(struct RSAKey));
+    if (!rsa) return NULL;
+    rsa->comment = NULL;
+
+    rsa->modulus = getmp(b, len);
+    rsa->exponent = getmp(b, len);
+    rsa->private_exponent = getmp(b, len);
+    rsa->iqmp = getmp(b, len);
+    rsa->p = getmp(b, len);
+    rsa->q = getmp(b, len);
+
+    if (!rsa->modulus || !rsa->exponent || !rsa->private_exponent ||
+       !rsa->iqmp || !rsa->p || !rsa->q) {
+       sfree(rsa->modulus);
+       sfree(rsa->exponent);
+       sfree(rsa->private_exponent);
+       sfree(rsa->iqmp);
+       sfree(rsa->p);
+       sfree(rsa->q);
+       sfree(rsa);
+       return NULL;
+    }
+
     return rsa;
 }
 
@@ -345,23 +409,34 @@ static char *rsa2_fingerprint(void *key) {
 /*
  * This is the magic ASN.1/DER prefix that goes in the decoded
  * signature, between the string of FFs and the actual SHA hash
- * value. As closely as I can tell, the meaning of it is:
+ * value. The meaning of it is:
  * 
  * 00 -- this marks the end of the FFs; not part of the ASN.1 bit itself
  * 
  * 30 21 -- a constructed SEQUENCE of length 0x21
  *    30 09 -- a constructed sub-SEQUENCE of length 9
  *       06 05 -- an object identifier, length 5
- *          2B 0E 03 02 1A -- 
+ *          2B 0E 03 02 1A -- object id { 1 3 14 3 2 26 }
+ *                            (the 1,3 comes from 0x2B = 43 = 40*1+3)
  *       05 00 -- NULL
  *    04 14 -- a primitive OCTET STRING of length 0x14
  *       [0x14 bytes of hash data follows]
+ * 
+ * The object id in the middle there is listed as `id-sha1' in
+ * ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1d2.asn (the
+ * ASN module for PKCS #1) and its expanded form is as follows:
+ * 
+ * id-sha1                OBJECT IDENTIFIER ::= {
+ *    iso(1) identified-organization(3) oiw(14) secsig(3)
+ *    algorithms(2) 26 }
  */
 static unsigned char asn1_weird_stuff[] = {
     0x00,0x30,0x21,0x30,0x09,0x06,0x05,0x2B,
     0x0E,0x03,0x02,0x1A,0x05,0x00,0x04,0x14,
 };
 
+#define ASN1_LEN ( (int) sizeof(asn1_weird_stuff) )
+
 static int rsa2_verifysig(void *key, char *sig, int siglen,
                         char *data, int datalen) {
     struct RSAKey *rsa = (struct RSAKey *)key;
@@ -389,12 +464,12 @@ static int rsa2_verifysig(void *key, char *sig, int siglen,
     if (bignum_byte(out, bytes-2) != 1)
         ret = 0;
     /* Most of the rest should be FF. */
-    for (i = bytes-3; i >= 20 + sizeof(asn1_weird_stuff); i--) {
+    for (i = bytes-3; i >= 20 + ASN1_LEN; i--) {
         if (bignum_byte(out, i) != 0xFF)
             ret = 0;
     }
     /* Then we expect to see the asn1_weird_stuff. */
-    for (i = 20 + sizeof(asn1_weird_stuff) - 1, j=0; i >= 20; i--,j++) {
+    for (i = 20 + ASN1_LEN - 1, j=0; i >= 20; i--,j++) {
         if (bignum_byte(out, i) != asn1_weird_stuff[j])
             ret = 0;
     }
@@ -422,9 +497,9 @@ unsigned char *rsa2_sign(void *key, char *data, int datalen, int *siglen) {
     bytes = smalloc(nbytes);
 
     bytes[0] = 1;
-    for (i = 1; i < nbytes-20-sizeof(asn1_weird_stuff); i++)
+    for (i = 1; i < nbytes-20-ASN1_LEN; i++)
        bytes[i] = 0xFF;
-    for (i = nbytes-20-sizeof(asn1_weird_stuff), j=0; i < nbytes-20; i++,j++)
+    for (i = nbytes-20-ASN1_LEN, j=0; i < nbytes-20; i++,j++)
        bytes[i] = asn1_weird_stuff[j];
     for (i = nbytes-20, j=0; i < nbytes; i++,j++)
        bytes[i] = hash[j];
@@ -455,6 +530,7 @@ const struct ssh_signkey ssh_rsa = {
     rsa2_public_blob,
     rsa2_private_blob,
     rsa2_createkey,
+    rsa2_openssh_createkey,
     rsa2_fingerprint,
     rsa2_verifysig,
     rsa2_sign,