Coder un decrypteur

**Popkhorn** · 27/05/2020, 22h24

Hello, désolé de vous déranger, mais je suis bloqué sur un projet et je n'arrive pas à trouver ce qui ne va pas.
Je suis en train de coder un décrypteur de texte en python (rien de bien fastidieux, ici c'est du code César, donc un décalage dans l'alphabet, avec une clé, qui désigne de combien de lettres on décale le texte.
J'ai réussi à rédiger un code qui, pour un texte et une clé donnée, va décrypter le message.
Je souhaiterais maintenant que le programme teste toutes les clés possibles (entre 1 et 25), et affiche chaque transcriptions associé à la clé qui a permit de l'obtenir.
Dans l'idée, mon code est fonctionnel, mais toutes les combinaisons s'affichent à chaque fois, s'ajoutant les unes à la suite des autres.
Voici les deux codes, celui fonctionnel permettant de décrypter si on a la clé, et la tentative que je n'arrive pas à mettre en place.

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
liste = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
for x in range(len(liste)):    #Dedouble la liste
    liste.append(liste[x])
 
message = input('Entrez votre message : ')
cle = int(input('Entrez votre clef ( entre 1 et 25 ) : '))
 
def dechiffrage_lettre(lettre,liste,cle):
    for i in range(len(liste)):
        if lettre==' ':       #au cas ou il y a un espace
            return ' '
        elif liste[i]==lettre:          
                return str(liste[i-cle])            
message_dechiffre = str()
for lettre in message:
    message_dechiffre += dechiffrage_lettre(lettre,liste,cle)
print(message_dechiffre)

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
liste = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
for x in range(len(liste)):    #Dédouble la liste
    liste.append(liste[x])
 
message = 'RTSXNJZW' #input('Entrez votre message : ')
 
def dechiffrage_lettre(lettre,liste,cle):
 
    for i in range(len(liste)):
        if lettre==' ':       
            return ' '
        elif liste[i]==lettre:
            return str(liste[i-cle])
 
message_dechiffre = str()
 
cle = 0
 
for n in range(25):
    cle = cle + 1    
    for lettre in message:
        message_dechiffre += dechiffrage_lettre(lettre,liste,cle)    
    print(cle)
    print(message_dechiffre)

Merci d'avance pour votre aide !!

PS: par soucis de simplicité, le mot à décoder est toujours le même, c'est RTSXNJZW, ce qui donne "MONSIEUR", en majuscule, décodé avec une clé = 5.

**Beginner.** · 27/05/2020, 23h07

Salut,

Envoyé par Popkhorn

Dans l'idée, mon code est fonctionnel, mais toutes les combinaisons s'affichent à chaque fois, s'ajoutant les unes à la suite des autres.

Il faut "vider" la chaine message_dechiffre = "" pour chaque clé :

Code python :

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

1
2
3
4
5
6
for n in range(25):<br>
    cle = cle + 1<br>
    for lettre in message:<br>
        message_dechiffre += dechiffrage_lettre(lettre, liste, cle)<br>
    print(cle, message_dechiffre)<br>
    message_dechiffre = ""

PS : On peut faire plus simple...

Exemple pour doubler la liste tu peux juste faire ça : liste *= 2... Mais je ne vois pas pourquoi tu la doubles dans le code de cryptage... Je pense que cela doit t'être utile pour le cryptage...

**Sve@r** · 28/05/2020, 08h42

Bonjour

Envoyé par Popkhorn

liste = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']

liste="ABCDEFGHIJKLMNOPQRSTUVWXYZ" aurait aussi fonctionné et est plus simple à écrire. ou bien import string; liste=string.ascii_uppercase

Envoyé par Popkhorn

if lettre==' ': #au cas ou il y a un espace

Et s'il y a un point-virgule ? Ou un chiffre ? Ou ...
if lettre not in liste: #au cas où la lettre n'est pas prévue

Envoyé par Beginner.

Mais je ne vois pas pourquoi tu la doubles dans le code de cryptage...

C'est parce qu'il ne connait pas le modulo (ou qu'il le connait mais qu'il n'a pas pensé à l'utiliser), et qu'il veut donc pouvoir gérer le circulaire (ie 'Z' qui donnera 'E' en chiffré). Mais malheureusement ça ne fonctionne pas pour gérer le circulaire inverse ('E' qui donne 'Z')...

**Popkhorn** · 28/05/2020, 09h46

Hey ,
De toute évidence je suis démasqué !
Je me suis inspiré d'algorithmes de cryptage pour créer mon code, donc en effet le dédoublement est dans mon cas inutile.
Pour le modulo, je suis en 1ère, donc disons que j'en ai entendu parler, mais de là à le mettre en place dans un programme, cela me semblait un peu... disons tendu.
En tout cas super, j'ai apporté quelques modif en suivant vos indications, et tout fonctionne, un grand merci à vous !

Juste une question, j'ai compris que dédoubler la liste dans un sens, compte tenu du fait que l'on recule pour décoder est inutile, mais du coup, comment le programme fait il pour retomber à lafin de la liste ? est ce qu'il définit à partir de la liste que l'on est en modulo26 ?

Bonne journée à vous et merci encore.

**VinsS** · 28/05/2020, 10h54

Envoyé par Popkhorn

Juste une question, j'ai compris que dédoubler la liste dans un sens, compte tenu du fait que l'on recule pour décoder est inutile, mais du coup, comment le programme fait il pour retomber à lafin de la liste ? est ce qu'il définit à partir de la liste que l'on est en modulo26 ?

Dans ce cas tu fais (26 - key) % 26

Dans cet exemple le codage recule et le décodage avance:

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
 
import string
LETTERS = string.ascii_uppercase
 
def encode_letter(letter, key):
    if letter == " ":
        return letter
 
    return LETTERS[(LETTERS.index(letter) + 26 - key) % 26]
 
def decode_letter(letter, key):
    if letter == " ":
        return letter
 
    return LETTERS[(LETTERS.index(letter) + key) % 26]
 
key = 12
message = "HELLO WORLD FROM THE MARVELLOUS PYTHON FLYING CIRCUS"
code = "".join([encode_letter(i, key) for i in message])
print(code)
print("".join([decode_letter(i, key) for i in code]))

**Sve@r** · 28/05/2020, 11h30

Envoyé par Popkhorn

Je me suis inspiré d'algorithmes de cryptage

Le terme exact est "chiffrement".
Le "chiffrement", c'est rendre un message inintelligible pour qui n'a pas la clef
Le "déchiffrement" c'est l'opération inverse par le destinataire (qui lui a la clef)
Le "décryptage" c'est tenter de trouver le message sans avoir la clef
Par opposition, le "cryptage" serait tenter de rendre le message inintelligible sans la clef, ce qui n'a pas de sens

Envoyé par Popkhorn

Pour le modulo, je suis en 1ère, donc disons que j'en ai entendu parler

Oui, au CM2 (7°) quand on t'a appris la division, avec le diviseur, le dividende, résultat et surtout le reste. Donc 6 ans pour te familiariser avec cette notion ultra-complexe évidemment c'est un peu court je suis d'accord...

Envoyé par VinsS

Dans ce cas tu fais (26 - key) % 26

Même pas besoin. Le modulo fonctionne aussi avec les négatifs purs. Et autant utiliser len(liste) plutôt que 26 pour être évolutif (si la liste s'allonge avec les minuscules, les chiffres etc ça continue à fonctionner) => return LETTERS[(LETTERS.index(letter) - key) % len(liste)].

Envoyé par VinsS

code = "".join([encode_letter(i, key) for i in message])

Pas besoin de transformer le générateur en liste (les crochets). La méthode join accepte parfaitement de traiter un generateur => code = "".join(encode_letter(i, key) for i in message).

En plus ça peut même être contre-productif car en transformant le générateur en tuple (ou liste), Python ne peut plus l'analyser lors de la génération et est obligé de tout générer avant d'évaluer

Exemple

Code python :

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

1
2
3
def fct(n):
	print(n)
	return n < 5

Si on commence par transformer le générateur en liste

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
12
>>> print(all([fct(x) for x in range(10)]))
0
1
2
3
4
5
6
7
8
9
False

Si on laisse Python utiliser le générateur à sa sauce

Code python :

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

1
2
3
4
5
6
7
8
>>> print(all(fct(x) for x in range(10)))
0
1
2
3
4
5
False

**wiztricks** · 28/05/2020, 20h00

Salut,

Lorsque les caractères à chiffrer vont de 'A' à 'Z', utiliser une séquence, c'est un peu "luxe" puisqu'on est supposé savoir que les caractères ASCII sont ordonnés et qu'on sait facilement convertir un caractère en entier (via ord) et réciproquement via chr.

Ca ne fait pas forcément un code plus joli:

Code :

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

1
2
3
4
def encode_letter(ch, key):
    if ('A' <= ch <= 'Z'):
        ch = chr(ord('A') + ((ord(ch) - ord('A')) + (26 - key)) % 26)
    return ch

mais c'est probablement plus rapide et... çà permet de toucher un peu aux correspondances entre entiers, caractères, bytes,...

- W

**Beginner.** · 28/05/2020, 20h32

Salut,

Oui effectivement, j'avais aussi pensé au modulo (mentionné par Sve@r) et même à ord et chr (mentionnés par wiztricks) mais pour ces derniers je mettais dit que ce n'était pas plus rapide (contrairement à wiztricks qui semble penser que c'est plus rapide). Oui car dans l'autre code on utilise une liste et l’accès à un élément d'une liste est à priori très rapide et on ne le fait qu'une fois par lettre (alors qu'on utilise plusieurs fois ord et chr)...

**Sve@r** · 28/05/2020, 23h21

Moi aussi la solution chr et ord me semble peu pertinente. Non pas pour des questions de rapidité mais plutôt concernant la plage des valeurs à chiffrer. Utiliser une séquence permet ensuite demain de la faire grandir (rajouter les minuscules, puis les chiffres, puis la ponctuation) et le code (pour peu qu'on remplace "26" par str(liste)) continue à fonctionner pareil.
Avec chr et ord, on est obligé de rajouter autant de cas particulier qu'on veut rajouter des plages de valeurs.

Envoyé par wiztricks

ch = chr(ord('A') + ((ord(ch) - ord('A')) + (26 - key)) % 26)

Comme je l'ai déjà dit, le modulo fonctionne aussi sur les négatifs C'est dommage de mettre en avant la rapidité quand on fait faire des opérations inutiles. ch = chr(ord('A') + (ord(ch) - ord('A') - key) % 26)

**Popkhorn** · 28/05/2020, 23h53

Rebonjour !

J'ai remanié mon code, il reste rudimentaire mais il est désormais fonctionnel et intègre tout les caractères (sauf erreur de ma part ^^). Dans la foulée, j'ai aussi créé le crypteur, pour faire le travail inverse.

Je le poste ici au cas où cela puisse être utile à quelqu'un, mais les codes étant long, je pense qu'un lien sera plus pratique.

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
liste = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
liste+= liste
listem = 'abcdefghijklmnopqrstuvwxyz'
listem += listem
listex = ',;:!?./§%¨^*£$¤}=+°)]^ç\'_`|-[({"~&0123456789çéèàùûêôîâ' 
listex += listex
 
message = input('Entrez votre message : ')
cle = int(input('Entrez votre clef : '))
def chiffrage_lettre(lettre,liste,cle):
   for i in range(len(liste)):
        if liste[i]==lettre:
            return str(liste[i+cle])       
        elif lettre==' ':       #au cas ou il y a un espace
            return ' '
   for m in range (len(listem)):
        if listem[m]==lettre:
            return str(listem[m+cle])
        elif lettre==' ':       #au cas ou il y a un espace
            return ' '
   for x in range (len(listex)):
        if listex[x]==lettre:
            if lettre=='é':
                return str(listem[4+cle])
            else:
                if lettre=='è':
                    return str(listem[4+cle])
                else:
                    if lettre=='ê':
                        return str(listem[4+cle])
                    else:
                        if lettre=='à':
                            return str(listem[0+cle])
                        else:
                            if lettre=='â':
                                return str(listem[0+cle])
                            else:
                                if lettre=='ù':
                                    return str(listem[20+cle])
                                else:
                                    if lettre=='û':
                                        return str(listem[20+cle])
                                    else:
                                        if lettre=='ô':
                                            return str(listem[14+cle])
                                        else:                                    
                                            if lettre=='î':
                                                return str(listem[8+cle])
                                            else:
                                                if lettre=='ç':
                                                    return str(listem[2+cle])
                                                else:
                                                    return str(listex[x])        
        elif lettre==' ':       #au cas ou il y a un espace
            return ' '    
 
 
message_chiffre = str()
for lettre in message:
    message_chiffre += chiffrage_lettre(lettre,liste,cle)    
print(message_chiffre)

Dé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
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
liste = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
liste += liste
listem = 'abcdefghijklmnopqrstuvwxyz'
listem += listem
listex = ',;:!?.@/§%¨^*£$¤}=+°)]^\'_`|-[({"~&0123456789çéèàùûêôîâ' 
listex += listex
 
 
message = input('Entrez votre message : ')
 
 
 
def dechiffrage_lettre(lettre,liste,listem,listex,cle):
    for i in range(len(liste)):
        if liste[i]==lettre:
            return str(liste[i-cle])       
        elif lettre==' ':       #au cas ou il y a un espace
            return ' '
    for m in range (len(listem)):
        if listem[m]==lettre:
            return str(listem[m-cle])
        elif lettre==' ':       #au cas ou il y a un espace
            return ' '
    for x in range (len(listex)):
        if listex[x]==lettre:
            if lettre=='é':
                return str(listem[4-cle])
            else:
                if lettre=='è':
                    return str(listem[4-cle])
                else:
                    if lettre=='ê':
                        return str(listem[4-cle])
                    else:
                        if lettre=='à':
                            return str(listem[0-cle])
                        else:
                            if lettre=='â':
                                return str(listem[0-cle])
                            else:
                                if lettre=='ù':
                                    return str(listem[20-cle])
                                else:
                                    if lettre=='û':
                                        return str(listem[20-cle])
                                    else:
                                        if lettre=='ô':
                                            return str(listem[14-cle])
                                        else:                                    
                                            if lettre=='î':
                                                return str(listem[8-cle])
                                            else:
                                                if lettre=='ç':
                                                    return str(listem[2-cle])
                                                else:
                                                    return str(listex[x])                                            
        elif lettre==' ':       #au cas ou il y a un espace
            return ' '
 
 
#########################################
#Pour un message dont on connait la clé de decryptage
#########################################
 
cle = int(input('Entrez votre clef : '))
 
message_dechiffre = str()
for lettre in message:
    message_dechiffre += dechiffrage_lettre(lettre,liste,listem,listex,cle)    
 
print(message_dechiffre)
 
##########################################
#Pour un message dont on ne connait pas la clé de décryptage (si vous décommentez cette partie, il faut commenter l'autre)
##########################################
 
#for cle in range(26):
#    message_dechiffre = str()
#    for lettre in message:
#        message_dechiffre += dechiffrage_lettre(lettre,liste,listem,listex,cle)    
#    print(cle)
#    print(message_dechiffre)

Encore merci !

Liens Pastebin :
https://pastebin.com/7wdvKakc

https://pastebin.com/KmNd90hn

**Beginner.** · 29/05/2020, 00h21

Envoyé par Popkhorn

J'ai remanié mon code, il reste rudimentaire mais il est désormais fonctionnel et intègre tout les caractères (sauf erreur de ma part ^^). Dans la foulée, j'ai aussi créé le crypteur, pour faire le travail inverse.

Tu n'as pas utilisé le modulo ???

Et tous ces if else imbriqués, ça fait beaucoup sachant qu'on peut faire plus lisible : déjà il y a les elif mais avec un if et un return pas besoin de else ou de elif, des if au même niveau d'indentation suffisent...

**marco056** · 29/05/2020, 00h54

Le modulo est indispensable en Python.
Il serait plus agréable d'utiliser un dictionnaire à la place de tous les "if". Ce n'est sans doute pas au programme mais c'est à ta portée.
Je te propose un code : essaie de comprendre et de tester certaines fonctions.

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
import string
 
def cesar_chiffre_lettre(lettre,dec):
    return(lettre+dec)%26
 
def cesar_dechiffre_lettre(lettre,dec):
    return(lettre-dec)%26
 
def cesar_chiffre_texte(texte,k):
    message_code=[]
    for lettre in texte:
        nb = ord(lettre) - 65
        nb_crypte=cesar_chiffre_lettre(nb,k)
        lettre_crypte=chr(nb_crypte+65)
        message_code.append(lettre_crypte)
    message_code="".join(message_code)
    return message_code
 
def cesar_dechiffre_texte(texte):
    for k in range(26):
        print(cesar_chiffre_texte(texte,-k))
    return None
 
def multi_replace(texte, dico):
    for clef in dico:
        texte = texte.replace(clef, dico[clef])
    return texte
 
def epurage(chaine):
    """on enlève les espaces et les caractères spéciaux
    les caractères accentués pourraient être remplacés
    par les mêmes non accentués"""
    # on passe la chaîne en minuscules
    chaine = chaine.lower()
    chaine = multi_replace(chaine,dictionnaire)
    # oon peut repasser en majuscules :
    chaine = chaine.upper()
    liste_chaine = chaine.split(" ")
    chaine_splite = "".join(liste_chaine)
    chaine_finale = ""
    for k in range(len(chaine_splite)):
        lettre=chaine_splite[k]
        if ((ord(lettre)> 64) and (ord(lettre)<91)):
            chaine_finale = chaine_finale+lettre
    return chaine_finale
 
dictionnaire = {"é" : 'e', "ê" : 'e', "è" : "e", "î" : "i", "ï" : "i", "ö" : "o",\
 "ô" : "o", "à" : "a", "â" : "a", "ù" : "u", "ç" : "c", "æ" : "ae", "œ" : "oe"}
 
def cesar(chaine,dec) :
    alph=string.ascii_uppercase
    s=chaine.upper()
    return s.translate(str.maketrans(alph,alph[dec:]+alph[:dec]))
 
def testetout(chaine) :
    for i in range(1,26) :
        print("Décalage de",i, "\t-> ", cesar(epurage(chaine), -i))
 
testetout("Un joli message à envoyer")

**Sve@r** · 29/05/2020, 01h02

Envoyé par Beginner.

Tu n'a pas utilisé le modulo ???

T'es fou !!! T'as pas vu comme c'est une notion super compliquée pour lui ? Il n'est qu'en 1ère quoi !!!

Envoyé par Popkhorn

Je le poste ici au cas où cela puisse être utile à quelqu'un

Non, à personne. Quand on fait l'effort de te montrer des exemples, le minimum c'est de les mettre en oeuvre. Sinon on s'abstient.

Code python :

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
#!/usr/bin/env python3
# coding: utf-8
 
def cesar(lettre, clef, alphabet, sens):
	if lettre not in alphabet: return lettre
	import operator
	modif={
		"<" : operator.pos,
		">" : operator.neg,
	}[sens]
	return alphabet[(alphabet.index(lettre) + modif(key)) % len(alphabet)]
# cesar
 
import string
alphabet=string.ascii_lowercase + string.ascii_uppercase + string.digits
 
message="Hello World 12345 !!!"
key=3
code="".join(cesar(i, key, alphabet, "<") for i in message)
print(code)
final="".join(cesar(i, key, alphabet, ">") for i in code)
print(final)
print(final == message)

**marco056** · 29/05/2020, 01h38

Tu es dur Sve@r !
Popkhorn est volontaire, travailleur et curieux : tu sais que cela commence à devenir rare ?
Il faut au contraire l'encourager : ce sera peut-être un pilier du forum dans 5 ou 10 ans.

La notion de modulo n'est pas forcément évidente, tu sais ? C'est une notion que je n'utilisais plus depuis 20 ans (sauf en trigo) et que j'ai redécouverte avec Python. Il verra plus tard que c'est magique mais laisse lui le temps d'avancer à son rythme.
Je pense à d'autres notions qui peuvent paraître évidentes pour les vieux, ce sont les aires, volumes, périmètres : certes, c'est vu au collège mais ensuite, on n'en parle plus du tout pendant le lycée.
Arrivés en post-bac, les gamins ne savent même pas calculer le périmètre d'un cercle ou la surface d'un disque (en plus l'homogénéité des formules avec les unités est un peu confuse à leur niveau).
Ce n'est pas pour cela que c'est trop compliqué.
Bref, un peu de bienveillance pour ceux qui sont de bonne volonté ne nuirait pas, amha.
Bonne fin de semaine à tous et toutes.

**wiztricks** · 29/05/2020, 08h17

Salut,

Envoyé par Popkhorn

J'ai remanié mon code, il reste rudimentaire mais il est désormais fonctionnel et intègre tout les caractères (sauf erreur de ma part ^^). Dans la foulée, j'ai aussi créé le crypteur, pour faire le travail inverse.

Pourquoi toutes ces listes?

Réfléchissez un peu au problème que vous essayez de résoudre.
Vous prenez un texte pour an fabriquer un autre en appliquant une fonction a chaque caractère.

Pas besoin de liste pour fabriquer une fonction qui modifie les caractères qui vont de 'A' a 'Z' car c'est une plage contiguë de 26 lettres.

Cà se corse lorsqu'on inclus 'a'..'z' et autres caractères accentués et imprimables. C'est là que la liste devient intéressante... Une seule liste mais toujours une fonction (mathématique) qui transforme un nombre de 0..N en un autre nombre de 0..N via une addition et un modulo.

- W

Coder un decrypteur

Python

Discussions similaires

Partager

Partager