Vous êtes sur la page 1sur 4

Cryptographie de Vigenère

La cryptographie de Vigenère (1523-1596) est une cryptographie à décalage par clé.


Au-lieu d'effectuer un décalage constant dans l'alphabet du message en clair, comme dans le
code de César, Vigenère réalise un décalage lié à une clé : la clé de chiffrement. Chaque lettre
de la clé sert de valeur de décalage dans l'alphabet du message en clair. Deux lettres
identiques de ce message en clair ne seront donc plus obligatoirement codées de la même
manière…

Le chiffrement est effectué de la manière suivante :


Chaque lettre de la clé de chiffrement est écrite sous chaque lettre du message en clair, sauf
sous les espaces qui ne sont pas chiffrés. Si la clé est plus petite que le message à chiffrer - et
c'est souvent le cas ! - on recopie la clé plusieurs fois.
Puis le décalage s'effectue comme suit : La lettre du message en clair est décalée de 0 position
dans l'alphabet (dons pas de décalage), si la lettre correspondante dans la clé est un "A"; De 1
position dans l'alphabet, si la lettre de la clé est un "B"; De 2 positions si c'est un "C"… Et
ainsi de suite, jusqu'à un décalage de 25 positions dans l'alphabet, si la lettre de la clé est
un"Z".

Par exemple, chiffrons le message "BONJOUR COMMENT ALLEZ VOUS", avec la clé
"AZERTYUIOP" :

Lettre B O N J O U R C O M M E N T A L L E Z V O U S
Clé répétée A Z E R T Y U I O P A Z E R T Y U I O P A Z E
Décalage 0 25 4 17 19 24 20 8 14 15 0 25 4 17 19 24 20 8 14 15 0 25 4
Code B N R A H S L K C B M D R K T J F M N K O T W

Le message chiffré est donc "BNRAHSL KCBMDRK TJFMN KOTW".

Ce type de chiffrement n'est plus utilisé depuis la fin du 19ième siècle, depuis que Babbage et
Kasiski en ont réalisé la cryptanalyse.

Vous devez

1. Ecrire un algorithme qui prend en entrée une phrase en majuscules uniquement


composée de lettres de l’alphabet (« A ».. »Z ») et d’espaces, une clé elle aussi en
majuscules et qui retourne cette phrase chiffrée par la méthode de Vigenère.

2. Modifier l’algorithme ci-dessus pour qu’il puisse aussi décrypter une phrase : Après
introduction de la phrase cryptée, de la clé et de l’information « codage » ou
« décodage », l’algorithme doit produire soit la phrase chiffrée, soit la phrase
déchiffrée par la méthode de Vigenère.

3. Implémenter ces deux algorithmes sous « Pratiquer l’algorithmique ».


Cryptographie de Vigenère : proposition de correction

1. Ecrire un algorithme qui prend en entrée une phrase en majuscules uniquement composée de lettres de l’alphabet (« A ».. »Z ») et
d’espaces, une clé elle aussi en majuscules et qui retourne cette phrase chiffrée par la méthode de Vigenère.

Algorithme cryptage_de_vigenère
Remarque Codage d'une phrase par la méthode de Vigenère
Variable message_en_clair , clé , message_crypté : Chaîne
Variable lettre_en_clair , lettre_clé , lettre_cryptée : Chaîne
Variable position_message_en_clair , position_clé , code : Entier
Début
| Afficher ( "Entrez le message à chiffrer [en majuscules] :" )
| Saisir ( message_en_clair )
| message_en_clair <- Maj ( message_en_clair )
|
| Répéter
| | Afficher ( "Entrez la clé de chiffrement [en majuscules] :" )
| | Saisir ( clé )
| Jusqu'à clé <> ""
| clé <- Maj ( clé )
|
| message_crypté <- ""
| position_clé <- 0
| Pour position_message_en_clair <- 1 à LgChaîne ( message_en_clair )
| | lettre_en_clair <- SousChaîne ( message_en_clair , position_message_en_clair , 1 )
| | Si lettre_en_clair <> " " Alors
| | | position_clé <- position_clé + 1
| | | Si position_clé > LgChaîne ( clé ) Alors
| | | | position_clé <- 1
| | | FinSi
| | | lettre_clé <- SousChaîne ( clé , position_clé , 1 )
| | | code <- CodeAscii ( lettre_en_clair ) + ( CodeAscii ( lettre_clé ) - 65 )
| | | Si code > 90 Alors
| | | | code <- code - 26
| | | FinSi
| | | lettre_cryptée <- CaractèreAscii ( code )
| | Sinon
| | | lettre_cryptée <- lettre_en_clair
| | FinSi
| | message_crypté <- message_crypté & lettre_cryptée
| FinPour
|
| Afficher ( "Le message crypté est : " , message_crypté )
Fin

2. Modifier l’algorithme ci-dessus pour qu’il puisse aussi décrypter une phrase : Après introduction de la phrase cryptée, de la clé et de
l’information « codage » ou « décodage », l’algorithme doit produire soit la phrase chiffrée, soit la phrase déchiffrée par la méthode de
Vigenère.

Algorithme cryptographie_de_vigenère
Remarque Codage Ou décodage d'une phrase par la méthode de Vigenère
Variable message_original , clé , clé_déchiffrement , message_traité : Chaîne
Variable lettre_en_clair , lettre_clé , lettre_cryptée : Chaîne
Variable commande : Chaîne
Variable position_message_original , position_clé , code : Entier
Début
| Répéter
| | Afficher ( "Que voulez-vous faire : [Entrez C pour crypter, D pour décrypter] " )
| | Saisir ( commande )
| | commande <- Maj ( commande )
| Jusqu'à commande = "C" Ou commande = "D"
| Si commande = "C" Alors
| | Afficher ( "Entrez le message à crypter : " )
| Sinon
| | Afficher ( "Entrez le message à décrypter : " )
| FinSi
| Saisir ( message_original )
| message_original <- Maj ( message_original )
|
| Répéter
| | Afficher ( "Entrez la clé [en majuscules] :" )
| | Saisir ( clé )
| Jusqu'à clé <> ""
| clé <- Maj ( clé )
| Si commande = "D" Alors
| | clé_déchiffrement <- ""
| | Pour position_clé <- 1 à LgChaîne ( clé )
| | | clé_déchiffrement <- clé_déchiffrement &
CaractèreAscii ( 156 - CodeAscii ( SousChaîne ( clé , position_clé , 1 ) ) )
| | FinPour
| | clé <- clé_déchiffrement
| FinSi
|
| message_traité <- ""
| position_clé <- 0
| Pour position_message_original <- 1 à LgChaîne ( message_original )
| | lettre_en_clair <- SousChaîne ( message_original , position_message_original , 1 )
| | Si lettre_en_clair <> " " Alors
| | | position_clé <- position_clé + 1
| | | Si position_clé > LgChaîne ( clé ) Alors
| | | | position_clé <- 1
| | | FinSi
| | | lettre_clé <- SousChaîne ( clé , position_clé , 1 )
| | | code <- CodeAscii ( lettre_en_clair ) + ( CodeAscii ( lettre_clé ) - 65 )
| | | Si code > 90 Alors
| | | | code <- code - 26
| | | FinSi
| | | lettre_cryptée <- CaractèreAscii ( code )
| | Sinon
| | | lettre_cryptée <- lettre_en_clair
| | FinSi
| | message_traité <- message_traité & lettre_cryptée
| FinPour
|
| Si commande = "C" Alors
| | Afficher ( "message crypté : " , message_traité )
| Sinon
| | Afficher ( "message décrypté : " , message_traité )
| FinSi
Fin