void BigInteger::getText(string& str, unsigned int radix) const { int size; CHECK_MP(mp_radix_size(const_cast<mp_int*>(&t), radix, &size)); str.resize(size - 1, ' '); CHECK_MP(mp_toradix(const_cast<mp_int*>(&t), str.begin(), radix)); }
int mp_fwrite(mp_int *a, int radix, FILE *stream) { char *buf; int err, len, x; if ((err = mp_radix_size(a, radix, &len)) != MP_OKAY) { return err; } buf = OPT_CAST(char) XMALLOC (len); if (buf == NULL) { return MP_MEM; } if ((err = mp_toradix(a, buf, radix)) != MP_OKAY) { XFREE (buf); return err; } for (x = 0; x < len; x++) { if (fputc(buf[x], stream) == EOF) { XFREE (buf); return MP_VAL; } } XFREE (buf); return MP_OKAY; }
int main(int argc, char *argv[]) { mp_int a, b, c; if(argc < 3) { fprintf(stderr, "Usage: %s <a> <b>\n", argv[0]); return 1; } mp_init(&a); mp_init(&b); mp_init(&c); mp_read_radix(&a, (unsigned char *)argv[1], 10); mp_read_radix(&b, (unsigned char *)argv[2], 10); mp_mul(&a, &b, &c); { int len = mp_radix_size(&c, 10); char *buf = malloc(len + 1); mp_todecimal(&c, (unsigned char *)buf); printf("a + b = %s\n", buf); free(buf); } mp_clear(&a); mp_clear(&b); mp_clear(&c); return 0; }
int main(void) { char input[128]; mp_int val; mp_err res; fprintf(stderr, "Please enter a number (base 10): "); fgets(input, sizeof(input), stdin); mp_init(&val); if((res = mp_read_radix(&val, (unsigned char *)input, 10)) != MP_OKAY) { fprintf(stderr, "Error converting input value: %s\n", mp_strerror(res)); return 1; } { int out_len = mp_radix_size(&val, 10); unsigned char *buf = malloc(out_len); mp_toradix(&val, buf, 10); printf("You entered: %s\n", buf); free(buf); } mp_clear(&val); return 0; }
int main(int argc, char *argv[]) { mp_int a, b, m; mp_err res; char *str; int len, rval = 0; if(argc < 3) { fprintf(stderr, "Usage: %s <a> <b> <m>\n", argv[0]); return 1; } mp_init(&a); mp_init(&b); mp_init(&m); mp_read_radix(&a, argv[1], 10); mp_read_radix(&b, argv[2], 10); mp_read_radix(&m, argv[3], 10); if((res = mp_exptmod(&a, &b, &m, &a)) != MP_OKAY) { fprintf(stderr, "%s: error: %s\n", argv[0], mp_strerror(res)); rval = 1; } else { len = mp_radix_size(&a, 10); str = calloc(len, sizeof(char)); mp_toradix(&a, str, 10); printf("%s\n", str); free(str); } mp_clear(&a); mp_clear(&b); mp_clear(&m); return rval; }
size_t bn_strlen (mp_int *a) { int needed_size; int ret = mp_radix_size (a, 10, &needed_size); if (ret != MP_OKAY) Fatal (1, error, "Error getting radix size"); return needed_size - 1; }
/* Serializes the data. */ static void serialize(PARROT_INTERP, STable *st, void *data, SerializationWriter *writer) { mp_int *i = &((P6bigintBody *)data)->i; int len; char *buf; mp_radix_size(i, 10, &len); buf = (char *) mem_sys_allocate(len); mp_toradix_n(i, buf, 10, len); /* len - 1 because buf is \0-terminated */ writer->write_str(interp, writer, Parrot_str_new(interp, buf, len - 1)); mem_sys_free(buf); }
void print_mp_int(mp_int *mp, FILE *ofp) { char *buf; int len; len = mp_radix_size(mp, 10); buf = calloc(len, sizeof(char)); mp_todecimal(mp, buf); fprintf(ofp, "%s\n", buf); free(buf); }
/** * Create a string representation of a given multi-precision integer * * @param s destination pointer * @param mp the number to represent * @param base Output the string representation in this base */ void static fhe_mp_to_string(char **s, mp_int *mp, int base) { int size; // is int, not size_t; this is how libtommath wants it // libtommath documentation says that the maximum base is 64; base < 2 does // not make sense. (Actually, base 1 makes sense, but nobody seems to // agree with me on that one.) assert(base > 1 && base <= 64); /* Allocate space and generate ASCII representation of private key */ (void)mp_radix_size(mp, 0x10, &size); *s = (char *)checkMalloc(size); (void)mp_toradix(mp, *s, 0x10); }
int main(int argc, char *argv[]) { mp_int a, m; mp_err res; char *buf; int len, out = 0; if (argc < 3) { fprintf(stderr, "Usage: %s <a> <m>\n", argv[0]); return 1; } mp_init(&a); mp_init(&m); mp_read_radix(&a, argv[1], 10); mp_read_radix(&m, argv[2], 10); if (mp_cmp(&a, &m) > 0) mp_mod(&a, &m, &a); switch ((res = mp_invmod(&a, &m, &a))) { case MP_OKAY: len = mp_radix_size(&a, 10); buf = malloc(len); mp_toradix(&a, buf, 10); printf("%s\n", buf); free(buf); break; case MP_UNDEF: printf("No inverse\n"); out = 1; break; default: printf("error: %s (%d)\n", mp_strerror(res), res); out = 2; break; } mp_clear(&a); mp_clear(&m); return out; }
int main(int argc, char *argv[]) { int ix, ibase = IBASE, obase = OBASE; mp_int val; ix = 1; if(ix < argc) { ibase = atoi(argv[ix++]); if(ibase < MINBASE || ibase > MAXBASE) { fprintf(stderr, "%s: input radix must be between %d and %d inclusive\n", argv[0], MINBASE, MAXBASE); return 1; } } if(ix < argc) { obase = atoi(argv[ix++]); if(obase < MINBASE || obase > MAXBASE) { fprintf(stderr, "%s: output radix must be between %d and %d inclusive\n", argv[0], MINBASE, MAXBASE); return 1; } } mp_init(&val); while(ix < argc) { char *out; int outlen; mp_read_radix(&val, argv[ix++], ibase); outlen = mp_radix_size(&val, obase); out = calloc(outlen, sizeof(char)); mp_toradix(&val, out, obase); printf("%s\n", out); free(out); } mp_clear(&val); return 0; }
int main(int argc, char *argv[]) { mp_int a; char *buf; int len; if(argc < 2) { fprintf(stderr, "Usage: %s <a>\n", argv[0]); return 1; } mp_init(&a); mp_read_radix(&a, argv[1], 16); len = mp_radix_size(&a, 10); buf = malloc(len); mp_toradix(&a, buf, 10); printf("%s\n", buf); free(buf); mp_clear(&a); return 0; }
/* The main() is not required -- it's just a test driver */ int main(int argc, char *argv[]) { mp_int start; mp_err res; if(argc < 2) { fprintf(stderr, "Usage: %s <start-value>\n", argv[0]); return 1; } mp_init(&start); if(argv[1][0] == '0' && tolower(argv[1][1]) == 'x') { mp_read_radix(&start, argv[1] + 2, 16); } else { mp_read_radix(&start, argv[1], 10); } mp_abs(&start, &start); if((res = make_prime(&start, 5)) != MP_OKAY) { fprintf(stderr, "%s: error: %s\n", argv[0], mp_strerror(res)); mp_clear(&start); return 1; } else { char *buf = malloc(mp_radix_size(&start, 10)); mp_todecimal(&start, buf); printf("%s\n", buf); free(buf); mp_clear(&start); return 0; } } /* end main() */
int main(int argc, char *argv[]) { unsigned char *raw; char *out; unsigned long nTries; int rawlen, bits, outlen, ngen, ix, jx; int g_strong = 0; mp_int testval; mp_err res; clock_t start, end; /* We'll just use the C library's rand() for now, although this won't be good enough for cryptographic purposes */ if((out = PR_GetEnvSecure("SEED")) == NULL) { srand((unsigned int)time(NULL)); } else { srand((unsigned int)atoi(out)); } if(argc < 2) { fprintf(stderr, "Usage: %s <bits> [<count> [strong]]\n", argv[0]); return 1; } if((bits = abs(atoi(argv[1]))) < CHAR_BIT) { fprintf(stderr, "%s: please request at least %d bits.\n", argv[0], CHAR_BIT); return 1; } /* If optional third argument is given, use that as the number of primes to generate; otherwise generate one prime only. */ if(argc < 3) { ngen = 1; } else { ngen = abs(atoi(argv[2])); } /* If fourth argument is given, and is the word "strong", we'll generate strong (Sophie Germain) primes. */ if(argc > 3 && strcmp(argv[3], "strong") == 0) g_strong = 1; /* testval - candidate being tested; nTries - number tried so far */ if ((res = mp_init(&testval)) != MP_OKAY) { fprintf(stderr, "%s: error: %s\n", argv[0], mp_strerror(res)); return 1; } if(g_strong) { printf("Requested %d strong prime value(s) of %d bits.\n", ngen, bits); } else { printf("Requested %d prime value(s) of %d bits.\n", ngen, bits); } rawlen = (bits / CHAR_BIT) + ((bits % CHAR_BIT) ? 1 : 0) + 1; if((raw = calloc(rawlen, sizeof(unsigned char))) == NULL) { fprintf(stderr, "%s: out of memory, sorry.\n", argv[0]); return 1; } /* This loop is one for each prime we need to generate */ for(jx = 0; jx < ngen; jx++) { raw[0] = 0; /* sign is positive */ /* Pack the initializer with random bytes */ for(ix = 1; ix < rawlen; ix++) raw[ix] = (rand() * rand()) & UCHAR_MAX; raw[1] |= 0x80; /* set high-order bit of test value */ raw[rawlen - 1] |= 1; /* set low-order bit of test value */ /* Make an mp_int out of the initializer */ mp_read_raw(&testval, (char *)raw, rawlen); /* Initialize candidate counter */ nTries = 0; start = clock(); /* time generation for this prime */ do { res = mpp_make_prime(&testval, bits, g_strong, &nTries); if (res != MP_NO) break; /* This code works whether digits are 16 or 32 bits */ res = mp_add_d(&testval, 32 * 1024, &testval); res = mp_add_d(&testval, 32 * 1024, &testval); FPUTC(',', stderr); } while (1); end = clock(); if (res != MP_YES) { break; } FPUTC('\n', stderr); puts("The following value is probably prime:"); outlen = mp_radix_size(&testval, 10); out = calloc(outlen, sizeof(unsigned char)); mp_toradix(&testval, (char *)out, 10); printf("10: %s\n", out); mp_toradix(&testval, (char *)out, 16); printf("16: %s\n\n", out); free(out); printf("Number of candidates tried: %lu\n", nTries); printf("This computation took %ld clock ticks (%.2f seconds)\n", (end - start), ((double)(end - start) / CLOCKS_PER_SEC)); FPUTC('\n', stderr); } /* end of loop to generate all requested primes */ if(res != MP_OKAY) fprintf(stderr, "%s: error: %s\n", argv[0], mp_strerror(res)); free(raw); mp_clear(&testval); return 0; }
int main(int argc, char *argv[]) { unsigned char *raw, *out; int rawlen, bits, outlen, ngen, ix, jx; mp_int testval, q, ntries; mp_err res; mp_digit np; clock_t start, end; #ifdef MACOS argc = ccommand(&argv); #endif /* We'll just use the C library's rand() for now, although this won't be good enough for cryptographic purposes */ if((out = (unsigned char *)getenv("SEED")) == NULL) { srand((unsigned int)time(NULL)); } else { srand((unsigned int)atoi((char *)out)); } if(argc < 2) { fprintf(stderr, "Usage: %s <bits> [<count> [strong]]\n", argv[0]); return 1; } if((bits = abs(atoi(argv[1]))) < CHAR_BIT) { fprintf(stderr, "%s: please request at least %d bits.\n", argv[0], CHAR_BIT); return 1; } /* If optional third argument is given, use that as the number of primes to generate; otherwise generate one prime only. */ if(argc < 3) { ngen = 1; } else { ngen = abs(atoi(argv[2])); } /* If fourth argument is given, and is the word "strong", we'll generate strong (Sophie Germain) primes. */ if(argc > 3 && strcmp(argv[3], "strong") == 0) g_strong = 1; /* testval - candidate being tested ntries - number tried so far q - used in finding strong primes */ if((res = mp_init(&testval)) != MP_OKAY || (res = mp_init(&ntries)) != MP_OKAY || (res = mp_init(&q)) != MP_OKAY) { fprintf(stderr, "%s: error: %s\n", argv[0], mp_strerror(res)); return 1; } if(g_strong) { printf("Requested %d strong prime values of at least %d bits.\n", ngen, bits); } else { printf("Requested %d prime values of at least %d bits.\n", ngen, bits); } rawlen = (bits / CHAR_BIT) + ((bits % CHAR_BIT) ? 1 : 0); if((raw = calloc(rawlen, sizeof(unsigned char))) == NULL) { fprintf(stderr, "%s: out of memory, sorry.\n", argv[0]); return 1; } /* This loop is one for each prime we need to generate */ for(jx = 0; jx < ngen; jx++) { /* Pack the initializer with random bytes */ for(ix = 0; ix < rawlen; ix++) raw[ix] = (rand() * rand()) & UCHAR_MAX; raw[0] |= 0x80; /* set high-order bit of test value */ if(g_strong) raw[rawlen - 1] |= 7; /* set low-order 3 bits of test value */ else raw[rawlen - 1] |= 1; /* set low-order bit of test value */ /* Make an mp_int out of the initializer */ mp_read_unsigned_bin(&testval, raw, rawlen); /* If we asked for a strong prime, shift down one bit so that when we double, we're still within the right range of bits ... this is why we OR'd with 7 instead of 1 above (leaves two bits set so that the value remains congruent to 3 (mod 4)). */ if(g_strong) { mp_copy(&testval, &q); mp_div_2(&testval, &testval); } /* Initialize candidate counter */ mp_zero(&ntries); mp_add_d(&ntries, 1, &ntries); start = clock(); /* time generation for this prime */ for(;;) { /* Test for divisibility by small primes (of which there is a table conveniently stored in mpprime.c) */ np = prime_tab_size; if(mpp_divis_primes(&testval, &np) == MP_NO) { /* If we're trying for a strong prime, test 2p+1 before running other primality tests */ if(g_strong) { np = prime_tab_size; if(mpp_divis_primes(&q, &np) == MP_YES) goto NEXT_CANDIDATE; } /* If that passed, run a Fermat test */ res = mpp_fermat(&testval, 2); switch(res) { case MP_NO: /* composite */ goto NEXT_CANDIDATE; case MP_YES: /* may be prime */ break; default: goto CLEANUP; /* some other error */ } /* If that passed, run some Miller-Rabin tests */ res = mpp_pprime(&testval, NUM_TESTS); switch(res) { case MP_NO: /* composite */ goto NEXT_CANDIDATE; case MP_YES: /* may be prime */ break; default: goto CLEANUP; /* some other error */ } /* At this point, we have strong evidence that our candidate is itself prime. If we want a strong prime, we need now to test q = 2p + 1 for primality... */ if(g_strong) { if(res == MP_YES) { fputc('.', stderr); /* If we get here, we've already tested q against small prime divisors, so we can just do the regular primality testing */ /* Fermat, as with its parent ... */ res = mpp_fermat(&q, 2); switch(res) { case MP_NO: /* composite */ goto NEXT_CANDIDATE; case MP_YES: /* may be prime */ break; default: goto CLEANUP; /* some other error */ } /* And, with Miller-Rabin, as with its parent ... */ res = mpp_pprime(&q, NUM_TESTS); switch(res) { case MP_NO: /* composite */ goto NEXT_CANDIDATE; case MP_YES: /* may be prime */ break; default: goto CLEANUP; /* some other error */ } /* If it passed, we've got a winner */ if(res == MP_YES) { fputc('\n', stderr); mp_copy(&q, &testval); break; } } /* end if(res == MP_YES) */ } else { /* We get here if g_strong is false */ if(res == MP_YES) break; } } /* end if(not divisible by small primes) */ /* If we're testing strong primes, skip to the next odd value congruent to 3 (mod 4). Otherwise, just skip to the next odd value */ NEXT_CANDIDATE: if(g_strong) { mp_add_d(&q, 4, &q); mp_div_2(&q, &testval); } else mp_add_d(&testval, 2, &testval); mp_add_d(&ntries, 1, &ntries); } /* end of loop to generate a single prime */ end = clock(); printf("After %d tests, the following value is still probably prime:\n", NUM_TESTS); outlen = mp_radix_size(&testval, 10); out = calloc(outlen, sizeof(unsigned char)); mp_toradix(&testval, out, 10); printf("10: %s\n", (char *)out); mp_toradix(&testval, out, 16); printf("16: %s\n\n", (char *)out); free(out); printf("Number of candidates tried: "); outlen = mp_radix_size(&ntries, 10); out = calloc(outlen, sizeof(unsigned char)); mp_toradix(&ntries, out, 10); printf("%s\n", (char *)out); free(out); printf("This computation took %ld clock ticks (%.2f seconds)\n", (end - start), ((double)(end - start) / CLOCKS_PER_SEC)); fputc('\n', stdout); } /* end of loop to generate all requested primes */ CLEANUP: if(res != MP_OKAY) fprintf(stderr, "%s: error: %s\n", argv[0], mp_strerror(res)); free(raw); mp_clear(&testval); mp_clear(&q); mp_clear(&ntries); return 0; }
int main(int argc, char *argv[]) { mp_int a, m, p, k; if(argc < 3) { fprintf(stderr, "Usage: %s <a> <m>\n", argv[0]); return 1; } mp_init(&a); mp_init(&m); mp_init(&p); mp_add_d(&p, 1, &p); mp_read_radix(&a, argv[1], 10); mp_read_radix(&m, argv[2], 10); mp_init_copy(&k, &a); signal(SIGINT, sig_catch); #ifndef __OS2__ signal(SIGHUP, sig_catch); #endif signal(SIGTERM, sig_catch); while(mp_cmp(&p, &m) < 0) { if(g_quit) { int len; char *buf; len = mp_radix_size(&p, 10); buf = malloc(len); mp_toradix(&p, buf, 10); fprintf(stderr, "Terminated at: %s\n", buf); free(buf); return 1; } if(mp_cmp_d(&k, 1) == 0) { int len; char *buf; len = mp_radix_size(&p, 10); buf = malloc(len); mp_toradix(&p, buf, 10); printf("%s\n", buf); free(buf); break; } mp_mulmod(&k, &a, &m, &k); mp_add_d(&p, 1, &p); } if(mp_cmp(&p, &m) >= 0) printf("No annihilating power.\n"); mp_clear(&p); mp_clear(&m); mp_clear(&a); return 0; }