comment on peut faire calculer la multiplication modulaire de nombre de 1024bits sous windows

calc.exe

pour l'utilisation en C++

essaie ça (sans garantie)
 
http://mysite.verizon.net/mccutchen/bigint/
 
c'est l'équivalent de la librairie BigInteger de java apparement

merci JagStang mais je veux travller sous windows

ben ya les sources

+1

voilà le code
#include <stdio.h>
#include "gmp.h"
 
/* Variable d'état pour le générateur aléatoire */
gmp_randstate_t etat;
 
/* Fonction aleatoire  
   renvoie un grand nombre aléatoire qui a env. taille chiffres */
 
void aleatoire(mpz_t nombre, int taille)
{
  unsigned long int i;
  mpz_t deuxn;  
 
  mpz_init(deuxn);
 
  i = (taille+1)*4;
 
  /* Calcul un nombre aléatoire entre 0 et 10^(n+1) */
  mpz_urandomb(nombre, etat, i);
 
  /* Résultat minimum: 10^taille */
  mpz_ui_pow_ui(deuxn, 10, taille);
 
  /* Ajoute les deux résulats */
  mpz_add(nombre,nombre,deuxn);
 
  mpz_clear(deuxn);
}
 
/* Fonction premier */
 
void premier(mpz_t premier, int taille)
{
  /* Prend un nombre au hasard de taille donnée */
  aleatoire(premier, taille);
 
  /* Prend le nombre premier qui suit notre nombre au hasard */
  mpz_nextprime(premier, premier);
}
 
/* Fonction phi
   calcule phi(pq)=(p-1)(q-1) */
 
void calculephi(mpz_t phi, mpz_t p,mpz_t q)
{
  mpz_t a;
  mpz_t b;
 
  mpz_init_set(a, p);
  mpz_init_set(b, q);
 
  mpz_sub_ui(a, a, 1);
  mpz_sub_ui(b, b, 1);
 
  mpz_mul(phi, a, b);
 
  mpz_clear(a);
  mpz_clear(b);
}
 
void cles(mpz_t a, mpz_t b, mpz_t p, mpz_t q, int taille)
{
  mpz_t phi;
  mpz_t temp;
     
  mpz_init(phi);
  mpz_init(temp);
 
  /* Calcul de phi */
  calculephi(phi,p,q);
   
  /* Choix de a, clé publique, avec (a,phi(n))=1 */
  do {
    aleatoire(a, taille);
    mpz_gcd(temp, a, phi);
  } while (mpz_cmp_ui(temp,1)!=0);
 
  /* Calcul de b, clé privée correspondante */
  mpz_invert(b, a, phi);
}
 
int main() {
  int taille;
  unsigned long int graine;
  mpz_t n,p,q,phi,a,b, clair, code, resultat;
 
  mpz_init(p);
  mpz_init(q);
  mpz_init(n);
  mpz_init(a);
  mpz_init(b);
  mpz_init(clair);
  mpz_init(code);
  mpz_init(resultat);
 
  printf("Graine pour le générateur aléatoire ? " );
  scanf("%d",&graine);
  printf("Taille de p et q ? " );
  scanf("%d",&taille);
  gmp_randinit(etat, GMP_RAND_ALG_DEFAULT);
  gmp_randseed_ui(etat, graine);
  mpz_urandomb(clair, etat, 10);
 
  /* Choix de p et de q différents l'un de l'autre */
 
  do {
    premier(p, taille);
    premier(q, taille);
  }  while (mpz_cmp(p, q)==0);
 
  /* Calcul de n */
  mpz_mul(n,p,q);
 
  /* Calcul des clés */
  cles(a,b,p,q, taille);
 
  /* Affichage de p,q,n,a,b */
 
  printf("\n\nParamètres de chiffrement :\n\n" );
  printf("p = " ); mpz_out_str(stdout, 10, p); printf("\n" );
  printf("q = " ); mpz_out_str(stdout, 10, q); printf("\n" );
  printf("n = " ); mpz_out_str(stdout, 10, n); printf("\n" );
  printf("a = " ); mpz_out_str(stdout, 10, a); printf("\n" );
  printf("b = " ); mpz_out_str(stdout, 10, b); printf("\n" );
     
  printf("\n\n" );
 
  /* Choix d'un message aléatoire et impression */
  aleatoire(clair, taille);
  printf("Message à chiffrer: " ); mpz_out_str(stdout, 10, clair); printf("\n" );
 
  /* Calcul du message chiffré et impression */
  mpz_powm(code, clair, a, n);
  printf("Message chiffré: " ); mpz_out_str(stdout, 10, code); printf("\n" );
 
  /* Calcul du message déchiffré et impression */
 
  mpz_powm(resultat, code, b, n);
  printf("Message déchiffré: " ); mpz_out_str(stdout, 10, resultat); printf("\n" );
 
}

"gmp_randinit" est obsolete et de plus elle est utilisée incorrectement ici.
 
Tu devrais utiliser à la place :
gmp_randinit_default (etat);