/**
* Encode the message of given length, using the public key (exponent, modulus)
* The resulting array will be of size len/bytes, each index being the encryption
* of "bytes" consecutive characters, given by m = (m1 + m2*128 + m3*128^2 + ..),
* encoded = m^exponent mod modulus
*/
bignum *encodeMessage(int len, int bytes, char *message, bignum *exponent, bignum *modulus) {
/* Calloc works here because capacity = 0 forces a realloc by callees but we should really
* bignum_init() all of these */
int i, j;
bignum *encoded = calloc(len/bytes, sizeof(bignum));
bignum *num128 = bignum_init(), *num128pow = bignum_init();
bignum *x = bignum_init(), *current = bignum_init();
bignum_fromint(num128, 128);
bignum_fromint(num128pow, 1);
for(i = 0; i < len; i += bytes) {
bignum_fromint(x, 0);
bignum_fromint(num128pow, 1);
/* Compute buffer[0] + buffer[1]*128 + buffer[2]*128^2 etc (base 128 representation for characters->int encoding)*/
for(j = 0; j < bytes; j++) {
bignum_fromint(current, message[i + j]);
bignum_imultiply(current, num128pow);
bignum_iadd(x, current); /*x += buffer[i + j] * (1 << (7 * j)) */
bignum_imultiply(num128pow, num128);
}
encode(x, exponent, modulus, &encoded[i/bytes]);
#ifndef NOPRINT
bignum_print(&encoded[i/bytes]);
printf(" ");
#endif
}
return encoded;
}
/**
* Compute the inverse of a mod m. Or, result = a^-1 mod m.
*/
void bignum_inverse(bignum* a, bignum* m, bignum* result) {
bignum *remprev = bignum_init(), *rem = bignum_init();
bignum *auxprev = bignum_init(), *aux = bignum_init();
bignum *rcur = bignum_init(), *qcur = bignum_init(), *acur = bignum_init();
bignum_copy(m, remprev);
bignum_copy(a, rem);
bignum_fromint(auxprev, 0);
bignum_fromint(aux, 1);
while(bignum_greater(rem, &NUMS[1])) {
bignum_divide(qcur, rcur, remprev, rem);
/* Observe we are finding the inverse in a finite field so we can use
* a modified algorithm that avoids negative numbers here */
bignum_subtract(acur, m, qcur);
bignum_imultiply(acur, aux);
bignum_iadd(acur, auxprev);
bignum_imodulate(acur, m);
bignum_copy(rem, remprev);
bignum_copy(aux, auxprev);
bignum_copy(rcur, rem);
bignum_copy(acur, aux);
}
bignum_copy(acur, result);
bignum_deinit(remprev);
bignum_deinit(rem);
bignum_deinit(auxprev);
bignum_deinit(aux);
bignum_deinit(rcur);
bignum_deinit(qcur);
bignum_deinit(acur);
}
/**
* Load a bignum from a base 10 string. Only pure numeric strings will work.
*/
void bignum_fromstring(bignum* b, char* string) {
int i, len = 0;
while(string[len] != '\0') len++; /* Find string length */
for(i = 0; i < len; i++) {
if(i != 0) bignum_imultiply(b, &NUMS[10]); /* Base 10 multiply */
bignum_iadd(b, &NUMS[string[i] - '0']); /* Add */
}
}
/**
* Perform modular exponentiation by repeated squaring. This will compute
* result = base^exponent mod modulus
*/
void bignum_modpow(bignum* base, bignum* exponent, bignum* modulus, bignum* result) {
bignum *a = bignum_init(), *b = bignum_init(), *c = bignum_init();
bignum *discard = bignum_init(), *remainder = bignum_init();
bignum_copy(base, a);
bignum_copy(exponent, b);
bignum_copy(modulus, c);
bignum_fromint(result, 1);
while(bignum_greater(b, &NUMS[0])) {
if(b->data[0] & 1) {
bignum_imultiply(result, a);
bignum_imodulate(result, c);
}
bignum_idivide(b, &NUMS[2]);
bignum_copy(a, discard);
bignum_imultiply(a, discard);
bignum_imodulate(a, c);
}
bignum_deinit(a);
bignum_deinit(b);
bignum_deinit(c);
bignum_deinit(discard);
bignum_deinit(remainder);
}
/**
* Divide two bignums by naive long division, producing both a quotient and remainder.
* quotient = floor(b1/b2), remainder = b1 - quotient * b2. If b1 < b2 the quotient is
* trivially 0 and remainder is b2.
*/
void bignum_divide(bignum* quotient, bignum* remainder, bignum* b1, bignum* b2) {
bignum *b2copy = bignum_init(), *b1copy = bignum_init();
bignum *temp = bignum_init(), *temp2 = bignum_init(), *temp3 = bignum_init();
bignum* quottemp = bignum_init();
word carry = 0;
int n, m, i, j, length = 0;
unsigned long long factor = 1;
unsigned long long gquot, gtemp, grem;
if(bignum_less(b1, b2)) { /* Trivial case, b1/b2 = 0 iff b1 < b2. */
quotient->length = 0;
bignum_copy(b1, remainder);
}
else if(bignum_iszero(b1)) { /* 0/x = 0.. assuming b2 is nonzero */
quotient->length = 0;
bignum_fromint(remainder, 0);
}
else if(b2->length == 1) { /* Division by a single limb means we can do simple division */
if(quotient->capacity < b1->length) {
quotient->capacity = b1->length;
quotient->data = realloc(quotient->data, quotient->capacity * sizeof(word));
}
for(i = b1->length - 1; i >= 0; i--) {
gtemp = carry * RADIX + b1->data[i];
gquot = gtemp / b2->data[0];
quotient->data[i] = (unsigned)gquot;
if(quotient->data[i] != 0 && length == 0) length = i + 1;
carry = gtemp % b2->data[0];
}
bignum_fromint(remainder, carry);
quotient->length = length;
}
else { /* Long division is neccessary */
n = b1->length + 1;
m = b2->length;
if(quotient->capacity < n - m) {
quotient->capacity = n - m;
quotient->data = realloc(quotient->data, (n - m) * sizeof(word));
}
bignum_copy(b1, b1copy);
bignum_copy(b2, b2copy);
/* Normalize.. multiply by the divisor by 2 until MSB >= HALFRADIX. This ensures fast
* convergence when guessing the quotient below. We also multiply the dividend by the
* same amount to ensure the result does not change. */
while(b2copy->data[b2copy->length - 1] < HALFRADIX) {
factor *= 2;
bignum_imultiply(b2copy, &NUMS[2]);
}
if(factor > 1) {
bignum_fromint(temp, (unsigned)factor);
bignum_imultiply(b1copy, temp);
}
/* Ensure the dividend is longer than the original (pre-normalized) divisor. If it is not
* we introduce a dummy zero word to artificially inflate it. */
if(b1copy->length != n) {
b1copy->length++;
if(b1copy->length > b1copy->capacity) {
b1copy->capacity = b1copy->length;
b1copy->data = realloc(b1copy->data, b1copy->capacity * sizeof(word));
}
b1copy->data[n - 1] = 0;
}
/* Process quotient by long division */
for(i = n - m - 1; i >= 0; i--) {
gtemp = RADIX * b1copy->data[i + m] + b1copy->data[i + m - 1];
gquot = gtemp / b2copy->data[m - 1];
if(gquot >= RADIX) gquot = UINT_MAX;
grem = gtemp % b2copy->data[m - 1];
while(grem < RADIX && gquot * b2copy->data[m - 2] > RADIX * grem + b1copy->data[i + m - 2]) { /* Should not overflow... ? */
gquot--;
grem += b2copy->data[m - 1];
}
quottemp->data[0] = (unsigned)gquot % RADIX;
quottemp->data[1] = (gquot / RADIX);
if(quottemp->data[1] != 0) quottemp->length = 2;
else quottemp->length = 1;
bignum_multiply(temp2, b2copy, quottemp);
if(m + 1 > temp3->capacity) {
temp3->capacity = m + 1;
temp3->data = realloc(temp3->data, temp3->capacity * sizeof(word));
}
temp3->length = 0;
for(j = 0; j <= m; j++) {
temp3->data[j] = b1copy->data[i + j];
if(temp3->data[j] != 0) temp3->length = j + 1;
}
if(bignum_less(temp3, temp2)) {
bignum_iadd(temp3, b2copy);
gquot--;
}
bignum_isubtract(temp3, temp2);
for(j = 0; j < temp3->length; j++) b1copy->data[i + j] = temp3->data[j];
for(j = temp3->length; j <= m; j++) b1copy->data[i + j] = 0;
quotient->data[i] = (unsigned)gquot;
if(quotient->data[i] != 0) quotient->length = i;
}
if(quotient->data[b1->length - b2->length] == 0) quotient->length = b1->length - b2->length;
else quotient->length = b1->length - b2->length + 1;
/* Divide by factor now to find final remainder */
carry = 0;
for(i = b1copy->length - 1; i >= 0; i--) {
gtemp = carry * RADIX + b1copy->data[i];
b1copy->data[i] = (unsigned)gtemp/factor;
if(b1copy->data[i] != 0 && length == 0) length = i + 1;
carry = (unsigned)gtemp % factor;
}
b1copy->length = length;
bignum_copy(b1copy, remainder);
}
bignum_deinit(temp);
bignum_deinit(temp2);
bignum_deinit(temp3);
bignum_deinit(b1copy);
bignum_deinit(b2copy);
bignum_deinit(quottemp);
}
/**
* Main method to demostrate the system. Sets up primes p, q, and proceeds to encode and
* decode the message given in "text.txt"
*/
int main(void) {
int i, bytes, len;
bignum *p = bignum_init(), *q = bignum_init(), *n = bignum_init();
bignum *phi = bignum_init(), *e = bignum_init(), *d = bignum_init();
bignum *bbytes = bignum_init(), *shift = bignum_init();
bignum *temp1 = bignum_init(), *temp2 = bignum_init();
bignum *encoded;
int *decoded;
char *buffer;
FILE* f;
srand(time(NULL));
randPrime(FACTOR_DIGITS, p);
printf("Got first prime factor, p = ");
bignum_print(p);
printf(" ... ");
getchar();
randPrime(FACTOR_DIGITS, q);
printf("Got second prime factor, q = ");
bignum_print(q);
printf(" ... ");
getchar();
bignum_multiply(n, p, q);
printf("Got modulus, n = pq = ");
bignum_print(n);
printf(" ... ");
getchar();
bignum_subtract(temp1, p, &NUMS[1]);
bignum_subtract(temp2, q, &NUMS[1]);
bignum_multiply(phi, temp1, temp2); /* phi = (p - 1) * (q - 1) */
printf("Got totient, phi = ");
bignum_print(phi);
printf(" ... ");
getchar();
randExponent(phi, EXPONENT_MAX, e);
printf("Chose public exponent, e = ");
bignum_print(e);
printf("\nPublic key is (");
bignum_print(e);
printf(", ");
bignum_print(n);
printf(") ... ");
getchar();
bignum_inverse(e, phi, d);
printf("Calculated private exponent, d = ");
bignum_print(d);
printf("\nPrivate key is (");
bignum_print(d);
printf(", ");
bignum_print(n);
printf(") ... ");
getchar();
/* Compute maximum number of bytes that can be encoded in one encryption */
bytes = -1;
bignum_fromint(shift, 1 << 7); /* 7 bits per char */
bignum_fromint(bbytes, 1);
while(bignum_less(bbytes, n)) {
bignum_imultiply(bbytes, shift); /* Shift by one byte, NB: we use bitmask representative so this can actually be a shift... */
bytes++;
}
printf("Opening file \"text.txt\" for reading\n");
f = fopen("text.txt", "r");
if(f == NULL) {
printf("Failed to open file \"text.txt\". Does it exist?\n");
return EXIT_FAILURE;
}
len = readFile(f, &buffer, bytes); /* len will be a multiple of bytes, to send whole chunks */
printf("File \"text.txt\" read successfully, %d bytes read. Encoding byte stream in chunks of %d bytes ... ", len, bytes);
getchar();
printf("\n");
encoded = encodeMessage(len, bytes, buffer, e, n);
printf("\n\nEncoding finished successfully ... ");
getchar();
printf("Decoding encoded message ... ");
getchar();
printf("\n");
decoded = decodeMessage(len/bytes, bytes, encoded, d, n);
printf("\n\nFinished RSA demonstration!");
/* Eek! This is why we shouldn't of calloc'd those! */
for(i = 0; i < len/bytes; i++) free(encoded[i].data);
free(encoded);
free(decoded);
free(buffer);
bignum_deinit(p);
bignum_deinit(q);
bignum_deinit(n);
bignum_deinit(phi);
bignum_deinit(e);
bignum_deinit(d);
bignum_deinit(bbytes);
bignum_deinit(shift);
bignum_deinit(temp1);
bignum_deinit(temp2);
fclose(f);
return EXIT_SUCCESS;
}
