/**
* 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;
}
int main (void) {
bignum_t * prime = bignum_pow (2, 7830457, DIGITS_TO_CONSIDER);
prime = bignum_mult_to (prime, 28433);
prime = bignum_add_to (prime, bignum_get (1));
prime->used = DIGITS_TO_CONSIDER;
bignum_print (prime);
bignum_delete (prime);
return 0;
}
/*
* MAIN: Run the program and tests your functions.
* sample command: ./bignum 4 12 + 13
* Result: 31
*/
int main(int argc, char** argv) {
int input_base;
int* input1;
int* input2;
int* result;
if(argc != 5) {
print_usage(argv[0]);
}
input_base = string_to_integer(argv[1]);
if(!valid_base(input_base)) {
fprintf(stderr, "Invalid base: %s\n", argv[1]);
print_usage(argv[0]);
}
if(!valid_input(argv[2], input_base)) {
fprintf(stderr, "Invalid input1: %s\n", argv[2]);
print_usage(argv[0]);
}
if(!valid_input(argv[4], input_base)) {
fprintf(stderr, "Invalid input2: %s\n", argv[4]);
print_usage(argv[0]);
}
if(argv[3][0] != '-' && argv[3][0] != '+') {
fprintf(stderr, "Invalid operation: %s\n", argv[3]);
print_usage(argv[0]);
}
input1 = string_to_integer_array(argv[2]);
input2 = string_to_integer_array(argv[4]);
result = perform_math(input1, input2, argv[3][0], input_base);
printf("Result: ");
bignum_print(result);
printf("\n");
exit(0);
}
int main(int argc, const char *argv[])
{
#ifdef DB
fp = fopen("input", "r");
#endif
int i, idx;
int digits = 1;
fibo[0].arr[0] = 1;
fibo[1].arr[0] = 2;
for (i = 2; i <= 5000; ++i) {
digits = bignum_add(i, digits);
}
while (scanf("%d", &idx) != EOF) {
if (!idx) {puts("1"); continue;}
bignum_print(idx);
putchar('\n');
}
return 0;
}
int main(int argc, const char * argv[]) {
char *p=(char*)malloc(BUF_SIZE*sizeof(char));
printf("\n请输入选择的大素数p：\n");
scanf("%s",p);
bignum *p1 = bignum_init();
bignum_fromstring(p1, p);
free(p);
if(probablePrime(p1, ACCURACY))
{
printf("p合理");
bignum *yz = bignum_init();
bignum_fromint(yz, 3);
if (bignum_equal(yz,p1)) {
printf("但p太小不适用！\n");
return 1;
}
}else{
printf("p不是素数！\n");
return 1;
}
bignum *p2 = bignum_init();
bignum *temp = bignum_init();
bignum_fromint(temp, 1);
bignum_subtract(p2, p1, temp);
printf("\n请输入选择的本原元α：\n");
char *a=(char*)malloc(BUF_SIZE*sizeof(char));
scanf("%s",a);
bignum *a1 = bignum_init();
bignum_fromstring(a1, a);
free(a);
printf("\n请输入选择的随机整数d：(2<=d<=p-2)\n");
char *d=(char*)malloc(BUF_SIZE*sizeof(char));
scanf("%s",d);
bignum *d1 = bignum_init();
bignum_fromstring(d1, d);
free(d);
bignum *yz0 = bignum_init();
bignum_fromint(yz0, 2);
bignum *yz1 = bignum_init();
bignum_subtract(yz1, p1, yz0);
if( (bignum_greater(d1, yz0)||bignum_equal(d1, yz0))&&(bignum_greater(yz1,d1)||bignum_equal(yz1,d1)) )
{
printf("d合理");
}else{
printf("d不合要求！\n");
return 1;
}
printf("\n请输入您的消息x：\n");
char *x=(char*)malloc(BUF_SIZE*sizeof(char));
scanf("%s",x);
bignum *x1 = bignum_init();
bignum_fromstring(x1, x);
free(x);
printf("\n请输入您选择的k：（2<=k<=p-2且k应与p-1互质）\n");
char *k=(char*)malloc(BUF_SIZE*sizeof(char));
scanf("%s",k);
bignum *k1 = bignum_init();
bignum_fromstring(k1, k);
free(k);
if( (bignum_greater(k1, yz0)||bignum_equal(k1, yz0))&&(bignum_greater(yz1,k1)||bignum_equal(yz1,k1)) )
{
bignum *yz2 = bignum_init();
bignum_gcd(k1, p2, yz2);
if (!bignum_equal(yz2,temp)) {
printf("k不合要求！\n");
return 1;
}
printf("k合理");
}else{
printf("k不合要求！\n");
return 1;
}
bignum *b1 = bignum_init();
bignum_modpow(a1,d1,p1,b1);
printf("\n\n所以\n您生成的公钥（p,α,β）为：\t(");
bignum_print(p1);
printf(",");
bignum_print(a1);
printf(",");
bignum_print(b1);
printf(")\n");
printf("您的私钥为：");
bignum_print(d1);
printf("\n");
printf("您发出的消息(x(r,s))为：\t(");
bignum_print(x1);
printf(",(");
bignum *r1 = bignum_init();
bignum_modpow(a1,k1,p1,r1);
bignum_print(r1);
printf(",");
bignum *s1=bignum_init();
bignum_multiply(temp, d1, r1);
bignum *temp2 = bignum_init();
bignum *x2 = bignum_init();
bignum_copy(x1, x2);
while (bignum_less(x2, temp)) {
bignum *add = bignum_init();
bignum_copy(p2, add);
bignum_iadd(x2, add) ;
}
bignum_subtract(temp2, x2, temp);
// printf("\ntemp2:");
// bignum_print(temp2);
// printf("\t");
// bignum_print(x2);
// printf("\t");
// bignum_print(temp);
// printf("\n");
bignum_inverse(k1, p2, temp);//计算a的逆元result = a^-1 mod m
bignum_multiply(s1, temp, temp2);
bignum_imodulate(s1, p2);//source = source % modulus
bignum_print(s1);
printf("))\n");
bignum *t0 = bignum_init();
bignum_modpow(a1,x1,p1,t0);
bignum *t1 = bignum_init();
bignum_modpow(b1,r1,p1,t1);
bignum *t2 = bignum_init();
bignum_modpow(r1,s1,p1,t2);
bignum *t3 = bignum_init();
bignum_multiply(t3, t1, t2);
bignum_imodulate(t3, p1);
printf("按t=(α^x)mod p，结果为：");
bignum_print(t0);
printf("\n按t=(β^r*r^s)mod p，结果为：");
bignum_print(t3);
printf("\n");
if (bignum_equal(t0, t3)) {
printf("此签名正确有效～\n\n");
}else{
printf("此签名错误无效！\n\n");
}
}
/**
* 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;
}
int main(void)
{
bignum_t sum;
int i;
comb_init();
timer_reset();
for (i = 0; i < 1000; i++)
{
TEST_COMB_SUM("\xf3\xe7\x7f\xfe\x9f\xff\xbd\xff\x37");
TEST_COMB_SUM("\xad\xbd\xde\xff\xfb\xff\xbb\xf7\x2d");
TEST_COMB_SUM("\xf6\xfb\x8a\xf5\xba\xbc\x59\xb3\x0f");
TEST_COMB_SUM("\x05\x40\x33\x02\x27\x00\x21\x87\x1e");
TEST_COMB_SUM("\x04\x00\x81\x06\x90\x08\x00\x52\x0c");
TEST_COMB_SUM("\x10\x0c\x08\x90\xba\x80\x12\x0b\x02");
TEST_COMB_SUM("\xf1\xd0\xa1\x42\x82\x89\x31\x51\x3a");
TEST_COMB_SUM("\x00\x00\x00\x00\x80\x80\x00\x00\x00");
TEST_COMB_SUM("\xbf\xff\xff\xff\xff\xf5\xff\xff\x3f");
TEST_COMB_SUM("\x94\x15\x90\x31\x00\x22\x40\x07\x20");
TEST_COMB_SUM("\xaf\x1f\x0c\xa4\x54\x76\xca\xef\x16");
TEST_COMB_SUM("\x00\x00\x00\x00\x26\x68\x04\x10\x14");
TEST_COMB_SUM("\xbf\xf7\x1b\xdf\xd7\xb7\x5e\xff\x1a");
TEST_COMB_SUM("\x0c\x05\xc0\xb1\x82\x7f\x9b\x9e\x1b");
TEST_COMB_SUM("\xfb\x1b\x3b\xbf\x7c\xef\xff\x7f\x3b");
TEST_COMB_SUM("\x06\x01\x25\x04\x00\x00\x42\x40\x02");
TEST_COMB_SUM("\x20\x02\x00\x20\x40\x00\x08\x00\x00");
TEST_COMB_SUM("\x68\x98\x5a\x4d\x30\xb6\x42\xd0\x2a");
TEST_COMB_SUM("\x57\xfa\x8c\xca\xa2\xae\x13\x45\x14");
TEST_COMB_SUM("\x40\x05\x9f\x99\x7b\x10\x00\xc1\x20");
}
printf("Elapsed time: %fs\n", timer_elapsed());
timer_reset();
for (i = 0; i < 1000; i++)
{
TEST_COMB_FSUM("\xf3\xe7\x7f\xfe\x9f\xff\xbd\xff\x37");
TEST_COMB_FSUM("\xad\xbd\xde\xff\xfb\xff\xbb\xf7\x2d");
TEST_COMB_FSUM("\xf6\xfb\x8a\xf5\xba\xbc\x59\xb3\x0f");
TEST_COMB_FSUM("\x05\x40\x33\x02\x27\x00\x21\x87\x1e");
TEST_COMB_FSUM("\x04\x00\x81\x06\x90\x08\x00\x52\x0c");
TEST_COMB_FSUM("\x10\x0c\x08\x90\xba\x80\x12\x0b\x02");
TEST_COMB_FSUM("\xf1\xd0\xa1\x42\x82\x89\x31\x51\x3a");
TEST_COMB_FSUM("\x00\x00\x00\x00\x80\x80\x00\x00\x00");
TEST_COMB_FSUM("\xbf\xff\xff\xff\xff\xf5\xff\xff\x3f");
TEST_COMB_FSUM("\x94\x15\x90\x31\x00\x22\x40\x07\x20");
TEST_COMB_FSUM("\xaf\x1f\x0c\xa4\x54\x76\xca\xef\x16");
TEST_COMB_FSUM("\x00\x00\x00\x00\x26\x68\x04\x10\x14");
TEST_COMB_FSUM("\xbf\xf7\x1b\xdf\xd7\xb7\x5e\xff\x1a");
TEST_COMB_FSUM("\x0c\x05\xc0\xb1\x82\x7f\x9b\x9e\x1b");
TEST_COMB_FSUM("\xfb\x1b\x3b\xbf\x7c\xef\xff\x7f\x3b");
TEST_COMB_FSUM("\x06\x01\x25\x04\x00\x00\x42\x40\x02");
TEST_COMB_FSUM("\x20\x02\x00\x20\x40\x00\x08\x00\x00");
TEST_COMB_FSUM("\x68\x98\x5a\x4d\x30\xb6\x42\xd0\x2a");
TEST_COMB_FSUM("\x57\xfa\x8c\xca\xa2\xae\x13\x45\x14");
TEST_COMB_FSUM("\x40\x05\x9f\x99\x7b\x10\x00\xc1\x20");
}
printf("Elapsed time: %fs\n", timer_elapsed());
timer_reset();
for (i = 0; i < 1000000; i++)
{
byte comb[12];
((uint32_t*)comb)[0] = get_random();
((uint32_t*)comb)[1] = get_random();
((uint32_t*)comb)[2] = get_random() & ((1 << (70 - 64)) - 1);
comb_sum(&sum, comb);
}
printf("Elapsed time: %fs\n", timer_elapsed());
timer_reset();
for (i = 0; i < 1000000; i++)
{
byte comb[12];
((uint32_t*)comb)[0] = get_random();
((uint32_t*)comb)[1] = get_random();
((uint32_t*)comb)[2] = get_random() & ((1 << (70 - 64)) - 1);
comb_fast_sum(&sum, comb);
}
printf("Elapsed time: %fs\n", timer_elapsed());
bignum_print(&sum);
comb_free();
return 0;
}
