Discussion :

[renard_473]

Bonjour, j'ai pu créer un programme pour coder en vigenere mais je ne trouve pas de solution pour décoder la phrase obtenue. Voici mon programme de codage. Pouvez-vous m'aider ?? Merci d'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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# Construction du carré de Vigenère
Carre=[]
ligne=[] 
for j in range(26):
    for i in range(26):
        ligne.append(chr(65+(i+j)%26)) # chr donne la lettre a partir du numero ASCII
    Carre.append(ligne)
    ligne=[]
 
# Initialisation des données    
TexteClair=raw_input("Entrer le texte(en majuscule):") #En majuscule uniquement
lg_tc=len(TexteClair)
Cle=raw_input("Entrer la clef(en majuscule):") #En majuscule uniquement
lg_C=len(Cle)
bl=0                   # variable pour stockage du nombre d'espaces
TexteCrypte=""
 
# Cryptage
for i in range(lg_tc):
    lettre=TexteClair[i]
    if lettre==" ":
        bl+=1
        TexteCrypte+=" "
    else:
        j=(i-bl)%lg_C           # % sert a inserer les valeurs dans la chaine
        k=ord(Cle[j])-65        #ord sert a donner le chiffre correspondant a la lettre dans la table ASCII
        h=ord(lettre)-65
        TexteCrypte+= Carre[h][k]
 
# Affichages
print "             Texte de départ :"
print TexteClair
print "             Clé :"
print Cle
print "             Texte crypté :"
print TexteCrypte

[Sve@r]

Bonjour, j'ai pu créer un programme pour coder en vigenere mais je ne trouve pas de solution pour décoder la phrase obtenue.

Salut

Le code de Vigenère n'est qu'un simple code de César. La seule différence, c'est que chaque lettre est chiffrée sur un alphabet ou un autre donné par la clef.

Donc pour l'alphabet "1", le A deviendra B, le B deviendra C etc. En sens inverse, le B devient A, le C de vient B etc.

Voici mon programme de codage. Pouvez-vous m'aider ?? Merci d'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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# Construction du carré de Vigenère
Carre=[]
ligne=[] 
for j in range(26):
    for i in range(26):
        ligne.append(chr(65+(i+j)%26)) # chr donne la lettre a partir du numero ASCII
    Carre.append(ligne)
    ligne=[]
 
# Initialisation des données    
TexteClair=raw_input("Entrer le texte(en majuscule):") #En majuscule uniquement
lg_tc=len(TexteClair)
Cle=raw_input("Entrer la clef(en majuscule):") #En majuscule uniquement
lg_C=len(Cle)
bl=0                   # variable pour stockage du nombre d'espaces
TexteCrypte=""
 
# Cryptage
for i in range(lg_tc):
    lettre=TexteClair[i]
    if lettre==" ":
        bl+=1
        TexteCrypte+=" "
    else:
        j=(i-bl)%lg_C           # % sert a inserer les valeurs dans la chaine
        k=ord(Cle[j])-65        #ord sert a donner le chiffre correspondant a la lettre dans la table ASCII
        h=ord(lettre)-65
        TexteCrypte+= Carre[h][k]
 
# Affichages
print "             Texte de départ :"
print TexteClair
print "             Clé :"
print Cle
print "             Texte crypté :"
print TexteCrypte

Le "carré" c'est bon quand on le fait à la main... pour éviter de reconstuire un alphabet à chaque lettre qu'on chiffre ou qu'on déchiffre. Mais en programmation on peut utiliser des raccourcis. Tu aurais décomposé en réfléchissant sur la façon dont fonctionne réellement Vigenère tu y serais arrivé tout seul. Et en plus tu aurais remarqué qu'on peut aussi chiffrer les éléments significatifs comme la ponctuation ou les espaces...

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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
 
import string
 
# Fonction qui chiffre/déchiffre une lettre en fonction d'un alphabet donné et d'une base de décalage
def Vigenere(alphaN, base, lettre, crypt=True):
	# Recherche position de la base dans l'alphabet
	ind=alphaN.find(base)
 
	# Si base non trouvée, alors alphabet chiffré identique à alphabet donné
	if ind == -1: ind=0
 
	# Création de l'alphabet chiffré à partir de l'alphabet normal et de la base
	alphaK="".join([alphaN[(ind + i) % len(alphaN)] for i in range(len(alphaN))])
 
	# Positionnement du masque de conversion en fonction du sens (chiffrage/déchiffrage)
	masque=(alphaN, alphaK) if crypt else (alphaK, alphaN)
 
	# Recherche index lettre dans le masque de départ
	ind=masque[0].find(lettre)
 
	# Si lettre n'appartient pas à l'alphabet on la renvoie telle quelle. Elle ne sera pas chiffrée mais ne plantera pas la fonction
	if ind == -1: return lettre
 
	# Renvoi lettre associée du masque d'arrivée
	return masque[1][ind]
# Vigenere
 
# Création de l'alphabet à partir de tous les caractères imprimables de la table ascii (majuscules, minuscules, chiffres, ponctuation, ...)
alpha="".join([chr(i) for i in range(256) if chr(i) in string.printable])
 
# Clef
clef="bonjour"
 
# Test de chiffrage sur clef
secret="".join(
	[Vigenere(alpha, clef[i % len(clef)], x) for (i, x) in enumerate("Les sanglots longs des violons de l'automne, bercent mon coeur d'une langueur monotone !!!")]
)
print "Chiffre: [%s]" % secret
print
 
# Test de déchiffrage (même clef)
print "Clair: [%s]" % "".join(
	[Vigenere(alpha, clef[i % len(clef)], x, False) for (i, x) in enumerate(secret)]
)