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