Rapport cyptographie

Séance 1

Nous avons fait tout les exercies du TP "l'enfance de l'art", nous n'avons pas eu de diffuculté majeur à faire les

differents exercices. Nous avons d'abord réalisé, le cryptage en utilisant le carré de 25.

Le code de Polybe

ficher: carre_polybe.py

Tableau de cryptage

Bout de code intéréssant

def crypteWithPoly(chaine):
chaineCrypte = ""
chaine = chaine.upper()
for x in chaine:
if x == "W":
chaineCrypte += "5252"
for i in range(6):
for j in range(6):
if x == carrePolybe[i][j]:
chaineCrypte += str(i)
chaineCrypte += str(j)
return chaineCrypte

def decryptePoly(chaine):
chaineDecrypt = ""
for x in range(0,len(chaine),2):
chaineDecrypt += carrePolybe[int(chaine[x])][int(chaine[x+1])]
return chaineDecrypt
Etude statstique

Nous avons crée une fonction a laquelle nous passons un très long texte français, et celle-ci va crée
directement des statistique pour chaque lettre. En utilisant les fréquances récolté, nous tentions une attaque
statistique, mais cela marchait très partiellement, nous n'avons pas réussi a crée un décryptage efficace et
après accord du professeur nous somme passer a la suite.
Le largonjem

ficher: largonjem.py

PRINCIPE DU LARGONJEM

Nous avons trouver le principe du Largonjem très interessant, car il permet de crypter un text très facilement.

Bout de code interessent

def largojem(text):
string=""
for k in text.split(' '):
if lagorjemPossible(k):
string+='l'+k[1:]+k[0]+'em ';
else:
string+=k+' '
return string

def lagorjemPossible(text):
if len(text) and text[0] not in "aeiouy":
return True
else:
return False

En ce qui concerne la réalisation du code, aucune diffculté particuliére nous avons bien compris le principe et
avons su l'appliquer aisément

Après avoir réalisé l'algorithme, nous avons essayer l'expériance sur un très long text et nous nous sommes
rendu compte que la méthode de cryptage était très voyante et que crée un décryptage de celle-ci ne serait être

trop difficile
Le code de César

ficher: cesar.py

Pour celui-ci, nous connaissions dèjà la méthode, donc nous n'avons pas appris grand chose, en ce qui

concerne l'algorithme il fut assez rapide a réaliser

Méthode césar

Pour ce faire nous avons d'abbord réaliser la méthode césar qui prend en paramètres le message à crypter et le
décalage. Il décale les lettres du message en suivant le décalage donnée. Si le décalage est trop grand, on

revient au début de l’alphabet.

def cesar(message, decalage) :

alpha = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', #alphabet
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
't', 'u', 'v', 'w', 'x', 'y', 'z']
new_message = ""
for letter in message :
for i in range(0, len(alpha)) :
if(letter == alpha[i] and (i+decalage)<26) :
new_message = new_message + alpha[(i+decalage)]
elif(letter == alpha[i].upper() and (i+decalage<26)) :
new_message = new_message + alpha[(i+decalage)].upper()
elif(letter == alpha[i] and (i+decalage)>25) :
new_message = new_message + alpha[(i+decalage-25)]
elif(letter == alpha[i].upper() and (i+decalage>25)) :
new_message = new_message + alpha[(i+decalage-25)].upper()
if(letter.lower() not in alpha) :
new_message = new_message + letter
return new_message

Méthode cesar_key

Pour ce faire nous avons d'abbord réaliser la méthode césar_key qui prend en paramètres le message à crypter
et la clé. Même principe que pour la fonction précédente, sauf que le décalage correspond au nombre de la clé

à l’indice de la lettre du message. Si la clef est trop petite, on revient au début.

def cesar_key(message, key) :

alpha = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', #alphabet
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
't', 'u', 'v', 'w', 'x', 'y', 'z']
new_message = ""
k = -1
for letter in message :
if(letter.lower() not in alpha) :
new_message = new_message + letter
else :
k = k+1
if(k == len(key)-1) : k = 0
#si la clef est plus petite que le message alors il faut la réinitilaiser pour continuer cad si la fair
 for i in range(0, len(alpha)) :
if(letter == alpha[i] and (i+int(key[k]))<26) :
new_message = new_message + alpha[i+int(key[k])]
elif(letter == alpha[i].upper() and (i+int(key[k])<26)) :
new_message = new_message + alpha[(i+int(key[k]))].upper()
elif(letter == alpha[i] and (i+i+int(key[k]))>25) :
new_message = new_message + alpha[(i+int(key[k])-25)]
elif(letter == alpha[i].upper() and (i+int(key[k])>25)) :
new_message = new_message + alpha[(i+int(key[k])-25)].upper()
return new_message

La bible, le code secret

Nous n'avons pas choisi de le réaliser, faute d'intérrsement, nous avons penser qu'il serait plus judicieux de

passer a la séance 2

Séance 2