Discussion :

[marco13]

Bonjour à tous!

Bon alors j'ai un petit problème.. Je suis en trin de coder une application qui permet à deux utilisateurs distants de communiquer, le text envoyé étant crypté en RSA!

Aucun problème pour le cryptage et les socket (c'est déjà ça ) mais j'ai un gros problème de transfert des clés publique!

Les clés sont générés comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
KeyPairGenerator pairgen = KeyPairGenerator.getInstance("RSA");
            SecureRandom random = new SecureRandom();
            pairgen.initialize(2048, random);
            KeyPair keyPair = pairgen.generateKeyPair();
 
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(publicOutputFileName));
            out.writeObject(keyPair.getPublic());
            out.close();
 
            out = new ObjectOutputStream(
                    new FileOutputStream(privateOutputFileName));
            out.writeObject(keyPair.getPrivate());
            out.close();

a la suite de quoi j'ai 2 fichiers sur mon disque dur.

Lorsqu'un client se connecte au serveur, les deux s'échangent leur clés. et la copient sur leur disques avec la méthode:

Envoie de la clé

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
    public void sendPublicKey() throws IOException{
 
 
  	   //on deballe la clé
          String path="keys/keypublic.data";
          ObjectInputStream keyIn = new ObjectInputStream(new FileInputStream(path));
          byte[] key=null;
 
          //lecture de la clé
  		try {
  			RSAPublicKey publicKey = (RSAPublicKey )keyIn.readObject();
  			key=publicKey.getEncoded();
  		} catch (ClassNotFoundException e) {
  			// TODO Auto-generated catch block
  			e.printStackTrace();
  		}
          keyIn.close();
 
  		//envoie des données
  		byte [] buffer=meth.convertinttobyte(key.length);
  		//concatenation des tableaux
  		byte []concat=meth.concatByte(buffer,key);
  		System.out.println("Envoi de x données:"+key.length);
 
  		//on envoie le buffer puis les data		
  		byteout.write(concat);
  		byteout.flush();
 
      }

reception de l'autre coté:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    private void receptionPublic(String path2) {
 
        PrintWriter writer;
		try {
			writer = new PrintWriter(new BufferedWriter (new FileWriter(path)));
			 reponse="";
			 //taille du buffer
			 bytein.read(byteresponse,0,4);
			 //transformation en int
			 int size=meth.byteArrayToInt(byteresponse, 0);
 
		     count = bytein.read(byteresponse,0,size);
		     reponse = meth.convertByteToText2(byteresponse,count);
		     writer.println(reponse);
 
		        writer.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}  ;
	}

Le problème c'est que les fichiers avant et après envoit ne sont pas les mêmes et il est impossible du coup de decrypter les données... Si je place moi meme les cléfs publique, mon programme marche très bien!

Je pense que c'est un problème d'écriture dans le fichier, à l'origine j'ai un objet de type RSAPublicKey dans les fichiers, mais je les lis comme des bytes pour les envoyer sur la socket. Quelqu'un peut m'aider? :'(

Merci

[marco13]

j'ai trouvé le problème....

dans la réception du fichier, je convertissais des bytes en string pour les placer dans mon fichier avec un PrintWriter. Or il etait incapable de convertir ces caracteres en String!

Maintenant j'utilise un FileOutputStream.

Si ça peut interesser quelqu'un voila les sources : http://marcmittler.fr/marc/projets/sources/cryto/

Et le code:

Crypter/decrypter des bytes[]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
//methode qui permet de crypter/decrypter des flux de byte
	public byte[] performByte(byte[] tempbyte, String keypub, String keypriv, boolean valide) {
 
		//cryptage
		if(valide){
 
			//System.out.println("RSA crypt:"+meth.convertByteToText(tempbyte));
			try {
            //deballe avec la clé publique RSA
            ObjectInputStream keyIn = new ObjectInputStream(new FileInputStream(keypub));
            RSAPublicKey publicKey = (RSAPublicKey )keyIn.readObject();
            keyIn.close();
 
            BigInteger msgEnBigInteger = new BigInteger(tempbyte);
            BigInteger msgCrypte = msgEnBigInteger.modPow(publicKey.getPublicExponent(), publicKey.getModulus());
            return msgCrypte.toByteArray();
 
			} 
 
			catch (Exception e)
			{
				e.printStackTrace();
			}
		}
 
//decryptage
		if(!valide){
			//System.out.println("RSA decrypt:"+meth.convertByteToText(tempbyte));
			try {
	            //déballe la clé RSA privée
	            ObjectInputStream keyIn = new ObjectInputStream( new FileInputStream(keypriv));
	            RSAPrivateKey privateKey = (RSAPrivateKey)keyIn.readObject();
	            keyIn.close();
 
	            BigInteger msgADecrypteEnBigInt = new BigInteger(tempbyte);
	            BigInteger msgDecrypteEnBigInt = msgADecrypteEnBigInt.modPow(privateKey.getPrivateExponent(), privateKey.getModulus());
 
	            return msgDecrypteEnBigInt.toByteArray();
 
				} 
 
				catch (Exception e)
				{
					e.printStackTrace();
				}
		}
		return null;
	}

Envoyer des données cryptés

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
//  methode pour envoyer un buffer au client de façon crypté ou non!
	public void sendData(String text,boolean crypt){
 
		try {
 
			//conversion du text en byte
			byte [] textbyte=null;
			if(crypt) textbyte=rsa.performByte(text.getBytes(),path, "empty",true);
			else textbyte=text.getBytes();
 
 
			//on place la taille dans un buffer
			byte [] buffer=meth.convertinttobyte(textbyte.length);
			//concatenation des tableaux
			byte []concat=meth.concatByte(buffer,textbyte);
 
			//on envoie le buffer puis les data		
			byteout.write(concat);
 
			byteout.flush();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

Reception des données

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
//on attend des données
            while(ok){
   			 	//taille du buffer
   			 	bytein.read(byteresponse,0,4);
   			 	//transformation en int
   			 	int size=meth.byteArrayToInt(byteresponse, 0);
   			 	//System.out.println("Serveur>Reception données: "+size);
            	//reception en byte[]
   			 	count = bytein.read(byteresponse,0,size);
            	//adaptation
   			 	byte [] tempbyte=meth.redimByte(byteresponse,count);
            	//decryptage
   			 	tempbyte=rsa.performByte(tempbyte,"empty", keys+filekeyPriv,false);
            	//conversion en string
   			 	reponse=meth.convertByteToText(tempbyte);
            	aff.debugtext("Serveur>reception");
            	aff.putText("Client>"+reponse);
            	if(reponse.equals("Exit"))ok=false;
            }