void hex_random_op2 (enum hex_random_op op, unsigned long maxbits,
char **ap, char **rp)
{
mpz_t a, r;
unsigned long abits;
unsigned signs;
mpz_init (a);
mpz_init (r);
abits = gmp_urandomb_ui (state, 32) % maxbits;
mpz_rrandomb (a, state, abits);
signs = gmp_urandomb_ui (state, 1);
if (signs & 1)
mpz_neg (a, a);
switch (op)
{
default:
abort ();
case OP_SQR:
mpz_mul (r, a, a);
break;
}
gmp_asprintf (ap, "%Zx", a);
gmp_asprintf (rp, "%Zx", r);
mpz_clear (a);
mpz_clear (r);
}
static PyObject *
Pympany_printf(PyObject *self, PyObject *args)
{
PyObject *result = 0, *x = 0;
char *buffer = 0, *fmtcode = 0;
int buflen;
void *generic;
if (!PyArg_ParseTuple(args, "sO", &fmtcode, &x))
return NULL;
if (CHECK_MPZANY(x) || Pympq_Check(x)) {
if (CHECK_MPZANY(x))
generic = Pympz_AS_MPZ(x);
else
generic = Pympq_AS_MPQ(x);
buflen = gmp_asprintf(&buffer, fmtcode, generic);
result = Py_BuildValue("s", buffer);
PyMem_Free(buffer);
return result;
}
#ifdef WITHMPFR
else if(Pympfr_Check(x)) {
generic = Pympfr_AS_MPFR(x);
buflen = mpfr_asprintf(&buffer, fmtcode, generic);
result = Py_BuildValue("s", buffer);
PyMem_Free(buffer);
return result;
}
#endif
else {
TYPE_ERROR("printf() requires a gmpy2 object as argument");
return NULL;
}
}
void HYBRID_process(int writeFile){
unsigned long i;
/*Calculates 5000 factorial*/
unsigned long N=3e3;
/*This sets up the storage variable to store the factorial*/
int bytesize;
char *buffer;
mpz_t factorial;
mpz_init(factorial);
mpz_set_str(factorial, "1", 10);
/*Lets be inefficent and mutiply them all one by one*/
for(i=2; i<=N; i++) {
mpz_mul_ui(factorial,factorial,i);
bytesize=gmp_asprintf(&buffer,"Current factoraial of is %Zd",
factorial);
if(write(writeFile,buffer,bytesize)<0){
perror("Error writing output file");
exit(EXIT_FAILURE);
}
}
/*We are done figuring out 35000 factorial time to cleanup and
*close the program*/
mpz_clear(factorial);
free(buffer);
if(close(writeFile)){
fprintf(stderr, "Error closing the output File");
}
}
int main() {
uint16_t answer = 0;
for (uint16_t i = 0; i < 10000; i++) {
mpz_t n, tmp;
mpz_init_set_ui(n, i);
for (int i=0; i<50; i++) {
char *str;
gmp_asprintf(&str, "%Zd", n);
char *rev = reverse(str);
mpz_init_set_str(tmp, rev, 10);
mpz_add(n, n, tmp);
mpz_clear(tmp);
free(rev);
free(str);
if (gmp_is_palindrome(n))
goto nonlychrel;
}
// If we exited the for loop, count this as a lychrel number
answer++;
nonlychrel:
mpz_clear(n);
}
printf("Answer: %hu lychrel numbers < 10000\n", answer);
return 0;
}
void Float::write(std::ostream& out) const
{
char* buffer;
const int bufferSize = gmp_asprintf(&buffer, "%.Fe", value);
out << buffer;
void (*freefunc)(void*, size_t);
mp_get_memory_functions (NULL, NULL, &freefunc);
freefunc(buffer, bufferSize);
}
void send_key(TcpSocket& stream, PointRef p)
{
char *bgxBuffer = NULL;
char *bgyBuffer = NULL;
string bgxString, bgyString;
Packet pkt;
gmp_asprintf(&bgxBuffer, "%Zd", p->x);
gmp_asprintf(&bgyBuffer, "%Zd", p->y);
bgxString = string(bgxBuffer);
bgyString = string(bgyBuffer);
free(bgxBuffer), bgxBuffer = NULL;
free(bgyBuffer), bgyBuffer = NULL;
pkt << bgxString;
pkt << bgyString;
stream.send(pkt);
cout << "Sent (" << bgxString << ", " << bgyString << ")" << endl;
}
char *
hex_rrandomb (unsigned long bits)
{
char *res;
mpz_t x;
mpz_init (x);
mpz_rrandomb (x, state, bits);
gmp_asprintf (&res, "%Zx", x);
mpz_clear (x);
return res;
}
char *
hex_rrandomb_export (void *dst, size_t *countp,
int order, size_t size, int endian, unsigned long bits)
{
char *res;
mpz_t x;
mpz_init (x);
mpz_rrandomb (x, state, bits);
gmp_asprintf (&res, "%Zx", x);
mpz_export (dst, countp, order, size, endian, 0, x);
mpz_clear (x);
return res;
}
/*
* The series, 1^1 + 2^2 + 3^3 + ... + 10^10 = 10405071317.
*
* Find the last ten digits of the series, 1^1 + 2^2 + 3^3 + ... + 1000^1000.
*/
int main(void) {
int i;
char *s = NULL;
mpz_t n, temp;
mpz_init(n);
mpz_init(temp);
for (i = 1; i <= 1000; i++) {
mpz_ui_pow_ui(temp, i, i);
mpz_add(n, n, temp);
}
i = gmp_asprintf(&s, "%Zd", n);
printf("%s\n", s+i-10);
return 0;
}
/**
* Helper function to convert an mpz_class object into
* its internal QString representation. Mainly used for
* debugging.
*/
static QString mpzToString(const mpz_class & val)
{
char *p = 0;
// use the gmp provided conversion routine
gmp_asprintf(&p, "%Zd", val.get_mpz_t());
// convert it into a QString
QString result(QString::fromLatin1(p));
// and free up the resources allocated by gmp_asprintf
__gmp_freefunc_t freefunc;
mp_get_memory_functions(NULL, NULL, &freefunc);
(*freefunc)(p, std::strlen(p) + 1);
// done
return result;
}
int main(int argc, const char *argv[]) {
uint64_t i;
// Declare and initialize the sum and the base.
mpz_t sum, base, bignum;
mpz_init(sum);
mpz_init(base);
mpz_init(bignum);
// Somewhere to store the char representation of our bignum
// and temp space for each number we will sum.
char *sumnum = NULL;
char tmpint[2];
tmpint[1] = '\0';
// Set the exponent to 1000
uint64_t exp = 1000;
// Set the base to 2
mpz_set_ui(base, 2);
// Perform the calculation: bignum = base^exp
mpz_pow_ui(bignum, base, exp);
// Now turn that into a char array so we can sum each number.
gmp_asprintf(&sumnum, "%Zd", bignum);
// Now sum the thing.
for (i = 0; i < strlen(sumnum); i++) {
memcpy(&tmpint, &sumnum[i], sizeof(char) * 1);
mpz_add_ui(sum, sum, atoi(tmpint));
}
gmp_printf("Sum Total: %Zd\n", sum);
// Clear up
mpz_clear(sum);
mpz_clear(base);
mpz_clear(bignum);
free(sumnum);
return 0;
}
std::string fixTrailingZeros(mpf_class &num, int precision) {
char *buffer = NULL;
gmp_asprintf(&buffer, "%.*Ff", precision + 2, num.get_mpf_t());
int counter = strlen(buffer) - 2;
buffer[counter] = '\0';
--counter;
while (buffer[counter] == '0') {
buffer[counter] = '\0';
--counter;
}
if (buffer[counter] == '.') {
buffer[counter] = '\0';
}
return std::string(buffer);
}
/**
* Helper function to convert an mpq_class object into
* its internal QString representation. Mainly used for
* debugging.
*/
static QString mpqToString(const mpq_class & val)
{
char *p = 0;
// use the gmp provided conversion routine
gmp_asprintf(&p, "%Qd", val.get_mpq_t());
// convert it into a QString
QString result = QString::fromLatin1(p);
// and free up the resources allocated by gmp_asprintf
__gmp_freefunc_t freefunc;
mp_get_memory_functions(NULL, NULL, &freefunc);
(*freefunc)(p, std::strlen(p) + 1);
if (!result.contains(QLatin1Char('/'))) {
result += QString::fromLatin1("/1");
}
// done
return result;
}
void
hex_random_scan_op (enum hex_random_op op, unsigned long maxbits,
char **ap, unsigned long *b, unsigned long *r)
{
mpz_t a;
unsigned long abits, bbits;
unsigned signs;
mpz_init (a);
abits = gmp_urandomb_ui (state, 32) % maxbits;
bbits = gmp_urandomb_ui (state, 32) % (maxbits + 100);
mpz_rrandomb (a, state, abits);
signs = gmp_urandomb_ui (state, 1);
if (signs & 1)
mpz_neg (a, a);
switch (op)
{
default:
abort ();
case OP_SCAN0:
*r = mpz_scan0 (a, bbits);
break;
case OP_SCAN1:
*r = mpz_scan1 (a, bbits);
break;
}
gmp_asprintf (ap, "%Zx", a);
*b = bbits;
mpz_clear (a);
}
extern char* _jl_mpf_printf(mpf_t* rop) {
char* pp;
gmp_asprintf(&pp, "%.Ff", *rop);
return pp;
}
void
hex_random_bit_op (enum hex_random_op op, unsigned long maxbits,
char **ap, unsigned long *b, char **rp)
{
mpz_t a, r;
unsigned long abits, bbits;
unsigned signs;
mpz_init (a);
mpz_init (r);
abits = gmp_urandomb_ui (state, 32) % maxbits;
bbits = gmp_urandomb_ui (state, 32) % (maxbits + 100);
mpz_rrandomb (a, state, abits);
signs = gmp_urandomb_ui (state, 1);
if (signs & 1)
mpz_neg (a, a);
switch (op)
{
default:
abort ();
case OP_SETBIT:
mpz_set (r, a);
mpz_setbit (r, bbits);
break;
case OP_CLRBIT:
mpz_set (r, a);
mpz_clrbit (r, bbits);
break;
case OP_COMBIT:
mpz_set (r, a);
mpz_combit (r, bbits);
break;
case OP_CDIV_Q_2:
mpz_cdiv_q_2exp (r, a, bbits);
break;
case OP_CDIV_R_2:
mpz_cdiv_r_2exp (r, a, bbits);
break;
case OP_FDIV_Q_2:
mpz_fdiv_q_2exp (r, a, bbits);
break;
case OP_FDIV_R_2:
mpz_fdiv_r_2exp (r, a, bbits);
break;
case OP_TDIV_Q_2:
mpz_tdiv_q_2exp (r, a, bbits);
break;
case OP_TDIV_R_2:
mpz_tdiv_r_2exp (r, a, bbits);
break;
}
gmp_asprintf (ap, "%Zx", a);
*b = bbits;
gmp_asprintf (rp, "%Zx", r);
mpz_clear (a);
mpz_clear (r);
}
void
hex_random_op4 (enum hex_random_op op, unsigned long maxbits,
char **ap, char **bp, char **cp, char **dp)
{
mpz_t a, b, c, d;
unsigned long abits, bbits;
unsigned signs;
mpz_init (a);
mpz_init (b);
mpz_init (c);
mpz_init (d);
if (op == OP_POWM)
{
unsigned long cbits;
abits = gmp_urandomb_ui (state, 32) % maxbits;
bbits = 1 + gmp_urandomb_ui (state, 32) % maxbits;
cbits = 2 + gmp_urandomb_ui (state, 32) % maxbits;
mpz_rrandomb (a, state, abits);
mpz_rrandomb (b, state, bbits);
mpz_rrandomb (c, state, cbits);
signs = gmp_urandomb_ui (state, 3);
if (signs & 1)
mpz_neg (a, a);
if (signs & 2)
{
mpz_t g;
/* If we negate the exponent, must make sure that gcd(a, c) = 1 */
if (mpz_sgn (a) == 0)
mpz_set_ui (a, 1);
else
{
mpz_init (g);
for (;;)
{
mpz_gcd (g, a, c);
if (mpz_cmp_ui (g, 1) == 0)
break;
mpz_divexact (a, a, g);
}
mpz_clear (g);
}
mpz_neg (b, b);
}
if (signs & 4)
mpz_neg (c, c);
mpz_powm (d, a, b, c);
}
else
{
unsigned long qbits;
bbits = 1 + gmp_urandomb_ui (state, 32) % maxbits;
qbits = gmp_urandomb_ui (state, 32) % maxbits;
abits = bbits + qbits;
if (abits > 30)
abits -= 30;
else
abits = 0;
mpz_rrandomb (a, state, abits);
mpz_rrandomb (b, state, bbits);
signs = gmp_urandomb_ui (state, 2);
if (signs & 1)
mpz_neg (a, a);
if (signs & 2)
mpz_neg (b, b);
switch (op)
{
default:
abort ();
case OP_CDIV:
mpz_cdiv_qr (c, d, a, b);
break;
case OP_FDIV:
mpz_fdiv_qr (c, d, a, b);
break;
case OP_TDIV:
mpz_tdiv_qr (c, d, a, b);
break;
}
}
gmp_asprintf (ap, "%Zx", a);
gmp_asprintf (bp, "%Zx", b);
gmp_asprintf (cp, "%Zx", c);
gmp_asprintf (dp, "%Zx", d);
mpz_clear (a);
mpz_clear (b);
mpz_clear (c);
mpz_clear (d);
}
void
hex_random_op3 (enum hex_random_op op, unsigned long maxbits,
char **ap, char **bp, char **rp)
{
mpz_t a, b, r;
unsigned long abits, bbits;
unsigned signs;
mpz_init (a);
mpz_init (b);
mpz_init (r);
abits = gmp_urandomb_ui (state, 32) % maxbits;
bbits = gmp_urandomb_ui (state, 32) % maxbits;
mpz_rrandomb (a, state, abits);
mpz_rrandomb (b, state, bbits);
signs = gmp_urandomb_ui (state, 3);
if (signs & 1)
mpz_neg (a, a);
if (signs & 2)
mpz_neg (b, b);
switch (op)
{
default:
abort ();
case OP_ADD:
mpz_add (r, a, b);
break;
case OP_SUB:
mpz_sub (r, a, b);
break;
case OP_MUL:
mpz_mul (r, a, b);
break;
case OP_GCD:
if (signs & 4)
{
/* Produce a large gcd */
unsigned long gbits = gmp_urandomb_ui (state, 32) % maxbits;
mpz_rrandomb (r, state, gbits);
mpz_mul (a, a, r);
mpz_mul (b, b, r);
}
mpz_gcd (r, a, b);
break;
case OP_LCM:
if (signs & 4)
{
/* Produce a large gcd */
unsigned long gbits = gmp_urandomb_ui (state, 32) % maxbits;
mpz_rrandomb (r, state, gbits);
mpz_mul (a, a, r);
mpz_mul (b, b, r);
}
mpz_lcm (r, a, b);
break;
case OP_AND:
mpz_and (r, a, b);
break;
case OP_IOR:
mpz_ior (r, a, b);
break;
case OP_XOR:
mpz_xor (r, a, b);
break;
}
gmp_asprintf (ap, "%Zx", a);
gmp_asprintf (bp, "%Zx", b);
gmp_asprintf (rp, "%Zx", r);
mpz_clear (a);
mpz_clear (b);
mpz_clear (r);
}
extern char* _jl_mpz_printf(mpz_t* rop) {
char* pp;
int s = gmp_asprintf(&pp, "%Zd", *rop);
return pp;
}
int main (int argc, char* argv[])
{
if(argc !=4)
{
printf("usage : ./craquage p r m\n");
return EXIT_FAILURE;
}
//Initialisation des variables
int nb_esclaves = atoi(argv[1]);
int* tids = (int*) calloc(nb_esclaves, sizeof(int));
int longueur_mdp = atoi(argv[2]);
char* mdp = (char*) calloc(strlen(argv[3])+1, sizeof(char));
strcpy(mdp, argv[3]);
//declaration de type de tres long entiers (avec bibliotheque GMP)
mpz_t debut_sequence, pas_reel, pas, fin_exec;
mpz_init(debut_sequence);
mpz_init(pas_reel);
mpz_init(pas);
mpz_init(fin_exec);
//recuperation du chemin de l executable
char* chemin = getcwd(NULL, 1000);
strcat(chemin, "/craquage_esclave");
//creation des arguments pour l esclave
char *argv_esclave[3];
argv_esclave[2]=NULL;
argv_esclave[0] = (char*) calloc(strlen(argv[2])+1, sizeof(char));
strcpy(argv_esclave[0],argv[2]);
argv_esclave[1] = (char*) calloc(strlen(argv[3])+1, sizeof(char));
strcpy(argv_esclave[1],argv[3]);
//printf("strlen %lu, %lu\n", (long unsigned)strlen(argv[2]),(long unsigned) strlen(argv[3]));
//printf("nb_esclaves %d\n", nb_esclaves);
int i;
int trouve = 0;
int fini = 0;
int size;
int nb_envoi = 0;
int nb_pas = nb_esclaves*longueur_mdp;
int nb_changement = 0;
char* envoi_char;
int bufid, info, bytes, type, source;
char * solution;
pvm_catchout(stderr);
struct timeval tv1, tv2;
gettimeofday(&tv1, NULL);
pvm_spawn(chemin, argv_esclave, PvmTaskDefault,"", nb_esclaves, tids);
//calcul du pas, fin_exec (= fin execution)
mpz_set_ui(debut_sequence, 0);
mpz_ui_pow_ui(fin_exec, 15, longueur_mdp+1);
mpz_sub_ui(fin_exec, fin_exec, 15);
mpz_cdiv_q_ui(fin_exec, fin_exec, 14);
mpz_set(pas, fin_exec);
mpz_cdiv_q_ui(pas, pas, nb_pas);
if(mpz_cmp_ui(pas, 0)==0)
{
mpz_set_ui(pas,1);
}
//gmp_printf("fin_exec: %Zd\npas:%Zd\ndebut_sequence:%Zd\n",fin_exec, pas, debut_sequence);
//boucle principale
while(!trouve && fini!=nb_esclaves)
{
//Attente de reception de donnees d un esclave
bufid = pvm_recv( -1, -1 );
info = pvm_bufinfo( bufid, &bytes, &type, &source );
if (info < 0)
{
printf("Erreur de reception : %d\n", info);
exit(1);
}
//selon le tag du message, demande de donnees ou solution trouvee
switch(type)
{
case(0)://mot de passe trouve
solution = calloc(bytes, sizeof(char));
pvm_upkstr(solution);
printf("\nLa solution est : %s\n\n", solution);
trouve = 1;
break;
case(1)://esclave veut plus de donnees
//prendre en compte la fin des donnees dans le calcul du pas
if(nb_changement <= 2 && nb_envoi>=(3*nb_pas/4))
{
mpz_cdiv_q_ui(pas, pas, 2);
nb_envoi = 0;
nb_pas/=2;
nb_changement++;
}
//gmp_printf("fin_exec: %Zd pas:%Zd debut_sequence:%Zd\n",fin_exec, pas, debut_sequence);
if(mpz_cmp(debut_sequence, fin_exec)< 0){
mpz_sub(pas_reel, fin_exec, debut_sequence);
if(mpz_cmp(pas, pas_reel)<0)
{
mpz_set(pas_reel, pas);
}
//envoi des donnes a l esclave
pvm_initsend(PvmDataDefault);
size = gmp_asprintf(&envoi_char, "%Zd", debut_sequence);
pvm_pkint(&size, 1, 1);
pvm_pkbyte(envoi_char,size+1, 1);
free(envoi_char);
size = gmp_asprintf(&envoi_char, "%Zd", pas_reel);
pvm_pkint(&size, 1, 1);
pvm_pkbyte(envoi_char,size+1 , 1);
free(envoi_char);
pvm_send(source,0);
if(mpz_cmp(pas_reel,pas)!=0)
{
mpz_set(debut_sequence,fin_exec);
}
else
{
mpz_add(debut_sequence, debut_sequence,pas);
}
nb_envoi++;
}
else{
fini++ ;
printf("Pas de solution pour %d esclave(s)\n", fini);
}
break;
default:
break;
}
}
// suppression des esclave
for(i=0; i<nb_esclaves;i++)
{
info = pvm_kill(tids[i]);
//printf("Suppression de l esclave %d: retour de pvm_kill: %d\n",i ,info);
}
pvm_exit();
gettimeofday(&tv2, NULL);
printf("%d %ld\n",longueur_mdp,(tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000);
mpz_clear(debut_sequence);
mpz_clear(pas_reel);
mpz_clear(pas);
mpz_clear(fin_exec);
free(tids);
free(mdp);
free(argv_esclave[0]);
free(argv_esclave[1]);
return EXIT_SUCCESS;
}
