diff --git a/extern/crypto/CryptBn.cpp b/extern/crypto/CryptBn.cpp new file mode 100644 index 0000000000..61c6ab111c --- /dev/null +++ b/extern/crypto/CryptBn.cpp @@ -0,0 +1,1073 @@ +/* + * Bignum routines for RSA and DH and stuff. + */ + +#include "global.h" +#include "CryptBn.h" + +#if defined(_MSC_VER) +#pragma warning (disable : 4244) // conversion from 'int' to 'BignumInt', possible loss of data +#endif + +BignumInt bnZero[1] = { 0 }; +BignumInt bnOne[2] = { 1, 1 }; + +/* + * The Bignum format is an array of `BignumInt'. The first + * element of the array counts the remaining elements. The + * remaining elements express the actual number, base 2^BIGNUM_INT_BITS, _least_ + * significant digit first. (So it's trivial to extract the bit + * with value 2^n for any n.) + * + * All Bignums in this module are positive. Negative numbers must + * be dealt with outside it. + * + * INVARIANT: the most significant word of any Bignum must be + * nonzero. + */ + +Bignum Zero = bnZero, One = bnOne; + +static Bignum newbn(int length) +{ + Bignum b = new BignumInt[length + 1]; + if (!b) + abort(); /* FIXME */ + memset(b, 0, (length + 1) * sizeof(*b)); + b[0] = length; + return b; +} + +void bn_restore_invariant(Bignum b) +{ + while (b[0] > 1 && b[b[0]] == 0) + b[0]--; +} + +Bignum copybn(Bignum orig) +{ + Bignum b = new BignumInt[orig[0] + 1]; + if (!b) + abort(); /* FIXME */ + memcpy(b, orig, (orig[0] + 1) * sizeof(*b)); + return b; +} + +void freebn(Bignum b) +{ + /* + * Burn the evidence, just in case. + */ + memset(b, 0, sizeof(b[0]) * (b[0] + 1)); + delete [] b; +} + +Bignum bn_power_2(int n) +{ + Bignum ret = newbn(n / BIGNUM_INT_BITS + 1); + bignum_set_bit(ret, n, 1); + return ret; +} + +/* + * Compute c = a * b. + * Input is in the first len words of a and b. + * Result is returned in the first 2*len words of c. + */ +static void internal_mul(BignumInt *a, BignumInt *b, + BignumInt *c, int len) +{ + int i, j; + BignumDblInt t; + + for (j = 0; j < 2 * len; j++) + c[j] = 0; + + for (i = len - 1; i >= 0; i--) { + t = 0; + for (j = len - 1; j >= 0; j--) { + t += MUL_WORD(a[i], (BignumDblInt) b[j]); + t += (BignumDblInt) c[i + j + 1]; + c[i + j + 1] = (BignumInt) t; + t = t >> BIGNUM_INT_BITS; + } + c[i] = (BignumInt) t; + } +} + +static void internal_add_shifted(BignumInt *number, + unsigned n, int shift) +{ + int word = 1 + (shift / BIGNUM_INT_BITS); + int bshift = shift % BIGNUM_INT_BITS; + BignumDblInt addend; + + addend = (BignumDblInt)n << bshift; + + while (addend) { + addend += number[word]; + number[word] = (BignumInt) addend & BIGNUM_INT_MASK; + addend >>= BIGNUM_INT_BITS; + word++; + } +} + +/* + * Compute a = a % m. + * Input in first alen words of a and first mlen words of m. + * Output in first alen words of a + * (of which first alen-mlen words will be zero). + * The MSW of m MUST have its high bit set. + * Quotient is accumulated in the `quotient' array, which is a Bignum + * rather than the internal bigendian format. Quotient parts are shifted + * left by `qshift' before adding into quot. + */ +static void internal_mod(BignumInt *a, int alen, + BignumInt *m, int mlen, + BignumInt *quot, int qshift) +{ + BignumInt m0, m1; + unsigned int h; + int i, k; + + m0 = m[0]; + if (mlen > 1) + m1 = m[1]; + else + m1 = 0; + + for (i = 0; i <= alen - mlen; i++) { + BignumDblInt t; + unsigned int q, r, c, ai1; + + if (i == 0) { + h = 0; + } else { + h = a[i - 1]; + a[i - 1] = 0; + } + + if (i == alen - 1) + ai1 = 0; + else + ai1 = a[i + 1]; + + /* Find q = h:a[i] / m0 */ + DIVMOD_WORD(q, r, h, a[i], m0); + + /* Refine our estimate of q by looking at +h:a[i]:a[i+1] / m0:m1 */ + t = MUL_WORD(m1, q); + if (t > ((BignumDblInt) r << BIGNUM_INT_BITS) + ai1) { + q--; + t -= m1; + r = (r + m0) & BIGNUM_INT_MASK; /* overflow? */ + if (r >= (BignumDblInt) m0 && + t > ((BignumDblInt) r << BIGNUM_INT_BITS) + ai1) q--; + } + + /* Subtract q * m from a[i...] */ + c = 0; + for (k = mlen - 1; k >= 0; k--) { + t = MUL_WORD(q, m[k]); + t += c; + c = t >> BIGNUM_INT_BITS; + if ((BignumInt) t > a[i + k]) + c++; + a[i + k] -= (BignumInt) t; + } + + /* Add back m in case of borrow */ + if (c != h) { + t = 0; + for (k = mlen - 1; k >= 0; k--) { + t += m[k]; + t += a[i + k]; + a[i + k] = (BignumInt) t; + t = t >> BIGNUM_INT_BITS; + } + q--; + } + if (quot) + internal_add_shifted(quot, q, qshift + BIGNUM_INT_BITS * (alen - mlen - i)); + } +} + +/* + * Compute (base ^ exp) % mod. + */ +Bignum modpow(Bignum base_in, Bignum exp, Bignum mod) +{ + BignumInt *a, *b, *n, *m; + int mshift; + int i,j,mlen; + Bignum base, result; + + /* + * The most significant word of mod needs to be non-zero. It + * should already be, but let's make sure. + */ + ASSERT(mod[mod[0]] != 0); + + /* + * Make sure the base is smaller than the modulus, by reducing + * it modulo the modulus if not. + */ + base = bigmod(base_in, mod); + + /* Allocate m of size mlen, copy mod to m */ + /* We use big endian internally */ + mlen = mod[0]; + m = new BignumInt[mlen]; + for (j = 0; j < mlen; j++) + m[j] = mod[mod[0] - j]; + + /* Shift m left to make msb bit set */ + for (mshift = 0; mshift < BIGNUM_INT_BITS-1; mshift++) + if ((m[0] << mshift) & BIGNUM_TOP_BIT) + break; + if (mshift) { + for (i = 0; i < mlen - 1; i++) + m[i] = (m[i] << mshift) | (m[i + 1] >> (BIGNUM_INT_BITS - mshift)); + m[mlen - 1] = m[mlen - 1] << mshift; + } + + /* Allocate n of size mlen, copy base to n */ + n = new BignumInt[mlen]; + i = mlen - base[0]; + for (j = 0; j < i; j++) + n[j] = 0; + for (j = 0; j < (int)base[0]; j++) + n[i + j] = base[base[0] - j]; + + /* Allocate a and b of size 2*mlen. Set a = 1 */ + a = new BignumInt[2 * mlen]; + b = new BignumInt[2 * mlen]; + for (i = 0; i < 2 * mlen; i++) + a[i] = 0; + a[2 * mlen - 1] = 1; + + /* Skip leading zero bits of exp. */ + i = 0; + j = BIGNUM_INT_BITS-1; + while (i < (int)exp[0] && (exp[exp[0] - i] & (1 << j)) == 0) { + j--; + if (j < 0) { + i++; + j = BIGNUM_INT_BITS-1; + } + } + + /* Main computation */ + while (i < (int)exp[0]) { + while (j >= 0) { + internal_mul(a + mlen, a + mlen, b, mlen); + internal_mod(b, mlen * 2, m, mlen, NULL, 0); + if ((exp[exp[0] - i] & (1 << j)) != 0) { + internal_mul(b + mlen, n, a, mlen); + internal_mod(a, mlen * 2, m, mlen, NULL, 0); + } else { + BignumInt *t; + t = a; + a = b; + b = t; + } + j--; + } + i++; + j = BIGNUM_INT_BITS-1; + } + + /* Fixup result in case the modulus was shifted */ + if (mshift) { + for (i = mlen - 1; i < 2 * mlen - 1; i++) + a[i] = (a[i] << mshift) | (a[i + 1] >> (BIGNUM_INT_BITS - mshift)); + a[2 * mlen - 1] = a[2 * mlen - 1] << mshift; + internal_mod(a, mlen * 2, m, mlen, NULL, 0); + for (i = 2 * mlen - 1; i >= mlen; i--) + a[i] = (a[i] >> mshift) | (a[i - 1] << (BIGNUM_INT_BITS - mshift)); + } + + /* Copy result to buffer */ + result = newbn(mod[0]); + for (i = 0; i < mlen; i++) + result[result[0] - i] = a[i + mlen]; + while (result[0] > 1 && result[result[0]] == 0) + result[0]--; + + /* Free temporary arrays */ + for (i = 0; i < 2 * mlen; i++) + a[i] = 0; + delete [] a; + for (i = 0; i < 2 * mlen; i++) + b[i] = 0; + delete [] b; + for (i = 0; i < mlen; i++) + m[i] = 0; + delete [] m; + for (i = 0; i < mlen; i++) + n[i] = 0; + delete [] n; + + freebn(base); + + return result; +} + +/* + * Compute (p * q) % mod. + * The most significant word of mod MUST be non-zero. + * We assume that the result array is the same size as the mod array. + */ +Bignum modmul(Bignum p, Bignum q, Bignum mod) +{ + BignumInt *a, *n, *m, *o; + int mshift; + int pqlen, mlen, rlen, i, j; + Bignum result; + + /* Allocate m of size mlen, copy mod to m */ + /* We use big endian internally */ + mlen = mod[0]; + m = new BignumInt[mlen]; + for (j = 0; j < mlen; j++) + m[j] = mod[mod[0] - j]; + + /* Shift m left to make msb bit set */ + for (mshift = 0; mshift < BIGNUM_INT_BITS-1; mshift++) + if ((m[0] << mshift) & BIGNUM_TOP_BIT) + break; + if (mshift) { + for (i = 0; i < mlen - 1; i++) + m[i] = (m[i] << mshift) | (m[i + 1] >> (BIGNUM_INT_BITS - mshift)); + m[mlen - 1] = m[mlen - 1] << mshift; + } + + pqlen = (p[0] > q[0] ? p[0] : q[0]); + + /* Allocate n of size pqlen, copy p to n */ + n = new BignumInt[pqlen]; + i = pqlen - p[0]; + for (j = 0; j < i; j++) + n[j] = 0; + for (j = 0; j < (int)p[0]; j++) + n[i + j] = p[p[0] - j]; + + /* Allocate o of size pqlen, copy q to o */ + o = new BignumInt[pqlen]; + i = pqlen - q[0]; + for (j = 0; j < i; j++) + o[j] = 0; + for (j = 0; j < (int)q[0]; j++) + o[i + j] = q[q[0] - j]; + + /* Allocate a of size 2*pqlen for result */ + a = new BignumInt[2 * pqlen]; + + /* Main computation */ + internal_mul(n, o, a, pqlen); + internal_mod(a, pqlen * 2, m, mlen, NULL, 0); + + /* Fixup result in case the modulus was shifted */ + if (mshift) { + for (i = 2 * pqlen - mlen - 1; i < 2 * pqlen - 1; i++) + a[i] = (a[i] << mshift) | (a[i + 1] >> (BIGNUM_INT_BITS - mshift)); + a[2 * pqlen - 1] = a[2 * pqlen - 1] << mshift; + internal_mod(a, pqlen * 2, m, mlen, NULL, 0); + for (i = 2 * pqlen - 1; i >= 2 * pqlen - mlen; i--) + a[i] = (a[i] >> mshift) | (a[i - 1] << (BIGNUM_INT_BITS - mshift)); + } + + /* Copy result to buffer */ + rlen = (mlen < pqlen * 2 ? mlen : pqlen * 2); + result = newbn(rlen); + for (i = 0; i < rlen; i++) + result[result[0] - i] = a[i + 2 * pqlen - rlen]; + while (result[0] > 1 && result[result[0]] == 0) + result[0]--; + + /* Free temporary arrays */ + for (i = 0; i < 2 * pqlen; i++) + a[i] = 0; + delete [] a; + for (i = 0; i < mlen; i++) + m[i] = 0; + delete [] m; + for (i = 0; i < pqlen; i++) + n[i] = 0; + delete [] n; + for (i = 0; i < pqlen; i++) + o[i] = 0; + delete [] o; + + return result; +} + +/* + * Compute p % mod. + * The most significant word of mod MUST be non-zero. + * We assume that the result array is the same size as the mod array. + * We optionally write out a quotient if `quotient' is non-NULL. + * We can avoid writing out the result if `result' is NULL. + */ +static void bigdivmod(Bignum p, Bignum mod, Bignum result, Bignum quotient) +{ + BignumInt *n, *m; + int mshift; + int plen, mlen, i, j; + + /* Allocate m of size mlen, copy mod to m */ + /* We use big endian internally */ + mlen = mod[0]; + m = new BignumInt[mlen]; + for (j = 0; j < mlen; j++) + m[j] = mod[mod[0] - j]; + + /* Shift m left to make msb bit set */ + for (mshift = 0; mshift < BIGNUM_INT_BITS-1; mshift++) + if ((m[0] << mshift) & BIGNUM_TOP_BIT) + break; + if (mshift) { + for (i = 0; i < mlen - 1; i++) + m[i] = (m[i] << mshift) | (m[i + 1] >> (BIGNUM_INT_BITS - mshift)); + m[mlen - 1] = m[mlen - 1] << mshift; + } + + plen = p[0]; + /* Ensure plen > mlen */ + if (plen <= mlen) + plen = mlen + 1; + + /* Allocate n of size plen, copy p to n */ + n = new BignumInt[plen]; + for (j = 0; j < plen; j++) + n[j] = 0; + for (j = 1; j <= (int)p[0]; j++) + n[plen - j] = p[j]; + + /* Main computation */ + internal_mod(n, plen, m, mlen, quotient, mshift); + + /* Fixup result in case the modulus was shifted */ + if (mshift) { + for (i = plen - mlen - 1; i < plen - 1; i++) + n[i] = (n[i] << mshift) | (n[i + 1] >> (BIGNUM_INT_BITS - mshift)); + n[plen - 1] = n[plen - 1] << mshift; + internal_mod(n, plen, m, mlen, quotient, 0); + for (i = plen - 1; i >= plen - mlen; i--) + n[i] = (n[i] >> mshift) | (n[i - 1] << (BIGNUM_INT_BITS - mshift)); + } + + /* Copy result to buffer */ + if (result) { + for (i = 1; i <= (int)result[0]; i++) { + int j = plen - i; + result[i] = j >= 0 ? n[j] : 0; + } + } + + /* Free temporary arrays */ + for (i = 0; i < mlen; i++) + m[i] = 0; + delete [] m; + for (i = 0; i < plen; i++) + n[i] = 0; + delete [] n; +} + +/* + * Decrement a number. + */ +void decbn(Bignum bn) +{ + int i = 1; + while (i < (int)bn[0] && bn[i] == 0) + bn[i++] = BIGNUM_INT_MASK; + bn[i]--; +} + +int bignum_bytes_size( const Bignum bn ) +{ + if( bn[0] == 0 ) + return 0; + return bn[1]; +} + +unsigned char *bignum_to_buffer( const Bignum bn, int *nbytes ) +{ + if( bn[0] == 0 ) + { + /* Special case: zero length. */ + *nbytes = bn[0]; + + unsigned char *ret = new unsigned char[1]; + return ret; + } + + *nbytes = bn[1]; + + unsigned char *ret = new unsigned char[bn[1]]; + unsigned char *p = ret; + for( int i = bn[1]-1; i >= 0; --i ) + *p++ = bignum_byte( bn, i+BIGNUM_INT_BYTES ); + return ret; +} + +Bignum bignum_from_buffer(const unsigned char *data, int nbytes) +{ + Bignum result; + int w, i; + + w = (nbytes + BIGNUM_INT_BYTES - 1) / BIGNUM_INT_BYTES; /* bytes->words */ + w += 1; /* size */ + + result = newbn(w); + for (i = 1; i <= w; i++) + result[i] = 0; + + result[1] = nbytes; + for (i = nbytes; i--;) { + unsigned char byte = *data++; + result[2 + i / BIGNUM_INT_BYTES] |= byte << (8*i % BIGNUM_INT_BITS); + } + + while (result[0] > 1 && result[result[0]] == 0) + result[0]--; + return result; +} + +unsigned char *bignum_to_bytes( const Bignum bn, int *nbytes ) +{ + if( bn[0] == 0 ) + { + /* Special case: zero length. */ + *nbytes = 0; + unsigned char *ret = new unsigned char[1]; + ret[0] = 0; + return ret; + } + + int len = *nbytes = bn[0] * BIGNUM_INT_BYTES; + + unsigned char *ret = new unsigned char[len]; + unsigned char *p = ret; + for( int i = len-1; i >= 0; --i ) + *p++ = bignum_byte( bn, i ); + return ret; +} + +/* Convert a sequence of bytes to a bignum. Any sequence is valid. */ +Bignum bignum_from_bytes(const unsigned char *data, int nbytes) +{ + Bignum result; + int w, i; + + w = (nbytes + BIGNUM_INT_BYTES - 1) / BIGNUM_INT_BYTES; /* bytes->words */ + + result = newbn(w); + for (i = 1; i <= w; i++) + result[i] = 0; + + for (i = nbytes; i--;) { + unsigned char byte = *data++; + result[1 + i / BIGNUM_INT_BYTES] |= byte << (8*i % BIGNUM_INT_BITS); + } + + while (result[0] > 1 && result[result[0]] == 0) + result[0]--; + return result; +} + +/* + * Read an ssh1-format bignum from a data buffer. Return the number + * of bytes consumed. + */ +int ssh1_read_bignum(const unsigned char *data, Bignum * result) +{ + const unsigned char *p = data; + int i; + int w, b; + + w = 0; + for (i = 0; i < 2; i++) + w = (w << 8) + *p++; + b = (w + 7) / 8; /* bits -> bytes */ + + if (!result) /* just return length */ + return b + 2; + + *result = bignum_from_bytes(p, b); + + return p + b - data; +} + +/* + * Return the bit count of a bignum, for ssh1 encoding. + */ +int bignum_bitcount(Bignum bn) +{ + int bitcount = bn[0] * BIGNUM_INT_BITS - 1; + while (bitcount >= 0 + && (bn[bitcount / BIGNUM_INT_BITS + 1] >> (bitcount % BIGNUM_INT_BITS)) == 0) bitcount--; + return bitcount + 1; +} + +/* + * Return the byte length of a bignum when ssh1 encoded. + */ +int ssh1_bignum_length(Bignum bn) +{ + return 2 + (bignum_bitcount(bn) + 7) / 8; +} + +/* + * Return the byte length of a bignum when ssh2 encoded. + */ +int ssh2_bignum_length(Bignum bn) +{ + return 4 + (bignum_bitcount(bn) + 8) / 8; +} + +/* + * Return a byte from a bignum; 0 is least significant, etc. + */ +unsigned char bignum_byte( const Bignum bn, int i ) +{ + if (i >= BIGNUM_INT_BYTES * (int)bn[0]) + return 0; /* beyond the end */ + else + return (bn[i / BIGNUM_INT_BYTES + 1] >> + ((i % BIGNUM_INT_BYTES)*8)) & 0xFF; +} + +/* + * Return a bit from a bignum; 0 is least significant, etc. + */ +int bignum_bit(Bignum bn, int i) +{ + if (i >= BIGNUM_INT_BITS * (int)bn[0]) + return 0; /* beyond the end */ + else + return (bn[i / BIGNUM_INT_BITS + 1] >> (i % BIGNUM_INT_BITS)) & 1; +} + +/* + * Set a bit in a bignum; 0 is least significant, etc. + */ +void bignum_set_bit(Bignum bn, int bitnum, int value) +{ + if (bitnum >= BIGNUM_INT_BITS * (int)bn[0]) + abort(); /* beyond the end */ + else { + int v = bitnum / BIGNUM_INT_BITS + 1; + int mask = 1 << (bitnum % BIGNUM_INT_BITS); + if (value) + bn[v] |= mask; + else + bn[v] &= ~mask; + } +} + +/* + * Write a ssh1-format bignum into a buffer. It is assumed the + * buffer is big enough. Returns the number of bytes used. + */ +int ssh1_write_bignum(void *data, Bignum bn) +{ + unsigned char *p = (unsigned char *) data; + int len = ssh1_bignum_length(bn); + int i; + int bitc = bignum_bitcount(bn); + + *p++ = (bitc >> 8) & 0xFF; + *p++ = (bitc) & 0xFF; + for (i = len - 2; i--;) + *p++ = bignum_byte(bn, i); + return len; +} + +/* + * Compare two bignums. Returns like strcmp. + */ +int bignum_cmp(Bignum a, Bignum b) +{ + int amax = a[0], bmax = b[0]; + int i = (amax > bmax ? amax : bmax); + while (i) { + BignumInt aval = (i > amax ? 0 : a[i]); + BignumInt bval = (i > bmax ? 0 : b[i]); + if (aval < bval) + return -1; + if (aval > bval) + return +1; + i--; + } + return 0; +} + +/* + * Right-shift one bignum to form another. + */ +Bignum bignum_rshift(Bignum a, int shift) +{ + Bignum ret; + int i, shiftw, shiftb, shiftbb, bits; + BignumInt ai, ai1; + + bits = bignum_bitcount(a) - shift; + ret = newbn((bits + BIGNUM_INT_BITS - 1) / BIGNUM_INT_BITS); + + if (ret) { + shiftw = shift / BIGNUM_INT_BITS; + shiftb = shift % BIGNUM_INT_BITS; + shiftbb = BIGNUM_INT_BITS - shiftb; + + ai1 = a[shiftw + 1]; + for (i = 1; i <= (int)ret[0]; i++) { + ai = ai1; + ai1 = (i + shiftw + 1 <= (int)a[0] ? a[i + shiftw + 1] : 0); + ret[i] = ((ai >> shiftb) | (ai1 << shiftbb)) & BIGNUM_INT_MASK; + } + } + + return ret; +} + +/* + * Non-modular multiplication and addition. + */ +Bignum bigmuladd(Bignum a, Bignum b, Bignum addend) +{ + int alen = a[0], blen = b[0]; + int mlen = (alen > blen ? alen : blen); + int rlen, i, maxspot; + BignumInt *workspace; + Bignum ret; + + /* mlen space for a, mlen space for b, 2*mlen for result */ + workspace = new BignumInt[mlen * 4]; + for (i = 0; i < mlen; i++) { + workspace[0 * mlen + i] = (mlen - i <= (int)a[0] ? a[mlen - i] : 0); + workspace[1 * mlen + i] = (mlen - i <= (int)b[0] ? b[mlen - i] : 0); + } + + internal_mul(workspace + 0 * mlen, workspace + 1 * mlen, + workspace + 2 * mlen, mlen); + + /* now just copy the result back */ + rlen = alen + blen + 1; + if (addend && rlen <= (int)addend[0]) + rlen = addend[0] + 1; + ret = newbn(rlen); + maxspot = 0; + for (i = 1; i <= (int)ret[0]; i++) { + ret[i] = (i <= 2 * mlen ? workspace[4 * mlen - i] : 0); + if (ret[i] != 0) + maxspot = i; + } + ret[0] = maxspot; + + /* now add in the addend, if any */ + if (addend) { + BignumDblInt carry = 0; + for (i = 1; i <= rlen; i++) { + carry += (i <= (int)ret[0] ? ret[i] : 0); + carry += (i <= (int)addend[0] ? addend[i] : 0); + ret[i] = (BignumInt) carry & BIGNUM_INT_MASK; + carry >>= BIGNUM_INT_BITS; + if (ret[i] != 0 && i > maxspot) + maxspot = i; + } + } + ret[0] = maxspot; + + delete [] workspace; + return ret; +} + +/* + * Non-modular multiplication. + */ +Bignum bigmul(Bignum a, Bignum b) +{ + return bigmuladd(a, b, NULL); +} + +/* + * Create a bignum which is the bitmask covering another one. That + * is, the smallest integer which is >= N and is also one less than + * a power of two. + */ +Bignum bignum_bitmask(Bignum n) +{ + Bignum ret = copybn(n); + int i; + BignumInt j; + + i = ret[0]; + while (n[i] == 0 && i > 0) + i--; + if (i <= 0) + return ret; /* input was zero */ + j = 1; + while (j < n[i]) + j = 2 * j + 1; + ret[i] = j; + while (--i > 0) + ret[i] = BIGNUM_INT_MASK; + return ret; +} + +/* + * Convert a (max 32-bit) long into a bignum. + */ +Bignum bignum_from_long(unsigned long nn) +{ + Bignum ret; + BignumDblInt n = nn; + + ret = newbn(3); + ret[1] = (BignumInt)(n & BIGNUM_INT_MASK); + ret[2] = (BignumInt)((n >> BIGNUM_INT_BITS) & BIGNUM_INT_MASK); + ret[3] = 0; + ret[0] = (ret[2] ? 2 : 1); + return ret; +} + +/* + * Add a long to a bignum. + */ +Bignum bignum_add_long(Bignum number, unsigned long addendx) +{ + Bignum ret = newbn(number[0] + 1); + int i, maxspot = 0; + BignumDblInt carry = 0, addend = addendx; + + for (i = 1; i <= (int)ret[0]; i++) { + carry += addend & BIGNUM_INT_MASK; + carry += (i <= (int)number[0] ? number[i] : 0); + addend >>= BIGNUM_INT_BITS; + ret[i] = (BignumInt) carry & BIGNUM_INT_MASK; + carry >>= BIGNUM_INT_BITS; + if (ret[i] != 0) + maxspot = i; + } + ret[0] = maxspot; + return ret; +} + +/* + * Compute the residue of a bignum, modulo a (max 16-bit) short. + */ +unsigned short bignum_mod_short(Bignum number, unsigned short modulus) +{ + BignumDblInt mod, r; + int i; + + r = 0; + mod = modulus; + for (i = number[0]; i > 0; i--) + r = (r * (BIGNUM_TOP_BIT % mod) * 2 + number[i] % mod) % mod; + return (unsigned short) r; +} + + +/* + * Simple division. + */ +Bignum bigdiv(Bignum a, Bignum b) +{ + Bignum q = newbn(a[0]); + bigdivmod(a, b, NULL, q); + return q; +} + +/* + * Simple remainder. + */ +Bignum bigmod(Bignum a, Bignum b) +{ + Bignum r = newbn(b[0]); + bigdivmod(a, b, r, NULL); + return r; +} + +/* + * Greatest common divisor. + */ +Bignum biggcd(Bignum av, Bignum bv) +{ + Bignum a = copybn(av); + Bignum b = copybn(bv); + + while (bignum_cmp(b, Zero) != 0) { + Bignum t = newbn(b[0]); + bigdivmod(a, b, t, NULL); + while (t[0] > 1 && t[t[0]] == 0) + t[0]--; + freebn(a); + a = b; + b = t; + } + + freebn(b); + return a; +} + +/* + * Modular inverse, using Euclid's extended algorithm. + */ +Bignum modinv(Bignum number, Bignum modulus) +{ + Bignum a = copybn(modulus); + Bignum b = copybn(number); + Bignum xp = copybn(Zero); + Bignum x = copybn(One); + int sign = +1; + + while (bignum_cmp(b, One) != 0) { + Bignum t = newbn(b[0]); + Bignum q = newbn(a[0]); + bigdivmod(a, b, t, q); + while (t[0] > 1 && t[t[0]] == 0) + t[0]--; + freebn(a); + a = b; + b = t; + t = xp; + xp = x; + x = bigmuladd(q, xp, t); + sign = -sign; + freebn(t); + freebn(q); + } + + freebn(b); + freebn(a); + freebn(xp); + + /* now we know that sign * x == 1, and that x < modulus */ + if (sign < 0) { + /* set a new x to be modulus - x */ + Bignum newx = newbn(modulus[0]); + BignumInt carry = 0; + int maxspot = 1; + int i; + + for (i = 1; i <= (int)newx[0]; i++) { + BignumInt aword = (i <= (int)modulus[0] ? modulus[i] : 0); + BignumInt bword = (i <= (int)x[0] ? x[i] : 0); + newx[i] = aword - bword - carry; + bword = ~bword; + carry = carry ? (newx[i] >= bword) : (newx[i] > bword); + if (newx[i] != 0) + maxspot = i; + } + newx[0] = maxspot; + freebn(x); + x = newx; + } + + /* and return. */ + return x; +} + +/* + * Render a bignum into decimal. Return a malloced string holding + * the decimal representation. + */ +char *bignum_decimal(Bignum x) +{ + int ndigits, ndigit; + int i, iszero; + BignumDblInt carry; + char *ret; + BignumInt *workspace; + + /* + * First, estimate the number of digits. Since log(10)/log(2) + * is just greater than 93/28 (the joys of continued fraction + * approximations...) we know that for every 93 bits, we need + * at most 28 digits. This will tell us how much to malloc. + * + * Formally: if x has i bits, that means x is strictly less + * than 2^i. Since 2 is less than 10^(28/93), this is less than + * 10^(28i/93). We need an integer power of ten, so we must + * round up (rounding down might make it less than x again). + * Therefore if we multiply the bit count by 28/93, rounding + * up, we will have enough digits. + */ + i = bignum_bitcount(x); + ndigits = (28 * i + 92) / 93; /* multiply by 28/93 and round up */ + ndigits++; /* allow for trailing \0 */ + ret = new char[ndigits]; + + /* + * Now allocate some workspace to hold the binary form as we + * repeatedly divide it by ten. Initialise this to the + * big-endian form of the number. + */ + workspace = new BignumInt[x[0]]; + for (i = 0; i < (int)x[0]; i++) + workspace[i] = x[x[0] - i]; + + /* + * Next, write the decimal number starting with the last digit. + * We use ordinary short division, dividing 10 into the + * workspace. + */ + ndigit = ndigits - 1; + ret[ndigit] = '\0'; + do { + iszero = 1; + carry = 0; + for (i = 0; i < (int)x[0]; i++) { + carry = (carry << BIGNUM_INT_BITS) + workspace[i]; + workspace[i] = (BignumInt) (carry / 10); + if (workspace[i]) + iszero = 0; + carry %= 10; + } + ret[--ndigit] = (char) (carry + '0'); + } while (!iszero); + + /* + * There's a chance we've fallen short of the start of the + * string. Correct if so. + */ + if (ndigit > 0) + memmove(ret, ret + ndigit, ndigits - ndigit); + + /* + * Done. + */ + delete [] workspace; + return ret; +} + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ diff --git a/extern/crypto/CryptBn.h b/extern/crypto/CryptBn.h new file mode 100644 index 0000000000..e1d926e151 --- /dev/null +++ b/extern/crypto/CryptBn.h @@ -0,0 +1,93 @@ +#ifndef SSHBN_H +#define SSHBN_H + +#if defined __GNUC__ && defined __i386__ +typedef unsigned long BignumInt; +typedef unsigned long long BignumDblInt; +#define BIGNUM_INT_MASK 0xFFFFFFFFUL +#define BIGNUM_TOP_BIT 0x80000000UL +#define BIGNUM_INT_BITS 32 +#define MUL_WORD(w1, w2) ((BignumDblInt)w1 * w2) +#define DIVMOD_WORD(q, r, hi, lo, w) \ +__asm__("div %2" : \ + "=d" (r), "=a" (q) : \ + "r" (w), "d" (hi), "a" (lo)) +#else +typedef unsigned short BignumInt; +typedef unsigned long BignumDblInt; +#define BIGNUM_INT_MASK 0xFFFFU +#define BIGNUM_TOP_BIT 0x8000U +#define BIGNUM_INT_BITS 16 +#define MUL_WORD(w1, w2) ((BignumDblInt)w1 * w2) +#define DIVMOD_WORD(q, r, hi, lo, w) do { \ + BignumDblInt n = (((BignumDblInt)hi) << BIGNUM_INT_BITS) | lo; \ + q = n / w; \ + r = n % w; \ +} while (0) +#endif + +#define BIGNUM_INT_BYTES (BIGNUM_INT_BITS / 8) +typedef BignumInt *Bignum; + +Bignum copybn(Bignum b); +Bignum bn_power_2(int n); +void bn_restore_invariant(Bignum b); +Bignum bignum_from_long(unsigned long n); +void freebn(Bignum b); +Bignum modpow(Bignum base, Bignum exp, Bignum mod); +Bignum modmul(Bignum a, Bignum b, Bignum mod); +void decbn(Bignum n); +extern Bignum Zero, One; +unsigned char *bignum_to_buffer( const Bignum bn, int *nbytes ); +Bignum bignum_from_buffer(const unsigned char *data, int nbytes); +Bignum bignum_from_bytes(const unsigned char *data, int nbytes); +unsigned char *bignum_to_bytes( const Bignum bn, int *nbytes ); +int ssh1_read_bignum(const unsigned char *data, Bignum * result); +int bignum_bitcount(Bignum bn); +int ssh1_bignum_length(Bignum bn); +int ssh2_bignum_length(Bignum bn); +unsigned char bignum_byte( const Bignum bn, int i ); +int bignum_bit( const Bignum bn, int i ); +void bignum_set_bit(Bignum bn, int i, int value); +int ssh1_write_bignum(void *data, Bignum bn); +Bignum biggcd(Bignum a, Bignum b); +unsigned short bignum_mod_short(Bignum number, unsigned short modulus); +Bignum bignum_add_long(Bignum number, unsigned long addend); +Bignum bigmul(Bignum a, Bignum b); +Bignum bigmuladd(Bignum a, Bignum b, Bignum addend); +Bignum bigdiv(Bignum a, Bignum b); +Bignum bigmod(Bignum a, Bignum b); +Bignum modinv(Bignum number, Bignum modulus); +Bignum bignum_bitmask(Bignum number); +Bignum bignum_rshift(Bignum number, int shift); +int bignum_cmp(Bignum a, Bignum b); +char *bignum_decimal(Bignum x); + +#endif + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ diff --git a/extern/crypto/CryptMD5.cpp b/extern/crypto/CryptMD5.cpp new file mode 100644 index 0000000000..1650062003 --- /dev/null +++ b/extern/crypto/CryptMD5.cpp @@ -0,0 +1,232 @@ +#include "global.h" +#include "CryptMD5.h" + +/* + * MD5 implementation for PuTTY. Written directly from the spec by + * Simon Tatham. + */ + +/* ---------------------------------------------------------------------- + * Core MD5 algorithm: processes 16-word blocks into a message digest. + */ + +#define F(x,y,z) ( ((x) & (y)) | ((~(x)) & (z)) ) +#define G(x,y,z) ( ((x) & (z)) | ((~(z)) & (y)) ) +#define H(x,y,z) ( (x) ^ (y) ^ (z) ) +#define I(x,y,z) ( (y) ^ ( (x) | ~(z) ) ) + +#define rol(x,y) ( ((x) << (y)) | (((uint32_t)x) >> (32-y)) ) + +#define subround(f,w,x,y,z,k,s,ti) \ + w = x + rol(w + f(x,y,z) + block[k] + ti, s) + +static void MD5_Core_Init(MD5_Core_State * s) +{ + s->h[0] = 0x67452301; + s->h[1] = 0xefcdab89; + s->h[2] = 0x98badcfe; + s->h[3] = 0x10325476; +} + +static void MD5_Block(MD5_Core_State * s, uint32_t * block) +{ + uint32_t a, b, c, d; + + a = s->h[0]; + b = s->h[1]; + c = s->h[2]; + d = s->h[3]; + + subround(F, a, b, c, d, 0, 7, 0xd76aa478); + subround(F, d, a, b, c, 1, 12, 0xe8c7b756); + subround(F, c, d, a, b, 2, 17, 0x242070db); + subround(F, b, c, d, a, 3, 22, 0xc1bdceee); + subround(F, a, b, c, d, 4, 7, 0xf57c0faf); + subround(F, d, a, b, c, 5, 12, 0x4787c62a); + subround(F, c, d, a, b, 6, 17, 0xa8304613); + subround(F, b, c, d, a, 7, 22, 0xfd469501); + subround(F, a, b, c, d, 8, 7, 0x698098d8); + subround(F, d, a, b, c, 9, 12, 0x8b44f7af); + subround(F, c, d, a, b, 10, 17, 0xffff5bb1); + subround(F, b, c, d, a, 11, 22, 0x895cd7be); + subround(F, a, b, c, d, 12, 7, 0x6b901122); + subround(F, d, a, b, c, 13, 12, 0xfd987193); + subround(F, c, d, a, b, 14, 17, 0xa679438e); + subround(F, b, c, d, a, 15, 22, 0x49b40821); + subround(G, a, b, c, d, 1, 5, 0xf61e2562); + subround(G, d, a, b, c, 6, 9, 0xc040b340); + subround(G, c, d, a, b, 11, 14, 0x265e5a51); + subround(G, b, c, d, a, 0, 20, 0xe9b6c7aa); + subround(G, a, b, c, d, 5, 5, 0xd62f105d); + subround(G, d, a, b, c, 10, 9, 0x02441453); + subround(G, c, d, a, b, 15, 14, 0xd8a1e681); + subround(G, b, c, d, a, 4, 20, 0xe7d3fbc8); + subround(G, a, b, c, d, 9, 5, 0x21e1cde6); + subround(G, d, a, b, c, 14, 9, 0xc33707d6); + subround(G, c, d, a, b, 3, 14, 0xf4d50d87); + subround(G, b, c, d, a, 8, 20, 0x455a14ed); + subround(G, a, b, c, d, 13, 5, 0xa9e3e905); + subround(G, d, a, b, c, 2, 9, 0xfcefa3f8); + subround(G, c, d, a, b, 7, 14, 0x676f02d9); + subround(G, b, c, d, a, 12, 20, 0x8d2a4c8a); + subround(H, a, b, c, d, 5, 4, 0xfffa3942); + subround(H, d, a, b, c, 8, 11, 0x8771f681); + subround(H, c, d, a, b, 11, 16, 0x6d9d6122); + subround(H, b, c, d, a, 14, 23, 0xfde5380c); + subround(H, a, b, c, d, 1, 4, 0xa4beea44); + subround(H, d, a, b, c, 4, 11, 0x4bdecfa9); + subround(H, c, d, a, b, 7, 16, 0xf6bb4b60); + subround(H, b, c, d, a, 10, 23, 0xbebfbc70); + subround(H, a, b, c, d, 13, 4, 0x289b7ec6); + subround(H, d, a, b, c, 0, 11, 0xeaa127fa); + subround(H, c, d, a, b, 3, 16, 0xd4ef3085); + subround(H, b, c, d, a, 6, 23, 0x04881d05); + subround(H, a, b, c, d, 9, 4, 0xd9d4d039); + subround(H, d, a, b, c, 12, 11, 0xe6db99e5); + subround(H, c, d, a, b, 15, 16, 0x1fa27cf8); + subround(H, b, c, d, a, 2, 23, 0xc4ac5665); + subround(I, a, b, c, d, 0, 6, 0xf4292244); + subround(I, d, a, b, c, 7, 10, 0x432aff97); + subround(I, c, d, a, b, 14, 15, 0xab9423a7); + subround(I, b, c, d, a, 5, 21, 0xfc93a039); + subround(I, a, b, c, d, 12, 6, 0x655b59c3); + subround(I, d, a, b, c, 3, 10, 0x8f0ccc92); + subround(I, c, d, a, b, 10, 15, 0xffeff47d); + subround(I, b, c, d, a, 1, 21, 0x85845dd1); + subround(I, a, b, c, d, 8, 6, 0x6fa87e4f); + subround(I, d, a, b, c, 15, 10, 0xfe2ce6e0); + subround(I, c, d, a, b, 6, 15, 0xa3014314); + subround(I, b, c, d, a, 13, 21, 0x4e0811a1); + subround(I, a, b, c, d, 4, 6, 0xf7537e82); + subround(I, d, a, b, c, 11, 10, 0xbd3af235); + subround(I, c, d, a, b, 2, 15, 0x2ad7d2bb); + subround(I, b, c, d, a, 9, 21, 0xeb86d391); + + s->h[0] += a; + s->h[1] += b; + s->h[2] += c; + s->h[3] += d; +} + +/* ---------------------------------------------------------------------- + * Outer MD5 algorithm: take an arbitrary length byte string, + * convert it into 16-word blocks with the prescribed padding at + * the end, and pass those blocks to the core MD5 algorithm. + */ + +#define BLKSIZE 64 + +void MD5Init(struct MD5Context *s) +{ + MD5_Core_Init(&s->core); + s->blkused = 0; + s->lenhi = s->lenlo = 0; +} + +void MD5Update(struct MD5Context *s, unsigned char const *p, unsigned len) +{ + unsigned char *q = (unsigned char *) p; + uint32_t wordblock[16]; + uint32_t lenw = len; + int i; + + /* + * Update the length field. + */ + s->lenlo += lenw; + s->lenhi += (s->lenlo < lenw); + + if (s->blkused + len < BLKSIZE) { + /* + * Trivial case: just add to the block. + */ + memcpy(s->block + s->blkused, q, len); + s->blkused += len; + } else { + /* + * We must complete and process at least one block. + */ + while (s->blkused + len >= BLKSIZE) { + memcpy(s->block + s->blkused, q, BLKSIZE - s->blkused); + q += BLKSIZE - s->blkused; + len -= BLKSIZE - s->blkused; + /* Now process the block. Gather bytes little-endian into words */ + for (i = 0; i < 16; i++) { + wordblock[i] = + (((uint32_t) s->block[i * 4 + 3]) << 24) | + (((uint32_t) s->block[i * 4 + 2]) << 16) | + (((uint32_t) s->block[i * 4 + 1]) << 8) | + (((uint32_t) s->block[i * 4 + 0]) << 0); + } + MD5_Block(&s->core, wordblock); + s->blkused = 0; + } + memcpy(s->block, q, len); + s->blkused = len; + } +} + +void MD5Final(unsigned char output[16], struct MD5Context *s) +{ + int i; + unsigned pad; + unsigned char c[64]; + uint32_t lenhi, lenlo; + + if (s->blkused >= 56) + pad = 56 + 64 - s->blkused; + else + pad = 56 - s->blkused; + + lenhi = (s->lenhi << 3) | (s->lenlo >> (32 - 3)); + lenlo = (s->lenlo << 3); + + memset(c, 0, pad); + c[0] = 0x80; + MD5Update(s, c, pad); + + c[7] = char((lenhi >> 24) & 0xFF); + c[6] = char((lenhi >> 16) & 0xFF); + c[5] = char((lenhi >> 8) & 0xFF); + c[4] = char((lenhi >> 0) & 0xFF); + c[3] = char((lenlo >> 24) & 0xFF); + c[2] = char((lenlo >> 16) & 0xFF); + c[1] = char((lenlo >> 8) & 0xFF); + c[0] = char((lenlo >> 0) & 0xFF); + + MD5Update(s, c, 8); + + for (i = 0; i < 4; i++) { + output[4 * i + 3] = char((s->core.h[i] >> 24) & 0xFF); + output[4 * i + 2] = char((s->core.h[i] >> 16) & 0xFF); + output[4 * i + 1] = char((s->core.h[i] >> 8) & 0xFF); + output[4 * i + 0] = char((s->core.h[i] >> 0) & 0xFF); + } +} + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ diff --git a/extern/crypto/CryptMD5.h b/extern/crypto/CryptMD5.h new file mode 100644 index 0000000000..661b569ac3 --- /dev/null +++ b/extern/crypto/CryptMD5.h @@ -0,0 +1,46 @@ +#ifndef SSHMD5_H +#define SSHMD5_H + +typedef struct { + uint32_t h[4]; +} MD5_Core_State; + +struct MD5Context { + MD5_Core_State core; + unsigned char block[64]; + int blkused; + uint32_t lenhi, lenlo; +}; + +void MD5Init(struct MD5Context *context); +void MD5Update(struct MD5Context *context, unsigned char const *buf, unsigned len); +void MD5Final(unsigned char digest[16], struct MD5Context *context); + +#endif + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ diff --git a/extern/crypto/CryptNoise.cpp b/extern/crypto/CryptNoise.cpp new file mode 100644 index 0000000000..f65cbe1810 --- /dev/null +++ b/extern/crypto/CryptNoise.cpp @@ -0,0 +1,154 @@ +/* + * Noise generation for PuTTY's cryptographic random number + * generator. + */ + +#include "global.h" + +#if defined(_WINDOWS) +#define _WIN32_WINNT 0x0400 // VC6 header needs this defined. +#include +#include + +/* + * This function is called once, at PuTTY startup, and will do some + * seriously silly things like listing directories and getting disk + * free space and a process snapshot. + */ +void noise_get_heavy(void (*func) (void *, int)) +{ + static HCRYPTPROV hProv = NULL; + if( hProv == NULL ) + { + if( !CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT) ) + { + char buf[1024] = ""; + FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, + 0, GetLastError(), 0, buf, sizeof(buf), NULL); + RageException::Throw( "CryptAcquireContext: %s", buf ); + } + } + + char buf[2048]; + if ( !CryptGenRandom(hProv, sizeof(buf), (BYTE*) buf) ) + RageException::Throw( "CryptGenRandom" ); + + func( buf, sizeof(buf) ); +} + +/* + * This function is called every time the random pool needs + * stirring, and will acquire the system time in all available + * forms and the battery status. + */ +void noise_get_light(void (*func) (void *, int)) +{ + SYSTEMTIME systime; + DWORD adjust[2]; + BOOL rubbish; + + GetSystemTime(&systime); + func(&systime, sizeof(systime)); + + GetSystemTimeAdjustment(&adjust[0], &adjust[1], &rubbish); + func(&adjust, sizeof(adjust)); +} + +#else +#include +#include +#include +#include + +static int read_dev_urandom(char *buf, int len) +{ + int fd; + int ngot, ret; + + fd = open("/dev/urandom", O_RDONLY); + if (fd < 0) + return 0; + + ngot = 0; + while (ngot < len) + { + ret = read(fd, buf+ngot, len-ngot); + if (ret < 0) { + close(fd); + return 0; + } + ngot += ret; + } + + return 1; +} + +/* + * This function is called once, at PuTTY startup. It will do some + * slightly silly things such as fetching an entire process listing + * and scanning /tmp, load the saved random seed from disk, and + * also read 32 bytes out of /dev/urandom. + */ + +void noise_get_heavy(void (*func) (void *, int)) +{ + char buf[512]; + + if (read_dev_urandom(buf, 32)) + func(buf, 32); + +#if defined(UNIX) + FILE *fp; + int ret; + + fp = popen("ps -axu 2>/dev/null", "r"); + while ( (ret = fread(buf, 1, sizeof(buf), fp)) > 0) + func(buf, ret); + pclose(fp); + + fp = popen("ls -al /tmp 2>/dev/null", "r"); + while ( (ret = fread(buf, 1, sizeof(buf), fp)) > 0) + func(buf, ret); + pclose(fp); +#endif +} + +/* + * This function is called every time the random pool needs + * stirring, and will acquire the system time. + */ +void noise_get_light(void (*func) (void *, int)) +{ + struct timeval tv; + gettimeofday(&tv, NULL); + func(&tv, sizeof(tv)); +} + +#endif + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ diff --git a/extern/crypto/CryptPrime.cpp b/extern/crypto/CryptPrime.cpp new file mode 100644 index 0000000000..faacb4b607 --- /dev/null +++ b/extern/crypto/CryptPrime.cpp @@ -0,0 +1,1419 @@ +/* + * Prime generation. + */ +#include "global.h" + +#include "CryptRand.h" +#include "CryptPrime.h" + +/* + * This prime generation algorithm is pretty much cribbed from + * OpenSSL. The algorithm is: + * + * - invent a B-bit random number and ensure the top and bottom + * bits are set (so it's definitely B-bit, and it's definitely + * odd) + * + * - see if it's coprime to all primes below 2^16; increment it by + * two until it is (this shouldn't take long in general) + * + * - perform the Miller-Rabin primality test enough times to + * ensure the probability of it being composite is 2^-80 or + * less + * + * - go back to square one if any M-R test fails. + */ + +/* + * The Miller-Rabin primality test is an extension to the Fermat + * test. The Fermat test just checks that a^(p-1) == 1 mod p; this + * is vulnerable to Carmichael numbers. Miller-Rabin considers how + * that 1 is derived as well. + * + * Lemma: if a^2 == 1 (mod p), and p is prime, then either a == 1 + * or a == -1 (mod p). + * + * Proof: p divides a^2-1, i.e. p divides (a+1)(a-1). Hence, + * since p is prime, either p divides (a+1) or p divides (a-1). + * But this is the same as saying that either a is congruent to + * -1 mod p or a is congruent to +1 mod p. [] + * + * Comment: This fails when p is not prime. Consider p=mn, so + * that mn divides (a+1)(a-1). Now we could have m dividing (a+1) + * and n dividing (a-1), without the whole of mn dividing either. + * For example, consider a=10 and p=99. 99 = 9 * 11; 9 divides + * 10-1 and 11 divides 10+1, so a^2 is congruent to 1 mod p + * without a having to be congruent to either 1 or -1. + * + * So the Miller-Rabin test, as well as considering a^(p-1), + * considers a^((p-1)/2), a^((p-1)/4), and so on as far as it can + * go. In other words. we write p-1 as q * 2^k, with k as large as + * possible (i.e. q must be odd), and we consider the powers + * + * a^(q*2^0) a^(q*2^1) ... a^(q*2^(k-1)) a^(q*2^k) + * i.e. a^((n-1)/2^k) a^((n-1)/2^(k-1)) ... a^((n-1)/2) a^(n-1) + * + * If p is to be prime, the last of these must be 1. Therefore, by + * the above lemma, the one before it must be either 1 or -1. And + * _if_ it's 1, then the one before that must be either 1 or -1, + * and so on ... In other words, we expect to see a trailing chain + * of 1s preceded by a -1. (If we're unlucky, our trailing chain of + * 1s will be as long as the list so we'll never get to see what + * lies before it. This doesn't count as a test failure because it + * hasn't _proved_ that p is not prime.) + * + * For example, consider a=2 and p=1729. 1729 is a Carmichael + * number: although it's not prime, it satisfies a^(p-1) == 1 mod p + * for any a coprime to it. So the Fermat test wouldn't have a + * problem with it at all, unless we happened to stumble on an a + * which had a common factor. + * + * So. 1729 - 1 equals 27 * 2^6. So we look at + * + * 2^27 mod 1729 == 645 + * 2^108 mod 1729 == 1065 + * 2^216 mod 1729 == 1 + * 2^432 mod 1729 == 1 + * 2^864 mod 1729 == 1 + * 2^1728 mod 1729 == 1 + * + * We do have a trailing string of 1s, so the Fermat test would + * have been happy. But this trailing string of 1s is preceded by + * 1065; whereas if 1729 were prime, we'd expect to see it preceded + * by -1 (i.e. 1728.). Guards! Seize this impostor. + * + * (If we were unlucky, we might have tried a=16 instead of a=2; + * now 16^27 mod 1729 == 1, so we would have seen a long string of + * 1s and wouldn't have seen the thing _before_ the 1s. So, just + * like the Fermat test, for a given p there may well exist values + * of a which fail to show up its compositeness. So we try several, + * just like the Fermat test. The difference is that Miller-Rabin + * is not _in general_ fooled by Carmichael numbers.) + * + * Put simply, then, the Miller-Rabin test requires us to: + * + * 1. write p-1 as q * 2^k, with q odd + * 2. compute z = (a^q) mod p. + * 3. report success if z == 1 or z == -1. + * 4. square z at most k-1 times, and report success if it becomes + * -1 at any point. + * 5. report failure otherwise. + * + * (We expect z to become -1 after at most k-1 squarings, because + * if it became -1 after k squarings then a^(p-1) would fail to be + * 1. And we don't need to investigate what happens after we see a + * -1, because we _know_ that -1 squared is 1 modulo anything at + * all, so after we've seen a -1 we can be sure of seeing nothing + * but 1s.) + */ + +/* + * The first few odd primes. + * + * import sys + * def sieve(n): + * z = [] + * list = [] + * for i in range(n): z.append(1) + * for i in range(2,n): + * if z[i]: + * list.append(i) + * for j in range(i,n,i): z[j] = 0 + * return list + * list = sieve(65535) + * for i in list[1:]: sys.stdout.write("%d," % i) + */ +static const unsigned short primes[] = { + 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, + 71, 73, 79, 83, 89, 97, 101, + 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, + 179, 181, 191, 193, + 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, + 277, 281, 283, 293, + 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, + 389, 397, 401, 409, + 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, + 499, 503, 509, 521, + 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, + 617, 619, 631, 641, + 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, + 739, 743, 751, 757, + 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, + 859, 863, 877, 881, + 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, + 991, 997, 1009, + 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, + 1091, 1093, + 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, + 1193, 1201, + 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, + 1291, 1297, + 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, + 1423, 1427, + 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, + 1493, 1499, + 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, + 1601, 1607, + 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, + 1699, 1709, + 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, + 1811, 1823, + 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, + 1931, 1933, + 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, + 2029, 2039, + 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, + 2137, 2141, + 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, + 2267, 2269, + 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, + 2357, 2371, + 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, + 2459, 2467, + 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, + 2593, 2609, + 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, + 2693, 2699, + 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, + 2791, 2797, + 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, + 2903, 2909, + 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, + 3023, 3037, + 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, + 3167, 3169, + 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, + 3271, 3299, + 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, + 3373, 3389, + 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, + 3511, 3517, + 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, + 3607, 3613, + 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, + 3709, 3719, + 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, + 3833, 3847, + 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, + 3931, 3943, + 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, + 4057, 4073, + 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, + 4177, 4201, + 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, + 4283, 4289, + 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, + 4423, 4441, + 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, + 4547, 4549, + 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, + 4657, 4663, + 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, + 4789, 4793, + 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, + 4931, 4933, + 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, + 5011, 5021, + 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, + 5147, 5153, + 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, + 5279, 5281, + 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, + 5413, 5417, + 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, + 5507, 5519, + 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, + 5647, 5651, + 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, + 5743, 5749, + 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, + 5857, 5861, + 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, + 6007, 6011, + 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, + 6121, 6131, + 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, + 6247, 6257, + 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, + 6343, 6353, + 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, + 6473, 6481, + 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, + 6607, 6619, + 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, + 6733, 6737, + 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, + 6857, 6863, + 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, + 6971, 6977, + 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, + 7103, 7109, + 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, + 7229, 7237, + 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, + 7369, 7393, + 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, + 7517, 7523, + 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, + 7603, 7607, + 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, + 7723, 7727, + 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, + 7873, 7877, + 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993, + 8009, 8011, + 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, + 8123, 8147, + 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, + 8263, 8269, + 8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, + 8387, 8389, + 8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513, 8521, 8527, + 8537, 8539, + 8543, 8563, 8573, 8581, 8597, 8599, 8609, 8623, 8627, 8629, 8641, 8647, + 8663, 8669, + 8677, 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, + 8753, 8761, + 8779, 8783, 8803, 8807, 8819, 8821, 8831, 8837, 8839, 8849, 8861, 8863, + 8867, 8887, + 8893, 8923, 8929, 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, + 9011, 9013, + 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, 9127, 9133, 9137, + 9151, 9157, + 9161, 9173, 9181, 9187, 9199, 9203, 9209, 9221, 9227, 9239, 9241, 9257, + 9277, 9281, + 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, 9391, + 9397, 9403, + 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463, 9467, 9473, 9479, + 9491, 9497, + 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, + 9631, 9643, + 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743, 9749, + 9767, 9769, + 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859, + 9871, 9883, + 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973, 10007, + 10009, 10037, + 10039, 10061, 10067, 10069, 10079, 10091, 10093, 10099, 10103, 10111, + 10133, 10139, + 10141, 10151, 10159, 10163, 10169, 10177, 10181, 10193, 10211, 10223, + 10243, 10247, + 10253, 10259, 10267, 10271, 10273, 10289, 10301, 10303, 10313, 10321, + 10331, 10333, + 10337, 10343, 10357, 10369, 10391, 10399, 10427, 10429, 10433, 10453, + 10457, 10459, + 10463, 10477, 10487, 10499, 10501, 10513, 10529, 10531, 10559, 10567, + 10589, 10597, + 10601, 10607, 10613, 10627, 10631, 10639, 10651, 10657, 10663, 10667, + 10687, 10691, + 10709, 10711, 10723, 10729, 10733, 10739, 10753, 10771, 10781, 10789, + 10799, 10831, + 10837, 10847, 10853, 10859, 10861, 10867, 10883, 10889, 10891, 10903, + 10909, 10937, + 10939, 10949, 10957, 10973, 10979, 10987, 10993, 11003, 11027, 11047, + 11057, 11059, + 11069, 11071, 11083, 11087, 11093, 11113, 11117, 11119, 11131, 11149, + 11159, 11161, + 11171, 11173, 11177, 11197, 11213, 11239, 11243, 11251, 11257, 11261, + 11273, 11279, + 11287, 11299, 11311, 11317, 11321, 11329, 11351, 11353, 11369, 11383, + 11393, 11399, + 11411, 11423, 11437, 11443, 11447, 11467, 11471, 11483, 11489, 11491, + 11497, 11503, + 11519, 11527, 11549, 11551, 11579, 11587, 11593, 11597, 11617, 11621, + 11633, 11657, + 11677, 11681, 11689, 11699, 11701, 11717, 11719, 11731, 11743, 11777, + 11779, 11783, + 11789, 11801, 11807, 11813, 11821, 11827, 11831, 11833, 11839, 11863, + 11867, 11887, + 11897, 11903, 11909, 11923, 11927, 11933, 11939, 11941, 11953, 11959, + 11969, 11971, + 11981, 11987, 12007, 12011, 12037, 12041, 12043, 12049, 12071, 12073, + 12097, 12101, + 12107, 12109, 12113, 12119, 12143, 12149, 12157, 12161, 12163, 12197, + 12203, 12211, + 12227, 12239, 12241, 12251, 12253, 12263, 12269, 12277, 12281, 12289, + 12301, 12323, + 12329, 12343, 12347, 12373, 12377, 12379, 12391, 12401, 12409, 12413, + 12421, 12433, + 12437, 12451, 12457, 12473, 12479, 12487, 12491, 12497, 12503, 12511, + 12517, 12527, + 12539, 12541, 12547, 12553, 12569, 12577, 12583, 12589, 12601, 12611, + 12613, 12619, + 12637, 12641, 12647, 12653, 12659, 12671, 12689, 12697, 12703, 12713, + 12721, 12739, + 12743, 12757, 12763, 12781, 12791, 12799, 12809, 12821, 12823, 12829, + 12841, 12853, + 12889, 12893, 12899, 12907, 12911, 12917, 12919, 12923, 12941, 12953, + 12959, 12967, + 12973, 12979, 12983, 13001, 13003, 13007, 13009, 13033, 13037, 13043, + 13049, 13063, + 13093, 13099, 13103, 13109, 13121, 13127, 13147, 13151, 13159, 13163, + 13171, 13177, + 13183, 13187, 13217, 13219, 13229, 13241, 13249, 13259, 13267, 13291, + 13297, 13309, + 13313, 13327, 13331, 13337, 13339, 13367, 13381, 13397, 13399, 13411, + 13417, 13421, + 13441, 13451, 13457, 13463, 13469, 13477, 13487, 13499, 13513, 13523, + 13537, 13553, + 13567, 13577, 13591, 13597, 13613, 13619, 13627, 13633, 13649, 13669, + 13679, 13681, + 13687, 13691, 13693, 13697, 13709, 13711, 13721, 13723, 13729, 13751, + 13757, 13759, + 13763, 13781, 13789, 13799, 13807, 13829, 13831, 13841, 13859, 13873, + 13877, 13879, + 13883, 13901, 13903, 13907, 13913, 13921, 13931, 13933, 13963, 13967, + 13997, 13999, + 14009, 14011, 14029, 14033, 14051, 14057, 14071, 14081, 14083, 14087, + 14107, 14143, + 14149, 14153, 14159, 14173, 14177, 14197, 14207, 14221, 14243, 14249, + 14251, 14281, + 14293, 14303, 14321, 14323, 14327, 14341, 14347, 14369, 14387, 14389, + 14401, 14407, + 14411, 14419, 14423, 14431, 14437, 14447, 14449, 14461, 14479, 14489, + 14503, 14519, + 14533, 14537, 14543, 14549, 14551, 14557, 14561, 14563, 14591, 14593, + 14621, 14627, + 14629, 14633, 14639, 14653, 14657, 14669, 14683, 14699, 14713, 14717, + 14723, 14731, + 14737, 14741, 14747, 14753, 14759, 14767, 14771, 14779, 14783, 14797, + 14813, 14821, + 14827, 14831, 14843, 14851, 14867, 14869, 14879, 14887, 14891, 14897, + 14923, 14929, + 14939, 14947, 14951, 14957, 14969, 14983, 15013, 15017, 15031, 15053, + 15061, 15073, + 15077, 15083, 15091, 15101, 15107, 15121, 15131, 15137, 15139, 15149, + 15161, 15173, + 15187, 15193, 15199, 15217, 15227, 15233, 15241, 15259, 15263, 15269, + 15271, 15277, + 15287, 15289, 15299, 15307, 15313, 15319, 15329, 15331, 15349, 15359, + 15361, 15373, + 15377, 15383, 15391, 15401, 15413, 15427, 15439, 15443, 15451, 15461, + 15467, 15473, + 15493, 15497, 15511, 15527, 15541, 15551, 15559, 15569, 15581, 15583, + 15601, 15607, + 15619, 15629, 15641, 15643, 15647, 15649, 15661, 15667, 15671, 15679, + 15683, 15727, + 15731, 15733, 15737, 15739, 15749, 15761, 15767, 15773, 15787, 15791, + 15797, 15803, + 15809, 15817, 15823, 15859, 15877, 15881, 15887, 15889, 15901, 15907, + 15913, 15919, + 15923, 15937, 15959, 15971, 15973, 15991, 16001, 16007, 16033, 16057, + 16061, 16063, + 16067, 16069, 16073, 16087, 16091, 16097, 16103, 16111, 16127, 16139, + 16141, 16183, + 16187, 16189, 16193, 16217, 16223, 16229, 16231, 16249, 16253, 16267, + 16273, 16301, + 16319, 16333, 16339, 16349, 16361, 16363, 16369, 16381, 16411, 16417, + 16421, 16427, + 16433, 16447, 16451, 16453, 16477, 16481, 16487, 16493, 16519, 16529, + 16547, 16553, + 16561, 16567, 16573, 16603, 16607, 16619, 16631, 16633, 16649, 16651, + 16657, 16661, + 16673, 16691, 16693, 16699, 16703, 16729, 16741, 16747, 16759, 16763, + 16787, 16811, + 16823, 16829, 16831, 16843, 16871, 16879, 16883, 16889, 16901, 16903, + 16921, 16927, + 16931, 16937, 16943, 16963, 16979, 16981, 16987, 16993, 17011, 17021, + 17027, 17029, + 17033, 17041, 17047, 17053, 17077, 17093, 17099, 17107, 17117, 17123, + 17137, 17159, + 17167, 17183, 17189, 17191, 17203, 17207, 17209, 17231, 17239, 17257, + 17291, 17293, + 17299, 17317, 17321, 17327, 17333, 17341, 17351, 17359, 17377, 17383, + 17387, 17389, + 17393, 17401, 17417, 17419, 17431, 17443, 17449, 17467, 17471, 17477, + 17483, 17489, + 17491, 17497, 17509, 17519, 17539, 17551, 17569, 17573, 17579, 17581, + 17597, 17599, + 17609, 17623, 17627, 17657, 17659, 17669, 17681, 17683, 17707, 17713, + 17729, 17737, + 17747, 17749, 17761, 17783, 17789, 17791, 17807, 17827, 17837, 17839, + 17851, 17863, + 17881, 17891, 17903, 17909, 17911, 17921, 17923, 17929, 17939, 17957, + 17959, 17971, + 17977, 17981, 17987, 17989, 18013, 18041, 18043, 18047, 18049, 18059, + 18061, 18077, + 18089, 18097, 18119, 18121, 18127, 18131, 18133, 18143, 18149, 18169, + 18181, 18191, + 18199, 18211, 18217, 18223, 18229, 18233, 18251, 18253, 18257, 18269, + 18287, 18289, + 18301, 18307, 18311, 18313, 18329, 18341, 18353, 18367, 18371, 18379, + 18397, 18401, + 18413, 18427, 18433, 18439, 18443, 18451, 18457, 18461, 18481, 18493, + 18503, 18517, + 18521, 18523, 18539, 18541, 18553, 18583, 18587, 18593, 18617, 18637, + 18661, 18671, + 18679, 18691, 18701, 18713, 18719, 18731, 18743, 18749, 18757, 18773, + 18787, 18793, + 18797, 18803, 18839, 18859, 18869, 18899, 18911, 18913, 18917, 18919, + 18947, 18959, + 18973, 18979, 19001, 19009, 19013, 19031, 19037, 19051, 19069, 19073, + 19079, 19081, + 19087, 19121, 19139, 19141, 19157, 19163, 19181, 19183, 19207, 19211, + 19213, 19219, + 19231, 19237, 19249, 19259, 19267, 19273, 19289, 19301, 19309, 19319, + 19333, 19373, + 19379, 19381, 19387, 19391, 19403, 19417, 19421, 19423, 19427, 19429, + 19433, 19441, + 19447, 19457, 19463, 19469, 19471, 19477, 19483, 19489, 19501, 19507, + 19531, 19541, + 19543, 19553, 19559, 19571, 19577, 19583, 19597, 19603, 19609, 19661, + 19681, 19687, + 19697, 19699, 19709, 19717, 19727, 19739, 19751, 19753, 19759, 19763, + 19777, 19793, + 19801, 19813, 19819, 19841, 19843, 19853, 19861, 19867, 19889, 19891, + 19913, 19919, + 19927, 19937, 19949, 19961, 19963, 19973, 19979, 19991, 19993, 19997, + 20011, 20021, + 20023, 20029, 20047, 20051, 20063, 20071, 20089, 20101, 20107, 20113, + 20117, 20123, + 20129, 20143, 20147, 20149, 20161, 20173, 20177, 20183, 20201, 20219, + 20231, 20233, + 20249, 20261, 20269, 20287, 20297, 20323, 20327, 20333, 20341, 20347, + 20353, 20357, + 20359, 20369, 20389, 20393, 20399, 20407, 20411, 20431, 20441, 20443, + 20477, 20479, + 20483, 20507, 20509, 20521, 20533, 20543, 20549, 20551, 20563, 20593, + 20599, 20611, + 20627, 20639, 20641, 20663, 20681, 20693, 20707, 20717, 20719, 20731, + 20743, 20747, + 20749, 20753, 20759, 20771, 20773, 20789, 20807, 20809, 20849, 20857, + 20873, 20879, + 20887, 20897, 20899, 20903, 20921, 20929, 20939, 20947, 20959, 20963, + 20981, 20983, + 21001, 21011, 21013, 21017, 21019, 21023, 21031, 21059, 21061, 21067, + 21089, 21101, + 21107, 21121, 21139, 21143, 21149, 21157, 21163, 21169, 21179, 21187, + 21191, 21193, + 21211, 21221, 21227, 21247, 21269, 21277, 21283, 21313, 21317, 21319, + 21323, 21341, + 21347, 21377, 21379, 21383, 21391, 21397, 21401, 21407, 21419, 21433, + 21467, 21481, + 21487, 21491, 21493, 21499, 21503, 21517, 21521, 21523, 21529, 21557, + 21559, 21563, + 21569, 21577, 21587, 21589, 21599, 21601, 21611, 21613, 21617, 21647, + 21649, 21661, + 21673, 21683, 21701, 21713, 21727, 21737, 21739, 21751, 21757, 21767, + 21773, 21787, + 21799, 21803, 21817, 21821, 21839, 21841, 21851, 21859, 21863, 21871, + 21881, 21893, + 21911, 21929, 21937, 21943, 21961, 21977, 21991, 21997, 22003, 22013, + 22027, 22031, + 22037, 22039, 22051, 22063, 22067, 22073, 22079, 22091, 22093, 22109, + 22111, 22123, + 22129, 22133, 22147, 22153, 22157, 22159, 22171, 22189, 22193, 22229, + 22247, 22259, + 22271, 22273, 22277, 22279, 22283, 22291, 22303, 22307, 22343, 22349, + 22367, 22369, + 22381, 22391, 22397, 22409, 22433, 22441, 22447, 22453, 22469, 22481, + 22483, 22501, + 22511, 22531, 22541, 22543, 22549, 22567, 22571, 22573, 22613, 22619, + 22621, 22637, + 22639, 22643, 22651, 22669, 22679, 22691, 22697, 22699, 22709, 22717, + 22721, 22727, + 22739, 22741, 22751, 22769, 22777, 22783, 22787, 22807, 22811, 22817, + 22853, 22859, + 22861, 22871, 22877, 22901, 22907, 22921, 22937, 22943, 22961, 22963, + 22973, 22993, + 23003, 23011, 23017, 23021, 23027, 23029, 23039, 23041, 23053, 23057, + 23059, 23063, + 23071, 23081, 23087, 23099, 23117, 23131, 23143, 23159, 23167, 23173, + 23189, 23197, + 23201, 23203, 23209, 23227, 23251, 23269, 23279, 23291, 23293, 23297, + 23311, 23321, + 23327, 23333, 23339, 23357, 23369, 23371, 23399, 23417, 23431, 23447, + 23459, 23473, + 23497, 23509, 23531, 23537, 23539, 23549, 23557, 23561, 23563, 23567, + 23581, 23593, + 23599, 23603, 23609, 23623, 23627, 23629, 23633, 23663, 23669, 23671, + 23677, 23687, + 23689, 23719, 23741, 23743, 23747, 23753, 23761, 23767, 23773, 23789, + 23801, 23813, + 23819, 23827, 23831, 23833, 23857, 23869, 23873, 23879, 23887, 23893, + 23899, 23909, + 23911, 23917, 23929, 23957, 23971, 23977, 23981, 23993, 24001, 24007, + 24019, 24023, + 24029, 24043, 24049, 24061, 24071, 24077, 24083, 24091, 24097, 24103, + 24107, 24109, + 24113, 24121, 24133, 24137, 24151, 24169, 24179, 24181, 24197, 24203, + 24223, 24229, + 24239, 24247, 24251, 24281, 24317, 24329, 24337, 24359, 24371, 24373, + 24379, 24391, + 24407, 24413, 24419, 24421, 24439, 24443, 24469, 24473, 24481, 24499, + 24509, 24517, + 24527, 24533, 24547, 24551, 24571, 24593, 24611, 24623, 24631, 24659, + 24671, 24677, + 24683, 24691, 24697, 24709, 24733, 24749, 24763, 24767, 24781, 24793, + 24799, 24809, + 24821, 24841, 24847, 24851, 24859, 24877, 24889, 24907, 24917, 24919, + 24923, 24943, + 24953, 24967, 24971, 24977, 24979, 24989, 25013, 25031, 25033, 25037, + 25057, 25073, + 25087, 25097, 25111, 25117, 25121, 25127, 25147, 25153, 25163, 25169, + 25171, 25183, + 25189, 25219, 25229, 25237, 25243, 25247, 25253, 25261, 25301, 25303, + 25307, 25309, + 25321, 25339, 25343, 25349, 25357, 25367, 25373, 25391, 25409, 25411, + 25423, 25439, + 25447, 25453, 25457, 25463, 25469, 25471, 25523, 25537, 25541, 25561, + 25577, 25579, + 25583, 25589, 25601, 25603, 25609, 25621, 25633, 25639, 25643, 25657, + 25667, 25673, + 25679, 25693, 25703, 25717, 25733, 25741, 25747, 25759, 25763, 25771, + 25793, 25799, + 25801, 25819, 25841, 25847, 25849, 25867, 25873, 25889, 25903, 25913, + 25919, 25931, + 25933, 25939, 25943, 25951, 25969, 25981, 25997, 25999, 26003, 26017, + 26021, 26029, + 26041, 26053, 26083, 26099, 26107, 26111, 26113, 26119, 26141, 26153, + 26161, 26171, + 26177, 26183, 26189, 26203, 26209, 26227, 26237, 26249, 26251, 26261, + 26263, 26267, + 26293, 26297, 26309, 26317, 26321, 26339, 26347, 26357, 26371, 26387, + 26393, 26399, + 26407, 26417, 26423, 26431, 26437, 26449, 26459, 26479, 26489, 26497, + 26501, 26513, + 26539, 26557, 26561, 26573, 26591, 26597, 26627, 26633, 26641, 26647, + 26669, 26681, + 26683, 26687, 26693, 26699, 26701, 26711, 26713, 26717, 26723, 26729, + 26731, 26737, + 26759, 26777, 26783, 26801, 26813, 26821, 26833, 26839, 26849, 26861, + 26863, 26879, + 26881, 26891, 26893, 26903, 26921, 26927, 26947, 26951, 26953, 26959, + 26981, 26987, + 26993, 27011, 27017, 27031, 27043, 27059, 27061, 27067, 27073, 27077, + 27091, 27103, + 27107, 27109, 27127, 27143, 27179, 27191, 27197, 27211, 27239, 27241, + 27253, 27259, + 27271, 27277, 27281, 27283, 27299, 27329, 27337, 27361, 27367, 27397, + 27407, 27409, + 27427, 27431, 27437, 27449, 27457, 27479, 27481, 27487, 27509, 27527, + 27529, 27539, + 27541, 27551, 27581, 27583, 27611, 27617, 27631, 27647, 27653, 27673, + 27689, 27691, + 27697, 27701, 27733, 27737, 27739, 27743, 27749, 27751, 27763, 27767, + 27773, 27779, + 27791, 27793, 27799, 27803, 27809, 27817, 27823, 27827, 27847, 27851, + 27883, 27893, + 27901, 27917, 27919, 27941, 27943, 27947, 27953, 27961, 27967, 27983, + 27997, 28001, + 28019, 28027, 28031, 28051, 28057, 28069, 28081, 28087, 28097, 28099, + 28109, 28111, + 28123, 28151, 28163, 28181, 28183, 28201, 28211, 28219, 28229, 28277, + 28279, 28283, + 28289, 28297, 28307, 28309, 28319, 28349, 28351, 28387, 28393, 28403, + 28409, 28411, + 28429, 28433, 28439, 28447, 28463, 28477, 28493, 28499, 28513, 28517, + 28537, 28541, + 28547, 28549, 28559, 28571, 28573, 28579, 28591, 28597, 28603, 28607, + 28619, 28621, + 28627, 28631, 28643, 28649, 28657, 28661, 28663, 28669, 28687, 28697, + 28703, 28711, + 28723, 28729, 28751, 28753, 28759, 28771, 28789, 28793, 28807, 28813, + 28817, 28837, + 28843, 28859, 28867, 28871, 28879, 28901, 28909, 28921, 28927, 28933, + 28949, 28961, + 28979, 29009, 29017, 29021, 29023, 29027, 29033, 29059, 29063, 29077, + 29101, 29123, + 29129, 29131, 29137, 29147, 29153, 29167, 29173, 29179, 29191, 29201, + 29207, 29209, + 29221, 29231, 29243, 29251, 29269, 29287, 29297, 29303, 29311, 29327, + 29333, 29339, + 29347, 29363, 29383, 29387, 29389, 29399, 29401, 29411, 29423, 29429, + 29437, 29443, + 29453, 29473, 29483, 29501, 29527, 29531, 29537, 29567, 29569, 29573, + 29581, 29587, + 29599, 29611, 29629, 29633, 29641, 29663, 29669, 29671, 29683, 29717, + 29723, 29741, + 29753, 29759, 29761, 29789, 29803, 29819, 29833, 29837, 29851, 29863, + 29867, 29873, + 29879, 29881, 29917, 29921, 29927, 29947, 29959, 29983, 29989, 30011, + 30013, 30029, + 30047, 30059, 30071, 30089, 30091, 30097, 30103, 30109, 30113, 30119, + 30133, 30137, + 30139, 30161, 30169, 30181, 30187, 30197, 30203, 30211, 30223, 30241, + 30253, 30259, + 30269, 30271, 30293, 30307, 30313, 30319, 30323, 30341, 30347, 30367, + 30389, 30391, + 30403, 30427, 30431, 30449, 30467, 30469, 30491, 30493, 30497, 30509, + 30517, 30529, + 30539, 30553, 30557, 30559, 30577, 30593, 30631, 30637, 30643, 30649, + 30661, 30671, + 30677, 30689, 30697, 30703, 30707, 30713, 30727, 30757, 30763, 30773, + 30781, 30803, + 30809, 30817, 30829, 30839, 30841, 30851, 30853, 30859, 30869, 30871, + 30881, 30893, + 30911, 30931, 30937, 30941, 30949, 30971, 30977, 30983, 31013, 31019, + 31033, 31039, + 31051, 31063, 31069, 31079, 31081, 31091, 31121, 31123, 31139, 31147, + 31151, 31153, + 31159, 31177, 31181, 31183, 31189, 31193, 31219, 31223, 31231, 31237, + 31247, 31249, + 31253, 31259, 31267, 31271, 31277, 31307, 31319, 31321, 31327, 31333, + 31337, 31357, + 31379, 31387, 31391, 31393, 31397, 31469, 31477, 31481, 31489, 31511, + 31513, 31517, + 31531, 31541, 31543, 31547, 31567, 31573, 31583, 31601, 31607, 31627, + 31643, 31649, + 31657, 31663, 31667, 31687, 31699, 31721, 31723, 31727, 31729, 31741, + 31751, 31769, + 31771, 31793, 31799, 31817, 31847, 31849, 31859, 31873, 31883, 31891, + 31907, 31957, + 31963, 31973, 31981, 31991, 32003, 32009, 32027, 32029, 32051, 32057, + 32059, 32063, + 32069, 32077, 32083, 32089, 32099, 32117, 32119, 32141, 32143, 32159, + 32173, 32183, + 32189, 32191, 32203, 32213, 32233, 32237, 32251, 32257, 32261, 32297, + 32299, 32303, + 32309, 32321, 32323, 32327, 32341, 32353, 32359, 32363, 32369, 32371, + 32377, 32381, + 32401, 32411, 32413, 32423, 32429, 32441, 32443, 32467, 32479, 32491, + 32497, 32503, + 32507, 32531, 32533, 32537, 32561, 32563, 32569, 32573, 32579, 32587, + 32603, 32609, + 32611, 32621, 32633, 32647, 32653, 32687, 32693, 32707, 32713, 32717, + 32719, 32749, + 32771, 32779, 32783, 32789, 32797, 32801, 32803, 32831, 32833, 32839, + 32843, 32869, + 32887, 32909, 32911, 32917, 32933, 32939, 32941, 32957, 32969, 32971, + 32983, 32987, + 32993, 32999, 33013, 33023, 33029, 33037, 33049, 33053, 33071, 33073, + 33083, 33091, + 33107, 33113, 33119, 33149, 33151, 33161, 33179, 33181, 33191, 33199, + 33203, 33211, + 33223, 33247, 33287, 33289, 33301, 33311, 33317, 33329, 33331, 33343, + 33347, 33349, + 33353, 33359, 33377, 33391, 33403, 33409, 33413, 33427, 33457, 33461, + 33469, 33479, + 33487, 33493, 33503, 33521, 33529, 33533, 33547, 33563, 33569, 33577, + 33581, 33587, + 33589, 33599, 33601, 33613, 33617, 33619, 33623, 33629, 33637, 33641, + 33647, 33679, + 33703, 33713, 33721, 33739, 33749, 33751, 33757, 33767, 33769, 33773, + 33791, 33797, + 33809, 33811, 33827, 33829, 33851, 33857, 33863, 33871, 33889, 33893, + 33911, 33923, + 33931, 33937, 33941, 33961, 33967, 33997, 34019, 34031, 34033, 34039, + 34057, 34061, + 34123, 34127, 34129, 34141, 34147, 34157, 34159, 34171, 34183, 34211, + 34213, 34217, + 34231, 34253, 34259, 34261, 34267, 34273, 34283, 34297, 34301, 34303, + 34313, 34319, + 34327, 34337, 34351, 34361, 34367, 34369, 34381, 34403, 34421, 34429, + 34439, 34457, + 34469, 34471, 34483, 34487, 34499, 34501, 34511, 34513, 34519, 34537, + 34543, 34549, + 34583, 34589, 34591, 34603, 34607, 34613, 34631, 34649, 34651, 34667, + 34673, 34679, + 34687, 34693, 34703, 34721, 34729, 34739, 34747, 34757, 34759, 34763, + 34781, 34807, + 34819, 34841, 34843, 34847, 34849, 34871, 34877, 34883, 34897, 34913, + 34919, 34939, + 34949, 34961, 34963, 34981, 35023, 35027, 35051, 35053, 35059, 35069, + 35081, 35083, + 35089, 35099, 35107, 35111, 35117, 35129, 35141, 35149, 35153, 35159, + 35171, 35201, + 35221, 35227, 35251, 35257, 35267, 35279, 35281, 35291, 35311, 35317, + 35323, 35327, + 35339, 35353, 35363, 35381, 35393, 35401, 35407, 35419, 35423, 35437, + 35447, 35449, + 35461, 35491, 35507, 35509, 35521, 35527, 35531, 35533, 35537, 35543, + 35569, 35573, + 35591, 35593, 35597, 35603, 35617, 35671, 35677, 35729, 35731, 35747, + 35753, 35759, + 35771, 35797, 35801, 35803, 35809, 35831, 35837, 35839, 35851, 35863, + 35869, 35879, + 35897, 35899, 35911, 35923, 35933, 35951, 35963, 35969, 35977, 35983, + 35993, 35999, + 36007, 36011, 36013, 36017, 36037, 36061, 36067, 36073, 36083, 36097, + 36107, 36109, + 36131, 36137, 36151, 36161, 36187, 36191, 36209, 36217, 36229, 36241, + 36251, 36263, + 36269, 36277, 36293, 36299, 36307, 36313, 36319, 36341, 36343, 36353, + 36373, 36383, + 36389, 36433, 36451, 36457, 36467, 36469, 36473, 36479, 36493, 36497, + 36523, 36527, + 36529, 36541, 36551, 36559, 36563, 36571, 36583, 36587, 36599, 36607, + 36629, 36637, + 36643, 36653, 36671, 36677, 36683, 36691, 36697, 36709, 36713, 36721, + 36739, 36749, + 36761, 36767, 36779, 36781, 36787, 36791, 36793, 36809, 36821, 36833, + 36847, 36857, + 36871, 36877, 36887, 36899, 36901, 36913, 36919, 36923, 36929, 36931, + 36943, 36947, + 36973, 36979, 36997, 37003, 37013, 37019, 37021, 37039, 37049, 37057, + 37061, 37087, + 37097, 37117, 37123, 37139, 37159, 37171, 37181, 37189, 37199, 37201, + 37217, 37223, + 37243, 37253, 37273, 37277, 37307, 37309, 37313, 37321, 37337, 37339, + 37357, 37361, + 37363, 37369, 37379, 37397, 37409, 37423, 37441, 37447, 37463, 37483, + 37489, 37493, + 37501, 37507, 37511, 37517, 37529, 37537, 37547, 37549, 37561, 37567, + 37571, 37573, + 37579, 37589, 37591, 37607, 37619, 37633, 37643, 37649, 37657, 37663, + 37691, 37693, + 37699, 37717, 37747, 37781, 37783, 37799, 37811, 37813, 37831, 37847, + 37853, 37861, + 37871, 37879, 37889, 37897, 37907, 37951, 37957, 37963, 37967, 37987, + 37991, 37993, + 37997, 38011, 38039, 38047, 38053, 38069, 38083, 38113, 38119, 38149, + 38153, 38167, + 38177, 38183, 38189, 38197, 38201, 38219, 38231, 38237, 38239, 38261, + 38273, 38281, + 38287, 38299, 38303, 38317, 38321, 38327, 38329, 38333, 38351, 38371, + 38377, 38393, + 38431, 38447, 38449, 38453, 38459, 38461, 38501, 38543, 38557, 38561, + 38567, 38569, + 38593, 38603, 38609, 38611, 38629, 38639, 38651, 38653, 38669, 38671, + 38677, 38693, + 38699, 38707, 38711, 38713, 38723, 38729, 38737, 38747, 38749, 38767, + 38783, 38791, + 38803, 38821, 38833, 38839, 38851, 38861, 38867, 38873, 38891, 38903, + 38917, 38921, + 38923, 38933, 38953, 38959, 38971, 38977, 38993, 39019, 39023, 39041, + 39043, 39047, + 39079, 39089, 39097, 39103, 39107, 39113, 39119, 39133, 39139, 39157, + 39161, 39163, + 39181, 39191, 39199, 39209, 39217, 39227, 39229, 39233, 39239, 39241, + 39251, 39293, + 39301, 39313, 39317, 39323, 39341, 39343, 39359, 39367, 39371, 39373, + 39383, 39397, + 39409, 39419, 39439, 39443, 39451, 39461, 39499, 39503, 39509, 39511, + 39521, 39541, + 39551, 39563, 39569, 39581, 39607, 39619, 39623, 39631, 39659, 39667, + 39671, 39679, + 39703, 39709, 39719, 39727, 39733, 39749, 39761, 39769, 39779, 39791, + 39799, 39821, + 39827, 39829, 39839, 39841, 39847, 39857, 39863, 39869, 39877, 39883, + 39887, 39901, + 39929, 39937, 39953, 39971, 39979, 39983, 39989, 40009, 40013, 40031, + 40037, 40039, + 40063, 40087, 40093, 40099, 40111, 40123, 40127, 40129, 40151, 40153, + 40163, 40169, + 40177, 40189, 40193, 40213, 40231, 40237, 40241, 40253, 40277, 40283, + 40289, 40343, + 40351, 40357, 40361, 40387, 40423, 40427, 40429, 40433, 40459, 40471, + 40483, 40487, + 40493, 40499, 40507, 40519, 40529, 40531, 40543, 40559, 40577, 40583, + 40591, 40597, + 40609, 40627, 40637, 40639, 40693, 40697, 40699, 40709, 40739, 40751, + 40759, 40763, + 40771, 40787, 40801, 40813, 40819, 40823, 40829, 40841, 40847, 40849, + 40853, 40867, + 40879, 40883, 40897, 40903, 40927, 40933, 40939, 40949, 40961, 40973, + 40993, 41011, + 41017, 41023, 41039, 41047, 41051, 41057, 41077, 41081, 41113, 41117, + 41131, 41141, + 41143, 41149, 41161, 41177, 41179, 41183, 41189, 41201, 41203, 41213, + 41221, 41227, + 41231, 41233, 41243, 41257, 41263, 41269, 41281, 41299, 41333, 41341, + 41351, 41357, + 41381, 41387, 41389, 41399, 41411, 41413, 41443, 41453, 41467, 41479, + 41491, 41507, + 41513, 41519, 41521, 41539, 41543, 41549, 41579, 41593, 41597, 41603, + 41609, 41611, + 41617, 41621, 41627, 41641, 41647, 41651, 41659, 41669, 41681, 41687, + 41719, 41729, + 41737, 41759, 41761, 41771, 41777, 41801, 41809, 41813, 41843, 41849, + 41851, 41863, + 41879, 41887, 41893, 41897, 41903, 41911, 41927, 41941, 41947, 41953, + 41957, 41959, + 41969, 41981, 41983, 41999, 42013, 42017, 42019, 42023, 42043, 42061, + 42071, 42073, + 42083, 42089, 42101, 42131, 42139, 42157, 42169, 42179, 42181, 42187, + 42193, 42197, + 42209, 42221, 42223, 42227, 42239, 42257, 42281, 42283, 42293, 42299, + 42307, 42323, + 42331, 42337, 42349, 42359, 42373, 42379, 42391, 42397, 42403, 42407, + 42409, 42433, + 42437, 42443, 42451, 42457, 42461, 42463, 42467, 42473, 42487, 42491, + 42499, 42509, + 42533, 42557, 42569, 42571, 42577, 42589, 42611, 42641, 42643, 42649, + 42667, 42677, + 42683, 42689, 42697, 42701, 42703, 42709, 42719, 42727, 42737, 42743, + 42751, 42767, + 42773, 42787, 42793, 42797, 42821, 42829, 42839, 42841, 42853, 42859, + 42863, 42899, + 42901, 42923, 42929, 42937, 42943, 42953, 42961, 42967, 42979, 42989, + 43003, 43013, + 43019, 43037, 43049, 43051, 43063, 43067, 43093, 43103, 43117, 43133, + 43151, 43159, + 43177, 43189, 43201, 43207, 43223, 43237, 43261, 43271, 43283, 43291, + 43313, 43319, + 43321, 43331, 43391, 43397, 43399, 43403, 43411, 43427, 43441, 43451, + 43457, 43481, + 43487, 43499, 43517, 43541, 43543, 43573, 43577, 43579, 43591, 43597, + 43607, 43609, + 43613, 43627, 43633, 43649, 43651, 43661, 43669, 43691, 43711, 43717, + 43721, 43753, + 43759, 43777, 43781, 43783, 43787, 43789, 43793, 43801, 43853, 43867, + 43889, 43891, + 43913, 43933, 43943, 43951, 43961, 43963, 43969, 43973, 43987, 43991, + 43997, 44017, + 44021, 44027, 44029, 44041, 44053, 44059, 44071, 44087, 44089, 44101, + 44111, 44119, + 44123, 44129, 44131, 44159, 44171, 44179, 44189, 44201, 44203, 44207, + 44221, 44249, + 44257, 44263, 44267, 44269, 44273, 44279, 44281, 44293, 44351, 44357, + 44371, 44381, + 44383, 44389, 44417, 44449, 44453, 44483, 44491, 44497, 44501, 44507, + 44519, 44531, + 44533, 44537, 44543, 44549, 44563, 44579, 44587, 44617, 44621, 44623, + 44633, 44641, + 44647, 44651, 44657, 44683, 44687, 44699, 44701, 44711, 44729, 44741, + 44753, 44771, + 44773, 44777, 44789, 44797, 44809, 44819, 44839, 44843, 44851, 44867, + 44879, 44887, + 44893, 44909, 44917, 44927, 44939, 44953, 44959, 44963, 44971, 44983, + 44987, 45007, + 45013, 45053, 45061, 45077, 45083, 45119, 45121, 45127, 45131, 45137, + 45139, 45161, + 45179, 45181, 45191, 45197, 45233, 45247, 45259, 45263, 45281, 45289, + 45293, 45307, + 45317, 45319, 45329, 45337, 45341, 45343, 45361, 45377, 45389, 45403, + 45413, 45427, + 45433, 45439, 45481, 45491, 45497, 45503, 45523, 45533, 45541, 45553, + 45557, 45569, + 45587, 45589, 45599, 45613, 45631, 45641, 45659, 45667, 45673, 45677, + 45691, 45697, + 45707, 45737, 45751, 45757, 45763, 45767, 45779, 45817, 45821, 45823, + 45827, 45833, + 45841, 45853, 45863, 45869, 45887, 45893, 45943, 45949, 45953, 45959, + 45971, 45979, + 45989, 46021, 46027, 46049, 46051, 46061, 46073, 46091, 46093, 46099, + 46103, 46133, + 46141, 46147, 46153, 46171, 46181, 46183, 46187, 46199, 46219, 46229, + 46237, 46261, + 46271, 46273, 46279, 46301, 46307, 46309, 46327, 46337, 46349, 46351, + 46381, 46399, + 46411, 46439, 46441, 46447, 46451, 46457, 46471, 46477, 46489, 46499, + 46507, 46511, + 46523, 46549, 46559, 46567, 46573, 46589, 46591, 46601, 46619, 46633, + 46639, 46643, + 46649, 46663, 46679, 46681, 46687, 46691, 46703, 46723, 46727, 46747, + 46751, 46757, + 46769, 46771, 46807, 46811, 46817, 46819, 46829, 46831, 46853, 46861, + 46867, 46877, + 46889, 46901, 46919, 46933, 46957, 46993, 46997, 47017, 47041, 47051, + 47057, 47059, + 47087, 47093, 47111, 47119, 47123, 47129, 47137, 47143, 47147, 47149, + 47161, 47189, + 47207, 47221, 47237, 47251, 47269, 47279, 47287, 47293, 47297, 47303, + 47309, 47317, + 47339, 47351, 47353, 47363, 47381, 47387, 47389, 47407, 47417, 47419, + 47431, 47441, + 47459, 47491, 47497, 47501, 47507, 47513, 47521, 47527, 47533, 47543, + 47563, 47569, + 47581, 47591, 47599, 47609, 47623, 47629, 47639, 47653, 47657, 47659, + 47681, 47699, + 47701, 47711, 47713, 47717, 47737, 47741, 47743, 47777, 47779, 47791, + 47797, 47807, + 47809, 47819, 47837, 47843, 47857, 47869, 47881, 47903, 47911, 47917, + 47933, 47939, + 47947, 47951, 47963, 47969, 47977, 47981, 48017, 48023, 48029, 48049, + 48073, 48079, + 48091, 48109, 48119, 48121, 48131, 48157, 48163, 48179, 48187, 48193, + 48197, 48221, + 48239, 48247, 48259, 48271, 48281, 48299, 48311, 48313, 48337, 48341, + 48353, 48371, + 48383, 48397, 48407, 48409, 48413, 48437, 48449, 48463, 48473, 48479, + 48481, 48487, + 48491, 48497, 48523, 48527, 48533, 48539, 48541, 48563, 48571, 48589, + 48593, 48611, + 48619, 48623, 48647, 48649, 48661, 48673, 48677, 48679, 48731, 48733, + 48751, 48757, + 48761, 48767, 48779, 48781, 48787, 48799, 48809, 48817, 48821, 48823, + 48847, 48857, + 48859, 48869, 48871, 48883, 48889, 48907, 48947, 48953, 48973, 48989, + 48991, 49003, + 49009, 49019, 49031, 49033, 49037, 49043, 49057, 49069, 49081, 49103, + 49109, 49117, + 49121, 49123, 49139, 49157, 49169, 49171, 49177, 49193, 49199, 49201, + 49207, 49211, + 49223, 49253, 49261, 49277, 49279, 49297, 49307, 49331, 49333, 49339, + 49363, 49367, + 49369, 49391, 49393, 49409, 49411, 49417, 49429, 49433, 49451, 49459, + 49463, 49477, + 49481, 49499, 49523, 49529, 49531, 49537, 49547, 49549, 49559, 49597, + 49603, 49613, + 49627, 49633, 49639, 49663, 49667, 49669, 49681, 49697, 49711, 49727, + 49739, 49741, + 49747, 49757, 49783, 49787, 49789, 49801, 49807, 49811, 49823, 49831, + 49843, 49853, + 49871, 49877, 49891, 49919, 49921, 49927, 49937, 49939, 49943, 49957, + 49991, 49993, + 49999, 50021, 50023, 50033, 50047, 50051, 50053, 50069, 50077, 50087, + 50093, 50101, + 50111, 50119, 50123, 50129, 50131, 50147, 50153, 50159, 50177, 50207, + 50221, 50227, + 50231, 50261, 50263, 50273, 50287, 50291, 50311, 50321, 50329, 50333, + 50341, 50359, + 50363, 50377, 50383, 50387, 50411, 50417, 50423, 50441, 50459, 50461, + 50497, 50503, + 50513, 50527, 50539, 50543, 50549, 50551, 50581, 50587, 50591, 50593, + 50599, 50627, + 50647, 50651, 50671, 50683, 50707, 50723, 50741, 50753, 50767, 50773, + 50777, 50789, + 50821, 50833, 50839, 50849, 50857, 50867, 50873, 50891, 50893, 50909, + 50923, 50929, + 50951, 50957, 50969, 50971, 50989, 50993, 51001, 51031, 51043, 51047, + 51059, 51061, + 51071, 51109, 51131, 51133, 51137, 51151, 51157, 51169, 51193, 51197, + 51199, 51203, + 51217, 51229, 51239, 51241, 51257, 51263, 51283, 51287, 51307, 51329, + 51341, 51343, + 51347, 51349, 51361, 51383, 51407, 51413, 51419, 51421, 51427, 51431, + 51437, 51439, + 51449, 51461, 51473, 51479, 51481, 51487, 51503, 51511, 51517, 51521, + 51539, 51551, + 51563, 51577, 51581, 51593, 51599, 51607, 51613, 51631, 51637, 51647, + 51659, 51673, + 51679, 51683, 51691, 51713, 51719, 51721, 51749, 51767, 51769, 51787, + 51797, 51803, + 51817, 51827, 51829, 51839, 51853, 51859, 51869, 51871, 51893, 51899, + 51907, 51913, + 51929, 51941, 51949, 51971, 51973, 51977, 51991, 52009, 52021, 52027, + 52051, 52057, + 52067, 52069, 52081, 52103, 52121, 52127, 52147, 52153, 52163, 52177, + 52181, 52183, + 52189, 52201, 52223, 52237, 52249, 52253, 52259, 52267, 52289, 52291, + 52301, 52313, + 52321, 52361, 52363, 52369, 52379, 52387, 52391, 52433, 52453, 52457, + 52489, 52501, + 52511, 52517, 52529, 52541, 52543, 52553, 52561, 52567, 52571, 52579, + 52583, 52609, + 52627, 52631, 52639, 52667, 52673, 52691, 52697, 52709, 52711, 52721, + 52727, 52733, + 52747, 52757, 52769, 52783, 52807, 52813, 52817, 52837, 52859, 52861, + 52879, 52883, + 52889, 52901, 52903, 52919, 52937, 52951, 52957, 52963, 52967, 52973, + 52981, 52999, + 53003, 53017, 53047, 53051, 53069, 53077, 53087, 53089, 53093, 53101, + 53113, 53117, + 53129, 53147, 53149, 53161, 53171, 53173, 53189, 53197, 53201, 53231, + 53233, 53239, + 53267, 53269, 53279, 53281, 53299, 53309, 53323, 53327, 53353, 53359, + 53377, 53381, + 53401, 53407, 53411, 53419, 53437, 53441, 53453, 53479, 53503, 53507, + 53527, 53549, + 53551, 53569, 53591, 53593, 53597, 53609, 53611, 53617, 53623, 53629, + 53633, 53639, + 53653, 53657, 53681, 53693, 53699, 53717, 53719, 53731, 53759, 53773, + 53777, 53783, + 53791, 53813, 53819, 53831, 53849, 53857, 53861, 53881, 53887, 53891, + 53897, 53899, + 53917, 53923, 53927, 53939, 53951, 53959, 53987, 53993, 54001, 54011, + 54013, 54037, + 54049, 54059, 54083, 54091, 54101, 54121, 54133, 54139, 54151, 54163, + 54167, 54181, + 54193, 54217, 54251, 54269, 54277, 54287, 54293, 54311, 54319, 54323, + 54331, 54347, + 54361, 54367, 54371, 54377, 54401, 54403, 54409, 54413, 54419, 54421, + 54437, 54443, + 54449, 54469, 54493, 54497, 54499, 54503, 54517, 54521, 54539, 54541, + 54547, 54559, + 54563, 54577, 54581, 54583, 54601, 54617, 54623, 54629, 54631, 54647, + 54667, 54673, + 54679, 54709, 54713, 54721, 54727, 54751, 54767, 54773, 54779, 54787, + 54799, 54829, + 54833, 54851, 54869, 54877, 54881, 54907, 54917, 54919, 54941, 54949, + 54959, 54973, + 54979, 54983, 55001, 55009, 55021, 55049, 55051, 55057, 55061, 55073, + 55079, 55103, + 55109, 55117, 55127, 55147, 55163, 55171, 55201, 55207, 55213, 55217, + 55219, 55229, + 55243, 55249, 55259, 55291, 55313, 55331, 55333, 55337, 55339, 55343, + 55351, 55373, + 55381, 55399, 55411, 55439, 55441, 55457, 55469, 55487, 55501, 55511, + 55529, 55541, + 55547, 55579, 55589, 55603, 55609, 55619, 55621, 55631, 55633, 55639, + 55661, 55663, + 55667, 55673, 55681, 55691, 55697, 55711, 55717, 55721, 55733, 55763, + 55787, 55793, + 55799, 55807, 55813, 55817, 55819, 55823, 55829, 55837, 55843, 55849, + 55871, 55889, + 55897, 55901, 55903, 55921, 55927, 55931, 55933, 55949, 55967, 55987, + 55997, 56003, + 56009, 56039, 56041, 56053, 56081, 56087, 56093, 56099, 56101, 56113, + 56123, 56131, + 56149, 56167, 56171, 56179, 56197, 56207, 56209, 56237, 56239, 56249, + 56263, 56267, + 56269, 56299, 56311, 56333, 56359, 56369, 56377, 56383, 56393, 56401, + 56417, 56431, + 56437, 56443, 56453, 56467, 56473, 56477, 56479, 56489, 56501, 56503, + 56509, 56519, + 56527, 56531, 56533, 56543, 56569, 56591, 56597, 56599, 56611, 56629, + 56633, 56659, + 56663, 56671, 56681, 56687, 56701, 56711, 56713, 56731, 56737, 56747, + 56767, 56773, + 56779, 56783, 56807, 56809, 56813, 56821, 56827, 56843, 56857, 56873, + 56891, 56893, + 56897, 56909, 56911, 56921, 56923, 56929, 56941, 56951, 56957, 56963, + 56983, 56989, + 56993, 56999, 57037, 57041, 57047, 57059, 57073, 57077, 57089, 57097, + 57107, 57119, + 57131, 57139, 57143, 57149, 57163, 57173, 57179, 57191, 57193, 57203, + 57221, 57223, + 57241, 57251, 57259, 57269, 57271, 57283, 57287, 57301, 57329, 57331, + 57347, 57349, + 57367, 57373, 57383, 57389, 57397, 57413, 57427, 57457, 57467, 57487, + 57493, 57503, + 57527, 57529, 57557, 57559, 57571, 57587, 57593, 57601, 57637, 57641, + 57649, 57653, + 57667, 57679, 57689, 57697, 57709, 57713, 57719, 57727, 57731, 57737, + 57751, 57773, + 57781, 57787, 57791, 57793, 57803, 57809, 57829, 57839, 57847, 57853, + 57859, 57881, + 57899, 57901, 57917, 57923, 57943, 57947, 57973, 57977, 57991, 58013, + 58027, 58031, + 58043, 58049, 58057, 58061, 58067, 58073, 58099, 58109, 58111, 58129, + 58147, 58151, + 58153, 58169, 58171, 58189, 58193, 58199, 58207, 58211, 58217, 58229, + 58231, 58237, + 58243, 58271, 58309, 58313, 58321, 58337, 58363, 58367, 58369, 58379, + 58391, 58393, + 58403, 58411, 58417, 58427, 58439, 58441, 58451, 58453, 58477, 58481, + 58511, 58537, + 58543, 58549, 58567, 58573, 58579, 58601, 58603, 58613, 58631, 58657, + 58661, 58679, + 58687, 58693, 58699, 58711, 58727, 58733, 58741, 58757, 58763, 58771, + 58787, 58789, + 58831, 58889, 58897, 58901, 58907, 58909, 58913, 58921, 58937, 58943, + 58963, 58967, + 58979, 58991, 58997, 59009, 59011, 59021, 59023, 59029, 59051, 59053, + 59063, 59069, + 59077, 59083, 59093, 59107, 59113, 59119, 59123, 59141, 59149, 59159, + 59167, 59183, + 59197, 59207, 59209, 59219, 59221, 59233, 59239, 59243, 59263, 59273, + 59281, 59333, + 59341, 59351, 59357, 59359, 59369, 59377, 59387, 59393, 59399, 59407, + 59417, 59419, + 59441, 59443, 59447, 59453, 59467, 59471, 59473, 59497, 59509, 59513, + 59539, 59557, + 59561, 59567, 59581, 59611, 59617, 59621, 59627, 59629, 59651, 59659, + 59663, 59669, + 59671, 59693, 59699, 59707, 59723, 59729, 59743, 59747, 59753, 59771, + 59779, 59791, + 59797, 59809, 59833, 59863, 59879, 59887, 59921, 59929, 59951, 59957, + 59971, 59981, + 59999, 60013, 60017, 60029, 60037, 60041, 60077, 60083, 60089, 60091, + 60101, 60103, + 60107, 60127, 60133, 60139, 60149, 60161, 60167, 60169, 60209, 60217, + 60223, 60251, + 60257, 60259, 60271, 60289, 60293, 60317, 60331, 60337, 60343, 60353, + 60373, 60383, + 60397, 60413, 60427, 60443, 60449, 60457, 60493, 60497, 60509, 60521, + 60527, 60539, + 60589, 60601, 60607, 60611, 60617, 60623, 60631, 60637, 60647, 60649, + 60659, 60661, + 60679, 60689, 60703, 60719, 60727, 60733, 60737, 60757, 60761, 60763, + 60773, 60779, + 60793, 60811, 60821, 60859, 60869, 60887, 60889, 60899, 60901, 60913, + 60917, 60919, + 60923, 60937, 60943, 60953, 60961, 61001, 61007, 61027, 61031, 61043, + 61051, 61057, + 61091, 61099, 61121, 61129, 61141, 61151, 61153, 61169, 61211, 61223, + 61231, 61253, + 61261, 61283, 61291, 61297, 61331, 61333, 61339, 61343, 61357, 61363, + 61379, 61381, + 61403, 61409, 61417, 61441, 61463, 61469, 61471, 61483, 61487, 61493, + 61507, 61511, + 61519, 61543, 61547, 61553, 61559, 61561, 61583, 61603, 61609, 61613, + 61627, 61631, + 61637, 61643, 61651, 61657, 61667, 61673, 61681, 61687, 61703, 61717, + 61723, 61729, + 61751, 61757, 61781, 61813, 61819, 61837, 61843, 61861, 61871, 61879, + 61909, 61927, + 61933, 61949, 61961, 61967, 61979, 61981, 61987, 61991, 62003, 62011, + 62017, 62039, + 62047, 62053, 62057, 62071, 62081, 62099, 62119, 62129, 62131, 62137, + 62141, 62143, + 62171, 62189, 62191, 62201, 62207, 62213, 62219, 62233, 62273, 62297, + 62299, 62303, + 62311, 62323, 62327, 62347, 62351, 62383, 62401, 62417, 62423, 62459, + 62467, 62473, + 62477, 62483, 62497, 62501, 62507, 62533, 62539, 62549, 62563, 62581, + 62591, 62597, + 62603, 62617, 62627, 62633, 62639, 62653, 62659, 62683, 62687, 62701, + 62723, 62731, + 62743, 62753, 62761, 62773, 62791, 62801, 62819, 62827, 62851, 62861, + 62869, 62873, + 62897, 62903, 62921, 62927, 62929, 62939, 62969, 62971, 62981, 62983, + 62987, 62989, + 63029, 63031, 63059, 63067, 63073, 63079, 63097, 63103, 63113, 63127, + 63131, 63149, + 63179, 63197, 63199, 63211, 63241, 63247, 63277, 63281, 63299, 63311, + 63313, 63317, + 63331, 63337, 63347, 63353, 63361, 63367, 63377, 63389, 63391, 63397, + 63409, 63419, + 63421, 63439, 63443, 63463, 63467, 63473, 63487, 63493, 63499, 63521, + 63527, 63533, + 63541, 63559, 63577, 63587, 63589, 63599, 63601, 63607, 63611, 63617, + 63629, 63647, + 63649, 63659, 63667, 63671, 63689, 63691, 63697, 63703, 63709, 63719, + 63727, 63737, + 63743, 63761, 63773, 63781, 63793, 63799, 63803, 63809, 63823, 63839, + 63841, 63853, + 63857, 63863, 63901, 63907, 63913, 63929, 63949, 63977, 63997, 64007, + 64013, 64019, + 64033, 64037, 64063, 64067, 64081, 64091, 64109, 64123, 64151, 64153, + 64157, 64171, + 64187, 64189, 64217, 64223, 64231, 64237, 64271, 64279, 64283, 64301, + 64303, 64319, + 64327, 64333, 64373, 64381, 64399, 64403, 64433, 64439, 64451, 64453, + 64483, 64489, + 64499, 64513, 64553, 64567, 64577, 64579, 64591, 64601, 64609, 64613, + 64621, 64627, + 64633, 64661, 64663, 64667, 64679, 64693, 64709, 64717, 64747, 64763, + 64781, 64783, + 64793, 64811, 64817, 64849, 64853, 64871, 64877, 64879, 64891, 64901, + 64919, 64921, + 64927, 64937, 64951, 64969, 64997, 65003, 65011, 65027, 65029, 65033, + 65053, 65063, + 65071, 65089, 65099, 65101, 65111, 65119, 65123, 65129, 65141, 65147, + 65167, 65171, + 65173, 65179, 65183, 65203, 65213, 65239, 65257, 65267, 65269, 65287, + 65293, 65309, + 65323, 65327, 65353, 65357, 65371, 65381, 65393, 65407, 65413, 65419, + 65423, 65437, + 65447, 65449, 65479, 65497, 65519, 65521, +}; + +#define NPRIMES (sizeof(primes) / sizeof(*primes)) + +/* + * Generate a prime. We can deal with various extra properties of + * the prime: + * + * - to speed up use in RSA, we can arrange to select a prime with + * the property (prime % modulus) != residue. + * + * - for use in DSA, we can arrange to select a prime which is one + * more than a multiple of a dirty great bignum. In this case + * `bits' gives the size of the factor by which we _multiply_ + * that bignum, rather than the size of the whole number. + */ +Bignum primegen(int bits, int modulus, int residue, Bignum factor, int phase) +{ + int i, k, v, byte, bitsleft, check, checks; + unsigned long delta; + unsigned long moduli[NPRIMES + 1]; + unsigned long residues[NPRIMES + 1]; + unsigned long multipliers[NPRIMES + 1]; + Bignum p, pm1, q, wqp, wqp2; + + byte = 0; + bitsleft = 0; + +STARTOVER: + + /* + * Generate a k-bit random number with top and bottom bits set. + * Alternatively, if `factor' is nonzero, generate a k-bit + * random number with the top bit set and the bottom bit clear, + * multiply it by `factor', and add one. + */ + p = bn_power_2(bits - 1); + for (i = 0; i < bits; i++) { + if (i == 0 || i == bits - 1) + v = (i != 0 || !factor) ? 1 : 0; + else { + if (bitsleft <= 0) + bitsleft = 8, byte = random_byte(); + v = byte & 1; + byte >>= 1; + bitsleft--; + } + bignum_set_bit(p, i, v); + } + if (factor) { + Bignum tmp = p; + p = bigmul(tmp, factor); + freebn(tmp); + ASSERT(bignum_bit(p, 0) == 0); + bignum_set_bit(p, 0, 1); + } + + /* + * Ensure this random number is coprime to the first few + * primes, by repeatedly adding either 2 or 2*factor to it + * until it is. + */ + for (i = 0; i < (int) NPRIMES; i++) { + moduli[i] = primes[i]; + residues[i] = bignum_mod_short(p, primes[i]); + if (factor) + multipliers[i] = bignum_mod_short(factor, primes[i]); + else + multipliers[i] = 1; + } + moduli[NPRIMES] = modulus; + residues[NPRIMES] = (bignum_mod_short(p, (unsigned short) modulus) + + modulus - residue); + if (factor) + multipliers[NPRIMES] = bignum_mod_short(factor, (unsigned short) modulus); + else + multipliers[NPRIMES] = 1; + delta = 0; + while (1) { + for (i = 0; i < int(sizeof(moduli) / sizeof(*moduli)); i++) + if (!((residues[i] + delta * multipliers[i]) % moduli[i])) + break; + if (i < int(sizeof(moduli) / sizeof(*moduli))) { /* we broke */ + delta += 2; + if (delta > 65536) { + freebn(p); + goto STARTOVER; + } + continue; + } + break; + } + q = p; + if (factor) { + Bignum tmp; + tmp = bignum_from_long(delta); + p = bigmuladd(tmp, factor, q); + freebn(tmp); + } else { + p = bignum_add_long(q, delta); + } + freebn(q); + + /* + * Now apply the Miller-Rabin primality test a few times. First + * work out how many checks are needed. + */ + checks = 27; + if (bits >= 150) + checks = 18; + if (bits >= 200) + checks = 15; + if (bits >= 250) + checks = 12; + if (bits >= 300) + checks = 9; + if (bits >= 350) + checks = 8; + if (bits >= 400) + checks = 7; + if (bits >= 450) + checks = 6; + if (bits >= 550) + checks = 5; + if (bits >= 650) + checks = 4; + if (bits >= 850) + checks = 3; + if (bits >= 1300) + checks = 2; + + /* + * Next, write p-1 as q*2^k. + */ + for (k = 0; bignum_bit(p, k) == !k; k++) + continue; /* find first 1 bit in p-1 */ + q = bignum_rshift(p, k); + /* And store p-1 itself, which we'll need. */ + pm1 = copybn(p); + decbn(pm1); + + /* + * Now, for each check ... + */ + for (check = 0; check < checks; check++) { + Bignum w; + + /* + * Invent a random number between 1 and p-1 inclusive. + */ + while (1) { + w = bn_power_2(bits - 1); + for (i = 0; i < bits; i++) { + if (bitsleft <= 0) + bitsleft = 8, byte = random_byte(); + v = byte & 1; + byte >>= 1; + bitsleft--; + bignum_set_bit(w, i, v); + } + bn_restore_invariant(w); + if (bignum_cmp(w, p) >= 0 || bignum_cmp(w, Zero) == 0) { + freebn(w); + continue; + } + break; + } + + /* + * Compute w^q mod p. + */ + wqp = modpow(w, q, p); + freebn(w); + + /* + * See if this is 1, or if it is -1, or if it becomes -1 + * when squared at most k-1 times. + */ + if (bignum_cmp(wqp, One) == 0 || bignum_cmp(wqp, pm1) == 0) { + freebn(wqp); + continue; + } + for (i = 0; i < k - 1; i++) { + wqp2 = modmul(wqp, wqp, p); + freebn(wqp); + wqp = wqp2; + if (bignum_cmp(wqp, pm1) == 0) + break; + } + freebn(wqp); + if (i < k - 1) { + continue; + } + + /* + * It didn't. Therefore, w is a witness for the + * compositeness of p. + */ + freebn(p); + freebn(pm1); + freebn(q); + goto STARTOVER; + } + + /* + * We have a prime! + */ + freebn(q); + freebn(pm1); + return p; +} + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ diff --git a/extern/crypto/CryptPrime.h b/extern/crypto/CryptPrime.h new file mode 100644 index 0000000000..a21c711266 --- /dev/null +++ b/extern/crypto/CryptPrime.h @@ -0,0 +1,34 @@ +#ifndef SSH_PRIME_H +#define SSH_PRIME_H + +#include "CryptBn.h" +Bignum primegen(int bits, int modulus, int residue, Bignum factor, int phase); + +#endif + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ diff --git a/extern/crypto/CryptRSA.cpp b/extern/crypto/CryptRSA.cpp new file mode 100644 index 0000000000..1582124344 --- /dev/null +++ b/extern/crypto/CryptRSA.cpp @@ -0,0 +1,799 @@ +/* + * RSA implementation for PuTTY. + */ + +#include "global.h" + +#include "RageUtil.h" +#include "CryptRSA.h" +#include "CryptSHA.h" +#include "CryptSH512.h" +#include "CryptMD5.h" +#include "CryptRand.h" +#include "CryptPrime.h" + +#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 PUT_32BIT(cp, value) { \ + (cp)[0] = (unsigned char)((value) >> 24); \ + (cp)[1] = (unsigned char)((value) >> 16); \ + (cp)[2] = (unsigned char)((value) >> 8); \ + (cp)[3] = (unsigned char)(value); } + +RSAKey::RSAKey() +{ + bits = bytes = 0; + modulus = exponent = private_exponent = p = q = iqmp = NULL; +} + +RSAKey::~RSAKey() +{ + if(p) + freebn(p); + if(q) + freebn(q); + if(modulus) + freebn(modulus); + if(exponent) + freebn(exponent); + if(private_exponent) + freebn(private_exponent); + if(iqmp) + freebn(iqmp); +} + + +int makekey(unsigned char *data, struct RSAKey *result, + unsigned char **keystr, int order) +{ + unsigned char *p = data; + int i; + + if (result) { + result->bits = 0; + for (i = 0; i < 4; i++) + result->bits = (result->bits << 8) + *p++; + } else + p += 4; + + /* + * order=0 means exponent then modulus (the keys sent by the + * server). order=1 means modulus then exponent (the keys + * stored in a keyfile). + */ + + if (order == 0) + p += ssh1_read_bignum(p, result ? &result->exponent : NULL); + if (result) + result->bytes = (((p[0] << 8) + p[1]) + 7) / 8; + if (keystr) + *keystr = p + 2; + p += ssh1_read_bignum(p, result ? &result->modulus : NULL); + if (order == 1) + p += ssh1_read_bignum(p, result ? &result->exponent : NULL); + + return p - data; +} + +int makeprivate( const unsigned char *data, struct RSAKey *result ) +{ + return ssh1_read_bignum(data, &result->private_exponent); +} + +unsigned char *GetBytes( Bignum bn, int *buflen ) +{ + int len = bn[0]*BIGNUM_INT_BYTES; + + unsigned char *ret = new unsigned char[len]; + unsigned char *p = ret; + for( int i = len-1; i >= 0; --i ) + *p++ = bignum_byte( bn, i ); + return ret; +} + +static void sha512_mpint(SHA512_State * s, Bignum b) +{ + unsigned char lenbuf[4]; + int len; + len = (bignum_bitcount(b) + 8) / 8; + PUT_32BIT(lenbuf, len); + SHA512_Bytes(s, lenbuf, 4); + while (len-- > 0) { + lenbuf[0] = bignum_byte(b, len); + SHA512_Bytes(s, lenbuf, 1); + } + memset(lenbuf, 0, sizeof(lenbuf)); +} + +/* + * This function is a wrapper on modpow(). It has the same effect + * as modpow(), but employs RSA blinding to protect against timing + * attacks. + */ +static Bignum rsa_privkey_op(Bignum input, const RSAKey *key) +{ + Bignum random, random_encrypted, random_inverse; + Bignum input_blinded, ret_blinded; + Bignum ret; + + SHA512_State ss; + unsigned char digest512[64]; + unsigned digestused = ARRAYLEN(digest512); + int hashseq = 0; + + /* + * Start by inventing a random number chosen uniformly from the + * range 2..modulus-1. (We do this by preparing a random number + * of the right length and retrying if it's greater than the + * modulus, to prevent any potential Bleichenbacher-like + * attacks making use of the uneven distribution within the + * range that would arise from just reducing our number mod n. + * There are timing implications to the potential retries, of + * course, but all they tell you is the modulus, which you + * already knew.) + * + * To preserve determinism and avoid Pageant needing to share + * the random number pool, we actually generate this `random' + * number by hashing stuff with the private key. + */ + while (1) { + int bits, byte, bitsleft, v; + random = copybn(key->modulus); + /* + * Find the topmost set bit. (This function will return its + * index plus one.) Then we'll set all bits from that one + * downwards randomly. + */ + bits = bignum_bitcount(random); + byte = 0; + bitsleft = 0; + while (bits--) { + if (bitsleft <= 0) { + bitsleft = 8; + /* + * Conceptually the following few lines are equivalent to + * byte = random_byte(); + */ + if (digestused >= ARRAYLEN(digest512)) { + unsigned char seqbuf[4]; + PUT_32BIT(seqbuf, hashseq); + SHA512_Init(&ss); + SHA512_Bytes(&ss, "RSA deterministic blinding", 26); + SHA512_Bytes(&ss, seqbuf, sizeof(seqbuf)); + sha512_mpint(&ss, key->private_exponent); + SHA512_Final(&ss, digest512); + hashseq++; + + /* + * Now hash that digest plus the signature + * input. + */ + SHA512_Init(&ss); + SHA512_Bytes(&ss, digest512, sizeof(digest512)); + sha512_mpint(&ss, input); + SHA512_Final(&ss, digest512); + + digestused = 0; + } + byte = digest512[digestused++]; + } + v = byte & 1; + byte >>= 1; + bitsleft--; + bignum_set_bit(random, bits, v); + } + + /* + * Now check that this number is strictly greater than + * zero, and strictly less than modulus. + */ + if (bignum_cmp(random, Zero) <= 0 || + bignum_cmp(random, key->modulus) >= 0) { + freebn(random); + continue; + } else { + break; + } + } + + /* + * RSA blinding relies on the fact that (xy)^d mod n is equal + * to (x^d mod n) * (y^d mod n) mod n. We invent a random pair + * y and y^d; then we multiply x by y, raise to the power d mod + * n as usual, and divide by y^d to recover x^d. Thus an + * attacker can't correlate the timing of the modpow with the + * input, because they don't know anything about the number + * that was input to the actual modpow. + * + * The clever bit is that we don't have to do a huge modpow to + * get y and y^d; we will use the number we just invented as + * _y^d_, and use the _public_ exponent to compute (y^d)^e = y + * from it, which is much faster to do. + */ + random_encrypted = modpow(random, key->exponent, key->modulus); + random_inverse = modinv(random, key->modulus); + input_blinded = modmul(input, random_encrypted, key->modulus); + ret_blinded = modpow(input_blinded, key->private_exponent, key->modulus); + ret = modmul(ret_blinded, random_inverse, key->modulus); + + freebn(ret_blinded); + freebn(input_blinded); + freebn(random_inverse); + freebn(random_encrypted); + freebn(random); + + return ret; +} + +bool RSAKey::Encrypt( RString &buf ) const +{ + Bignum bn = bignum_from_bytes( (unsigned char *) buf.data(), buf.size() ); + Bignum encrypted_bn = Encrypt( bn ); + delete [] bn; + + int len; + unsigned char *bytes = bignum_to_buffer( encrypted_bn, &len ); + buf = RString( (const char *) bytes, len ); + delete [] encrypted_bn; + + return true; +} + +bool RSAKey::Decrypt( RString &buf ) const +{ + Bignum bn = bignum_from_buffer( (unsigned char *) buf.data(), buf.size() ); + if( bn == NULL ) + return false; + + Bignum decrypted_bn = Decrypt( bn ); + delete [] bn; + + int len; + unsigned char *bytes = bignum_to_bytes( decrypted_bn, &len ); + buf = RString( (const char *) bytes, len ); + delete [] decrypted_bn; + + return true; +} + +Bignum RSAKey::Encrypt(const Bignum input) const +{ + return modpow( input, this->exponent, this->modulus ); +} + +Bignum RSAKey::Decrypt(const Bignum input) const +{ + return rsa_privkey_op(input, this); +} + +int RSAKey::StrLen() const +{ + Bignum md, ex; + int mdlen, exlen; + + md = this->modulus; + ex = this->exponent; + mdlen = (bignum_bitcount(md) + 15) / 16; + exlen = (bignum_bitcount(ex) + 15) / 16; + return 4 * (mdlen + exlen) + 20; +} + +void RSAKey::StrFmt( char *str ) const +{ + int len = 0, i, nibbles; + static const char hex[] = "0123456789abcdef"; + + len += sprintf(str + len, "0x"); + + nibbles = (3 + bignum_bitcount(this->exponent)) / 4; + if (nibbles < 1) + nibbles = 1; + for (i = nibbles; i--;) + str[len++] = hex[(bignum_byte(this->exponent, i / 2) >> (4 * (i % 2))) & 0xF]; + + len += sprintf(str + len, ",0x"); + + nibbles = (3 + bignum_bitcount(this->modulus)) / 4; + if (nibbles < 1) + nibbles = 1; + for (i = nibbles; i--;) + str[len++] = hex[(bignum_byte(this->modulus, i / 2) >> (4 * (i % 2))) & 0xF]; + + str[len] = '\0'; +} + +/* + * Generate a fingerprint string for the key. Compatible with the + * OpenSSH fingerprint code. + */ +void RSAKey::Fingerprint( char *str, int len ) const +{ + struct MD5Context md5c; + unsigned char digest[16]; + char buffer[16 * 3 + 40]; + int numlen, slen, i; + + MD5Init(&md5c); + numlen = ssh1_bignum_length(this->modulus) - 2; + for (i = numlen; i--;) { + unsigned char c = bignum_byte(this->modulus, i); + MD5Update(&md5c, &c, 1); + } + numlen = ssh1_bignum_length(this->exponent) - 2; + for (i = numlen; i--;) { + unsigned char c = bignum_byte(this->exponent, i); + MD5Update(&md5c, &c, 1); + } + MD5Final(digest, &md5c); + + sprintf(buffer, "%d ", bignum_bitcount(this->modulus)); + for (i = 0; i < 16; i++) + sprintf(buffer + strlen(buffer), "%s%02x", i ? ":" : "", + digest[i]); + strncpy(str, buffer, len); + str[len - 1] = '\0'; + slen = strlen(str); + if (!this->comment.empty() && slen < len - 1) + { + str[slen] = ' '; + strncpy(str + slen + 1, this->comment, len - slen - 1); + 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. + */ +bool RSAKey::Check() const +{ + Bignum n, ed, pm1, qm1; + int cmp; + + /* n must equal pq. */ + n = bigmul(this->p, this->q); + cmp = bignum_cmp(n, this->modulus); + freebn(n); + if (cmp != 0) + return 0; + + /* e * d must be congruent to 1, modulo (p-1) and modulo (q-1). */ + pm1 = copybn(this->p); + decbn(pm1); + ed = modmul(this->exponent, this->private_exponent, pm1); + cmp = bignum_cmp(ed, One); + delete [] ed; + if (cmp != 0) + return 0; + + qm1 = copybn(this->q); + decbn(qm1); + ed = modmul(this->exponent, this->private_exponent, qm1); + cmp = bignum_cmp(ed, One); + delete [] ed; + if (cmp != 0) + return 0; + + /* + * Ensure p > q. + */ + if (bignum_cmp(this->p, this->q) <= 0) + return 0; + + /* + * Ensure iqmp * q is congruent to 1, modulo p. + */ + n = modmul(this->iqmp, this->q, this->p); + cmp = bignum_cmp(n, One); + delete [] n; + if (cmp != 0) + return 0; + + return 1; +} + +/* ---------------------------------------------------------------------- + * Implementation of the ssh-rsa signing key type. + */ + +static void getstring(const char **data, int *datalen, const char **p, int *length) +{ + *p = NULL; + if (*datalen < 4) + return; + *length = GET_32BIT(*data); + *datalen -= 4; + *data += 4; + if (*datalen < *length) + return; + *p = *data; + *data += *length; + *datalen -= *length; +} +static Bignum getmp(const char **data, int *datalen) +{ + const char *p; + int length; + Bignum b; + + getstring(data, datalen, &p, &length); + if (!p) + return NULL; + b = bignum_from_bytes((unsigned char *)p, length); + return b; +} + +bool RSAKey::LoadFromPublicBlob( const RString &str ) +{ + int len = str.size(); + const char *data = str.data(); + const char *p; + int slen; + getstring(&data, &len, &p, &slen); + if (!p || slen != 7 || memcmp(p, "ssh-rsa", 7)) { + return false; + } + + struct RSAKey *rsa = new RSAKey; + rsa->exponent = getmp(&data, &len); + rsa->modulus = getmp(&data, &len); + rsa->private_exponent = NULL; + + return true; +} + + +char *RSAKey::FmtKey() const +{ + int len = this->StrLen(); + char *p = new char[len]; + StrFmt( p ); + return p; +} + +void RSAKey::PublicBlob( RString &out ) const +{ + int elen, mlen, bloblen; + int i; + unsigned char *blob, *p; + + elen = (bignum_bitcount(this->exponent) + 8) / 8; + mlen = (bignum_bitcount(this->modulus) + 8) / 8; + + /* + * string "ssh-rsa", mpint exp, mpint mod. Total 19+elen+mlen. + * (three length fields, 12+7=19). + */ + bloblen = 19 + elen + mlen; + blob = new unsigned char[bloblen]; + p = blob; + PUT_32BIT(p, 7); + p += 4; + memcpy(p, "ssh-rsa", 7); + p += 7; + PUT_32BIT(p, elen); + p += 4; + for (i = elen; i--;) + *p++ = bignum_byte(this->exponent, i); + PUT_32BIT(p, mlen); + p += 4; + for (i = mlen; i--;) + *p++ = bignum_byte(this->modulus, i); + ASSERT(p == blob + bloblen); + + out = RString( (const char *) blob, bloblen ); +} + +void RSAKey::PrivateBlob( RString &out ) const +{ + int i; + unsigned char *blob, *p; + + int elen = (bignum_bitcount(this->exponent) + 8) / 8; + int mlen = (bignum_bitcount(this->modulus) + 8) / 8; + int dlen = (bignum_bitcount(this->private_exponent) + 8) / 8; + int plen = (bignum_bitcount(this->p) + 8) / 8; + int qlen = (bignum_bitcount(this->q) + 8) / 8; + int ulen = (bignum_bitcount(this->iqmp) + 8) / 8; + + /* + * mpint exp, mpint mod, mpint private_exp, mpint p, mpint q, mpint iqmp. Total 24 + + * sum of lengths. + */ + int bloblen = 24 + elen + mlen + dlen + plen + qlen + ulen; + blob = new unsigned char[bloblen]; + p = blob; + + PUT_32BIT(p, elen); + p += 4; + for (i = elen; i--;) + *p++ = bignum_byte(this->exponent, i); + PUT_32BIT(p, mlen); + p += 4; + for (i = mlen; i--;) + *p++ = bignum_byte(this->modulus, i); + PUT_32BIT(p, dlen); + p += 4; + for (i = dlen; i--;) + *p++ = bignum_byte(this->private_exponent, i); + PUT_32BIT(p, plen); + p += 4; + for (i = plen; i--;) + *p++ = bignum_byte(this->p, i); + PUT_32BIT(p, qlen); + p += 4; + for (i = qlen; i--;) + *p++ = bignum_byte(this->q, i); + PUT_32BIT(p, ulen); + p += 4; + for (i = ulen; i--;) + *p++ = bignum_byte(this->iqmp, i); + ASSERT(p == blob + bloblen); + + out = RString( (const char *) blob, bloblen ); +} + +bool RSAKey::LoadFromPrivateBlob( const RString &str ) +{ + int len = str.size(); + const char *data = str.data(); + + this->exponent = getmp(&data, &len); + this->modulus = getmp(&data, &len); + this->private_exponent = getmp(&data, &len); + this->p = getmp(&data, &len); + this->q = getmp(&data, &len); + this->iqmp = getmp(&data, &len); + + if (!this->Check()) + return false; + + return true; +} + +/* static struct RSAKey *rsa2_openssh_createkey(unsigned char **blob, int *len) +{ + const char **b = (const char **) blob; + struct RSAKey *rsa = new RSAKey; + + 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) + { + delete rsa; + return NULL; + } + + return rsa; +} + +static int rsa2_openssh_fmtkey( struct RSAKey *rsa, unsigned char *blob, int len ) +{ + int 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); + int i; + ENC(rsa->modulus); + ENC(rsa->exponent); + ENC(rsa->private_exponent); + ENC(rsa->iqmp); + ENC(rsa->p); + ENC(rsa->q); + + return bloblen; +} +*/ +int rsa2_pubkey_bits( const RString &blob ) +{ + RSAKey rsa; + if( !rsa.LoadFromPublicBlob( blob ) ) + return 0; + + return bignum_bitcount(rsa.modulus); +} + +char *rsa2_fingerprint( struct RSAKey *rsa ) +{ + struct MD5Context md5c; + unsigned char digest[16], lenbuf[4]; + char buffer[16 * 3 + 40]; + char *ret; + int numlen, i; + + MD5Init(&md5c); + MD5Update(&md5c, (unsigned char *)"\0\0\0\7ssh-rsa", 11); + +#define ADD_BIGNUM(bignum) \ + 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); \ + MD5Update(&md5c, &c, 1); \ + } + ADD_BIGNUM(rsa->exponent); + ADD_BIGNUM(rsa->modulus); +#undef ADD_BIGNUM + + MD5Final(digest, &md5c); + + 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 = new char[strlen(buffer) + 1]; + if (ret) + strcpy(ret, buffer); + return ret; +} + +bool RSAKey::Verify( const RString &data, const RString &sig ) const +{ + Bignum in, out; + int bytes, i, j; + unsigned char hash[20]; + + in = bignum_from_bytes( (const unsigned char *) sig.data(), sig.size() ); + + /* Base (in) must be smaller than the modulus. */ + if( bignum_cmp(in, this->modulus) >= 0 ) + { + freebn(in); + return false; + } + out = modpow(in, this->exponent, this->modulus); + freebn(in); + + bool ret = true; + + bytes = (bignum_bitcount(this->modulus)+7) / 8; + /* Top (partial) byte should be zero. */ + if (bignum_byte(out, bytes - 1) != 0) + ret = 0; + /* First whole byte should be 1. */ + if (bignum_byte(out, bytes - 2) != 1) + ret = 0; + /* Most of the rest should be FF. */ + for (i = bytes - 3; i >= 20; i--) { + if (bignum_byte(out, i) != 0xFF) + ret = 0; + } + /* Finally, we expect to see the SHA-1 hash of the signed data. */ + SHA_Simple( data.data(), data.size(), hash ); + for (i = 19, j = 0; i >= 0; i--, j++) { + if (bignum_byte(out, i) != hash[j]) + ret = false; + } + freebn(out); + + return ret; +} + +void RSAKey::Sign( const RString &data, RString &out ) const +{ + Bignum in; + { + unsigned char hash[20]; + SHA_Simple(data.data(), data.size(), hash); + + int nbytes = (bignum_bitcount(this->modulus) - 1) / 8; + unsigned char *bytes = new unsigned char[nbytes]; + + memset( bytes, 0xFF, nbytes ); + bytes[0] = 1; + memcpy( bytes + nbytes - 20, hash, 20 ); + + in = bignum_from_bytes(bytes, nbytes); + delete [] bytes; + } + + Bignum outnum = rsa_privkey_op(in, this); + delete [] in; + + int siglen; + unsigned char *bytes = bignum_to_bytes( outnum, &siglen ); + delete [] outnum; + + out = RString( (const char *) bytes, siglen ); + delete [] bytes; +} + +#define RSA_EXPONENT 37 /* we like this prime */ + +int RSAKey::Generate( int bits ) +{ + Bignum pm1, qm1, phi_n; + + /* + * We don't generate e; we just use a standard one always. + */ + this->exponent = bignum_from_long(RSA_EXPONENT); + + /* + * Generate p and q: primes with combined length `bits', not + * congruent to 1 modulo e. (Strictly speaking, we wanted (p-1) + * and e to be coprime, and (q-1) and e to be coprime, but in + * general that's slightly more fiddly to arrange. By choosing + * a prime e, we can simplify the criterion.) + */ + this->p = primegen(bits / 2, RSA_EXPONENT, 1, NULL, 1); + this->q = primegen(bits - bits / 2, RSA_EXPONENT, 1, NULL, 2); + + /* + * Ensure p > q, by swapping them if not. + */ + if (bignum_cmp(this->p, this->q) < 0) + swap( p, q ); + + /* + * Now we have p, q and e. All we need to do now is work out + * the other helpful quantities: n=pq, d=e^-1 mod (p-1)(q-1), + * and (q^-1 mod p). + */ + this->modulus = bigmul(this->p, this->q); + pm1 = copybn(this->p); + decbn(pm1); + qm1 = copybn(this->q); + decbn(qm1); + phi_n = bigmul(pm1, qm1); + freebn(pm1); + freebn(qm1); + this->private_exponent = modinv(this->exponent, phi_n); + this->iqmp = modinv(this->q, this->p); + + /* + * Clean up temporary numbers. + */ + freebn(phi_n); + + return 1; +} + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ diff --git a/extern/crypto/CryptRSA.h b/extern/crypto/CryptRSA.h new file mode 100644 index 0000000000..8c4c6bf3f8 --- /dev/null +++ b/extern/crypto/CryptRSA.h @@ -0,0 +1,68 @@ +#ifndef RSAKEY_H +#define RSAKEY_H + +#include "CryptBn.h" +struct RSAKey +{ + RSAKey(); + ~RSAKey(); + + int bits; + int bytes; + Bignum modulus; + Bignum exponent; + Bignum private_exponent; + Bignum p; + Bignum q; + Bignum iqmp; + RString comment; + + int Generate( int bits ); + void Fingerprint( char *str, int len ) const; + void Sign( const RString &data, RString &out ) const; + bool Verify( const RString &data, const RString &sig ) const; + + bool Encrypt( RString &buf ) const; + bool Decrypt( RString &buf ) const; + Bignum Encrypt( const Bignum input ) const; + Bignum Decrypt( const Bignum input ) const; + + bool Check() const; + int StrLen() const; + void StrFmt( char *str ) const; + char *FmtKey() const; + + void PublicBlob( RString &out ) const; + void PrivateBlob( RString &out ) const; + bool LoadFromPublicBlob( const RString &PublicBlob ); + bool LoadFromPrivateBlob( const RString &PrivateBlob ); +}; + +#endif + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ diff --git a/extern/crypto/CryptRand.cpp b/extern/crypto/CryptRand.cpp new file mode 100644 index 0000000000..5620039947 --- /dev/null +++ b/extern/crypto/CryptRand.cpp @@ -0,0 +1,241 @@ +/* + * cryptographic random number generator for PuTTY's ssh client + */ + +#include "global.h" +#include "CryptSHA.h" +#include "CryptRand.h" + +void noise_get_heavy(void (*func) (void *, int)); +void noise_get_light(void (*func) (void *, int)); + +/* + * `pool' itself is a pool of random data which we actually use: we + * return bytes from `pool', at position `poolpos', until `poolpos' + * reaches the end of the pool. At this point we generate more + * random data, by adding noise, stirring well, and resetting + * `poolpos' to point to just past the beginning of the pool (not + * _the_ beginning, since otherwise we'd give away the whole + * contents of our pool, and attackers would just have to guess the + * next lot of noise). + * + * `incomingb' buffers acquired noise data, until it gets full, at + * which point the acquired noise is SHA'ed into `incoming' and + * `incomingb' is cleared. The noise in `incoming' is used as part + * of the noise for each stirring of the pool, in addition to local + * time, process listings, and other such stuff. + */ + +#define HASHINPUT 64 /* 64 bytes SHA input */ +#define HASHSIZE 20 /* 160 bits SHA output */ +#define POOLSIZE 1200 /* size of random pool */ + +struct RandPool +{ + unsigned char pool[POOLSIZE]; + int poolpos; + + unsigned char incoming[HASHSIZE]; + + unsigned char incomingb[HASHINPUT]; + int incomingpos; +}; + +static struct RandPool pool; +bool random_active = false; + +static void random_stir(void) +{ + unsigned block[HASHINPUT / sizeof(unsigned)]; + unsigned digest[HASHSIZE / sizeof(unsigned)]; + int i, j; + + SHATransform((unsigned *) pool.incoming, (unsigned *) pool.incomingb); + pool.incomingpos = 0; + + /* + * Chunks of this code are blatantly endianness-dependent, but + * as it's all random bits anyway, WHO CARES? + */ + memcpy(digest, pool.incoming, sizeof(digest)); + + /* + * Make two passes over the pool. + */ + for (i = 0; i < 2; i++) { + + /* + * We operate SHA in CFB mode, repeatedly adding the same + * block of data to the digest. But we're also fiddling + * with the digest-so-far, so this shouldn't be Bad or + * anything. + */ + memcpy(block, pool.pool, sizeof(block)); + + /* + * Each pass processes the pool backwards in blocks of + * HASHSIZE, just so that in general we get the output of + * SHA before the corresponding input, in the hope that + * things will be that much less predictable that way + * round, when we subsequently return bytes ... + */ + for (j = POOLSIZE; (j -= HASHSIZE) >= 0;) { + /* + * XOR the bit of the pool we're processing into the + * digest. + */ + unsigned k; + for (k = 0; k < sizeof(digest) / sizeof(*digest); k++) + digest[k] ^= ((unsigned *) (pool.pool + j))[k]; + + /* + * Munge our unrevealed first block of the pool into + * it. + */ + SHATransform(digest, block); + + /* + * Stick the result back into the pool. + */ + + for( k = 0; k < sizeof(digest) / sizeof(*digest); k++ ) + ((unsigned *) (pool.pool + j))[k] = digest[k]; + } + } + + /* + * Might as well save this value back into `incoming', just so + * there'll be some extra bizarreness there. + */ + SHATransform(digest, block); + memcpy(pool.incoming, digest, sizeof(digest)); + + pool.poolpos = sizeof(pool.incoming); +} + +void random_add_noise( const RString &noise ) +{ + unsigned char *p = (unsigned char *) noise.data(); + int i; + + if (!random_active) + return; + + /* + * This function processes HASHINPUT bytes into only HASHSIZE + * bytes, so _if_ we were getting incredibly high entropy + * sources then we would be throwing away valuable stuff. + */ + int length = noise.size(); + while (length >= (HASHINPUT - pool.incomingpos)) { + memcpy(pool.incomingb + pool.incomingpos, p, + HASHINPUT - pool.incomingpos); + p += HASHINPUT - pool.incomingpos; + length -= HASHINPUT - pool.incomingpos; + SHATransform((unsigned *) pool.incoming, (unsigned *) pool.incomingb); + for (i = 0; i < HASHSIZE; i++) { + pool.pool[pool.poolpos++] ^= pool.incomingb[i]; + if (pool.poolpos >= POOLSIZE) + pool.poolpos = 0; + } + if (pool.poolpos < HASHSIZE) + random_stir(); + + pool.incomingpos = 0; + } + + memcpy(pool.incomingb + pool.incomingpos, p, length); + pool.incomingpos += length; +} + +void random_add_heavynoise(void *noise, int length) +{ + unsigned char *p = (unsigned char *) noise; + int i; + + while (length >= POOLSIZE) { + for (i = 0; i < POOLSIZE; i++) + pool.pool[i] ^= *p++; + random_stir(); + length -= POOLSIZE; + } + + for (i = 0; i < length; i++) + pool.pool[i] ^= *p++; + random_stir(); +} + +static void random_add_heavynoise_bitbybit(void *noise, int length) +{ + unsigned char *p = (unsigned char *) noise; + int i; + + while (length >= POOLSIZE - pool.poolpos) { + for (i = 0; i < POOLSIZE - pool.poolpos; i++) + pool.pool[pool.poolpos + i] ^= *p++; + random_stir(); + length -= POOLSIZE - pool.poolpos; + pool.poolpos = 0; + } + + for (i = 0; i < length; i++) + pool.pool[i] ^= *p++; + pool.poolpos = i; +} + +void random_init(void) +{ + if( random_active ) + return; + random_active = true; + memset(&pool, 0, sizeof(pool)); /* just to start with */ + + + noise_get_heavy(random_add_heavynoise_bitbybit); + random_stir(); +} + +unsigned char random_byte(void) +{ + if (pool.poolpos >= POOLSIZE) + random_stir(); + + return pool.pool[pool.poolpos++]; +} + +void random_get_savedata(char **data, int *len) +{ + char *buf = new char[POOLSIZE / 2]; + random_stir(); + memcpy(buf, pool.pool + pool.poolpos, POOLSIZE / 2); + *len = POOLSIZE / 2; + *data = buf; + random_stir(); +} + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ diff --git a/extern/crypto/CryptRand.h b/extern/crypto/CryptRand.h new file mode 100644 index 0000000000..ad82257288 --- /dev/null +++ b/extern/crypto/CryptRand.h @@ -0,0 +1,36 @@ +#ifndef SSH_RAND_H +#define SSH_RAND_H + +void random_init(); +void random_add_noise( const RString &noise ); +unsigned char random_byte(); +void random_get_savedata( char **data, int *len ); + +#endif + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ diff --git a/extern/crypto/CryptSH512.cpp b/extern/crypto/CryptSH512.cpp new file mode 100644 index 0000000000..ce12439140 --- /dev/null +++ b/extern/crypto/CryptSH512.cpp @@ -0,0 +1,390 @@ +/* + * SHA-512 algorithm as described at + * + * http://csrc.nist.gov/cryptval/shs.html + */ + +#include "global.h" +#include "CryptSH512.h" + +#define BLKSIZE 128 + +/* + * Arithmetic implementations. Note that AND, XOR and NOT can + * overlap destination with one source, but the others can't. + */ +#define add(r,x,y) ( r.lo = y.lo + x.lo, \ + r.hi = y.hi + x.hi + (r.lo < y.lo) ) +#define rorB(r,x,y) ( r.lo = (x.hi >> ((y)-32)) | (x.lo << (64-(y))), \ + r.hi = (x.lo >> ((y)-32)) | (x.hi << (64-(y))) ) +#define rorL(r,x,y) ( r.lo = (x.lo >> (y)) | (x.hi << (32-(y))), \ + r.hi = (x.hi >> (y)) | (x.lo << (32-(y))) ) +#define shrB(r,x,y) ( r.lo = x.hi >> ((y)-32), r.hi = 0 ) +#define shrL(r,x,y) ( r.lo = (x.lo >> (y)) | (x.hi << (32-(y))), \ + r.hi = x.hi >> (y) ) +#define band(r,x,y) ( r.lo = x.lo & y.lo, r.hi = x.hi & y.hi ) +#define bxor(r,x,y) ( r.lo = x.lo ^ y.lo, r.hi = x.hi ^ y.hi ) +#define bnot(r,x) ( r.lo = ~x.lo, r.hi = ~x.hi ) +#define INIT(h,l) { h, l } +#define BUILD(r,h,l) ( r.hi = h, r.lo = l ) +#define EXTRACT(h,l,r) ( h = r.hi, l = r.lo ) + +/* ---------------------------------------------------------------------- + * Core SHA512 algorithm: processes 16-doubleword blocks into a + * message digest. + */ + +#define Ch(r,t,x,y,z) ( bnot(t,x), band(r,t,z), band(t,x,y), bxor(r,r,t) ) +#define Maj(r,t,x,y,z) ( band(r,x,y), band(t,x,z), bxor(r,r,t), \ + band(t,y,z), bxor(r,r,t) ) +#define bigsigma0(r,t,x) ( rorL(r,x,28), rorB(t,x,34), bxor(r,r,t), \ + rorB(t,x,39), bxor(r,r,t) ) +#define bigsigma1(r,t,x) ( rorL(r,x,14), rorL(t,x,18), bxor(r,r,t), \ + rorB(t,x,41), bxor(r,r,t) ) +#define smallsigma0(r,t,x) ( rorL(r,x,1), rorL(t,x,8), bxor(r,r,t), \ + shrL(t,x,7), bxor(r,r,t) ) +#define smallsigma1(r,t,x) ( rorL(r,x,19), rorB(t,x,61), bxor(r,r,t), \ + shrL(t,x,6), bxor(r,r,t) ) + +static void SHA512_Core_Init(SHA512_State *s) +{ + static const uint64 iv[] = { + INIT(0x6a09e667, 0xf3bcc908), + INIT(0xbb67ae85, 0x84caa73b), + INIT(0x3c6ef372, 0xfe94f82b), + INIT(0xa54ff53a, 0x5f1d36f1), + INIT(0x510e527f, 0xade682d1), + INIT(0x9b05688c, 0x2b3e6c1f), + INIT(0x1f83d9ab, 0xfb41bd6b), + INIT(0x5be0cd19, 0x137e2179), + }; + int i; + for (i = 0; i < 8; i++) + s->h[i] = iv[i]; +} + +static void SHA512_Block(SHA512_State *s, uint64 *block) +{ + uint64 w[80]; + uint64 a,b,c,d,e,f,g,h; + static const uint64 k[] = { + INIT(0x428a2f98, 0xd728ae22), INIT(0x71374491, 0x23ef65cd), + INIT(0xb5c0fbcf, 0xec4d3b2f), INIT(0xe9b5dba5, 0x8189dbbc), + INIT(0x3956c25b, 0xf348b538), INIT(0x59f111f1, 0xb605d019), + INIT(0x923f82a4, 0xaf194f9b), INIT(0xab1c5ed5, 0xda6d8118), + INIT(0xd807aa98, 0xa3030242), INIT(0x12835b01, 0x45706fbe), + INIT(0x243185be, 0x4ee4b28c), INIT(0x550c7dc3, 0xd5ffb4e2), + INIT(0x72be5d74, 0xf27b896f), INIT(0x80deb1fe, 0x3b1696b1), + INIT(0x9bdc06a7, 0x25c71235), INIT(0xc19bf174, 0xcf692694), + INIT(0xe49b69c1, 0x9ef14ad2), INIT(0xefbe4786, 0x384f25e3), + INIT(0x0fc19dc6, 0x8b8cd5b5), INIT(0x240ca1cc, 0x77ac9c65), + INIT(0x2de92c6f, 0x592b0275), INIT(0x4a7484aa, 0x6ea6e483), + INIT(0x5cb0a9dc, 0xbd41fbd4), INIT(0x76f988da, 0x831153b5), + INIT(0x983e5152, 0xee66dfab), INIT(0xa831c66d, 0x2db43210), + INIT(0xb00327c8, 0x98fb213f), INIT(0xbf597fc7, 0xbeef0ee4), + INIT(0xc6e00bf3, 0x3da88fc2), INIT(0xd5a79147, 0x930aa725), + INIT(0x06ca6351, 0xe003826f), INIT(0x14292967, 0x0a0e6e70), + INIT(0x27b70a85, 0x46d22ffc), INIT(0x2e1b2138, 0x5c26c926), + INIT(0x4d2c6dfc, 0x5ac42aed), INIT(0x53380d13, 0x9d95b3df), + INIT(0x650a7354, 0x8baf63de), INIT(0x766a0abb, 0x3c77b2a8), + INIT(0x81c2c92e, 0x47edaee6), INIT(0x92722c85, 0x1482353b), + INIT(0xa2bfe8a1, 0x4cf10364), INIT(0xa81a664b, 0xbc423001), + INIT(0xc24b8b70, 0xd0f89791), INIT(0xc76c51a3, 0x0654be30), + INIT(0xd192e819, 0xd6ef5218), INIT(0xd6990624, 0x5565a910), + INIT(0xf40e3585, 0x5771202a), INIT(0x106aa070, 0x32bbd1b8), + INIT(0x19a4c116, 0xb8d2d0c8), INIT(0x1e376c08, 0x5141ab53), + INIT(0x2748774c, 0xdf8eeb99), INIT(0x34b0bcb5, 0xe19b48a8), + INIT(0x391c0cb3, 0xc5c95a63), INIT(0x4ed8aa4a, 0xe3418acb), + INIT(0x5b9cca4f, 0x7763e373), INIT(0x682e6ff3, 0xd6b2b8a3), + INIT(0x748f82ee, 0x5defb2fc), INIT(0x78a5636f, 0x43172f60), + INIT(0x84c87814, 0xa1f0ab72), INIT(0x8cc70208, 0x1a6439ec), + INIT(0x90befffa, 0x23631e28), INIT(0xa4506ceb, 0xde82bde9), + INIT(0xbef9a3f7, 0xb2c67915), INIT(0xc67178f2, 0xe372532b), + INIT(0xca273ece, 0xea26619c), INIT(0xd186b8c7, 0x21c0c207), + INIT(0xeada7dd6, 0xcde0eb1e), INIT(0xf57d4f7f, 0xee6ed178), + INIT(0x06f067aa, 0x72176fba), INIT(0x0a637dc5, 0xa2c898a6), + INIT(0x113f9804, 0xbef90dae), INIT(0x1b710b35, 0x131c471b), + INIT(0x28db77f5, 0x23047d84), INIT(0x32caab7b, 0x40c72493), + INIT(0x3c9ebe0a, 0x15c9bebc), INIT(0x431d67c4, 0x9c100d4c), + INIT(0x4cc5d4be, 0xcb3e42b6), INIT(0x597f299c, 0xfc657e2a), + INIT(0x5fcb6fab, 0x3ad6faec), INIT(0x6c44198c, 0x4a475817), + }; + + int t; + + for (t = 0; t < 16; t++) + w[t] = block[t]; + + for (t = 16; t < 80; t++) { + uint64 p, q, r, tmp; + smallsigma1(p, tmp, w[t-2]); + smallsigma0(q, tmp, w[t-15]); + add(r, p, q); + add(p, r, w[t-7]); + add(w[t], p, w[t-16]); + } + + a = s->h[0]; b = s->h[1]; c = s->h[2]; d = s->h[3]; + e = s->h[4]; f = s->h[5]; g = s->h[6]; h = s->h[7]; + + for (t = 0; t < 80; t+=8) { + uint64 tmp, p, q, r; + +#define ROUND(j,a,b,c,d,e,f,g,h) \ + bigsigma1(p, tmp, e); \ + Ch(q, tmp, e, f, g); \ + add(r, p, q); \ + add(p, r, k[j]) ; \ + add(q, p, w[j]); \ + add(r, q, h); \ + bigsigma0(p, tmp, a); \ + Maj(tmp, q, a, b, c); \ + add(q, tmp, p); \ + add(p, r, d); \ + d = p; \ + add(h, q, r); + + ROUND(t+0, a,b,c,d,e,f,g,h); + ROUND(t+1, h,a,b,c,d,e,f,g); + ROUND(t+2, g,h,a,b,c,d,e,f); + ROUND(t+3, f,g,h,a,b,c,d,e); + ROUND(t+4, e,f,g,h,a,b,c,d); + ROUND(t+5, d,e,f,g,h,a,b,c); + ROUND(t+6, c,d,e,f,g,h,a,b); + ROUND(t+7, b,c,d,e,f,g,h,a); + } + + { + uint64 tmp; +#define UPDATE(state, local) ( tmp = state, add(state, tmp, local) ) + UPDATE(s->h[0], a); UPDATE(s->h[1], b); + UPDATE(s->h[2], c); UPDATE(s->h[3], d); + UPDATE(s->h[4], e); UPDATE(s->h[5], f); + UPDATE(s->h[6], g); UPDATE(s->h[7], h); + } +} + +/* ---------------------------------------------------------------------- + * Outer SHA512 algorithm: take an arbitrary length byte string, + * convert it into 16-doubleword blocks with the prescribed padding + * at the end, and pass those blocks to the core SHA512 algorithm. + */ + +void SHA512_Init(SHA512_State *s) +{ + int i; + SHA512_Core_Init(s); + s->blkused = 0; + for (i = 0; i < 4; i++) + s->len[i] = 0; +} + +void SHA512_Bytes(SHA512_State *s, const void *p, int len) +{ + unsigned char *q = (unsigned char *)p; + uint64 wordblock[16]; + uint32_t lenw = len; + int i; + + /* + * Update the length field. + */ + for (i = 0; i < 4; i++) { + s->len[i] += lenw; + lenw = (s->len[i] < lenw); + } + + if (s->blkused && s->blkused+len < BLKSIZE) { + /* + * Trivial case: just add to the block. + */ + memcpy(s->block + s->blkused, q, len); + s->blkused += len; + } else { + /* + * We must complete and process at least one block. + */ + while (s->blkused + len >= BLKSIZE) { + memcpy(s->block + s->blkused, q, BLKSIZE - s->blkused); + q += BLKSIZE - s->blkused; + len -= BLKSIZE - s->blkused; + /* Now process the block. Gather bytes big-endian into words */ + for (i = 0; i < 16; i++) { + uint32_t h, l; + h = ( ((uint32_t)s->block[i*8+0]) << 24 ) | + ( ((uint32_t)s->block[i*8+1]) << 16 ) | + ( ((uint32_t)s->block[i*8+2]) << 8 ) | + ( ((uint32_t)s->block[i*8+3]) << 0 ); + l = ( ((uint32_t)s->block[i*8+4]) << 24 ) | + ( ((uint32_t)s->block[i*8+5]) << 16 ) | + ( ((uint32_t)s->block[i*8+6]) << 8 ) | + ( ((uint32_t)s->block[i*8+7]) << 0 ); + BUILD(wordblock[i], h, l); + } + SHA512_Block(s, wordblock); + s->blkused = 0; + } + memcpy(s->block, q, len); + s->blkused = len; + } +} + +void SHA512_Final(SHA512_State *s, unsigned char *digest) +{ + int i; + int pad; + unsigned char c[BLKSIZE]; + uint32_t len[4]; + + if (s->blkused >= BLKSIZE-16) + pad = (BLKSIZE-16) + BLKSIZE - s->blkused; + else + pad = (BLKSIZE-16) - s->blkused; + + for (i = 4; i-- ;) { + uint32_t lenhi = s->len[i]; + uint32_t lenlo = i > 0 ? s->len[i-1] : 0; + len[i] = (lenhi << 3) | (lenlo >> (32-3)); + } + + memset(c, 0, pad); + c[0] = 0x80; + SHA512_Bytes(s, &c, pad); + + for (i = 0; i < 4; i++) { + c[i*4+0] = char((len[3-i] >> 24) & 0xFF); + c[i*4+1] = char((len[3-i] >> 16) & 0xFF); + c[i*4+2] = char((len[3-i] >> 8) & 0xFF); + c[i*4+3] = char((len[3-i] >> 0) & 0xFF); + } + + SHA512_Bytes(s, &c, 16); + + for (i = 0; i < 8; i++) { + uint32_t h, l; + EXTRACT(h, l, s->h[i]); + digest[i*8+0] = char((h >> 24) & 0xFF); + digest[i*8+1] = char((h >> 16) & 0xFF); + digest[i*8+2] = char((h >> 8) & 0xFF); + digest[i*8+3] = char((h >> 0) & 0xFF); + digest[i*8+4] = char((l >> 24) & 0xFF); + digest[i*8+5] = char((l >> 16) & 0xFF); + digest[i*8+6] = char((l >> 8) & 0xFF); + digest[i*8+7] = char((l >> 0) & 0xFF); + } +} + +void SHA512_Simple(const void *p, int len, unsigned char *output) { + SHA512_State s; + + SHA512_Init(&s); + SHA512_Bytes(&s, p, len); + SHA512_Final(&s, output); +} + +#ifdef TEST + +#include +#include + +int main(void) { + unsigned char digest[64]; + int i, j, errors; + + struct { + const char *teststring; + unsigned char digest512[64]; + } tests[] = { + { "abc", { + 0xdd, 0xaf, 0x35, 0xa1, 0x93, 0x61, 0x7a, 0xba, + 0xcc, 0x41, 0x73, 0x49, 0xae, 0x20, 0x41, 0x31, + 0x12, 0xe6, 0xfa, 0x4e, 0x89, 0xa9, 0x7e, 0xa2, + 0x0a, 0x9e, 0xee, 0xe6, 0x4b, 0x55, 0xd3, 0x9a, + 0x21, 0x92, 0x99, 0x2a, 0x27, 0x4f, 0xc1, 0xa8, + 0x36, 0xba, 0x3c, 0x23, 0xa3, 0xfe, 0xeb, 0xbd, + 0x45, 0x4d, 0x44, 0x23, 0x64, 0x3c, 0xe8, 0x0e, + 0x2a, 0x9a, 0xc9, 0x4f, 0xa5, 0x4c, 0xa4, 0x9f, + } }, + { "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn" + "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu", { + 0x8e, 0x95, 0x9b, 0x75, 0xda, 0xe3, 0x13, 0xda, + 0x8c, 0xf4, 0xf7, 0x28, 0x14, 0xfc, 0x14, 0x3f, + 0x8f, 0x77, 0x79, 0xc6, 0xeb, 0x9f, 0x7f, 0xa1, + 0x72, 0x99, 0xae, 0xad, 0xb6, 0x88, 0x90, 0x18, + 0x50, 0x1d, 0x28, 0x9e, 0x49, 0x00, 0xf7, 0xe4, + 0x33, 0x1b, 0x99, 0xde, 0xc4, 0xb5, 0x43, 0x3a, + 0xc7, 0xd3, 0x29, 0xee, 0xb6, 0xdd, 0x26, 0x54, + 0x5e, 0x96, 0xe5, 0x5b, 0x87, 0x4b, 0xe9, 0x09, + } }, + { NULL, { + 0xe7, 0x18, 0x48, 0x3d, 0x0c, 0xe7, 0x69, 0x64, + 0x4e, 0x2e, 0x42, 0xc7, 0xbc, 0x15, 0xb4, 0x63, + 0x8e, 0x1f, 0x98, 0xb1, 0x3b, 0x20, 0x44, 0x28, + 0x56, 0x32, 0xa8, 0x03, 0xaf, 0xa9, 0x73, 0xeb, + 0xde, 0x0f, 0xf2, 0x44, 0x87, 0x7e, 0xa6, 0x0a, + 0x4c, 0xb0, 0x43, 0x2c, 0xe5, 0x77, 0xc3, 0x1b, + 0xeb, 0x00, 0x9c, 0x5c, 0x2c, 0x49, 0xaa, 0x2e, + 0x4e, 0xad, 0xb2, 0x17, 0xad, 0x8c, 0xc0, 0x9b, + } }, + }; + + errors = 0; + + for (i = 0; i < sizeof(tests) / sizeof(*tests); i++) { + if (tests[i].teststring) { + SHA512_Simple(tests[i].teststring, + strlen(tests[i].teststring), digest); + } else { + SHA512_State s; + int n; + SHA512_Init(&s); + for (n = 0; n < 1000000 / 40; n++) + SHA512_Bytes(&s, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + 40); + SHA512_Final(&s, digest); + } + for (j = 0; j < 64; j++) { + if (digest[j] != tests[i].digest512[j]) { + fprintf(stderr, + "\"%s\" digest512 byte %d should be 0x%02x, is 0x%02x\n", + tests[i].teststring, j, tests[i].digest512[j], + digest[j]); + errors++; + } + } + + } + + printf("%d errors\n", errors); + + return 0; +} + +#endif + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ diff --git a/extern/crypto/CryptSH512.h b/extern/crypto/CryptSH512.h new file mode 100644 index 0000000000..43cf9a87f7 --- /dev/null +++ b/extern/crypto/CryptSH512.h @@ -0,0 +1,49 @@ +#ifndef SSH_SHA512_H +#define SSH_SHA512_H + +typedef struct +{ + unsigned long hi, lo; +} uint64, int64; + +typedef struct +{ + uint64 h[8]; + unsigned char block[128]; + int blkused; + uint32_t len[4]; +} SHA512_State; + +void SHA512_Init(SHA512_State * s); +void SHA512_Bytes(SHA512_State * s, const void *p, int len); +void SHA512_Final(SHA512_State * s, unsigned char *output); +void SHA512_Simple(const void *p, int len, unsigned char *output); + +#endif + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ diff --git a/extern/crypto/CryptSHA.cpp b/extern/crypto/CryptSHA.cpp new file mode 100644 index 0000000000..78f82a0a92 --- /dev/null +++ b/extern/crypto/CryptSHA.cpp @@ -0,0 +1,218 @@ +/* + * SHA1 hash algorithm. Used in SSH2 as a MAC, and the transform is + * also used as a `stirring' function for the PuTTY random number + * pool. Implemented directly from the specification by Simon + * Tatham. + */ + +#include "global.h" +#include "CryptSHA.h" + +/* ---------------------------------------------------------------------- + * Core SHA algorithm: processes 16-word blocks into a message digest. + */ + +#define rol(x,y) ( ((x) << (y)) | (((uint32_t)x) >> (32-y)) ) + +static void SHA_Core_Init(uint32_t h[5]) +{ + h[0] = 0x67452301; + h[1] = 0xefcdab89; + h[2] = 0x98badcfe; + h[3] = 0x10325476; + h[4] = 0xc3d2e1f0; +} + +void SHATransform(unsigned int *digest, unsigned int *block) +{ + unsigned int w[80]; + unsigned int a, b, c, d, e; + int t; + + for (t = 0; t < 16; t++) + w[t] = block[t]; + + for (t = 16; t < 80; t++) { + unsigned int tmp = w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16]; + w[t] = rol(tmp, 1); + } + + a = digest[0]; + b = digest[1]; + c = digest[2]; + d = digest[3]; + e = digest[4]; + + for (t = 0; t < 20; t++) { + unsigned int tmp = + rol(a, 5) + ((b & c) | (d & ~b)) + e + w[t] + 0x5a827999; + e = d; + d = c; + c = rol(b, 30); + b = a; + a = tmp; + } + for (t = 20; t < 40; t++) { + unsigned int tmp = rol(a, 5) + (b ^ c ^ d) + e + w[t] + 0x6ed9eba1; + e = d; + d = c; + c = rol(b, 30); + b = a; + a = tmp; + } + for (t = 40; t < 60; t++) { + unsigned int tmp = rol(a, + 5) + ((b & c) | (b & d) | (c & d)) + e + w[t] + + 0x8f1bbcdc; + e = d; + d = c; + c = rol(b, 30); + b = a; + a = tmp; + } + for (t = 60; t < 80; t++) { + unsigned int tmp = rol(a, 5) + (b ^ c ^ d) + e + w[t] + 0xca62c1d6; + e = d; + d = c; + c = rol(b, 30); + b = a; + a = tmp; + } + + digest[0] += a; + digest[1] += b; + digest[2] += c; + digest[3] += d; + digest[4] += e; +} + +/* ---------------------------------------------------------------------- + * Outer SHA algorithm: take an arbitrary length byte string, + * convert it into 16-word blocks with the prescribed padding at + * the end, and pass those blocks to the core SHA algorithm. + */ + +void SHA_Init(SHA_State * s) +{ + SHA_Core_Init(s->h); + s->blkused = 0; + s->lenhi = s->lenlo = 0; +} + +void SHA_Bytes(SHA_State * s, const void *p, int len) +{ + unsigned char *q = (unsigned char *) p; + uint32_t wordblock[16]; + uint32_t lenw = len; + int i; + + /* + * Update the length field. + */ + s->lenlo += lenw; + s->lenhi += (s->lenlo < lenw); + + if (s->blkused && s->blkused + len < 64) { + /* + * Trivial case: just add to the block. + */ + memcpy(s->block + s->blkused, q, len); + s->blkused += len; + } else { + /* + * We must complete and process at least one block. + */ + while (s->blkused + len >= 64) { + memcpy(s->block + s->blkused, q, 64 - s->blkused); + q += 64 - s->blkused; + len -= 64 - s->blkused; + /* Now process the block. Gather bytes big-endian into words */ + for (i = 0; i < 16; i++) { + wordblock[i] = + (((uint32_t) s->block[i * 4 + 0]) << 24) | + (((uint32_t) s->block[i * 4 + 1]) << 16) | + (((uint32_t) s->block[i * 4 + 2]) << 8) | + (((uint32_t) s->block[i * 4 + 3]) << 0); + } + SHATransform((unsigned int *)s->h, (unsigned int *)wordblock); + s->blkused = 0; + } + memcpy(s->block, q, len); + s->blkused = len; + } +} + +void SHA_Final(SHA_State * s, unsigned char *output) +{ + int i; + int pad; + unsigned char c[64]; + uint32_t lenhi, lenlo; + + if (s->blkused >= 56) + pad = 56 + 64 - s->blkused; + else + pad = 56 - s->blkused; + + lenhi = (s->lenhi << 3) | (s->lenlo >> (32 - 3)); + lenlo = (s->lenlo << 3); + + memset(c, 0, pad); + c[0] = 0x80; + SHA_Bytes(s, &c, pad); + + c[0] = char((lenhi >> 24) & 0xFF); + c[1] = char((lenhi >> 16) & 0xFF); + c[2] = char((lenhi >> 8) & 0xFF); + c[3] = char((lenhi >> 0) & 0xFF); + c[4] = char((lenlo >> 24) & 0xFF); + c[5] = char((lenlo >> 16) & 0xFF); + c[6] = char((lenlo >> 8) & 0xFF); + c[7] = char((lenlo >> 0) & 0xFF); + + SHA_Bytes(s, &c, 8); + + for (i = 0; i < 5; i++) + { + output[i * 4] = char((s->h[i] >> 24) & 0xFF); + output[i * 4 + 1] = char((s->h[i] >> 16) & 0xFF); + output[i * 4 + 2] = char((s->h[i] >> 8) & 0xFF); + output[i * 4 + 3] = char((s->h[i]) & 0xFF); + } +} + +void SHA_Simple(const void *p, int len, unsigned char *output) +{ + SHA_State s; + + SHA_Init(&s); + SHA_Bytes(&s, p, len); + SHA_Final(&s, output); +} + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ diff --git a/extern/crypto/CryptSHA.h b/extern/crypto/CryptSHA.h new file mode 100644 index 0000000000..8b54663875 --- /dev/null +++ b/extern/crypto/CryptSHA.h @@ -0,0 +1,44 @@ +#ifndef SSHSHA_H +#define SSHSHA_H + +typedef struct { + uint32_t h[5]; + unsigned char block[64]; + int blkused; + uint32_t lenhi, lenlo; +} SHA_State; + +void SHA_Init(SHA_State * s); +void SHA_Bytes(SHA_State * s, const void *p, int len); +void SHA_Final(SHA_State * s, unsigned char *output); +void SHA_Simple(const void *p, int len, unsigned char *output); +void SHATransform(unsigned int *digest, unsigned int *block); + +#endif + +/* + * PuTTY is copyright 1997-2001 Simon Tatham. + * + * Portions copyright Robert de Bath, Joris van Rantwijk, Delian + * Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas Barry, + * Justin Bradford, and CORE SDI S.A. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE + * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */