Forum de mathématiques - Bibm@th.net

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 17 385

[Python]Cryptage et Décriptage affine

Bonjour,

Suite au post de Shengao http://www.bibmath.net/forums/viewtopic.php?id=2465dans le forum de crypto, voici mes deux bricolages.
Chiffrement (avec définition de clé aléatoire)

# -*- coding: Latin-1 -*-
#!/usr/bin/env python

####################################
#  Chiffrement par fonction affine #
####################################
import random
 
def tirage_aleatoire(k):
    k=random.randint(1,25)    
    return k

def prepare(PhraseEnClair):
    li1=["âà","éèêë","îï","ô","ûü","ç"]
    li2=["A","E","I","O","U","C"]
    i=0
    # Remplacement des caractères accentués éventuels
    for mot in li1:
       repl=li2[i]
       for lettre in mot:
           PhraseEnClair=PhraseEnClair.replace(lettre,repl)
       i+=1      
    PhraseEnClair=PhraseEnClair.upper()    # Passage en majuscules
    return PhraseEnClair

PhraseEnClair="Le cryptage par fonction affine est très loin d'être sûr !"
Acrypter=PhraseEnClair
PhraseEnClair=prepare(PhraseEnClair)
lg=len(PhraseEnClair)

# Tirage aléatoire de la Clé avec a et b différents
k=0
k=tirage_aleatoire(k)
a=k
while k==a:
    k=tirage_aleatoire(k)
b=k
a,b=21,13
# Debut du chiffrement
MessageCrypte=""
for i in range(lg):
    lettre = PhraseEnClair[i]
    if lettre in " ',-;:!?.":
        MessageCrypte += lettre
    else:
        MessageCrypte += chr((a*(ord(lettre)-65)+ b)%26 + 65)
   
# Affichage du résultat
print
print
print 'Clé : ('+ str(a) + ' ; '+ str(b)+')'
print "Message d'origine : "+Acrypter
print "Message codé : "+MessageCrypte

Et le programme de décodage en supposant qu'on connaisse deux correspondances de lettres. ce derrnier programme est susceptible de modification pour une meilleure gestion du travail modulo 26...

# -*- coding: Latin-1 -*-
#!/usr/bin/env python

##################################################
#  Décodage d'un chiffrement par fonction affine #
##################################################

MessageCrypte="KT DGXQWNJT QNG OVADWZVA NOOZAT TBW WGTB KVZA Y'TWGT BRG !"
lg=len(MessageCrypte)
MessageClair=""

# Recherche de la clé sachant que L --> K et  E --> T
# Affectation des valeurs des lettres : ax+b=y puis axx+b=yy
x,y = ord('L')-65,ord('K')-65
xx,yy = ord('E')-65,ord('T')-65

# Résolution du système
u,v=xx-x,yy-y
if u < 0:
    u,v=x-xx,y-yy
k=0
while not ((v+26*k)%u==0 and v+26*k >0):
    k+= 1
a = int((v+26*k)/u)

b=y-a*x
k=0
while not y-a*x+26*k > 0:
    k+= 1
b = y-a*x+26*k

# Déchiffrement proprement dit
for i in range(lg):
    lettre = MessageCrypte[i]
    if lettre in " ',-;:!?.":
        MessageClair+= lettre
    else:
        res,k=ord(lettre)-65-b,0
        while (res+26*k)%a>0 or res+26*k<0:
            k+=1
        MessageClair += chr((res+26*k)/a+65)
   
# Affichage du résultat
print
print
print 'Avec L --> K  et  E --> T, la Clé est : ('+ str(a) + ' ; '+ str(b)+')'
print
print "Message d'origine : "+MessageCrypte
print
print "Message clair     : "+MessageClair

@+

Dernière modification par yoshi (19-10-2010 16:24:57)

Tyler

Membre

Inscription : 25-10-2013

Messages : 1

Re : [Python]Cryptage et Décriptage affine

Ca date pas mal ton programme pourrais tu en proposer un nouveau sur le cryptage Affine en language Python avec m et p qu'on définit nous même?

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 17 385

Re : [Python]Cryptage et Décriptage affine

Salut,

C'est déjà du Python.
C'est facilement modifiable, puisque j'avais opté, en ce qui concerne la partie codage, pour une définition aléatoire n: je peux le modifier sans problème pour que vous choisissiez les correspondances...

Je dois me repencher sur ce que j'avais fait et le comprendre...

Maintenant, que la proposition qui figure au post #1 ait été faite, il y a 10 ans ou il y a 8 jours, ça changerait quoi ?
Le "ça date pas mal" me fait donc doucement rigoler...

Il me faudra un peu de temps...
Je m'y colle dès que possible.

@+

[EDIT]
A la réflexion, je vais tout refaire, ce sera plus rapide...

Dernière modification par yoshi (25-10-2013 18:28:48)

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 17 385

Re : [Python]Cryptage et Décriptage affine

Bonsoir,

J'ai refait le programme de codage : il est fonctionnel. J'ai ajouté la sortie classique en groupe de 5 lettres.
Il me reste à mettre en place le questionnement pour a et b : c'est le plus ch... pénible, parce que je dois vérifier la conformité du couple clé (a,b) choisi :
* Ce sont des entiers naturels, pas autre chose,
* a doit être premier avec 26 et b compris entre 1 et 26,...
* Rejeter les entrées tant qu'il n'y a pas conformité.

Heureusement, je dois avoir quelque chose comme ça dans ce que j'ai déjà fait...

@+

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 17 385

Re : [Python]Cryptage et Décriptage affine

Re,

Je me débats avec le décodage automatique, sans passer par faire le tour des 212 solutions possibles avec l'arrêt par l'utilisateur dès que la sortie est cohérente ou l'analyse de fréquence...
Je n'aboutis pour l'instant à rien.
Décoder connaissant la correspondance de 2 couples de lettres, fonctionne.

@+

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 17 385

Re : [Python]Cryptage et Décriptage affine

Bonjour,

Codage affine avec choix entre aléatoire et personnel.

# -*- coding: Latin-1 -*-
#!/usr/bin/env python

import random

def titre(P):
    print "        ####################################"
    print "        #  Chiffrement par fonction affine #"
    print "        ####################################"
    print
    print
    print
    print
   
def prepare(PhraseEnClair):
    li1=["âà","éèêë","îï","ô","ûü","ç"]
    li2=["A","E","I","O","U","C"]
    i=0
    # Remplacement des caractères accentués éventuels  et ponctuation
    for mot in li1:
       repl=li2[i]
       for lettre in mot:
           PhraseEnClair=PhraseEnClair.replace(lettre,repl)
       i+=1
    for l in PhraseEnClair:
        if l in ['"',"'",",",";",":","!","%","$","<",",","."]:
            nb=PhraseEnClair.find(l)
            PhraseEnClair=PhraseEnClair[:nb]+PhraseEnClair[nb+1:]          
    return PhraseEnClair

def alea(P):
    aa=random.randint(0,10)
    a=P[aa]
    b=random.randint(1,25)
    codage(a,b)
    return

def perso(P):
    ok=0
    print "    --- Attention, voici la liste des nombres premiers avec 26 ---"
    print "         ",
    for n in P:
        print n,
    print
    while not ok:
        print
        aa=raw_input("Choix du coefficient a (à prendre dans la liste ci-dessus): ")
        try :
            a=int(aa)
            if a  not in P:
                print "Entrée incorrecte. Veuillez recommencer s'il vous plaît !"
            else:
                ok=1
        except ValueError:
            print "Entrée incorrecte. Veuillez recommencer s'il vous plaît !"
    ok=0    
    while not ok:
        aa=raw_input("Entrer le npmbre b (doit être compris entre 0 et 25) : ")
        try :
            b=int(aa)
            if b<0 or b>25:
                print "Entrée incorrecte. Veuillez recommencer s'il vous plaît !"
            else:
                ok=1
        except ValueError:
            print "Entrée incorrecte. Veuillez recommencer s'il vous plaît !"
    print
    return a,b

def codage(a,b):
    ######## Ecrire, ci-dessous, entre les guillemets, votre phrase ########
       
    Acrypter = "Euler, le grand mathématicien, a donné une règle permettant \
de résoudre tous les problèmes de labyrinthes et qui consiste \
essentiellement à chercher un chemin depuis la sortie."

    ########################################################################
    Alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    PhraseEnClair=Acrypter
    PhraseEnClair=prepare(PhraseEnClair).replace(" ","").upper()
    lg=len(PhraseEnClair)
    PhraseCodee=""
    for i,lt in enumerate(PhraseEnClair):
        pos = Alpha.find(lt)
        PhraseCodee+=Alpha[(a*pos+b)%26]  
    affichage(Acrypter,PhraseCodee,lg,a,b)
    return  

def affichage(Acrypter,PhrC,lg,a,b):
    # Préparation du message de sortie en groupes de 5 lettres séparés
    # par une espace    
    coupes=lg/5-(lg%5==0)
    for i in xrange(coupes):
        # Insertion d'un espace tous les 5 caractères dans PhraseCodee
        PhrC=PhrC[0:5+6*i]+" "+PhrC[5+6*i:lg]
        lg+=1
    # Affichage du résultat
    print
    print
    print 'Clé : ('+ str(a) + ' ; '+ str(b)+')'
    print
    print "                 Message d'origine :"
    print Acrypter
    print
    print "                 Message codé :"
    print PhrC
    print
    print
    print
    return

   
P= [3,5,7,9,11,15,17,19,21,23,25]
titre(P)
while 1:
    print "A- Choix aléatoire du code"
    print "B- Vous choisissez vous-même votre code"
    print "      Q- Quitter le programme ?"
    print
    print "           *** Votre Choix *** "
    rep=raw_input("                     ")
    rep=rep.upper()
    if rep not in "ABQ":
        print
        print "Erreur - Recommencez s'il vous plaît !"
        print
    elif rep=="A":
        alea(P)
    elif rep=="B":
        a,b=perso(P)
        codage(a,b)
    else:
        break
print
print"          Au revoir !"

Sortie :

        ####################################
        #  Chiffrement par fonction affine #
        ####################################

A- Choix aléatoire du code
B- Vous choisissez vous-même votre code
      Q- Quitter le programme ?

           *** Votre Choix ***
                     B
    --- Attention, voici la liste des nombres premiers avec 26 ---
          3 5 7 9 11 15 17 19 21 23 25

Choix du coefficient a (à prendre dans la liste ci-dessus): 17
Entrer le npmbre b (doit être compris entre 0 et 25) : 11

Clé : (17 ; 11)

                 Message d'origine :
Euler, le grand mathématicien, a donné une règle permettant de résoudre tous les problèmes de labyrinthes et qui consiste essentiellement à chercher un chemin depuis la sortie.

                 Message codé :
BNQBO QBJOL YKHLW ABHLW RTRBY LKPYY BNYBO BJQBG BOHBW WLYWK BOBFP NKOBW PNFQB FGOPC QBHBF KBQLC DORYW ABFBW XNRTP YFRFW BBFFB YWRBQ QBHBY WLTAB OTABO NYTAB HRYKB GNRFQ LFPOW RB

En ce qui concerne le décodage, j'offre 2 possibilités :
1. Connaissant le couple qui a servi à coder (méthode sure)
2. Connaissant deux paires de lettres correspondantes dans le sens Clair --> Codage.
    Dans ce cas, selon le choix de lettres :
    - Soit, il n'y a pas de problème
    - Soit, il y a 11 possibilités entre lesquelles, je demande de trancher.
   J'ai encore 2-3 tests à faire dans ce cas précis pour le module de décodage.

Le décodage automatique sans rien connaître demanderait à passer en revue 286 possibilités : j'ai donc abandonné cette idée...

@+