Kalkulator's Knights
Crypto's not safe...
Vous n'êtes pas identifié.
#1 18-10-2009 20:06:42
- Sorcier_FXK
- Administrateur
- Date d'inscription: 27-10-2008
- Messages: 378
[crypto] Le Chiffre de César
Vercingétorix jette ses armes aux pieds de Jules César, 1899, par Lionel-Noël Royer.
MAJ: 16/11/09
Le Chiffre de César
Version 0.9
0x01-Introduction
|----0x01.1 Sur un plan historique
|
0x02- Le Chiffre de César
|----0x02.1 Sur un plan mathématique
|----0x02.2 Notes
|----0x02.3 Conclusion
|
0x03 Les variantes du Chiffre de César
|----0x03.1 Le ROT13
|----0x03.2 La variante aux 52 clés
|----0x03.3 Les clés aléatoires
|--------0x03.31 Le modèle de base
|--------0x03.311 Comment déterminer le nombre de clés
|--------0x03.32 Le modèle complet
|
|----0x04 Cracking
|--------0x04.1 Cracker le Chiffre de César
|--------0x04.2 Cracker les clés aléatoires (non disponible pour le moment)
|
0x05 Les exercices
|----0x05.1 Le Chiffre de César
|----0x05.2 La variante aux 52 clés
|----0x05.3 Les clés aléatoires
0x01- Introduction
0x01.1 Sur un plan historique
Suétone, écrivain Romain, 70-127, en fait mention dans son ouvrage "La vie de 12 Césars", une bibliographie des 12 premiers Empereurs. Le Chiffre de César (ou le Code de César) est une des méthodes les plus anciennes admisent par les historiens, la première étant "le Carré de Polybe". Polybe, historien grec (env. 200 - 125 av. J.-C.), est à l'origine du premier procédé de chiffrement par substitution. Il s'agit d'un carré (ou tableau) de 25 cases. Le Carré de Polybe sera le sujet d'un prochain article, nous y reviendrons donc plus tard.
Le Chiffre de César fut employé également par l'armée Russe en 1915. L'armé Russe préféré cette méthode à d'autre car il était simple à utiliser par leurs troupes. Leurs ennemis Autrichiens et Allemands n'ont pas eu de difficulté à déchiffrer leurs messages. Cette méthode de chiffrement fut encore employé par des officiers sudistes pendant la guerre de Sécession.
0x02- Le Chiffre de César
Le Chiffre de César est une substitution mono-alphabétique couplé avec un décalage de lettres, ce décalage de lettre peut se faire vers la droite ou vers la gauche. Il appartient à la famille des "chiffres mono-alphabétiques". Prenons un exemple...
Exemple : brcblcrkfi'j bezxykj
A première vue, c'est pas très compréhensible. Pour chiffrer/déchiffrer un message on doit faire un petit tableau d'équivalence.
0x02.1 Sur un plan mathématique
Dans cet exemple, on constate que nous avons décalé notre alphabet vers la droite, la lettre "a" se retrouve en 11ème position. Une fois notre tableau créé, il devient facile de retrouver le message secret.
Exemple : brcblcrkfi'j bezxykj
Message en clair : kalkulator's knights
On dit alors que la clé de notre message était : rstuvwxyzabcdefghijklmnopq
Comme le Chiffre de César est un décalage de lettres, nous avons donc 26 clés différentes. Ce qui en fait une méthode de chiffrement très obsolète de nos jours. De plus avec un peu d'astuces, on peut facilement déchiffrer le message de tête sans en connaitre la clé.
Maintenant nous savons que le Chiffre de César est une substitution mono-alphabétique avec n+x caractères ou n-x caractères (x pouvant être compris entre 1 et 25)
Soit les 26 clés possibles :
abcdefghijklmnopqrstuvwxyz fghijklmnopqrstuvwxyzabcde klmnopqrstuvwxyzabcdefghij
bcdefghijklmnopqrstuvwxyza ghijklmnopqrstuvwxyzabcdef lmnopqrstuvwxyzabcdefghijk
cdefghijklmnopqrstuvwxyzab hijklmnopqrstuvwxyzabcdefg mnopqrstuvwxyzabcdefghijkl
defghijklmnopqrstuvwxyzabc ijklmnopqrstuvwxyzabcdefgh nopqrstuvwxyzabcdefghijklm
efghijklmnopqrstuvwxyzabcd jklmnopqrstuvwxyzabcdefghi opqrstuvwxyzabcdefghijklmn
pqrstuvwxyzabcdefghijklmno uvwxyzabcdefghijklmnopqrst zabcdefghijklmnopqrstuvwxy
qrstuvwxyzabcdefghijklmnop vwxyzabcdefghijklmnopqrstu
rstuvwxyzabcdefghijklmnopq wxyzabcdefghijklmnopqrstuv
stuvwxyzabcdefghijklmnopqr xyzabcdefghijklmnopqrstuvw
tuvwxyzabcdefghijklmnopqrs yzabcdefghijklmnopqrstuvwx
0x02.2 Notes
Dans la réalité, Jules César appliquait une contrainte supplémentaire, il retirait la ponctuation et groupait les lettres par 5.
Exemple : brcbl crkfi jbezx ykj
Message en clair : kalku lator sknig hts
Clé : rstuvwxyzabcdefghijklmnopq
0x02.3 Conclusion
Le Chiffre de César n'est pas vraiment compliqué à comprendre et à mettre en œuvre. Il peut être la source d'un jeu entre amis où les premières épreuves d'un challenge en cryptographie. Il n'y a rien de plus à savoir sur cette méthode de chiffrement simple, nous allons donc aborder maintenant ses variantes. Je vous donne aussi un code source en python qui applique cette méthode, je le donne à titre informatif, il a été écrit dans l'idée que tout le monde pourrai le relire pour comprendre, et n'est donc pas un modèle de programmation en soi, il peut être amélioré par bien des manières différentes. N'hésitez pas à le modifier vous même.
Si vous voulez essayer de chiffrer/déchiffrer des messages personnels, voici un code source en python qui appuiera tout ce qui a été expliqué ici:
Code:
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
import sys
from os import system
def welcome():
system('clear')
print "##############################################################"
print "# Le Chiffre de Cesar #"
print "# by Sorcier FXK for Staff DK & Project Kalkulator's Knights #"
print "# www.tdark-knight.com #"
print "# forum.kalkulators.org #"
print "# sorcierfxk@kalkulators.org #"
print "##############################################################"
def chiffrement():
message_clair = raw_input("[>] Saisissez votre message secret : ")
message_cle = raw_input("[?] Saisissez votre cle secrete : ")
#on vérifie que la clé contient bien les 26 lettres de l'alphabet
if len(message_cle) != 26:
print "[x] Votre clé ne contient pas les 26 lettres de l'alphabet"
sys.exit()
if len(message_cle) == 26:
print "[>] Votre clé contient bien 26 caractères"
cle_control_1 = ['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']
control_cle = 0
for x in range(len(message_cle)):
if message_cle[x] in cle_control_1:
control_cle = control_cle + 1
else:
control_cle = 0
if control_cle >= 1:
print "[>] Votre Clé est valide"
else:
print "[>] Votre Clé contient une erreur..."
sys.exit()
#on fait un tableau d équivalence pour la clé
tableau_equi = {}
for x in range(len(message_cle)):
tableau_equi[cle_control_1[x]] = message_cle[x]
#on chiffre maintenant le message
message_chiffre = ""
for x in range(len(message_clair)):
if message_clair[x] == " " or message_clair[x] == "," or message_clair[x] == "'" or message_clair[x] == "." or message_clair[x] == "!":
message_chiffre = message_chiffre + message_clair[x]
else:
message_chiffre = message_chiffre + tableau_equi[message_clair[x]]
print "[>] Message chiffre : ", message_chiffre
sys.exit()
def dechiffrement():
message_chiffre = raw_input("[>] Saisissez votre message secret : ")
print "[!] Attention, si votre clé n'est pas la bonne, le résultat sera faux."
message_cle = raw_input("[?] Saisissez votre clé secrête : ")
#on vérifie que la clé contient bien les 26 lettres de l'alphabet
if len(message_cle) != 26:
print "[x] Votre clé ne contient pas les 26 lettres de l'alphabet"
sys.exit()
if len(message_cle) == 26:
print "[>] Votre clé contient bien 26 caracteres"
cle_control_1 = ['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']
control_cle = 0
for x in range(len(message_cle)):
if message_cle[x] in cle_control_1:
control_cle = control_cle + 1
else:
control_cle = 0
if control_cle >= 1:
print "[>] Votre Clé est valide"
else:
print "[>] Votre Clé contient une erreur..."
sys.exit()
#on fait un tableau d équivalence pour la clé
tableau_equi = {}
for x in range(len(message_cle)):
tableau_equi[message_cle[x]] = cle_control_1[x]
#on déchiffre maintenant le message
message_clair = ""
for x in range(len(message_chiffre)):
if message_chiffre[x] == " " or message_chiffre[x] == "," or message_chiffre[x] == "'" or message_chiffre[x] == "." or message_chiffre[x] == "!":
message_clair = message_clair + message_chiffre[x]
else:
message_clair = message_clair + tableau_equi[message_chiffre[x]]
print "[>] Message déchiffre : ", message_clair
sys.exit()
def menu():
choix = ""
while choix != "1" and choix != "2" and choix != "x":
welcome()
print "[§] Menu Principal"
print "[§] Chiffrer un message......[1]"
print "[§] Déchiffrer un message....[2]"
print "[§] Quit.....................[x]"
choix = raw_input("[§] Choix : ")
if choix == "1":
chiffrement()
if choix == "2":
déchiffrement()
if choix == "x":
sys.exit()
menu()0x03 Les variantes du Chiffre de César
0x03.1 Le ROT13
Derrière ce nom étrange se cache rien de bien compliqué, et même quelque chose de très basique. ROT pour "rotation" et 13 parce qu'il s'agit d'un décalage de 13 crans sur notre alphabet. Il n'y a donc qu'une seule et unique clé pour cette méthode de chiffrement. Il ne présente pas vraiment d'intérêt particulier
0x03.2 Le variante aux 52 clés
Cette variante est très simple à comprendre. Nous savons que le Chiffre de César est un décalage de l'alphabet soit vers la droite soit vers la gauche. Mais il respecte l'ordre qui va de "a" vers "z". On peut donc très facilement imaginer qu'on regarde notre alphabet dans un miroir.
Notre alphabet serai ainsi : zyxwvutsrqponmlkjihgfedcba
Il nous reste plus qu'à appliquer le principe du décalage vers la droite ou vers la gauche, et on se retrouve avec 26 clés de plus , soit un total de 52. Nous sommes toujours loin d'une variante efficace, elle reste donc dans le domaine du loisir.
0x03.3 Les clés aléatoires
0x03.31 Le modèle de base
Comme nous l'avons vu précédemment, le Chiffre de César est un décalage de lettre vers la droite ou vers la gauche, ce qui a pour conséquence d'avoir peu de clés. Maintenant rien ne nous empêche de générer de clés parfaitement aléatoires. Si on prend toujours notre alphabet de a -> z en référence, cette variante nous propose 4.0329146113e+26 clés soit 403291461126605635592388608 exactement. Pour déchiffrer un message codé qui utilise cette variante, c'est déjà plus dur, mais pas insurmontable. Pourquoi cette méthode n'est pas insurmontable ? Tout simplement parce qu'elle ne tient pas compte de la ponctuation et autres espaces. Cela peut paraitre simpliste, mais la ponctuation et les espaces donnent de précieuses informations à la personne qui tente de déchiffrer votre message sans en connaitre la clé.
Penchons nous sur un exemple afin de mieux comprendre:
Exemple :
Texte en clair : le chat est sagement installé sur son fauteuil, tandis que le chien, couche dans la véranda, observe la pluie tombée. il est triste car il aimerait jouer dehors.
Texte chiffré : yc okal cvl vatcgcdl pdvlayyc vsr vmd qaslcpy, ladnpv xsc yc okpcd, omsokc nadv ya wcradna, mbvcrwc ya hyspc lmgbcr. py cvl lrpvlc oar py apgcrap emscr nckmrv.
La clé : aboncqtkpezygdmhxrvlswiujf
Pour déchiffrer un tel message sans en avoir la clé, on regarde les mots les plus courts, c'est très facile car la ponctuation et les espaces nous montre très clairement les mots.
yc okal cvl vatcgcdl pdvlayyc vsr vmd qaslcpy, ladnpv xsc yc okpcd, omsokc nadv ya wcradna, mbvcrwc ya hyspc lmgbcr. py cvl lrpvlc oar py apgcrap emscr nckmrv.
Les mots les plus faciles à retrouver ont été surlignés. En francais, les mots de 2 et 3 lettres sont peu nombreux, il peut s'agir de "le", "la", "les", "de", "du", "est" ... Le premier mot de notre phrase chiffré est "yc", il y a de très fortes chances que ce mot soit "le" ou "la". Partant de la nous avons un debut de piste et ainsi de suite on retrouve la phrase au complet. Malgré ses 403291461126605635592388608 clés possibles, le message reste facilement déchiffrable, une fois de plus cette variante restera dans le domaine du loisir. Mais cette expérience n'est pas vaine, on vient d'apprendre qu'il faut impérativement chiffrer la ponctuation et les espaces. Voici le code source qui a permis de chiffrer le message de notre exemple. Amusez vous à le modifier, ca reste très instructifs.
Code:
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
import sys
from os import system
from random import randrange
def welcome():
system('clear')
print "##############################################################"
print "# Le Chiffre de Cesar #"
print "# by Sorcier FXK for Staff DK & Project Kalkulator's Knights #"
print "# www.tdark-knight.com #"
print "# forum.kalkulators.org #"
print "# sorcierfxk@kalkulators.org #"
print "##############################################################"
def hardest(key=""):
welcome()
print "[§] Chiffre de Cesar avec full charset et cles aleatoires"
message_clair = raw_input("[>] Saisissez votre message secret : ")
if message_clair == "":
menu()
cle_primaire = ['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']
cle_control = ['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']
if key == "":
for x in range(26):
if len(cle_control) > 0:
a = randrange(len(cle_control))
key = key + str(cle_control[a])
cle_control.pop(a)
print "[>] Votre cle : ", "["+key+"]"
else:
if len(key) != 26:
print "[x] Votre clé ne contient pas les les 26 caracteres"
sys.exit()
if len(key) == 26:
print "[>] Votre clé contient bien 26 caracteres"
cle_control_1 = ['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']
control_cle = 0
for x in range(len(key)):
if key[x] in cle_control_1:
control_cle = control_cle + 1
else:
control_cle = 0
if control_cle >= 1:
print "[>] Votre Cle est valide"
else:
print "[>] Votre Clé contient une erreur..."
sys.exit()
#on fait un tableau d équivalence pour la clé
tableau_equi = {}
for x in range(len(key)):
tableau_equi[cle_primaire[x]] = key[x]
#on chiffre maintenant le message
message_chiffre = ""
for x in range(len(message_clair)):
if message_clair[x] == " " or message_clair[x] == "," or message_clair[x] == "'" or message_clair[x] == "." or message_clair[x] == "!":
message_chiffre = message_chiffre + message_clair[x]
else:
message_chiffre = message_chiffre + tableau_equi[message_clair[x]]
print "[>] Message chiffre : ", message_chiffre
sys.exit()
def unhardest():
welcome()
print "[§] Chiffre de César avec full charset et clés aléatoires"
message_chiffre = raw_input("[>] Saisissez votre message secret : ")
if message_chiffre == "":
menu()
print "[!] Attention, si votre clé n'est pas la bonne, le résultat sera faux."
message_cle = raw_input("[?] Saisissez votre cle secrete : ")
#on vérifie que la clé contient bien les 81 caractères
if len(message_cle) != 26:
print "[x] Votre clé ne contient pas les 81 caracteres"
sys.exit()
if len(message_cle) == 26:
print "[>] Votre clé contient bien 26 caracteres"
cle_control_1 = ['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']
control_cle = 0
for x in range(len(message_cle)):
if message_cle[x] in cle_control_1:
control_cle = control_cle + 1
else:
control_cle = 0
if control_cle >= 1:
print "[>] Votre Clé est valide"
else:
print "[>] Votre Clé contient une erreur..."
sys.exit()
#on fait un tableau d équivalence pour la clé
tableau_equi = {}
for x in range(len(message_cle)):
tableau_equi[message_cle[x]] = cle_control_1[x]
#on déchiffre maintenant le message
message_clair = ""
for x in range(len(message_chiffre)):
if message_chiffre[x] == " " or message_chiffre[x] == "," or message_chiffre[x] == "'" or message_chiffre[x] == "." or message_chiffre[x] == "!":
message_clair = message_clair + message_chiffre[x]
else:
message_clair = message_clair + tableau_equi[message_chiffre[x]]
print "[>] Message déchiffré : ", message_clair
sys.exit()
def menu():
choix = ""
while choix != "1" and choix != "2" and choix != "x":
welcome()
print "[§] Menu Principal"
print "[§] Chiffrer un message......[1]"
print "[§] Déchiffrer un message....[2]"
print "[§] Quit.....................[x]"
choix = raw_input("[§] Choix : ")
if choix == "1":
menu2()
if choix == "2":
menu3()
if choix == "x":
sys.exit()
def menu2():
choix = ""
while choix != "1" and choix != "r":
welcome()
print "[§] Menu Chiffrement"
print "[§] Chiffre de César avec clés aléatoires...........[1]"
print "[§] Retour..........................................[r]"
choix = raw_input("[§] Choix : ")
if choix == "1":
menu4()
if choix == "r":
menu()
def menu3():
choix = ""
while choix != "1" and choix != "r":
welcome()
print "[§] Menu Déchiffrement"
print "[§] Chiffre de César avec clés aléatoires...........[1]"
print "[§] Retour..........................................[r]"
choix = raw_input("[§] Choix : ")
if choix == "1":
unhardest()
if choix == "r":
menu()
def menu4():
choix = ""
while choix != "1" and choix != "2" and choix != "r":
welcome()
print "[§] Choix de la clé"
print "[§] J'ai deja ma clé...............[1]"
print "[§] Je veux une nouvelle clé.......[2]"
print "[§] Retour.................. ......[r]"
choix = raw_input("[§] Choix : ")
if choix == "1":
key = raw_input("[>] Saisissez votre clé : ")
hardest(key)
if choix == "2":
hardest()
if choix == "r":
menu()
menu()0x03.311 Comment déterminer le nombre de clés
Plus haut, j'expliquais que la variante précédante avait 403291461126605635592388608 clés (ou combinaisons) possibles. Mais comment déterminer le nombre de clés dans nos variantes du Chiffre de César ? C'est très simple, vous allez voir.
Pour déterminer le nombre de clés possibles sur une telle méthode de chiffrement, nous allons utiliser les factoriels. Pas de panique derriere ce terme barbare de mathématicien, se cache un principe très simple. On va donc ouvrir une parenthèse et prendre le temps de l'expliquer brievement au travers d'un petit problème simple et à la porté de tous.
Ennoncé : Nous avons une chaine de 3 caractères qui est constitué de 3 symboles. Ces symboles sont 1, 2, et 3.
Notre chaine va ressembler à ça : 123, 321, 132...
Dans notre chaine nous devons utiliser qu'un symbole à la fois, c'est à dire que les chaines comme 111, 222, 333, 112, 223... n'existent pas.
Comme nous avons des chaines de 3 caractères de long sur trois symboles nous avons 3^3 combinaisons possible soit 27. Dans ces 27 combinaisons une partie est fausse car elles ne respectent pas notre contrainte qui nous oblige à avoir qu'une fois un symbole. Dans notre exercice il n'y a que 27 combinaisons possibles, ce qui nous donne l'avantage de pouvoir le faire sur une feuille de papier.
Les 27 combinaisons:
111 222 333
112 221 331
113 223 332
123 212 323
121 213 321
122 211 322
131 232 313
132 231 312
133 233 311
En appliquant les conditions de l'exercice, on peut retirer de cette liste 21 combinaisons, il nous en reste 6.
Les 6 combinaisons restantes sont 123, 132, 213, 231, 321, 312. Il nous faut donc trouver un calcul simple pour arriver à 6. En fait quand on regarde de plus prés, le premier caractère peut être n'importe lequel, 1 , 2 ou 3, le 2ème caractère lui ne peut être qu'un des 2 qui reste, et enfin le dernier ne peut être que celui qui reste.
Ca nous fait donc 3*2*1 = 6. C'est justement ça une factoriel, on l'ecrira 3! , qui se lira factoriel 3. Maintenant on peut retester le même exercice mais avec des chaines de 4 caractères de long sur 4 symboles, on voit bien que cela fonctionne encore.
4*3*2*1 = 24 // donc dans se nouvelle exemple on sait que nous avons 24 combinaisons qui respectent les exigences de l'exercice.
La parenthèse étant close, revenons sur le Chiffre de César, c'est exactement le même exercices que ceux vu précédement, mais ici nous avons des chaines de 26 caractères sur 26 symboles, ce qui nous donne :
26*25*24*23*22*21*20*19*18*17*16*15*14*13*12*11*10*9*8*7*6*5*4*3*2*1 = 403291461126605635592388608
Sur une caculatrice à notation scientifique, le résultat sera sous la forme suivante : 4.0329146113e+26. La notation 26! étant quand même plus agréable à utiliser.
0x03.32 Le modèle complet
Dans la même optique que la variante précédente, pourquoi ne pas utiliser un alphabet le plus grand possible qui inclurait minuscules, majuscules, chiffres, ponctuations et le fameux caractère d'espacement. Ce qui porterai la chose à des clés de 81 caractères. Mais combien de clés sont possible avec un tel alphabet ? Très simple, nous allons de se pas appliquer les fameuses factoriels abordées précédement. Let's go !
Soit notre alphabet : abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.!:', ()@&-_/[]=+*#
L'espace est bien pris en compte
81! = 5.7971260207e+120 = 5797126020747367985821359469856838345078340715866521034711057880160400487681544819751446973604648306414253942720371359744
Comme on peut le constater, le nombre de combinaisons est absolument énorme ! Mais seulement pour un être humain, pour une machine, retrouver le message chiffré, reste très facile. Les puissances de calculs actuelles nous ont propulsées en avant dans le domaine de la cryptographie et de l'ingénieurie inverse. Reprennons notre phrase d'exemple et voyont ce que cela donne une fois chiffré avec cette variante.
Texte en clair : Le chat est sagement installé sur son fauteil, tandis que le chien, couche dans la véranda, observe la pluie tomber. Il est triste car il aimerait jouer dehors.
Texte chiffré : y5Cs1K2C5M2CMKO5'5R2CdRM2KBB5CM7GCMURChK725dB+C2KR/dMC*75CB5Cs1d5R+CsU7s15C/KRMCBKCe5GKR/K+CUWM5Ge5CBKCDB7d5C2U'W5G3CJBC5M2C2GdM25CsKGCdBCKd'5GKdC4U75GC/51UGM3
La clé : KWs/5hO1d4@B'RUD*GM27eoqvwZ9ncmASbJ):yxY.! &VTu0aILl]-#_j=k(6[38Xz+C,iFfgPNrEQpHt
On voit clairement que maintenant pour prendre en repère des mots, ca va être beaucoup plus dur, il nous est impossible de dire combien de mots sont utilisés, ou se trouve la ponctuation etc. On pourrai pousser encore plus loin la chose et utiliser tout le tableau ASCII soit 256 caractères. Le nombre de combinaison est vraiment impressionnant.
256! = 8.5781777534e+506 = 857817775342842654130980792755364056177472686427075039341964343972391992331066084389612928025695117026212533068028088806917989036657256600255071177309708384410198806874091914224059850870187935548479007035217388882998277722548957788791562175168667782710559989159688127308032867742028487888212267460091838532775334921673500680389354857034944843322406631029578623865145590028777381829488770509395258279
Rien que ça...
Avec une telle méthode, on pourrai simplement utiliser cela pour un usage personnel, mais ne vous sentez pas à l'abris d'un gouvernement, le Chiffre de César et ses variantes sont à considérer comme un cas d'ecole. L'étudier reste cependant intéressant car il introduit des notions qui seront utiles et considérées comme des bases dans les prochaines méthodes de chiffrement que nous verront ensemble.
Voici le code source qui vous permettra de chiffrer vos messages avec des clés de 81 caracteres.
Code:
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
import sys
from os import system
from random import randrange
def welcome():
system('clear')
print "##############################################################"
print "# Le Chiffre de Cesar #"
print "# by Sorcier FXK for Staff DK & Project Kalkulator's Knights #"
print "# www.tdark-knight.com #"
print "# forum.kalkulators.org #"
print "# sorcierfxk@kalkulators.org #"
print "##############################################################"
def cesar_classic_code():
welcome()
print "[§] Chiffre de Cesar traditionnel"
print "[>] Uniquement des minuscules sans accents, apostrophe, chiffres."
message_clair = raw_input("[>] Saisissez votre message secret : ")
if message_clair == "":
menu()
cle_primaire = ['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']
cle_control = ['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']
key = ""
a = randrange(25+1)
print "[>] Décalage de",a, "caracteres."
while a > 0:
tampon = cle_control[0]
cle_control.pop(0)
cle_control.append(tampon)
a = a - 1
for x in cle_control:
key = key + x
print "[>] Votre clé : ", "["+key+"]"
#on fait un tableau d équivalence pour la clé
tableau_equi = {}
for x in range(len(key)):
tableau_equi[cle_primaire[x]] = key[x]
#on chiffre maintenant le message
message_chiffre = ""
for x in range(len(message_clair)):
if message_clair[x] in (" ", ",", "'", '.', "!", "(", ")", "@",):
message_chiffre = message_chiffre + message_clair[x]
else:
message_chiffre = message_chiffre + tableau_equi[message_clair[x]]
print "[>] Message chiffre : ", message_chiffre
sys.exit()
def cesar_classic_decode():
welcome()
print "[§] Chiffre de César traditionnel"
message_chiffre = raw_input("[>] Saisissez votre message secret : ")
if message_chiffre == "":
menu()
print "[!] Attention, si votre clé n'est pas la bonne, le resultat sera faux."
message_cle = raw_input("[?] Saisissez votre cle secrete : ")
#on verifie que la clé contient bien les 26 lettres de l'alphabet
if len(message_cle) != 26:
print "[x] Votre clé ne contient pas les 26 lettres de l'alphabet"
sys.exit()
if len(message_cle) == 26:
print "[>] Votre clé contient bien 26 caractères"
cle_control_1 = ['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']
control_cle = 0
for x in range(len(message_cle)):
if message_cle[x] in cle_control_1:
control_cle = control_cle + 1
else:
control_cle = 0
if control_cle >= 1:
print "[>] Votre Clé est valide"
else:
print "[>] Votre Clé contient une erreur..."
sys.exit()
#on fait un tableau d équivalence pour la clé
tableau_equi = {}
for x in range(len(message_cle)):
tableau_equi[message_cle[x]] = cle_control_1[x]
#on dechiffre maintenant le message
message_clair = ""
for x in range(len(message_chiffre)):
if message_chiffre[x] == " " or message_chiffre[x] == "," or message_chiffre[x] == "'" or message_chiffre[x] == "." or message_chiffre[x] == "!":
message_clair = message_clair + message_chiffre[x]
else:
message_clair = message_clair + tableau_equi[message_chiffre[x]]
print "[>] Message déchiffre : ", message_clair
sys.exit()
def hardest(key=""):
welcome()
print "[§] Chiffre de César avec full charset et cles aléatoires"
message_clair = raw_input("[>] Saisissez votre message secret : ")
if message_clair == "":
menu()
cle_primaire = ['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','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','0','1','2','3','4','5','6','7','8','9','.','!',':',"'",',',' ','(',')','@','&','-','_','/','[',']','=','+','*','#']
cle_control = ['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','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','0','1','2','3','4','5','6','7','8','9','.','!',':',"'",',',' ','(',')','@','&','-','_','/','[',']','=','+','*','#']
if key == "":
for x in range(81):
if len(cle_control) > 0:
a = randrange(len(cle_control))
key = key + str(cle_control[a])
cle_control.pop(a)
print "[>] Votre cle : ", "["+key+"]"
else:
if len(key) != 81:
print "[x] Votre clé ne contient pas les les 81 caractères"
sys.exit()
if len(key) == 81:
print "[>] Votre clé contient bien 81 caractères"
cle_control_1 = ['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','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','0','1','2','3','4','5','6','7','8','9','.','!',':',"'",',',' ','(',')','@','&','-','_','/','[',']','=','+','*','#']
control_cle = 0
for x in range(len(key)):
if key[x] in cle_control_1:
control_cle = control_cle + 1
else:
control_cle = 0
if control_cle >= 1:
print "[>] Votre Clé est valide"
else:
print "[>] Votre Clé contient une erreur..."
sys.exit()
#on fait un tableau d équivalence pour la clé
tableau_equi = {}
for x in range(len(key)):
tableau_equi[cle_primaire[x]] = key[x]
#on chiffre maintenant le message
message_chiffre = ""
for x in range(len(message_clair)):
message_chiffre = message_chiffre + tableau_equi[message_clair[x]]
print "[>] Message chiffre : ", message_chiffre
sys.exit()
def unhardest():
welcome()
print "[§] Chiffre de César avec full charset et clés aléatoires"
message_chiffre = raw_input("[>] Saisissez votre message secret : ")
if message_chiffre == "":
menu()
print "[!] Attention, si votre clé n'est pas la bonne, le resultat sera faux."
message_cle = raw_input("[?] Saisissez votre cle secrete : ")
#on verifie que la clé contient bien les 81 caractères
if len(message_cle) != 81:
print "[x] Votre clé ne contient pas les 81 caractères"
sys.exit()
if len(message_cle) == 81:
print "[>] Votre clé contient bien 81 caractères"
cle_control_1 = ['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','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','0','1','2','3','4','5','6','7','8','9','.','!',':',"'",',',' ','(',')','@','&','-','_','/','[',']','=','+','*','#']
control_cle = 0
for x in range(len(message_cle)):
if message_cle[x] in cle_control_1:
control_cle = control_cle + 1
else:
control_cle = 0
if control_cle >= 1:
print "[>] Votre Clé est valide"
else:
print "[>] Votre Clé contient une erreur..."
sys.exit()
#on fait un tableau d équivalence pour la clé
tableau_equi = {}
for x in range(len(message_cle)):
tableau_equi[message_cle[x]] = cle_control_1[x]
#on déchiffre maintenant le message
message_clair = ""
for x in range(len(message_chiffre)):
message_clair = message_clair + tableau_equi[message_chiffre[x]]
print "[>] Message dechiffre : ", message_clair
sys.exit()
def menu():
choix = ""
while choix != "1" and choix != "2" and choix != "x":
welcome()
print "[§] Menu Principal"
print "[§] Chiffrer un message......[1]"
print "[§] Déchiffrer un message....[2]"
print "[§] Quit.....................[x]"
choix = raw_input("[§] Choix : ")
if choix == "1":
menu2()
if choix == "2":
menu3()
if choix == "x":
sys.exit()
def menu2():
choix = ""
while choix != "1" and choix != "2" and choix != "r":
welcome()
print "[§] Menu Chiffrement"
print "[§] Chiffre de César traditionnel...............................[1]"
print "[§] Chiffre de César avec full charset et clés aléatoires.......[2]"
print "[§] Retour......................................................[r]"
choix = raw_input("[§] Choix : ")
if choix == "1":
cesar_classic_code()
if choix == "2":
menu4()
if choix == "r":
menu()
def menu3():
choix = ""
while choix != "1" and choix != "2" and choix != "r":
welcome()
print "[§] Menu Déchiffrement"
print "[§] Chiffre de César traditionnel...............................[1]"
print "[§] Chiffre de César avec full charset et clés aléatoires.......[2]"
print "[§] Retour......................................................[r]"
choix = raw_input("[§] Choix : ")
if choix == "1":
cesar_classic_decode()
if choix == "2":
unhardest()
if choix == "r":
menu()
def menu4():
choix = ""
while choix != "1" and choix != "2" and choix != "r":
welcome()
print "[§] Choix de la clé"
print "[§] J'ai deja ma clé...............[1]"
print "[§] Je veux une nouvelle clé.......[2]"
print "[§] Retour.................. ......[r]"
choix = raw_input("[§] Choix : ")
if choix == "1":
key = raw_input("[>] Saisissez votre clé : ")
hardest(key)
if choix == "2":
hardest()
if choix == "r":
menu()
menu()0x04 Cracking
0x04.1 Cracker le Chiffre de César
Maintenant je vous propose un autre code source, toujours en python, celui ci permet de cracker n'importe quel texte chiffré avec le Chiffre de César (je parle de la méthode tradionnelle qu'on a vu au tout debut de cet article). Ce chiffre possédant que 26 clés possibles, il vous donne en sortie les 26 variantes, la bonne est donc forcement dedans. Je me suis même permis d'aller plus loin, car en fait il teste les 26 permutations de a -> z mais aussi les 26 de z -> a.
Code:
#!/usr/bin/env python
# -*- coding:Utf-8 -*-
import sys
from os import system
def welcome():
system('clear')
print "##############################################################"
print "# Cracker Le Chiffre de César #"
print "# by Sorcier FXK for Staff DK & Project Kalkulator's Knights #"
print "# www.tdark-knight.com #"
print "# forum.kalkulators.org #"
print "# sorcierfxk@kalkulators.org #"
print "##############################################################"
def dechiffrement():
message_chiffre = raw_input("[>] Saisissez votre message secret : ")
a = 0 # a est notre compteur
charset = "zabcdefghijklmnopqrstuvwxy" #charset de depart
while a <= 51:
if a == 26:
charset = "zyxwvutsrqponmlkjihgfedcba"
tableau_equi = {}
if a != 26:
charset = charset[1:] + charset[0]
print "[>] Clé numero : ", a
print "[>] Clé potentielle : ", charset
a = a + 1
cle_control_1 = ['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(charset)):
tableau_equi[charset[x]] = cle_control_1[x]
#on déchiffre maintenant le message
message_clair = ""
for x in range(len(message_chiffre)):
if message_chiffre[x] == " " or message_chiffre[x] == "," or message_chiffre[x] == "'" or message_chiffre[x] == "." or message_chiffre[x] == "!":
message_clair = message_clair + message_chiffre[x]
else:
message_clair = message_clair + tableau_equi[message_chiffre[x]]
print "[>] Message dechiffre : ", message_clair
#sys.exit()
welcome()
dechiffrement()Par manque de temps hélas, je ne suis pas en mesure de vous fournir tout de suite le cracker pour la variante à 81 caractères que nous avons vu en dernier, cependant je promet de fournir ce code source rapidement.
0x05 Les exercices
Maintenant ça va être à votre tour de réflechir un peu, en toute convivialité bien sur 
Essayer de resoudre ces petits exercices à difficultés progressives.
0x05.1 Le Chiffre de César
Déchiffrer ces messages et indiquez la clé qui à permis le chiffrement. N'utilisez pas le craker donné plus haut pour cet exercice, sinon ça n'aurai aucun interet, par contre pour vous corriger, c'est pas interdit
cvj trifkvj jfek tlzkvj !
wi wecsm sc cy qyyn
fqzbd z k'hmenqlzshptd lncdqmd, mntr zunmr ezhs cdr oqnfqdr bnmrhcdqzakdr czmr k'zqs ct bgheeqdldms.
0x05.2 La variante aux 52 clés
Déchiffrez ces messages et indiquer la clé utilisée pour chiffrer.
xvhzi vg mzklovlm hlmg wv tizmwh hgizgvtvh nrorgzrivh
hs qefaeggszkef po qsno skpo s hs qefqofzbszkef
jifsvy ymn u f'ilcachy xo jlygcyl wbczzlygyhn jul movmncnoncih gihi ufjbuvynckoy
0x05.3 Les clés aléatoires
Consigne identique , déchiffrer ce message et donner la clé de chiffrement.
af cyka pcre jrkaaf p xfjr hrzzr qsjpar, h'raz tkr cyka pcre mfru hygqjfa xr qjfuhfqr, hykjpwr cyka pjjfcre p xp dfu bra rlrjhfhra !!
hd bchiao hdsaowd xcs cbowdrics d viskir tokwo hcadho, qorwkixow rckrox hox bwokpox or wosqou pckx dk bcisr dhbtd. rowviso
juste pour le fun de vous taquiner un peu (il est méchant hein ?)
ho,&rhyCy0rtyrLyP.cCyPrLo,&riy&ry)yP+c+y&rvyic+cbLcoCr+[biiyCZyPrK
Voila c'est tout, mais c'est déjà pas mal, si vous avez des problèmes avec le sujet traité ici, n'hesitez pas à laisser un message ou à venir directement nous rencontrer sur notre salon IRC, on se fera un plaisir de vous aider 
Hors ligne