Probleme cryptage [Résolu]

Messages postés
13
Date d'inscription
samedi 8 mai 2004
Dernière intervention
20 décembre 2006
- 17 déc. 2006 à 18:48 - Dernière réponse :
Messages postés
13
Date d'inscription
samedi 8 mai 2004
Dernière intervention
20 décembre 2006
- 17 déc. 2006 à 23:01
Bonsoir tt le monde, j'ai un problème avec mon programme.
C'est un programme de cryptage (DES, RSA, Hashage MD5 ) avec bouncycaslte, Tous se fait nikel

Je vx signer un fichier, (j'utilise le RSA pour signer un fichier hashé avec MD5 )

Ce que je fé, c utiliser la foncton RSA.decrypt() ( ki marche nikel) pour signer (avec Engine.init(true, privParameters); pour signer au lieu de eng.init(false, privParameters); pour decrypter ) ==> ça marche

mais qd je vx unsigner mon fichier, j'utilise RSA.crypt() ( ki marche nikel ) pour unsigner (avec Engine.init(false, pubParameters); pour unsigner au lieu de Engine.init(true, pubParameters); pour crypter ) ==> j'ai une erreur de ce type :
        java.lang.ArrayIndexOutOfBoundsException
                at java.lang.System.arraycopy(Native Method)
                at java.io.BufferedOutputStream.write(BufferedOutputStream.java:111)
                at RSA.unsigned(RSA.java:333)

Voici ma Classe RSA :    (aidez moi c tres urgent )

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.io.DataInputStream;
import java.io.InputStreamReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.File;
import java.math.BigInteger;
import java.security.SecureRandom;
 
import org.bouncycastle.crypto.AsymmetricBlockCipher;
import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
import org.bouncycastle.crypto.encodings.PKCS1Encoding;
import org.bouncycastle.crypto.engines.RSAEngine;
import org.bouncycastle.crypto.generators.RSAKeyPairGenerator;
import org.bouncycastle.crypto.params.RSAKeyGenerationParameters;
import org.bouncycastle.crypto.params.RSAKeyParameters;
import org.bouncycastle.crypto.params.RSAPrivateCrtKeyParameters;

public class RSA{
   
    AsymmetricCipherKeyPair  pair;
   
    String fi, fo, publickey, privatekey, key;
   
   
    ////////////////////////////////////////////////////////////////////////////
    //////////////////////////Constructor1 ()///////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    public RSA(String privatekey, String publickey){
        this.publickey  = publickey;
        this.privatekey = privatekey;
    }
   
   
    ////////////////////////////////////////////////////////////////////////////
    //////////////////////////Constructor2 ()///////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    public RSA(String in, String out, String key){
        this.fi = in;
        this.fo = out;
        this.key = key;
    }
   
   
    ////////////////////////////////////////////////////////////////////////////
    //////////////////////////Generate Key ()///////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    public boolean generateRSAKeyPair(){
        RSAKeyPairGenerator          pGen         = new RSAKeyPairGenerator();
        RSAKeyGenerationParameters  genParam    = new RSAKeyGenerationParameters(BigInteger.valueOf(0x11), new SecureRandom(), 768, 25);
       
        pGen.init(genParam);
       
        pair = pGen.generateKeyPair();
       
       
        try {
            FileWriter        fwpu    = new FileWriter(publickey);
            BufferedWriter    bwpu    = new BufferedWriter(fwpu);
           
            bwpu.write((((RSAKeyParameters)pair.getPublic()).getModulus()).toString());
            bwpu.write("\n");
            bwpu.write((((RSAKeyParameters)pair.getPublic()).getExponent()).toString());
           
            bwpu.close();
            fwpu.close();
           
            FileWriter fwpr= new FileWriter(privatekey);
            BufferedWriter bwpr = new BufferedWriter(fwpr);
           
            bwpr.write((((RSAPrivateCrtKeyParameters)pair.getPrivate()).getModulus()).toString());
            bwpr.write("\n");
            bwpr.write((((RSAPrivateCrtKeyParameters)pair.getPrivate()).getPublicExponent()).toString());
            bwpr.write("\n");
            bwpr.write((((RSAPrivateCrtKeyParameters)pair.getPrivate()).getExponent()).toString());
            bwpr.write("\n");
            bwpr.write((((RSAPrivateCrtKeyParameters)pair.getPrivate()).getP()).toString());
            bwpr.write("\n");
            bwpr.write((((RSAPrivateCrtKeyParameters)pair.getPrivate()).getQ()).toString());
            bwpr.write("\n");
            bwpr.write((((RSAPrivateCrtKeyParameters)pair.getPrivate()).getDP()).toString());
            bwpr.write("\n");
            bwpr.write((((RSAPrivateCrtKeyParameters)pair.getPrivate()).getDQ()).toString());
            bwpr.write("\n");
            bwpr.write((((RSAPrivateCrtKeyParameters)pair.getPrivate()).getQInv()).toString());
           
            bwpr.close();
            fwpr.close();
           
            return true;
        }
        catch(FileNotFoundException e){
            System.err.println("Error : File Not Found");
            e.printStackTrace();
            return false;
        }
        catch(IOException e){
            System.err.println("Error : Cannot read file");
            e.printStackTrace();
            return false;
        }
    }
   
   
    ////////////////////////////////////////////////////////////////////////////
    //////////////////////////Encrypt ()////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    public boolean encrypt(){
       
        AsymmetricBlockCipher   eng = new RSAEngine();
        byte[] inBuf;
       
        try {
            //lecture de la key
            BufferedInputStream ink                = new BufferedInputStream(new FileInputStream(key));
            BufferedReader         br                = new BufferedReader(new InputStreamReader(ink));
           
            BigInteger             mod             = new BigInteger(br.readLine());
            BigInteger            pubExp            = new BigInteger(br.readLine());
            RSAKeyParameters    pubParameters    = new RSAKeyParameters(false, mod, pubExp);
           
            br.close();
            ink.close();
           
            eng.init(true, pubParameters);
           
            //cryptage du fichier
            BufferedOutputStream    stream     = new BufferedOutputStream(new FileOutputStream(fo));       
            File                     f        = new File(fi);
            DataInputStream         in        = new DataInputStream(new FileInputStream(f));
           
            //Definition de la taille du block a crypter
            int inBlockSize                    = eng.getInputBlockSize();
            int outBlockSize                = eng.getOutputBlockSize();
           
            inBuf                             = new byte[inBlockSize];
           
            int inL;
            while ( (inL = in.read(inBuf, 0, inBlockSize)) > 0 ){
                byte[] outBuf    = null;
                outBuf            = eng.processBlock(inBuf, 0, inL);
                stream.write(outBuf, 0, outBlockSize);
                stream.flush();
                outBuf            = null;
            }
           
            stream.close();
            in.close();
           
            return true;
        }
        catch (Exception e) {e.printStackTrace(); return false;}
    }
   
   
    ////////////////////////////////////////////////////////////////////////////
    //////////////////////////Decrypt ()////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    public boolean decrypt(){
       
        AsymmetricBlockCipher   eng        = new RSAEngine();
        byte[] inBuf;
       
        try {
            //lecture de la key
            BufferedInputStream    ink        = new BufferedInputStream(new FileInputStream(key));
            BufferedReader        br        = new BufferedReader(new InputStreamReader(ink));
           
            BigInteger            mod        = new BigInteger(br.readLine());
            BigInteger            pubExp    = new BigInteger(br.readLine());
            BigInteger            privExp    = new BigInteger(br.readLine());
            BigInteger            p        = new BigInteger(br.readLine());
            BigInteger            q        = new BigInteger(br.readLine());
            BigInteger            pExp    = new BigInteger(br.readLine());
            BigInteger            qExp    = new BigInteger(br.readLine());
            BigInteger            crtCoef = new BigInteger(br.readLine());
           
           
            RSAKeyParameters    privParameters = new RSAPrivateCrtKeyParameters(mod, pubExp, privExp, p, q, pExp, qExp, crtCoef);
           
            br.close();
            ink.close();
           
            eng.init(false, privParameters);
           
            BufferedOutputStream    stream    = new BufferedOutputStream(new FileOutputStream(fo));       
            File                     f        = new File(fi);
            byte[]                    buffer    = new byte[(int)f.length()];
            DataInputStream            in        = new DataInputStream(new FileInputStream(f));
           
           
            //Definition de la taille du block a crypter
            int inBlockSize                    = eng.getInputBlockSize();
            int outBlockSize                = eng.getOutputBlockSize();
           
            inBuf                            = new byte[inBlockSize];
           
           
            int inL;
            while ( (inL = in.read(inBuf, 0, inBlockSize)) > 0){
                byte[] outBuf = null;
                outBuf = eng.processBlock(inBuf, 0, inL);
                stream.write(outBuf);
                stream.flush();
            }
           
            stream.close();
            in.close();
           
            return true;
        }
        catch (Exception e) {e.printStackTrace(); return false;}
    }
   
   
    ////////////////////////////////////////////////////////////////////////////
    //////////////////////////Sign ()///////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    public boolean signed(){
       
        AsymmetricBlockCipher   eng        = new RSAEngine();
        byte[] inBuf;
       
        try {
            //lecture de la key
            BufferedInputStream    ink        = new BufferedInputStream(new FileInputStream(key));
            BufferedReader        br        = new BufferedReader(new InputStreamReader(ink));
           
            BigInteger            mod        = new BigInteger(br.readLine());
            BigInteger            pubExp    = new BigInteger(br.readLine());
            BigInteger            privExp    = new BigInteger(br.readLine());
            BigInteger            p        = new BigInteger(br.readLine());
            BigInteger            q        = new BigInteger(br.readLine());
            BigInteger            pExp    = new BigInteger(br.readLine());
            BigInteger            qExp    = new BigInteger(br.readLine());
            BigInteger            crtCoef = new BigInteger(br.readLine());
           
           
            RSAKeyParameters    privParameters = new RSAPrivateCrtKeyParameters(mod, pubExp, privExp, p, q, pExp, qExp, crtCoef);
           
            br.close();
            ink.close();
           
            eng.init(true, privParameters);
           
            BufferedOutputStream    stream    = new BufferedOutputStream(new FileOutputStream(fo));       
            File                     f        = new File(fi);
            byte[]                    buffer    = new byte[(int)f.length()];
            DataInputStream            in        = new DataInputStream(new FileInputStream(f));
           
           
            //Definition de la taille du block a crypter
            int inBlockSize                    = eng.getInputBlockSize();
            int outBlockSize                = eng.getOutputBlockSize();
           
            inBuf                            = new byte[inBlockSize];
           
           
            int inL;
            while ( (inL = in.read(inBuf, 0, inBlockSize)) > 0){
                byte[] outBuf = null;
                outBuf = eng.processBlock(inBuf, 0, inL);
                stream.write(outBuf);
                stream.flush();
            }
           
            stream.close();
            in.close();
           
            return true;
        }
        catch (Exception e) {e.printStackTrace(); return false;}
    }
   
   
    ////////////////////////////////////////////////////////////////////////////
    //////////////////////////Unsign ()/////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    public boolean unsigned(){
       
        AsymmetricBlockCipher   eng = new RSAEngine();
        byte[] inBuf;
       
        try {
            //lecture de la key
            BufferedInputStream ink                = new BufferedInputStream(new FileInputStream(key));
            BufferedReader         br                = new BufferedReader(new InputStreamReader(ink));
           
            BigInteger             mod             = new BigInteger(br.readLine());
            BigInteger            pubExp            = new BigInteger(br.readLine());
            RSAKeyParameters    pubParameters    = new RSAKeyParameters(false, mod, pubExp);
           
            br.close();
            ink.close();
           
            eng.init(false, pubParameters);
           
            //cryptage du fichier
            BufferedOutputStream    stream     = new BufferedOutputStream(new FileOutputStream(fo));       
            File                     f        = new File(fi);
            DataInputStream         in        = new DataInputStream(new FileInputStream(f));
           
            //Definition de la taille du block a crypter
            int inBlockSize                    = eng.getInputBlockSize();
            int outBlockSize                = eng.getOutputBlockSize();
           
            inBuf                             = new byte[inBlockSize];
           
            int inL;
            while ( (inL = in.read(inBuf, 0, inBlockSize)) > 0 ){
                byte[] outBuf    = null;
                outBuf            = eng.processBlock(inBuf, 0, inL);
                stream.write(outBuf, 0, outBlockSize);
                stream.flush();
                outBuf            = null;
            }
           
            stream.close();
            in.close();
           
            return true;
        }
        catch (Exception e) {e.printStackTrace(); return false;}
    }
}

Skalli
Afficher la suite 

Votre réponse

4 réponses

Meilleure réponse
Messages postés
5292
Date d'inscription
dimanche 4 mai 2003
Dernière intervention
12 novembre 2018
- 17 déc. 2006 à 22:18
3
Merci
Salut,

à tout les coups affiche la taille de outBuf et je suis presque certaint qu'elle est plus petite que outBlockSize

une solution serait de faire :
stream.write(outBuf, 0, outBuf.length);

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA

Merci Twinuts 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 88 internautes ce mois-ci

Commenter la réponse de Twinuts
Messages postés
5292
Date d'inscription
dimanche 4 mai 2003
Dernière intervention
12 novembre 2018
- 17 déc. 2006 à 19:52
0
Merci
Salut,

merci d'éviter le langage sms tu est sur un forum ici pas sur ton téléphone portable !

la prochaine fois donne pas toute la classe mais seulement les portion critiques... ton erreur veux simplement dire que tu dépasse la capacitée du tableau... (pas plus de détail à moins que tu précise ou est la ligne 333 correspondant à :
at RSA.unsigned(RSA.java:333)

trop la flemme de lire tout le code...

------------------------------------
"On n'est pas au resto : ici on ne fait pas dans les plats tout cuits ..."

WORA
Commenter la réponse de Twinuts
Messages postés
13
Date d'inscription
samedi 8 mai 2004
Dernière intervention
20 décembre 2006
- 17 déc. 2006 à 20:40
0
Merci
désolé pour mon brouillon,
la ligne 333 est "  stream.write(outBuf, 0, outBlockSize); " dans la boucle while de la methode unsigned() .

s'il vous plait c'est tres urgent.

Merci d'avance.
Commenter la réponse de sprere16
Messages postés
13
Date d'inscription
samedi 8 mai 2004
Dernière intervention
20 décembre 2006
- 17 déc. 2006 à 23:01
0
Merci
merci [auteurdetail.aspx?ID=43739 Twinuts];
franchement tu me sauves la vie, c'est à rendre demain.
encore merci.

Skalli
Commenter la réponse de sprere16

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.