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