Discussion :

[acero]

Bonjour, actuellement en terminale s pour mon projet d isn je suis confront� � un probl�me avec mon programme de masque jetable , au niveau de la fonction codage je ne sais pas comment transformer mon nombre binaire en caract�re, voila le code :

def transformationenbinaire (mot):
chaine=""
for k in range(len(mot)):
codek=ord(mot[k]) #code ascii de la lettre
a=bin (codek) [2:].zfill(8)
print k," ",
chaine+=a
return chaine


def transformationenbinaire2 (mot):
chaine=""
for lettre in mot:
chaine+=bin (ord(lettre)) [2:].zfill(8)
return chaine

def xor (motbin,clebin):
return str(int(((motbin and not clebin)or(clebin and not motbin))))

def xormot(mot1,mot2):

chaine=""
for k in range (len(mot1)):
chaine+=xor(int(mot1[k]),int(mot2[k]))
return chaine


def codage(motcodebin):




mot=raw_input("Entrer votre message:")
cle=raw_input("Entrer la cle:")
motbin= transformationenbinaire2(mot)
clebin= transformationenbinaire2(cle)
motcodebin=xormot(motbin,clebin)
motcode=codage(motcodebin)
print motcode






Merci d'avance

[deusyss]

Bonjour acero,

Pourquoi reinventer la roue? regarde du c�t� du module binascii

http://docs.python.org/2/library/binascii.html

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
 
#! /usr/bin/python
 
import binascii
 
a = raw_input("saisir un mot: ")
print a
b = binascii.hexlify(a)
print bin(int(b))
c = binascii.unhexlify(b)
print c

Cela te convient-il?

[acero]

Merci de ta r�ponse , cette fonction remplacerait elle donc le programme en entier ?

[deusyss]

Bonjour,

Pas le programme entier non mais le plus gros des lignes oui, car avec ce module de base, plus besoin de parcourir lettre � lettre. Tu donne ta phrase et elle est directement traduisible en binaire, de m�me pour le chemin inverse.

Tu t'�vite ainsi de reinventer la roue, simplifie ton code et le standardise.

A titre d'exemple:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
 
def transformationenbinaire (mot):
    chaine=bin(int(binascii.hexlify(mot)))
    return chaine #chaine contient la conversion de mot en binaire

Cela pourrait �tre une fonction de transformation binaire. Tu pourrais presque utiliser un lambda. Je t'invite � faire quelques essais de ton c�t� avec ce module, et en tirer conclusion pour ton besoin.

Pour rappel sinon, PYTHON est un langage � typage dynamique. Pas besoin donc de d�finir un "chaine = "" "

[acero]

Merci de tes pr�cisions, cette fonction est en effet tr�s utile , mais dans le cas du masque jetable apr�s avoir appliquer le ou exclusif sur la conversion binaire du mot et de la cl� , comment transformer cela en message cod� ? merci de d'avance.

[deusyss]

SI tu regarde plus avant le principe de masque jetable sur WIkI, tu te rendra compte de trois choses principales:

-Le message cod� est celui que tu as en sortie de ton XOR.
-La cl� doit avoir la m�me longueur que le message pour bien fonctionn�
-Il faut utiliser un modulo

Pour ton message de sortie, le mieux c'est de le laisser en binaire, c'est inexploitable ainsi pour qui n'a pas la cle.

Concernant la longueur de la cl�, je te propose de boucler en rond, ou a rebourd. Ainsi la taille de ta cle est independante de la taille du message.

Ta fonction XOR n'integre pas le modulo. L'ideal dans ton cas serait un modulo 2, qui correspondrait en fait � un complement � 1 (si bit vaut 1 alors il vaut 0 et vice-versa).


Je me permet de te sugg�rer des nom plus �vocateurs pour les fonctions et de respecter les r�gles de codage du PYTHON pour ton code. Ci-dessous un exemple �toff� rapport � ton besoin.

Avec ce code, tu peut encoder et decoder selon l'algo de masque jetable � l'aide d'une cle. Cependant, je n'ai pas coder la cle qui tourne en boucle (c'est juste un jet rapide mais fonctionnel)

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
#! /usr/bin/python
 
import binascii
 
#Code pour le principe
#a = raw_input("saisir un mot: ")
#print a
#b = bin(int(binascii.hexlify(a))) #on convertie en binaire
#print b
#c = binascii.unhexlify(str(int(b, 2))) #on convertie en string hexa
#print c
 
#test effectue avec test/hell
#probleme si message et cle ont une taille differente
 
 
def ascii_to_binaire(chaine):
	"""
                Fonction permettant de convertir une chaine en binaire
        """
	binaire=bin(int(binascii.hexlify(chaine),16))
	return binaire  #chaine contient la conversion de mot en binaire
 
 
 
 
def binaire_to_ascii(binaire):
	"""
                Fonction permettant de convertir un binaire en chaine
        """
	tmp = "%X" % (int(binaire,2)) #creation d'un hexstring
	chaine=binascii.unhexlify(tmp)
	return chaine #chaine contient la conversion de mot en binaire
 
 
 
 
def encode(motbin,clebin):
	"""
                Fonction permettant de coder une chaine grace a une cle
                selon l'algorithme de masque jetable
        """
	chaine = "" #chaine est a declarer avant a cause du +=
	result = "" #idem
 
	mot_tmp = motbin.split('b')[1]
	cle_tmp = clebin.split('b')[1]
 
	for k in range (len(mot_tmp)): #probleme en fonction de la taille du message
		chaine+=str(int(mot_tmp[k],2) ^ int(cle_tmp[k],2)) # !!! probleme si taille differente !!!
		result+=str(int(chaine[k])%26)
 
	return result
 
 
 
 
def decode (motbin,clebin):
	"""
                Fonction permettant de decoder une chaine grace a une cle
                selon l'algorithme de masque jetable
        """
	chaine = "" #chaine est a declarer avant a cause du +=
	result = "" #idem
 
	mot_tmp = motbin
	cle_tmp = clebin.split('b')[1]
 
 
	for k in range (len(mot_tmp)): #probleme en fonction de la taille du message
		chaine+=str(int(mot_tmp[k],2) ^ int(cle_tmp[k],2)) # !!! probleme si taille differente !!!
		result+=str(int(chaine[k])%26)
 
	return result
 
 
 
 
if __name__ == "__main__":
	"""
                Fonction principale du module PYTHON
                    1-Selection de l'operation
                    2-Saisie du message et de la cle (encoder ou non) ou sortie
                    3-Recuperation du message encode ou non
        """
	choix = raw_input("Desirez vous encoder(e) ou decoder(d) un message?")
	while choix.upper() not in ("Q", "D", "E"):
		choix = raw_input("Desirez vous encoder(e) ou decoder(d) un message (quitter:q)?")
 
	if choix.upper() == "E":
		mot = raw_input("Entrer votre message:")
		cle = raw_input("Entrer la cle:")
 
		motbin= ascii_to_binaire(mot)
		clebin= ascii_to_binaire(cle)
		result = encode(motbin,clebin)
 
		print "Le message chiffre est: ", result
 
	elif choix.upper() == "D":
		motbin = raw_input("Entrer votre message:")
		cle = raw_input("Entrer la cle:")
 
		clebin= ascii_to_binaire(cle)
		result_tmp = decode(motbin,clebin)
		result = binaire_to_ascii('0b'+result_tmp)
 
		print "Le message dechiffre est: ", result
 
	else:
		print "Au revoir..."

Le langage PYTHON ets d'autant plus appreciable, si on prend tous le soin de respecter les quelques regles predefinies. je ne peut que te les recommander

[acero]

Je tiens tout d�abord � te remercier de tes explications et du temps que tu as passer � m'aider , tout cela m'a beaucoup aid�. Merci probl�me r�solu.

[deusyss]

Aucun soucis, ce forum est fait pour l'entraide

Si tu considere ton probleme vraiment resolu n'oublie pas la petite balise [RESOLU]. Si tu a encore des questions n'hesite pas

Petite precision: comme je n'ai paas implementer de modulo viable (ils sont present dans le code mais en l'etat ne servent � rien), si tu rentre comme mot cle ton message, tu retombe sur ta cle. Pour eviter cela, il faut implementer le modulo.

Si Python t'int�resse, je t'invite � regarder les tutos de ce site, et les PDF sur le sujet.

@+

[RedGuff]

Bonjour.
"Concernant la longueur de la cl�, je te propose de boucler en rond, ou � rebour. Ainsi la taille de ta cl� est ind�pendante de la taille du message."
Le principe du code et sa fiabilit� seraient rompus, si cela devait �tre fait !

[tyrtamos]

Bonjour,

Deux petits additifs:

1- Une fois le texte initial trait� avec xor, on obtient des octets non imprimables. Si on veut les transmettre en ASCII, on peut le faire avec le module base64 de Python. Cela n'augmente la taille que de 30% environ, plut�t que l'hexa qui multiplie par 2.

Exemple:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
import base64
 
x = "Que j'aime à faire apprendre des nombres utiles aux sages"
 
y = base64.b64encode(x)
print y
UXVlIGonYWltZSDgIGZhaXJlIGFwcHJlbmRyZSBkZXMgbm9tYnJlcyB1dGlsZXMgYX
 
z = base64.b64decode(y)
print z
Que j'aime à faire apprendre des nombres utiles aux sages

On peut aussi cr�er en Python une fonction qui pr�sence les longues chaines en lignes de 80 caract�res (par exemple) pour les transmettre plus facilement.

2- Il y a une logique simple pour trouver un masque aussi long qu'il faut pour crypter n'importe quoi, y compris une image: un g�n�rateur de nombres pseudo-al�atoires, en choisissant un des g�n�rateurs qui g�n�rent la m�me s�rie avec la m�me graine de d�part. Et il existe des g�n�rateurs suffisamment bons pour �tre reconnus en cryptographie (Blum Blum Shub par exemple). Il faudra, bien s�r, transmettre les graines au destinataire de mani�re s�curis�e.

Mais � titre d'exemple, on peut toujours essayer avec:

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
import random
graine = 123456
random.seed(graine)
for i in xrange(0, 10):
    print random.randint(0,255)
206
203
7
44
0
169
19
68
29
58

[Edit]

On pourrait ainsi avoir avec random:

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
import random, base64
 
def encode_mg(msg, graine):
    """masque jetable: crypter msg avec random initialisé par graine"""
    ch = ""
    random.seed(graine) # initialisation du générateur pseudo-aléatoire
    for car in msg:
        ch += chr(ord(car) ^ random.randint(0,255))
    return ch
 
def decode_mg(msgcrypt, graine):
    """masque jetable: décrypter msgcrypt avec random initialisé par graine"""
    msg = ""
    random.seed(graine) # initialisation du générateur pseudo-aléatoire
    for car in msgcrypt:
        msg += chr(ord(car) ^ random.randint(0,255))
    return msg
 
msg = "Que j'aime à faire apprendre des nombres utiles aux sages"
graine = 4893578
 
msgcrypt = encode_mg(msg, graine)
print base64.b64encode(msgcrypt)
 
msg2 = decode_mg(msgcrypt, graine)
print msg2 == msg

Affichage:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
jnJCrUj8U/JUO6Cv1AxXXJulAB5jF7gAYm1FVeW+QN/I4xB4dbstWg+Fu/aeZGJdrO67ai/T0R6lAw==
True