Discussion :

[jubaPython]

salut,

alors j'ai qlq difficultés à créer une clé public ElGamal
la génération de la clé privé se passe à merveille suivant le code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
import pickle
from Crypto.PublicKey import ElGamal
from Crypto.Util.randpool import RandomPool 
 
keySize = 256
 
f = open("RSAkey.private","wb")
KH=RandomPool(keySize) 
RSAkey=ElGamal.generate(keySize,KH.get_bytes)
pickle.dump(RSAkey,f)
fic.close()

en RSA ma génération de clés (privé et public) fonctionne correctement comme suit :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
keySize=1024
 
f= open("RSAkey.private","wb")
KH=RandomPool(keySize) 
RSAkey=RSA.generate(keySize,KH.get_bytes)
 
pickle.dump(RSAkey,f)
f.close()
 
f= open("RSAkey.public","wb")
RSApub = RSAkey.publickey()
pickle.dump(RSApub,f)
fclose()

donc sachant que la classe Elgamal connait un extends a la Publickey .. comment pourais-je généré corectement la clé public pour ElGamal ?

merci pour votre aide.

Juba

[pacificator]

Il existe une sur-couche à Crypto: ezPyCrypto qui simplifie enormement le travail.

Même si tu ne veux pas l'utiliser, tu peux t'inspirer du code source pour la géneration des paires de clès.

[jubaPython]

salut,

oui je l'ai déjà lus c pour ça que mes clés RSA ainsi que ELGamal privé sont correctes
mais tjrs des problemes avec la clé publique d'ElGamal car la class ELGAMALobj fait un extends au module pubkey

Code :

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

class ElGamalobj(pubkey):

donc normalement je pourrais tres bien faire l'appel

Code :

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

ElGamal.publickey()

le plus normalement du monde mais g l'erreur suivante :

Code :

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

AttributeError: 'module' object has no attribute 'publickey'

comme ci que l'heritage n'existait po !

donc voilà de mon coté j'essais tjrs de trouver ... on y croit

[jubaPython]

tjrs rien ... déjà que RSA produit des fichiers corrompus, sauf les .PDF, vec qlq Octets manquants, survivent à la decryption !

dommage que l'API PyCrypto connait qlq Bugs, si j'arrive a "reparer" tt ça, je vous ferai signe, mais pour les clés ElGamal g tjrs rien,

personne ne pourrait m'aider ?

merci à vous

[jubaPython]

g finis par résoudre la génération de clés el Gamal comme suit

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
#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-
 
 
 
from Crypto.PublicKey import ElGamal
from Crypto.Util.randpool import RandomPool 
import cerealizer as pickle # pour sauvegarder un objet dans un fichier
 
 
 
taille_cle=512
 
fic = open("GMLkey.private","wb")
x=RandomPool(taille_cle) # taille_cle*8 bits
GMLkey=ElGamal.generate(taille_cle,x.get_bytes)
 
pickle.register(ElGamal.ElGamalobj)
pickle.dump(GMLkey,fic)
fic.close()
 
fic1 = open("GMLkey.public","wb")
GMLpub = GMLkey.publickey()
pickle.dump(GMLpub,fic1)
fic1.close()

maintenant le probleme se pose avec la l'encryption de la decryption de fichiers

voici mes codes (Provisoires)

celui du crypteur :

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
:
# -*- coding: iso-8859-1 -*-
""" Un petit test de GML"""
 
from Crypto.PublicKey import ElGamal
import cerealizer as pickle 
import sys
 
 
NomFicIn='Test.JPG'
taille=32
 
fic = open("GMLkey.public","rb")
pickle.register(ElGamal.ElGamalobj)
GMLkey=pickle.load(fic)
fic.close()
 
fic=open(NomFicIn,'rb')
print " crypting ..."
vec=[]
text=fic.read(taille)
 
while (text):
    vec.append(text)
    text=fic.read(taille)
fic.close()
 
diff=taille-len(vec[-1])
vec[-1] += "x"*(diff)
print vec[-1:]
vecCrypt=[]
a = 0
 
for i in (vec):        
    vecCrypt.append(GMLkey.encrypt((i),""))
    a+=1
 
ficCrypt=open('TEMP_CrptFile.ndk','wb')
vecfinal=[]
vecfinal.append(vecCrypt)
vecfinal.append(diff)
pickle.dump(vecfinal,ficCrypt)
ficCrypt.close()
 
print " end crypting."
print "nombre de ligne : "+str(a)

et celui du decrypteur :

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
#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-
 
from Crypto.PublicKey import ElGamal
from Crypto.Util.randpool import RandomPool 
import cerealizer as pickle 
import sys
 
 
nomFicIn='TEMP_CrptFile.ndk'
nomFicOut='dec_img.jpg'
 
# on charge la clé privée
fic = open("GMLkey.private","rb")
pickle.register(ElGamal.ElGamalobj)
GMLkey=pickle.load(fic)
fic.close()
 
# on charge tout le fichier en memoire
fic2=open(nomFicIn,"rb")
preList= pickle.load(fic2)
fic2.close()
 # on charge le vecteur contenant le fichier crypte
vecCrypt=preList[0]
# on charge le nombre de X ajouter a l'encryption
dif=preList[1]
taille=len(vecCrypt[1])
taille=32
ficDerupt=open(nomFicOut,'wb')
i=0
reslt=''
nombre=len(vecCrypt)
# le k est juste pour controler le bon deroulement de l'encryption
k=0
for i in range(nombre-1):
    ficDerupt.write(GMLkey.decrypt(vecCrypt[i]))
    k+=1
ficDerupt.write((GMLkey.decrypt(vecCrypt[-1]))[0:taille-dif])
ficDerupt.close()
k+=1
 
print " end decrypting ..."
print "nombre de ligne : "+str(k)

Probleme : seules les fichiers .PDF passent l'encryption et la decryption avec succes, les autres types de fichiers (JPG, DOC etc ..) sont corrumpus

est ce un probleme au niveau de l'API de la cryptographie Python ?

merci pour votre aide

[jubaPython]

voilà g pu fixé mon souci et c'est tant mieux

donc pour les curieux, qui s'interesseront a ce poste la résolution se trouve dans le Testcode qui suit

Code :

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
50
51
52
53
54
from Crypto.PublicKey import ElGamal
import cerealizer as pickle 
import sys
from time import time
 
NomFicIn='doc.pdf'
# il fallait travailler sous 8 bits, bloc de 1 Octet
taille=1
 
#### chargement de la cle public ####
 
fic = open("GMLkey.public","rb")
pickle.register(ElGamal.ElGamalobj)
GMLkey=pickle.load(fic)
fic.close()
 
###### Vectorisation du fichier ####
 
fic=open(NomFicIn,'rb')
print " crypting ..."
vec=[]
text=fic.read(taille)
while (text):
    vec.append(text)
    text=fic.read(taille)
fic.close()
 
##### Encryption ######
vecCrypt=[]
t = time()
for i in vec :
    vecCrypt.append(GMLkey.encrypt((i),"a"))
print "time taken: %f :" % (time() - t)
 
######################################
 
#### chargement de la cle prive #########
 
fic = open("GMLkey.private","rb")
GMLkey=pickle.load(fic)
fic.close()
 
 
NomFicIn = 'TestDec.pdf'
nombre=len(vec)
ficDecrypt=open(NomFicIn,'wb')
 
########decryption ######
t = time()
print " decryption ..."
for i in range(nombre):
    ficDecrypt.write(GMLkey.decrypt(vecCrypt[i]))
ficDecrypt.close()
print "time taken: %f :" % (time() - t)

voilà

bon courage à tous