[Python] Chiffreur/DéChiffreur de texte en console

[fr0g]

Plop', ne sachant que faire et voulant me remettre un peu au python, j'ai décidé
de me faire un petit Chiffreur/DéChiffreur de texte en Py.

(l'algo est simple pour le moment)

code source ici bien entendu :

Code PHP :

#!/usr/bin/python
# -*- coding: latin-1 -*-

import os
import platform
import sys

########################
# Author : fr0g
# WebSite : hwc-crew.com
#
########################


# Note : si vous vous demandez pourquoi le programme affiche de 
# l'anglais alors que les commentaires en francais,
# c'est juste car je suis un gros bordelique.
# non c'est pour que son utilisation reste intuitive 
# pour les utilisateurs (souvent plus ou moins bilingues)
# tandis que le code source (bien que libre) est principalement organise
# pour faciliter ma propre comprehension du code ( comment m'y retrouver dans un bordel pareil ? ... ca me regarde ;))






#-----------------------------------------CLASS and/or FUNCTIONS

def cryptix(a):                # Fonction de cryptage

#-----------------------------------------------Alpha
    b = a.replace('a','ķ',sys.maxint)
    b = b.replace('b','ľ',sys.maxint)
    b = b.replace('c','Ľ',sys.maxint)
    b = b.replace('d','ń',sys.maxint)
    b = b.replace('e','ň',sys.maxint)
    b = b.replace('f','Łǥ',sys.maxint)
    b = b.replace('g','ĬȐ',sys.maxint)
    b = b.replace('h','Ĥ',sys.maxint)
    b = b.replace('i','ĥ',sys.maxint)
    b = b.replace('j','Č',sys.maxint)
    b = b.replace('k','Ĕ',sys.maxint)
    b = b.replace('l','ᴕ',sys.maxint)
    b = b.replace('m','ō',sys.maxint)
    b = b.replace('n','ᵼ',sys.maxint)
    b = b.replace('o','Ōƻ',sys.maxint)
    b = b.replace('p','Ŕ',sys.maxint)
    b = b.replace('q','ŕ',sys.maxint)
    b = b.replace('r','řᵫ',sys.maxint)
    b = b.replace('s','ŧ',sys.maxint)
    b = b.replace('t','Ŧ',sys.maxint)
    b = b.replace('u','Ũ',sys.maxint)
    b = b.replace('v','ᴥ',sys.maxint)
    b = b.replace('w','ţ',sys.maxint)
    b = b.replace('x','Ů',sys.maxint)
    b = b.replace('y','Ŷ',sys.maxint)
    b = b.replace('z','ƃ',sys.maxint)
#-----------------------------------------------Num
    b = b.replace('0','Ɖ',sys.maxint)
    b = b.replace('1','ƍ',sys.maxint)
    b = b.replace('2','ƕ',sys.maxint)
    b = b.replace('3','Ƣ',sys.maxint)
    b = b.replace('4','Ʃ',sys.maxint)
    b = b.replace('5','ƪ',sys.maxint)
    b = b.replace('6','Ɨ',sys.maxint)
    b = b.replace('7','Ƴ',sys.maxint)
    b = b.replace('8','ƴ',sys.maxint)
    b = b.replace('9','Ƶ',sys.maxint)
#-----------------------------------------------Others
    b = b.replace('.','ƺ',sys.maxint)
    b = b.replace('!','dž',sys.maxint)
    b = b.replace('?','Nj',sys.maxint)
    b = b.replace(',','ǒ',sys.maxint)
    b = b.replace('é','ǥ',sys.maxint)
    b = b.replace('è','Ǻ',sys.maxint)
    b = b.replace('à','Ȑ',sys.maxint)
    b = b.replace('ê','ȣ',sys.maxint)
    b = b.replace('ù','ȸ',sys.maxint)
    b = b.replace('(','ȹ',sys.maxint)
    b = b.replace(')','Ⱥ',sys.maxint)
    b = b.replace('/','ɷ',sys.maxint)
    b = b.replace(';','ᴤ',sys.maxint)
    b = b.replace(':','ᴲ',sys.maxint)
    b = b.replace(' ','ᴽ',sys.maxint)
    b = b.replace("'","ᵻ",sys.maxint)
    b += b
    b = b[::-1]

    print b

    save = raw_input("\n Save file (y/n) ? : ") 
    
    if save == "y" or save == "":
        filename = raw_input(" Type a name for the new crypted file : ")
        
        if filename != "":
            f = open(filename,"w")
            f.write(b)
            f.close
        else:
            print "Error ... no name given"    
            raw_input()
    else:    
        sys.exit()
    

    a = ""

    return b





#---------------------------------------------------------------------



def decryptix(x):            # Fonction de decryptage
        


    y = len(x) / 2
    b = x[-int(y):]    
    
    b = b[::-1]



#-----------------------------------------------Alpha
    b = b.replace('ķ','a',sys.maxint)
    b = b.replace('ľ','b',sys.maxint)
    b = b.replace('Ľ','c',sys.maxint)
    b = b.replace('ń','d',sys.maxint)
    b = b.replace('ň','e',sys.maxint)
    b = b.replace('Łǥ','f',sys.maxint)
    b = b.replace('ĬȐ','g',sys.maxint)
    b = b.replace('Ĥ','h',sys.maxint)
    b = b.replace('ĥ','i',sys.maxint)
    b = b.replace('Č','j',sys.maxint)
    b = b.replace('Ĕ','k',sys.maxint)
    b = b.replace('ᴕ','l',sys.maxint)
    b = b.replace('ō','m',sys.maxint)
    b = b.replace('ᵼ','n',sys.maxint)
    b = b.replace('Ōƻ','o',sys.maxint)
    b = b.replace('Ŕ','p',sys.maxint)
    b = b.replace('ŕ','q',sys.maxint)
    b = b.replace('řᵫ','r',sys.maxint)
    b = b.replace('ŧ','s',sys.maxint)
    b = b.replace('Ŧ','t',sys.maxint)
    b = b.replace('Ũ','u',sys.maxint)
    b = b.replace('ᴥ','v',sys.maxint)
    b = b.replace('ţ','w',sys.maxint)
    b = b.replace('Ů','x',sys.maxint)
    b = b.replace('Ŷ','y',sys.maxint)
    b = b.replace('ƃ','z',sys.maxint)
#-----------------------------------------------Num
    b = b.replace('Ɖ','0',sys.maxint)
    b = b.replace('ƍ','1',sys.maxint)
    b = b.replace('ƕ','2',sys.maxint)
    b = b.replace('Ƣ','3',sys.maxint)
    b = b.replace('Ʃ','4',sys.maxint)
    b = b.replace('ƪ','5',sys.maxint)
    b = b.replace('Ɨ','6',sys.maxint)
    b = b.replace('Ƴ','7',sys.maxint)
    b = b.replace('ƴ','8',sys.maxint)
    b = b.replace('Ƶ','9',sys.maxint)
#-----------------------------------------------Others
    b = b.replace('ƺ','.',sys.maxint)
    b = b.replace('dž','!',sys.maxint)
    b = b.replace('Nj','?',sys.maxint)
    b = b.replace('ǒ',',',sys.maxint)
    b = b.replace('ǥ','é',sys.maxint)
    b = b.replace('Ǻ','è',sys.maxint)
    b = b.replace('Ȑ','à',sys.maxint)
    b = b.replace('ȣ','ê',sys.maxint)
    b = b.replace('ȸ','ù',sys.maxint)
    b = b.replace('ȹ','(',sys.maxint)
    b = b.replace('Ⱥ',')',sys.maxint)
    b = b.replace('ɷ','/',sys.maxint)
    b = b.replace('ᴤ',';',sys.maxint)
    b = b.replace('ᴲ',':',sys.maxint)
    b = b.replace('ᴽ',' ',sys.maxint)
    b = b.replace("ᵻ","'",sys.maxint)
    
    print b
    
    save = raw_input("\n Save file (y/n) ? : ") 
    
    if save == "y" or save == "":
        filename = raw_input(" Type a name for the new decrypted file : ")
        
        if filename != "":
            f = open(filename,"w")
            f.write(b)
            f.close
        else:
            print "Error ... no name given"    
            raw_input()
    else:    
        sys.exit()
    
    
    x = ""

    return b




    
    

#####################################################################################################PAUSE ICI TROU DU CUL

    
#-----------------------------------------VAR
#----------------------Header

console_header = """
##############################
#                 #
#     x.i.t.p.y.r.c       #
#                 #
# version : 0.1             #
# Author : fr0g             #
# Website : hwc-crew.com     #
##############################
"""

#--------------------Menu

console_menu = """
Options :
---------------------------------------
- cfile        / Crypt text file 
- dfile        / Decrypt text file
- r/read       / Read file

- q/quit       / Exit program
---------------------------------------
"""

#------------------Loop the program

program_loop = 1 # tant que la variable est a 1, le programme tournes.


#-----------------------------------------START

while program_loop == 1:




    #-----------------------------------------fonction de nettoyage de la console
    _sys = platform.system()

    if _sys == "Linux":
        os.system("clear")

    elif _sys == "Windows":
        os.system("cls")

    else:
        print "Little Error ... (unknown system ... (sorry, I'm a bad programmer ...))"
        raw_input("Push Entr for continue ...")
    
    #-----------------------------------------

    print console_header
    print console_menu

    what_the_func = raw_input(" Choose your function : ")     # Classe comme nom de variable non ? :p

#---------------------



    if what_the_func == "q" or what_the_func == "quit":
        program_loop = 0                                       # on stop le programme si l'utilisateur entre "q" (pour "quit")


#-----------------------------------------------------------------------------cf : Crypt File



    elif what_the_func == "cfile" or what_the_func == "cf":
        s_text = ""                            # declaration de la variable recuperant le contenu du fichier
        x_file = raw_input(" Encrypt file : ")         # variable recuperant le nom du fichier


        try:
            f = open(x_file,"r")                   # tentative d'ouverture du fichier en lecture
        except:                 
            print "\nError..."       
            raw_input()
        else:
            for line in f:
    
                if len(s_text) == 0:      # si la variable s_text est vide
                    s_text = line     # on lui attribue en valeur : le contenu de la ligne lue
                else:                     # sinon
                    s_text += line    # on lui attribue en valeur son contenu + le contenu de la ligne lue
                        
                continue
            f.close()

            cryptix(s_text)                # on lance le cryptage du texte
    



#-----------------------------------------------------------------------------df : Decrypt File

    elif what_the_func == "dfile" or what_the_func == "df" :

        s_text = ""                            # declaration de la variable recuperant le contenu du fichier
        x_file = raw_input(" Decrypt file : ")         # variable recuperant le nom du fichier


        try:
            f = open(x_file,"r")                   # tentative d'ouverture du fichier en lecture
        except:                 
            print "\nError..."       
            raw_input()
        else:
            for line in f:
    
                if len(s_text) == 0:      # si la variable s_text est vide
                    s_text = line     # on lui attribue en valeur : le contenu de la ligne lue
                else:                     # sinon
                    s_text += line    # on lui attribue en valeur son contenu + le contenu de la ligne lue
                        
                continue
            f.close()
            decryptix(s_text)                # on lance le decryptage du texte        
    

#--------------------------------------------------------------    Fonction de lecture d'un fichier

    elif what_the_func == "r" or what_the_func == "read":


        fileread = raw_input(" type a file name to read : ")
    
        if fileread != "":
            f = open(fileread,"r")
            _text = f.readlines()
            f.close

            print "\n"+ str(_text)+"\n"
            raw_input("Push Entr to continue")
        else:
            print "Error ... no name given"    
            raw_input()
    

#--------------------------------------------------------------    
    else:
        print "Error... (unknown command)"
        raw_input()

#-----------------------------------------END
raw_input("\n thank you for using xitpyrc...") 


[CyberSee]

Ah ouais beau travail ^^ !
Tu devrais ajouter 5 caractères de remplacement pour chaque lettre

Ex : A peut être égale à: 1, 2, 3, 4 ou 5

Quand tu cryptes, tu choisis un des 5 choix de remplacement ce qui empêche d'avoir une logique de constante, car c'est comme sa que l'ont reverse engeneer le cryptage. J'ai donné comme exemple 5, mais si tu peux en mettre plus ce serait encore mieux ^^ et pourquoi cette limite a 1 caractère? Tu pourrais avoir plus de choix en faisant des combinaisons séparer par des espaces

Ex: À peut être égale à: &?, %%, *%, @$ ou &)
B peut être égale à: 8&, $@, 5%, #9 ou !%
C peut être égale à: =4, &9, {*, Þ6 ou ☼&

Donc, ABC pourrait être égale à: &? $@ Þ6 (3 à la puissance 5 = 243 combinaisons et sa augmente a chaque lettre encrypter ^^)
Chaque combinaison serait séparée par un espace. Imagine le casse tête du gars qui essai de décrypter ça sans avoir la recette lol

&? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6 &? $@ Þ6

Une dernière chose, tu devrais agrandir ta bibliothèque de caractère pour éventuellement pouvoir crypter des fichiers :-). Plutôt que de répété la liste des caractères l'hors du cryptage et ensuite pour le décryptage tu devrais faire seulement qu’un array et ensuite interroger cet array l'hor des 2 procédures

[fr0g]

et pourquoi cette limite a 1 caractère?

Car je partage le code "brut" pour le moment, le premier "fonctionnel" du projet, évidemment je vais l'améliorer au fur et à mesure .

[CyberSee]

Ben en tout cas, bravo :-) ça promet comme projet! Tu reliras mon poste, je faisais des édits pendant que tu composais ton message ^^

[fr0g]

Oui, là j'ai bordeliquement utilisé une fonction toute faite ^^ (

pour les prochaines versions je compte utiliser les dictionnaires en python, et évidemment multiplier les possibilités de chiffrement pour chaque caractère.

[CyberSee]

Cool j'ai hâte de voir ce que sa va donné :-)

[Dobry]

Ca faut un petit bout de temps que tu l'as publié, mais pour les prochains qui passerait pas là sachez qu'il sertait plus court et simple de passer par un système de tableau, un contiendrait les lettres et l'autre sont equivalence (rangée dans le même ordre), il n'y aurait qu'a parcourir les tableaux, et effectuer un replace avec les deux paramètre des tableaux en arguments).

good job

[fr0g]

Ca faut un petit bout de temps que tu l'as publié, mais pour les prochains qui passerait pas là sachez qu'il sertait plus court et simple de passer par un système de tableau, un contiendrait les lettres et l'autre sont equivalence (rangée dans le même ordre), il n'y aurait qu'a parcourir les tableaux, et effectuer un replace avec les deux paramètre des tableaux en arguments).

good job

Oui c'est la méthode que j'utilise pour la prochaine version (avec GUI)

[Booster2ooo]

Chaque combinaison serait séparée par un espace. Imagine le casse tête du gars qui essai de décrypter ça sans avoir la recette lol

Pourquoi mettre un espace tous les deux caractères?
En faisant cela, on donne une partie de l'information au reverseur. Or, notre programme sait qu'un caractère = 2 caractères une fois chiffré, donc il n'a pas besoin de l'espace... Me trompe-je?

Sinon, quel est l'efficacité d'un tel système comparé à des opérations mathématiques sur les bytes? (remplacement vs opérations sur une clé)

Ensuite, ne serait-il pas judicieux de créer un tableau de remplacement "dynamique"?
Je m'explique, ou, en tous cas, je vais essayer.

A| AA|AB|AC
B| AD|AE|AF
C| AG|AH|AI
etc

Si je chiffre "Albert", le A dans mon texte à crypter est en 1er position, donc je prend le 1er code cad AA. Disons maintenant que je chiffre "UnMotA", le A se trouve en 6eme position, donc je commence à mon indexe de A et j'ajoute 6, je tombe sur AF. Enfin, prenons "UnMotB", B est en 6eme position, je commence à mon indexe B et je compte 6, j'arrive sur AI.
... Pour déchiffrer, je sais que AI est en 6eme position, je remonte de 6, je suis dans l'indexe B, idem pour les exemples avec le A.
Est-ce envisageable? Est-ce performant? Est-ce facile à reverse?

J'espère que je vous embête pas trop avec toutes ces questions