md = key->modulus;
ex = key->exponent;
- mdlen = (ssh1_bignum_bitcount(md)+15) / 16;
- exlen = (ssh1_bignum_bitcount(ex)+15) / 16;
+ mdlen = (bignum_bitcount(md)+15) / 16;
+ exlen = (bignum_bitcount(ex)+15) / 16;
return 4 * (mdlen+exlen) + 20;
}
len += sprintf(str+len, "0x");
- nibbles = (3 + ssh1_bignum_bitcount(ex))/4; if (nibbles<1) nibbles=1;
+ nibbles = (3 + bignum_bitcount(ex))/4; if (nibbles<1) nibbles=1;
for (i=nibbles; i-- ;)
str[len++] = hex[(bignum_byte(ex, i/2) >> (4*(i%2))) & 0xF];
len += sprintf(str+len, ",0x");
- nibbles = (3 + ssh1_bignum_bitcount(md))/4; if (nibbles<1) nibbles=1;
+ nibbles = (3 + bignum_bitcount(md))/4; if (nibbles<1) nibbles=1;
for (i=nibbles; i-- ;)
str[len++] = hex[(bignum_byte(md, i/2) >> (4*(i%2))) & 0xF];
}
MD5Final(digest, &md5c);
- sprintf(buffer, "%d ", ssh1_bignum_bitcount(key->modulus));
+ sprintf(buffer, "%d ", bignum_bitcount(key->modulus));
for (i = 0; i < 16; i++)
sprintf(buffer+strlen(buffer), "%s%02x", i?":":"", digest[i]);
strncpy(str, buffer, len); str[len-1] = '\0';
}
}
+/*
+ * Verify that the public data in an RSA key matches the private
+ * data. We also check the private data itself: we ensure that p >
+ * q and that iqmp really is the inverse of q mod p.
+ */
+int rsa_verify(struct RSAKey *key) {
+ Bignum n, ed, pm1, qm1;
+ 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) and modulo (q-1). */
+ pm1 = copybn(key->p);
+ decbn(pm1);
+ ed = modmul(key->exponent, key->private_exponent, pm1);
+ cmp = bignum_cmp(ed, One);
+ sfree(ed);
+ if (cmp != 0)
+ return 0;
+
+ qm1 = copybn(key->q);
+ decbn(qm1);
+ ed = modmul(key->exponent, key->private_exponent, qm1);
+ cmp = bignum_cmp(ed, One);
+ sfree(ed);
+ if (cmp != 0)
+ return 0;
+
+ /*
+ * Ensure p > q.
+ */
+ if (bignum_cmp(key->p, key->q) <= 0)
+ return 0;
+
+ /*
+ * Ensure iqmp * q is congruent to 1, modulo p.
+ */
+ n = modmul(key->iqmp, key->q, key->p);
+ cmp = bignum_cmp(n, One);
+ sfree(n);
+ if (cmp != 0)
+ return 0;
+
+ return 1;
+}
+
void freersakey(struct RSAKey *key) {
if (key->modulus) freebn(key->modulus);
if (key->exponent) freebn(key->exponent);
len = rsastr_len(rsa);
p = smalloc(len);
- rsastr_fmt(p, rsa);
+ rsastr_fmt(p, rsa);
return p;
}
int i;
unsigned char *blob, *p;
- elen = (ssh1_bignum_bitcount(rsa->exponent)+8)/8;
- mlen = (ssh1_bignum_bitcount(rsa->modulus)+8)/8;
+ elen = (bignum_bitcount(rsa->exponent)+8)/8;
+ mlen = (bignum_bitcount(rsa->modulus)+8)/8;
/*
* string "ssh-rsa", mpint exp, mpint mod. Total 19+elen+mlen.
int i;
unsigned char *blob, *p;
- dlen = (ssh1_bignum_bitcount(rsa->private_exponent)+8)/8;
- plen = (ssh1_bignum_bitcount(rsa->p)+8)/8;
- qlen = (ssh1_bignum_bitcount(rsa->q)+8)/8;
- ulen = (ssh1_bignum_bitcount(rsa->iqmp)+8)/8;
+ dlen = (bignum_bitcount(rsa->private_exponent)+8)/8;
+ plen = (bignum_bitcount(rsa->p)+8)/8;
+ qlen = (bignum_bitcount(rsa->q)+8)/8;
+ ulen = (bignum_bitcount(rsa->iqmp)+8)/8;
/*
* mpint private_exp, mpint p, mpint q, mpint iqmp. Total 16 +
rsa->q = getmp(&pb, &priv_len);
rsa->iqmp = getmp(&pb, &priv_len);
+ if (!rsa_verify(rsa)) {
+ rsa2_freekey(rsa);
+ return NULL;
+ }
+
return rsa;
}
return rsa;
}
+static int *rsa2_openssh_fmtkey(void *key, unsigned char *blob, int len) {
+ struct RSAKey *rsa = (struct RSAKey *)key;
+ int bloblen, i;
+
+ bloblen =
+ ssh2_bignum_length(rsa->modulus) +
+ ssh2_bignum_length(rsa->exponent) +
+ ssh2_bignum_length(rsa->private_exponent) +
+ ssh2_bignum_length(rsa->iqmp) +
+ ssh2_bignum_length(rsa->p) +
+ ssh2_bignum_length(rsa->q);
+
+ if (bloblen > len)
+ return bloblen;
+
+ bloblen = 0;
+#define ENC(x) \
+ PUT_32BIT(blob+bloblen, ssh2_bignum_length((x))-4); bloblen += 4; \
+ for (i = ssh2_bignum_length((x))-4; i-- ;) blob[bloblen++]=bignum_byte((x),i);
+ ENC(rsa->modulus);
+ ENC(rsa->exponent);
+ ENC(rsa->private_exponent);
+ ENC(rsa->iqmp);
+ ENC(rsa->p);
+ ENC(rsa->q);
+
+ return bloblen;
+}
+
static char *rsa2_fingerprint(void *key) {
struct RSAKey *rsa = (struct RSAKey *)key;
struct MD5Context md5c;
MD5Update(&md5c, "\0\0\0\7ssh-rsa", 11);
#define ADD_BIGNUM(bignum) \
- numlen = (ssh1_bignum_bitcount(bignum)+8)/8; \
+ numlen = (bignum_bitcount(bignum)+8)/8; \
PUT_32BIT(lenbuf, numlen); MD5Update(&md5c, lenbuf, 4); \
for (i = numlen; i-- ;) { \
unsigned char c = bignum_byte(bignum, i); \
MD5Final(digest, &md5c);
- sprintf(buffer, "ssh-rsa %d ", ssh1_bignum_bitcount(rsa->modulus));
+ sprintf(buffer, "ssh-rsa %d ", bignum_bitcount(rsa->modulus));
for (i = 0; i < 16; i++)
sprintf(buffer+strlen(buffer), "%s%02x", i?":":"", digest[i]);
ret = smalloc(strlen(buffer)+1);
ret = 1;
- bytes = ssh1_bignum_bitcount(rsa->modulus) / 8;
+ bytes = bignum_bitcount(rsa->modulus) / 8;
/* Top (partial) byte should be zero. */
if (bignum_byte(out, bytes-1) != 0)
ret = 0;
SHA_Simple(data, datalen, hash);
- nbytes = (ssh1_bignum_bitcount(rsa->modulus)-1) / 8;
+ nbytes = (bignum_bitcount(rsa->modulus)-1) / 8;
bytes = smalloc(nbytes);
bytes[0] = 1;
out = modpow(in, rsa->private_exponent, rsa->modulus);
freebn(in);
- nbytes = (ssh1_bignum_bitcount(out)+7)/8;
+ nbytes = (bignum_bitcount(out)+7)/8;
bytes = smalloc(4+7+4+nbytes);
PUT_32BIT(bytes, 7);
memcpy(bytes+4, "ssh-rsa", 7);
rsa2_private_blob,
rsa2_createkey,
rsa2_openssh_createkey,
+ rsa2_openssh_fmtkey,
rsa2_fingerprint,
rsa2_verifysig,
rsa2_sign,