/** * 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; }