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