Encryption rsa (avec biginteger)

Télécharger le projet
Commenter

Description

Mon programme encrypte les fichiers avec l'algorithme d'encryptions rsa, mais en utilisant java sécurité uniquement pour générer des nombre aléatoire. Il aide à la gestion des utilisateurs et encrypte(ou exclusif) les clées privé.

J'ai fais ce programme dans un plus pédagogique qu'utilitaire, les class dans le package java sécurité sont surement plus efficace.

n.b. : la class RSA a été prise sur se cite http://www.cs.princeton.edu/introcs/104crypto/RSA.java.html
mais je l'ais modifier pour l'améliorer et l'adapter à mon application

Comment RSA fonctionne:

Pour l'encryptions,

//les clés public
publicKey = privateKey modulo inverse de (pr1 - 1) * (pr2 - 1)
modulo = pr1 * pr2
//les clés privé
//nombres premier(divisible uniquement par un et eux-même) les plus grand possible
pr1
pr2
privateKey:
  • 1. n'a aucun autre diviseur que 1
  • 2. qu'il est plus grand que p1 et p2
  • 3. qu'il est plus petit que p1*p2


pour l'encryptions on coupe le message en bout et on le transforme en numérique.

sur chaque bout n on effectue l'opération suivante
n^publicKey mod modulo
La publicKey étant la clé public du destinataire.

Pour la décryptions
pour chaque bout n on effectue l'opération suivante
n^privateKey mod modulo
privateKey étant la clé privé du destinataire.

Pour plus de détailles: http://fr.wikipedia.org/wiki/Rivest_Shamir_Adleman

Source / Exemple : 


package rsa;

/**


     
  •  <p>Titre : RSA </p>

    •  
  •  <p>Description : Encodage de données selon le protocole RSA </p>

    •  
  •  <p>Copyright : Copyright (c) 2004</p>

    •  
  •  @author François Bradette

    •  
  •  @version 1.1

    •  
  •  version originale de Robert Sedgewick and Kevin Wayne.Copyright © 2004

    •  
  •  pris sur le site http://www.cs.princeton.edu/introcs/104crypto/RSA.java.html

    •  
  • /

import java.io.*;
import java.math.*;
import java.security.*;

public class RSA
    implements Serializable
{
  private final static BigInteger one = BigInteger.ONE;
  private final static SecureRandom random = new SecureRandom();

  private BigInteger privateKey = null;
  private BigInteger publicKey = null;
  private BigInteger modulus = null;

  private BigInteger p1 = null;
  private BigInteger p2 = null;

  //Ces variables doivent être initialisé pour l'encrytage de données.
  private BigInteger modulusE;
  private BigInteger publicKeyE;

  private int N;
  private BigInteger phi0;
  public RSA(int N)
  {
    this.N = N;
    // generate an N-bit (roughly) public and private key
    //clés privé
    //p1
    p1 = BigInteger.probablePrime(N / 2, random);
    //p2
    p2 = BigInteger.probablePrime(N / 2, random);
    //0
    phi0 = (p1.subtract(one)).multiply(p2.subtract(one));
    //
    //n
    modulus = p1.multiply(p2);
    //d
    setPrivateKey();
    //e
    publicKey = privateKey.modInverse(phi0);

    modulusE = modulus;
    publicKeyE = publicKey;
  }

//renvois la variable public modulo utilisé pour l'encryption
// des donné
  public BigInteger getModulus()
  {
    return modulus;
  }

//renvois la variable public publicKey utilisé par d'autre pour l'encryption
  public BigInteger getPublicKey()
  {
    return publicKey;
  }

//Cette variable doit être initialisé pour être en mesure d'encrypté
//Ces
  public void setPublicKey(BigInteger p, BigInteger n)
  {
    publicKeyE = p;
    modulusE = n;
  }

  /**


       
  •  @param xor BigInteger

   *


       
  •  Cette méthode est employer pour encrypté et pour décrypté les clées

    •    
  •  C'est l'avantage du ou exclusif il sufi de répété la même oprération pour

    •    
  •  encodé et décodé

         
    • /

  public void xOrClePrive(BigInteger xor)
  {
    xor = xor.pow(4);
    privateKey = privateKey.xor(xor);

  }

  /**s'assure que privateKey


       
  •  1. n'a aucun autre diviseur que 1

    •    
  •  2. qu'il est plus grand que le plus grand entre p1 et p2

    •    
  •  3. qu'il est plus petit que p1*p2

    •    
  •  */

  private void setPrivateKey()
  {
    do
    {
      privateKey = BigInteger.probablePrime(N / 2, random);
    }
    while (privateKey.gcd(phi0).intValue() != 1 ||
           privateKey.compareTo(modulus) != -1 ||
           privateKey.compareTo(p1.max(p2)) == -1);
  }

  /*
   Encrypte le message avec les clés public
   pour l'encryption les clés public doivent etre initialisées
   le message doit être divisé en paket de N / 8 octects ou bytes


       
  • /

  public BigInteger encrypt(BigInteger message)
  {
    BigInteger rep = null;
    String str_message = new String(message.toByteArray());
    if (message != null)
    {
      if (str_message.length() <= (N / 8))
        if (publicKeyE != null && modulusE != null &&
            message.toByteArray().length < Integer.MAX_VALUE)
          rep = message.modPow(publicKeyE, modulusE);
    }
    return rep;
  }

  public BigInteger encrypt(BigInteger message, BigInteger publicKeyP,
                            BigInteger modulusP)
  {
    BigInteger rep = null;
    String str_message = new String(message.toByteArray());

    if (str_message.length() <= (N / 8))
      if (publicKeyP != null && modulusP != null &&
          message.toByteArray().length < Integer.MAX_VALUE)
        rep = message.modPow(publicKeyP, modulusP);

    return rep;
  }

  //Décrypte le message avec les clés privé
  public BigInteger decrypt(BigInteger encrypted)
  {
    return encrypted.modPow(privateKey, modulus);
  }

  public String toString()
  {
    String s = "";
    s += "public  = " + publicKey + "\n";
    s += "modulus = " + modulus;
    return s;
  }
}

Conclusion :


Pour l'instant il n'y a pas de bug connus, mais les passwords sont seulement décoratifs(ils ne sont pas validé pour l'instant :) mais ca ne nuis pas au fonctionnement du programme ). Pour avoir plus de détaille sur le fonctionnement de mon logiciel vous pouvez faire un tour sur mon site web http://darksid1.no-ip.biz/Darksid1/Index.jsp
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_darksid)