Avis sur mon programme "Chiffre du Che"

Version imprimable

Bonjours a tous,

Pour m’entraîner a programmer en python j'ai réaliser un programme qui permet de crypter un fichier selon la méthode du "chiffre du che" (plus d'information ici : http://www.cryptage.org/chiffre-che-guevara.html ).
Voila j'ai réaliser le programme il marche mais je trouve qu'il est un peu mal programmé et j'aimerai avoir votre avis dessus.

Code:

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
import os
 
# Cette fonction lit le fichier et récupére son texte
def encodage(fichier):
	fs = open(fichier, 'r') # fichier source
 
	# On enléve les espace, majuscule, minuscule, accent
	txt = fs.read()
	txt = txt.lower()	# convertie la chaine en minuscule
	fs.close()
	substitution(txt)
 
# Cette fonction substitue les lettre de la chaine
def substitution(ch):
	# On substitue selon la méthode du che
	substitut = {'a' : 6, 'b' : 38, 'c' : 32, 'd' : 4, 'e' : 8, 'f' : 30, 'g' : 36, 'h' : 34, 'i' : 39, 'j' : 31, 'k':78 , 'l' :72, 'm' : 70,'n' : 76, 'o' :9, 'p' : 79, 'q' : 71, 'r' : 58, 's' : 2, 't': 0, 'u' :52, 'v' :50, 'w' : 56, 'x' : 54, 'y' : 1, 'z' : 59, ' ' : ''}
 
	listeNombre = []	# Contiendra les nombre substituée
	for car in ch:		# subtitution
		# Cette instruction permet de faire la substitution de chaque caractére de la chaine grace au dictionnaire et l'ajoute dans une liste
		listeNombre.append(substitut[car])
	paquet(listeNombre)
 
# Cette fonction va transférer tous les chiffre de la liste dans une chaine
def paquet(liste):
	chCinq = ""	# Contiendra la chaine de nombre encodée
	# Place les élements de la liste dans une chaine
	espace = 0
	for nb in liste:
		if nb != '':
			chCinq += str(nb)
	encodageFinal(chCinq, 25638, 'encoChe')
 
 
# Cette fonction procéde a l'encodage finale
def encodageFinal(chEncoder, cleSecrete, nomDuFichier):
	encodageFinal = ""	# Cette chaine servira au resultat final de l'encodage
	cleSecrete = str(cleSecrete)
	i, j = 0, 0
	while i < len(chEncoder):
		if j == len(cleSecrete):
			j = 0
		mod10 = int(chEncoder[i]) + int(cleSecrete[j])
		mod10 = mod10 % 10
		encodageFinal += str(mod10)
		i, j = i+1, j+1
 
	print(encodageFinal)
	# Sépare la chaine en paquet de 5
	chFinale, k = "", 0
	for n in encodageFinal:
		if k % 5 == 0:
			chFinale += ' '
		chFinale += n
		k += 1
	print(chFinale)
 
	# écriture de l'encodage dans un fichier:
	fd = open(nomDuFichier, 'w')
	fd.write(chFinale)
	fd.close()
 
if __name__ == '__main__':
	encodage('che')

Voila en attendant vos critique et futur conseille qui je l’espéré me permettrons de m'améliorer.

08/06/2015, 07h51
marco056

Amha, ce serait mieux si toutes tes fonctions prenaient en argument la variable "CleSecrete".
08/06/2015, 09h47
BufferBob

salut,

@marco056, je comprends pas pourquoi tu dis ça, dans quel but ?

@wercos, le découpage de ton code fait plus penser à une suite de checkpoints qu'à une organisation vraiment pertinente, si chaque fonction n'est appelée qu'une seule fois à la fin de la fonction précédente, alors tu peux tout mettre dans une fonction unique et la rendre lisible grâce aux commentaires

aussi la fonction principale prend en argument uniquement un nom de fichier, on ne peut pas choisir le fichier de sortie il est spécifié en dur tout à la fin du traitement "encoChe", dans un cas comme celui là soit on affiche sur la console et l'utilisateur se débrouille pour enregistrer dans le fichier qui l'intéresse grâce aux redirections, soit la fonction d'appel doit permettre de préciser le nom du fichier de sortie

enfin... il est où le déchiffrement ? :mrgreen:
08/06/2015, 09h49
wiztricks
Salut,

Citation:

Envoyé par werkos

Voila en attendant vos critique et futur conseille qui je l’espéré me permettrons de m'améliorer.

"encodage" appelle "substitution" qui appelle "paquet" qui appelle "encodageFinal"...
Ça fait une longue chaîne d'appels de fonctions pas facile à tester les unes indépendamment des autres.

Imaginez vouloir paramétrer le nom du fichier de sortie en fonction de celui du fichier d'entrée. C'est une fonctionnalité "simple" qui s'applique à une chaîne de caractère que les fonctions n'ont pas vraiment à connaître pour faire leur job.

Pour le réaliser, il va falloir modifier 2/3 fonctions: "encoder" pour passer le nom du fichier, "paquet" pour le transmettre à "encodageFinal"...

Imaginez aussi vouloir changer la substitution ou la clé secrète: ces données étant enfouies dans des sous fonctions, il faudra changer les interfaces.

Vous pourriez réorganiser tout çà:
Code:

1 2 3 4 def encoder(data, substitut, cle_secrete): nombres = substitution(data, substitut) paquets = empaqueter(nombres) return encodage(paquets, cle_secrete)
Vous y retrouvez la séquence des 3 étapes de l'algorithme.
nota: vous pourriez enchaîner çà via "encodage(empaqueter(substitution(data, substitut)), cle_secrete)" i.e. en composant "naturellement" les fonctions.

la fonction encoder reçoit le contenu du fichier et le retourne encrypté.
Le détail côté nom de fichier est laissé à l'appelant.

Vous voyez l'idée? Cela fait, il vous sera plus facile de comprendre les étapes que vous avez loupées dans le codage de l'algo.

- W
08/06/2015, 12h55
marco056

Citation:

Envoyé par BufferBob

salut,

@marco056, je comprends pas pourquoi tu dis ça, dans quel but ?

Dans le but de pouvoir changer de clé secrète.
08/06/2015, 18h42
BufferBob

Citation:

Envoyé par marco056

Dans le but de pouvoir changer de clé secrète.

oui en fait j'ai compris après coup ce que tu voulais dire, j'avais pas fait attention que sa clé était un nombre codée en dur dans le code, effectivement ça serait une bonne idée de pouvoir spécifier la clé en paramètre

Salut,

Dans l'ordre des fonctions:

Code:

1
2
3
4
5
6
7
8
9
 
def encodage(fichier):
	fs = open(fichier, 'r') # fichier source
 
	# On enléve les espace, majuscule, minuscule, accent
	txt = fs.read()
	txt = txt.lower()	# convertie la chaine en minuscule
	fs.close()
	substitution(txt)

cette fonction n'enlève ni les espaces ni les majuscules ni les minuscules ni les accents.

Tout au plus remplace-t-elle les majuscules par des minuscules, mais surtout elle n'enlève pas les "retour-ligne", ce qui est important puisqu'il s'agit de lire un texte contenu dans un fichier.

On peut donc convertir le texte de la sorte:

Code:

1
2
3
4
5
6
 
>>> import unicodedata
>>> TEXT = "Ernesto Rafael Guevara de la Serna alias 'Che Guevara' était un révolutionnaire marxiste d'Amérique latine, né le 14 juin 1928 à Rosario et décédé le 8 octobre 1967 à La Higuera en Bolivie."
>>> txt = unicodedata.normalize('NFKD', TEXT).encode('ascii', 'ignore').lower().decode('utf-8')
>>> txt
"ernesto rafael guevara de la serna alias 'che guevara' etait un revolutionnaire marxiste d'amerique latine, ne le 14 juin 1928 a rosario et decede le 8 octobre 1967 a la higuera en bolivie.""

Nous avons notre texte, mais il peut encore contenir des espaces des retour-lignes et quelques autres intrus.
On peut se permettre de les ignorer.

Pour cela on va utiliser le droit à l'erreur:

Code:

1
2
3
4
5
6
7
8
9
10
 
>>> code_txt = []
>>> for i in txt:
...     try:
...             code_txt.append(substitutes[i])
...     except:
...             pass
... 
>>> code_txt
[8, 58, 76, 8, 2, 0, 9, 58, 6, 30, 6, 8, 72, 36, 52, 8, 50, 6, 58, 6, 4, 8, 72, 6, 2, 8, 58, 76, 6, 6, 72, 39, 6, 2, 32, 34, 8, 36, 52, 8, 50, 6, 58, 6, 8, 0, 6, 39, 0, 52, 76, 58, 8, 50, 9, 72, 52, 0, 39, 9, 76, 76, 6, 39, 58, 8, 70, 6, 58, 54, 39, 2, 0, 8, 4, 6, 70, 8, 58, 39, 71, 52, 8, 72, 6, 0, 39, 76, 8, 76, 8, 72, 8, 31, 52, 39, 76, 6, 58, 9, 2, 6, 58, 39, 9, 8, 0, 4, 8, 32, 8, 4, 8, 72, 8, 9, 32, 0, 9, 38, 58, 8, 6, 72, 6, 34, 39, 36, 52, 8, 58, 6, 8, 76, 38, 9, 72, 39, 50, 39, 8]

Ensuite, dans ton code on trouve ceci:

Code:

1
2
3
4
5
6
7
8
9
 
def paquet(liste):
	chCinq = ""	# Contiendra la chaine de nombre encodée
	# Place les élements de la liste dans une chaine
	espace = 0
	for nb in liste:
		if nb != '':
			chCinq += str(nb)
	encodageFinal(chCinq, 25638, 'encoChe')

Je m'étonne que personne ne l'aie remarqué, mais cela ne sert à rien, tu reconvertis en entier à l'étape suivante.

Donc on saute, voyons la clé, rendons la plus simple à utiliser:

Code:

1
2
3
4
5
 
>>> KEY = 25638
>>> key = [int(i) for i in str(KEY)]
>>> key
[2, 5, 6, 3, 8]

On a le texte et la clé. Yapluka:

Code:

1
2
3
4
5
6
7
8
9
10
 
>>> crypted = []
>>> for ct in range(0, len(code_txt), 5):
...     bloc = ""
...     for c, k in zip(code_txt[ct:ct+5], key):
...             bloc += str((c + k) % 10)
...     crypted.append(bloc)
... 
>>> crypted
['03210', '24498', '83890', '05214', '63890', '03294', '44250', '63256', '21496', '21530', '83437', '47627', '81226', '05212', '17612', '85417', '37454', '24214', '07440', '11217', '41427', '05010', '09456', '17626', '03254', '64256', '01496', '17537', '0']

On termine en joignant le tout en une seule chaîne de texte:

Code:

1
2
3
4
 
>>> crypted = " ".join(crypted)
>>> crypted
'03210 24498 83890 05214 63890 03294 44250 63256 21496 21530 83437 47627 81226 05212 17612 85417 37454 24214 07440 11217 41427 05010 09456 17626 03254 64256 01496 17537 0'

Puis faut mettre cela dans des fonctions séparées appelées indépendamment comme on t'a expliqué précédemment. Ça c'est de la mise au propre.

Edit: J'ai enlevé l'espace du dictionnaire substitutes

Bravo VinsS ! Je n'ai pas tout compris du premier coup mais tant mieux : cela me permet de progresser aussi.
Je crois cependant qu'il y a une petite erreur dans ton code.
Je vais essayer d'être à peu près clair :
Les lettres sont codées dans l'ordre, par exemple ici : e : 8 ; r : 58.
La clé commence par 256 et le codage doit faire 8 + 2 = 0 , 5 + 5 = 0, 8 + 6 = 4 alors que ton code fait 8 + 2 = 0 puis 58 + 5 = 3.
On verra cela quand il fera jour...

[edit]

Je pense que c'est ok en faisant :
Code:

1 2 3 4 5 6 7 8 9 code='' for j in code_txt: code+=str(j) crypted = [] for ct in range(0, len(code), 5): bloc = "" for c, k in zip(code[ct:ct+5], key): bloc += str((int(c) + k) % 10) crypted.append(bloc)

Pour le nom de fichier, c'est plus sympa en faisant par exemple :
Code:

1 2 3 nom_fich = "che" ext = ".txt" mon_fichier = nom_fich + ext
puis en écriture :
Code:

1 2 3 4 # écriture de l'encodage dans un fichier : sortie = open(nom_fich+"-crypt"+ext, 'w') sortie.write(encodage(mon_fichier)) sortie.close()

09/06/2015, 05h59
VinsS

Tu as raison, j'ai opéré lettre par lettre et non pas par chiffre unique.

Comme tu l'as corrigé c'est maintenant exact. Merci.
09/06/2015, 16h08
werkos

Salut tout le monde,

Déjà merci pour votre aide je n'y serait certainement pas arriver seul. Je vais modifier mon code comme vous me l'avez indiquée et je vais aussi créer un deuxième programme qui permettra de décrypter le fichier. Je posterai mon code final pour les gens intéresser si jamais.
09/06/2015, 16h59
marco056

Citation:

Envoyé par werkos

Salut tout le monde,

Déjà merci pour votre aide je n'y serait certainement pas arriver seul. Je vais modifier mon code comme vous me l'avez indiquée et je vais aussi créer un deuxième programme qui permettra de décrypter le fichier. Je posterai mon code final pour les gens intéresser si jamais.

Cela m'intéresse car je l'ai fait, du coup. Il me reste aussi le décryptage...

Re

Voila j'ai terminer mon programme en prenant en compte vos remarques. Je le poste ici ainsi que celui qui permet de dechiffrer le fichier.

Chiffrement :

Code:

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
import os
import unicodedata
from DéchiffrementChe import *
 
def encoder(data, substitut, cle_secrete):
	nombres = substitution(data, substitut)
	return encodage(nombres, cle_secrete)
 
# Cette fonction substitue les lettre de la chaine
def substitution(data, substitut):
	# On substitue selon la méthode du che
	code_txt = []	# Contiendra les nombre substituée
	for i in data:		# subtitution
		try:
		# Cette instruction permet de faire la substitution de chaque caractére de la chaine grace au dictionnaire et l'ajoute dans une liste
			code_txt.append(substitut[i])
		except:
			pass
	return code_txt
 
# Cette fonction procéde a l'encodage finale
def encodage(nombres, cle_secrete):
	code = ''	# Cette chaine servira au resultat final de l'encodage
	key = [int(i) for i in str(cle_secrete)]	# Place chaque chiffre dans une liste
	for j in nombres:
		code+= str(j)
	crypted = []
	for ct in range(0, len(code), 5):
		bloc = ""
		for c, k in zip(code[ct:ct+5], key):
			bloc += str((int(c) + k) % 10)
		crypted.append(bloc)
 
	crypted = " ".join(crypted)
	return crypted
 
if __name__ == '__main__':
	substitut = {'a' : 6, 'b' : 38, 'c' : 32, 'd' : 4, 'e' : 8, 'f' : 30, 'g' : 36, 'h' : 34, 'i' : 39, 'j' : 31, 'k':78 , 'l' :72, 'm' : 70,'n' : 76, 'o' :9, 'p' : 79, 'q' : 71, 'r' : 58, 's' : 2, 't': 0, 'u' :52, 'v' :50, 'w' : 56, 'x' : 54, 'y' : 1, 'z' : 59}
	nom_fichier_entrer = "a_encoder"
	ext = ".txt"
 
	# Lecture du fichier ou récuperer le texte
	entrer = open(nom_fichier_entrer+ext, 'r')
	txt = entrer.read()
	entrer.close()
	data = unicodedata.normalize('NFKD', txt).encode('ascii', 'ignore').lower().decode('utf-8')
 
	ch_encoder = encoder(data,substitut,25638) # Renvoie une chaine de caractére crypter
	print(ch_encoder)
	print(decoder(ch_encoder, 25638, substitut))
 
	nom_fichier_sortie = "crypter"
	# écriture de l'encodage dans un fichier
	sortie = open(nom_fichier_sortie+"-crypte"+ext, 'w')
	sortie.write(ch_encoder)
	sortie.close()

et le dechiffrement :

Code:

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
def decoder(data, cle_secrete, substitut):
	messageChiffre = decryptage(data, cle_secrete)
	return dechiffrage(messageChiffre, substitut)
 
def decryptage(data, cle_secrete):
	data = data.replace(" ","")
 
	key = [int(i) for i in str(cle_secrete)]
 
	decrypter = []
	for ct in range(0, len(data), 5):
		bloc = ""
		for d, k in zip(data[ct:ct+5], key):
			bloc += str((int(d) - k) % 10)
		decrypter.append(bloc)
 
	decrypter = "".join(decrypter)
	return decrypter
 
def dechiffrage(messageChiffre, substitut):
	valeurDico = list(substitut.values())
	# Invertion du dictionnaire (valeurs, cle) ce qui permettra une recherche avec la clef plus facile
	nbSubstitut = {}
	for k, v in substitut.items():
		nbSubstitut[v] = k
	messageFinal, i = "", 0
	while i < len(messageChiffre):
		# Si le nombre a un chiffre se trouve dans le dictionnaire
		if int(messageChiffre[i]) in valeurDico:
			messageFinal += nbSubstitut[int(messageChiffre[i])]
		# Sinon le nombre est peut étre a deux chiffre
		else:
			nb = str(messageChiffre[i]) + str(messageChiffre[i+1])
			if int(nb) in valeurDico:
				messageFinal += nbSubstitut[int(nb)]
				i += 1
		i +=1
	return messageFinal

Voila merci encore pour votre aide.