Partage
  • Partager sur Facebook
  • Partager sur Twitter

MSE (Multiples Subtitution Encryption)

Chiffrement par subtitution

    22 mars 2022 à 20:52:40

    bonjour / bonsoir

    J'ai programmer un programme en python de chiffrement par substitution.

    Mon but c'est de ne pas créer un super programme sécurisé, mais d'apprendre un peu la cryptographie et la cryptanalyse.

    le projet est technique à expliquer c'est pour cela que je vous laisse découvrir sont https://github.com/flowlord/encryption-by-mutilple-subtitution

    Je vous conseille de regarder entièrement le code source et tous les fichiers avant d'écrire une réponse.

    Je pense que d'après ma petite connaissance en cryptographie, dite moi si j'ai faux, que c'est la première fois qu'une méthode de chiffrement par substitution qui résiste à une attaque par analyse fréquentielle !

    et si le projet est original et inédit pourquoi pas créer une page wikipédia ?

    Merci de vos réponses !

    -
    Edité par FLOW LORD 22 mars 2022 à 20:55:30

    • Partager sur Facebook
    • Partager sur Twitter

    https://github.com/flowlord/Multiple-Substitution-Encryption

      23 mars 2022 à 19:34:50

      FLOW LORD a écrit:

      Je pense que d'après ma petite connaissance en cryptographie, dite moi si j'ai faux, que c'est la première fois qu'une méthode de chiffrement par substitution qui résiste à une attaque par analyse fréquentielle !

      Tu as déjà sans doute entendu parlé de Enigma? Pour ne citer que ça. Je pense qu'il en existe plein d'autres.

      FLOW LORD a écrit:

      Je vous conseille de regarder entièrement le code source et tous les fichiers avant d'écrire une réponse.

      Honnêtement, c'est difficile et long. J'ai abandonné au bloc B. Trop de trucs dans tous les sens.

      Je pense que tu devrais clarifier quelles sont les secrets qui servent à chiffrer et déchiffrer le message. Je n'ai pas trop compris ce que je dois modifier et ce que je dois garder secret pour que personne d'autres que moi puisse déchiffrer le message avec ton code.

      -
      Edité par KoaTao 23 mars 2022 à 19:36:21

      • Partager sur Facebook
      • Partager sur Twitter
        24 mars 2022 à 11:10:10

        le fichier keylib.py sont t'est clé de chiffrement ! Tu dois les garder à tous prix secret ! il est généré lorsque tu chiffre ton premier message

        Si tu le surprime tous les messages que tu a chiffré avant sont plus déchiffrable ! Comme si tu perdais t'est bitcoin à jamais ! (Enfin normalement il peut toujours avoir un faille)

        • Partager sur Facebook
        • Partager sur Twitter

        https://github.com/flowlord/Multiple-Substitution-Encryption

          24 mars 2022 à 13:46:54

          Je n'y connais pas en chiffrement, mais l'architecture de ton projet est assez brouillon, on sait pas ou regarder, pas de découplage de code et d'organisation de tes modules.

          Ton code pourrait être simplifié pour le lecteur, tu utilises de noms de variable et fonction incompréhensible parfois.

          Bref j'ai pas poussé plus loin... 

          • Partager sur Facebook
          • Partager sur Twitter

          Ancien étudiant OpenClassroom, diplômé en développeur d'application Python

            24 mars 2022 à 14:25:26

            Itou, rien compris, trop de variable  mono caractère, c'est illisible.

            Sinon mis a part les remarques de lisibilité déjà faites, quelques autres:

            - Mettre la clé dans un fichier code ne me semble pas cohérent, c'est une ressource, pas du code, ni sur, si quelqu'un commit et push la sienne sur le repo par inadvertance et que d'autre font un pull, c'est la cata.

            - Les noms de fichiers devraient être plus explicites, sans creuser dedans, impossible d'avoir une idée de ce qu'ils font.

            - Utilise le Français pour le readme, les grosses fautes d'anglais le rendent parfois incomprehensible.

            exemple:

             for copy automatically coded message

             I take a character group and divide it into of them:

            ca ne veut strictement rien dire.

            - Inutile de polluer les commit message avec la date, un commit est déjà daté, un message est supposé décrire la modification faite afin d'avoir un historique.

            Ce qui est dommage c'est que ton code est peut être intéressant, d'autant qu'il est tout petit et donc devrait être simple a comprendre, mais a cause de tout ca, ca ne donne pas envie d'aller plus loin.

            • Partager sur Facebook
            • Partager sur Twitter
              25 mars 2022 à 4:07:10

              Je donne en bref ce que j'ai déjà essayé:

              Supposons que les codes à encrypter font 8 bits et que j'ai un mélange des codes:
              table = [i for i in range(256)]
              je fais un mélange:
              shuffle(table)
              Si j'applique le remplacement:
              char[i] = table[char[i]]
              C'est une substitution simple. Si je l'applique plus d'une fois aux caractères suivants:
              char[i] = table[table[char[i]]]
              et je le fais 3 fois pour le suivant ...
              Je peux avoir un cycle de N fois. 1 remplacement pour le premier, 2 remplacements pour le deuxième, ..., N remplacements pour le N-ième.
              et je reviens à 1 pour le N+1-ième (donc modulo N)

              Ça peut ressembler grossièrement à ceci:
              n = 1
              for c in stream:
                  for _ in range(n):
                      c = table[c]
                  n = n%N + 1
                  sortie.append(c)
              Je crois que ceci également défie les analyses fréquencielles.
              Si on a le moyen de coder la fonction de mélange et qu'on y met les paramètre au début du code, on peut varier le mélange.
              Ça se fait bien avec le modulo:
              s' = s*m % 257
              ou m est un multiplicateur tel qu'on cicle sur 256 itérations.
              On n'a qu'à donner s de départ et m au début. Plutôt s-1 et m-1
              On peut s'arranger pour changer de table de substitution régulièrement. Ça aussi pourrait ètre codé dans le message.

              On place la longueur sujette à cette table dans le message (déjà encodé)

              Les premières valeurs de s et m pourraient déjà être encodées selon une table (qui sera la clé secrète)
              etc.

              -

              Voici le code Python pour générer la liste des multiplicateurs donnant un cycle de 256 itérations pour une fonction pseudo-aléatoire:
              -
              sm = lambda s, m: s*m%257
              mList = []
              for m in range(2, 257):
                  s = sm(1, m)
                  c = 1
                  while c < 257 and s != 1:
                      s = sm(s, m)
                      c += 1
                  if c == 256:
                      mList.append(m)
              print(len(mList))
              print(*mList)

              -
              Edité par PierrotLeFou 25 mars 2022 à 6:44:07

              • Partager sur Facebook
              • Partager sur Twitter

              Le Tout est souvent plus grand que la somme de ses parties.

                27 mars 2022 à 1:21:35

                Mcflan_7 a écrit:

                Je n'y connais pas en chiffrement, mais l'architecture de ton projet est assez brouillon, on sait pas ou regarder, pas de découplage de code et d'organisation de tes modules.

                Ton code pourrait être simplifié pour le lecteur, tu utilises de noms de variable et fonction incompréhensible parfois.

                Bref j'ai pas poussé plus loin... 


                C'est bon j'ai simplifier.
                • Partager sur Facebook
                • Partager sur Twitter

                https://github.com/flowlord/Multiple-Substitution-Encryption

                  27 mars 2022 à 4:04:06

                  FLOW LORD a écrit:
                  > Je pense que d'après ma petite connaissance en cryptographie, dite moi si j'ai faux, que c'est la première fois qu'une méthode de chiffrement par substitution qui résiste à une attaque par analyse fréquentielle !
                  Crois-tu que ce que j'ai décrit (brièvement ...) résiste également à une analyse fréquencielle?
                  Je l'ai codé en C il y a plus de 20 ans.

                  Si je prend le mot "ananas" et le nombre de substitutions (modulo 3):
                  a(1) n(2) a(3) n(1) a(2) s(3)
                  On a 3 façon différentes de coder le 'a' et 2 façons différentes de coder le 'n'.
                  La contrainte est qu'on ne doit rien perdre du message sinon tout sera décalé.

                  Peut-on décripter cela?

                  Ça ne marche pas en Python car un caractère ne peut pas servir d'indice. Il faut utiliser ord()

                  Voir le   chiffrement polyalphabétique avec un mot comme clé.

                  -
                  Edité par PierrotLeFou 27 mars 2022 à 7:46:17

                  • Partager sur Facebook
                  • Partager sur Twitter

                  Le Tout est souvent plus grand que la somme de ses parties.

                    10 avril 2022 à 17:07:16

                    Le code est globalement extrêmement mauvais. Juste un exemple avec ta fonction `ìnverser_liste` là où un simple `reversed(key)` suffit...

                    def inverser_liste(key):
                        """
                        KEYX = ['a','b','c'] ---> KEYX = ['c', 'b', 'a']
                        
                        """
                        new_list = []
                        for elment in reversed(key):
                            new_list = new_list+[elment]
                            
                        return new_list

                    Je passe sur le nom des méthodes pas explicite (b, b1, c, d), sur le nom de méthodes qui induisent en erreur (get_len qui renvoie la moitié de la vraie longueur), sur les méthodes inutiles (sérieusement pourquoi implémenter une méthode inverser_texte quand tu as déjà une fonction inverser liste -- qui comme je l'ai dit est déjà inutile), les path de fichier hardcodés, les messages des commits non informatifs. Bref, je m'arrête.

                    Egalement, un chiffrage efficace est également parcimonieux et ne multiplie par par 100 la taille du message original...

                    • Partager sur Facebook
                    • Partager sur Twitter
                      11 avril 2022 à 1:26:05

                      À part cela c'est bien? :)
                      Est-ce que le PO est encore intéressé au sujet?

                      Voici un petit programme en Python qui trouve tous les multiplicateurs m tels que:
                          s = s * m % 257
                      retourne à la valeur initiale après exactement 256 itérations.
                      Ces multiplicateurs servent à générer des tables de permutation pour l'encryptage par substitution.
                      -
                      F = lambda s, m: s * m % 257
                      multi = []
                      for m in range(2, 256+1):
                          s = F(1, m)
                          c = 1
                          while c < 256 and s != 1:
                              s = F(s, m)
                              c += 1
                          if c == 256:
                              multi.append(m)
                      print(len(multi))
                      print(*multi)
                      -
                      128                                                                                                                     
                      3 5 6 7 10 12 14 19 20 24 27 28 33 37 38 39 40 41 43 45 47 48 51 53 54 55 56 63 65 66 69 71 74 75 76 77 78 80 82 83 85
                      86 87 90 91 93 94 96 97 101 102 103 105 106 107 108 109 110 112 115 119 125 126 127 130 131 132 138 142 145 147 148 149
                      150 151 152 154 155 156 160 161 163 164 166 167 170 171 172 174 175 177 179 180 181 182 183 186 188 191 192 194 201 202
                      203 204 206 209 210 212 214 216 217 218 219 220 224 229 230 233 237 238 243 245 247 250 251 252 254
                      -
                       Voici un bout de code en C qui illustre l'utilisation de ces multiplicateurs.
                      Il suffit de placer dans le message le multiplicateur et la semence de départ pour retrouver la table de permutation utilisée.
                      -
                      #include <stdio.h>
                      #include <stdlib.h>
                      #include <time.h>
                      typedef unsigned char uchar;
                      // Ma fonction pseudo-aléatoire pour permuter la table des codes.
                      int myRand(int m, int s) {
                          return(m*s%257);
                      }
                      // Programme principal.
                      int main() {
                          uchar tableEncoder[256], tableDecoder[256];
                          // La table complète compte 128 éléments.
                          int tableMultiply[] = {14, 19, 20, 24, 27, 28, 33, 37, 38, 39, 40, 41, 43, 45, 47, 48};
                          srand(time(NULL));
                          int m = sizeof tableMultiply / sizeof(int);
                          m = tableMultiply[rand() % m];
                          printf("Multiplicateur: %d\n", m);
                          int s = rand() % 256 + 1;
                          for(int i = 0; i < 256; i++) {
                              s = myRand(m, s);
                              tableEncoder[i] = s-1;
                              tableDecoder[s-1] = i;
                          }
                          uchar tableOrigine[256], tableSecrete[256];
                          for(int i = 0; i < 256; i++ ) {
                              tableOrigine[i] = i;
                              tableSecrete[i] = tableEncoder[i];
                          }
                          for(int i = 0; i < 256; i++) {
                              // Les éléments de tableOrigine ne sont rien d'autre que les indices eux-mêmes.
                              // Ne marche pas si le multiplicateur 'm' est une valeur entre 14 et 48 mais ne se trouvant pas dans la table.
                              if(tableOrigine[i] != tableDecoder[tableSecrete[i]]) {
                                  printf("Différence pour %d et %d\n", tableOrigine[i], tableDecoder[tableSecrete[i]]);
                              }
                          }
                          return(0);
                      }                                                                                                                       

                      -
                      Edité par PierrotLeFou 11 avril 2022 à 2:33:49

                      • Partager sur Facebook
                      • Partager sur Twitter

                      Le Tout est souvent plus grand que la somme de ses parties.

                        27 avril 2022 à 12:15:51

                        Nephthys a écrit:

                        Le code est globalement extrêmement mauvais. Juste un exemple avec ta fonction `ìnverser_liste` là où un simple `reversed(key)` suffit...

                        def inverser_liste(key):
                            """
                            KEYX = ['a','b','c'] ---> KEYX = ['c', 'b', 'a']
                            
                            """
                            new_list = []
                            for elment in reversed(key):
                                new_list = new_list+[elment]
                                
                            return new_list

                        Je passe sur le nom des méthodes pas explicite (b, b1, c, d), sur le nom de méthodes qui induisent en erreur (get_len qui renvoie la moitié de la vraie longueur), sur les méthodes inutiles (sérieusement pourquoi implémenter une méthode inverser_texte quand tu as déjà une fonction inverser liste -- qui comme je l'ai dit est déjà inutile), les path de fichier hardcodés, les messages des commits non informatifs. Bref, je m'arrête.

                        Egalement, un chiffrage efficace est également parcimonieux et ne multiplie par par 100 la taille du message original...


                        Merci pour t'est correction !

                        Honnêtement je ne savais pas quand pouvais le faire en une seule ligne ! Pour la fonction inverser_liste

                        Pour la fonction get_len c'est le nom de la fonction qui prêtait à confusion, je l'ai modifié. 

                        Pour les fonctions a et b le fonction est un peut dure à expliquer mais je dois faire des tests et je reviendrais !

                        • Partager sur Facebook
                        • Partager sur Twitter

                        https://github.com/flowlord/Multiple-Substitution-Encryption

                          27 avril 2022 à 14:02:35

                          Le code reste toujours mauvais. Ta fonction inverser_liste NE SERT A RIEN. La ligne https://github.com/flowlord/encryption-by-mutilple-subtitution/blob/4c0d65c0cf0dc6014d26cbb372e33bfd7d6322ad/MSE.py#L222 doit être remplacée par `list(reversed(key))`

                          -
                          Edité par Nephthys 27 avril 2022 à 14:02:43

                          • Partager sur Facebook
                          • Partager sur Twitter
                            27 avril 2022 à 17:25:30

                            Donc ce n'est pas pour aujourd'hui le prix Nobel?
                            • Partager sur Facebook
                            • Partager sur Twitter

                            Le Tout est souvent plus grand que la somme de ses parties.

                              27 avril 2022 à 21:55:06

                              Juste le prix Nomoche pour la lisibilité du code...

                              • Partager sur Facebook
                              • Partager sur Twitter
                                28 avril 2022 à 1:32:11

                                Mo much better ...
                                • Partager sur Facebook
                                • Partager sur Twitter

                                Le Tout est souvent plus grand que la somme de ses parties.

                                  28 avril 2022 à 22:40:08

                                  Bonjour,

                                  Je vois pas trop l'intérêt de se moquer. Vous faisiez sûrement pas mieux lorsque vous débutiez la programmation.

                                  Revenons à nos moutons:

                                  @FLOW LORD, il va un moment falloir que tu poses ton système de chiffrement sur le papier. Et ensuite, tu pourras l'implémenter en Python. Parce que là j'ai surtout l'impression qu'une partie de ton algo sert uniquement à faire plein d'opération sur des chaînes de caractères pour mélanger le tout avant de le chiffrer.

                                  On a toujours des «méthodes» aux noms peu éloquent, et souvent, quand on fait ça, c'est qu'on sait pas trop à quoi elles servent et/ou qu'on ne les comprend pas vraiment. Je te ferai remarquer que C1, C2 et C2_inv donnent la même sortie pour une même chaîne en entrée.

                                  Sans compter plein de morceau de code complètement inutile dont on t'a déjà fait part pour certains (je rajouterai un des grands classiques du genre: if reversed_key is True:). Je parle pas de check_word qui est une insulte à l'algorithmie...

                                  Les classes, c'est fait pour faire de la POO, pas pour organiser ton code dans un fichier. Pour ça on divise le code en module, c'est fait pour.

                                  Des logiques parfois douteuses. Un petit ping-pong bloc A, bloc B pour le déchiffrement? On déchiffre complétement une fois et à mince... ça ne fonctionne pas, re déchiffrons autrement?!! Le tout basé uniquement sur une liste exhaustive de mot (pas de chance si on fait une faute ou qu'on utilise des mots qui ne sont pas dans ton dico alors...).

                                  Quand on a un code pas si gros, et qu'on commence à devoir ajouter de nouvelles fonctionnalités dans le code uniquement parce qu'on a un bug qu'on ne sait pas corriger, c'est souvent signe d'un projet mal conçu dès le départ qui ne pourra jamais évoluer.

                                  Bref, un minimum de réflexion avant de coder, ça évite de se retrouver à maintenir un code de 200 lignes qui pourrait en faire 4 fois moins. Sors la tête de python, réfléchis à ce que tu fais vraiment.

                                  -
                                  Edité par KoaTao 28 avril 2022 à 22:47:16

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    29 avril 2022 à 1:13:53

                                    @KoaTao: c'est

                                    vrai que j'ai été méchant.
                                    FLOW LORD ne m'a pas donné de réponse satisfaisante.
                                    Il a écrit au début:
                                    «Je pense que d'après ma petite connaissance en cryptographie, dite moi si j'ai faux, que c'est la première fois qu'une méthode de chiffrement par substitution
                                    qui résiste à une attaque par analyse fréquentielle !»
                                    Tu dis qu'il est débutant? Je trouve son affirmation un peu préttentieuse.
                                    S'il avait exposé son algorithme ou sa méthode au lieu de son code, on aurait pu le conseiller plus facilement.

                                    @FLOW LORD: essaies de nous expliquer ton principe en français et on essaiera de le coder ensemble.

                                    -
                                    Edité par PierrotLeFou 29 avril 2022 à 7:57:19

                                    • Partager sur Facebook
                                    • Partager sur Twitter

                                    Le Tout est souvent plus grand que la somme de ses parties.

                                      29 avril 2022 à 7:53:11

                                      Salut KaoTao,

                                      Je n'y vois pas de méchanceté, pour les raisons suivantes: 

                                      1) Des remarques bienveillantes lui ont été fournie en parallèle

                                      2) Une des leçons les plus importantes selon moi quand on ouvre son code au monde, est qu'on est pas son code, et que l'attaque est sur le code et nullement sur la personne, si on mélange les 2, on se ferme a l'expérience des autres(qui ne sont pas toujours tendre), et au vu des corrections qu'a fait FlowLord, il a certainement très bien compris ce principe sinon il aurait tout rejeté en bloc.

                                      Mais si il l'a mal pris, je lui présente mes excuse d'avance.

                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        5 mai 2022 à 11:05:54

                                        Hello !

                                        Sa vous dit d'ouvrir un discord autour du projet pour l'améliorer ?

                                        Cela me permettrait d'expliquer plus en détaille ce que j'ai dans la tête !

                                        • Partager sur Facebook
                                        • Partager sur Twitter

                                        https://github.com/flowlord/Multiple-Substitution-Encryption

                                          5 mai 2022 à 17:54:01

                                          Ce forum est là pour ça. Puisque tu as commencé ici, pourquoi ne pas continuer ici?
                                          • Partager sur Facebook
                                          • Partager sur Twitter

                                          Le Tout est souvent plus grand que la somme de ses parties.

                                            5 mai 2022 à 20:35:55

                                            Aucune raison de vouloir éclater les échanges sur plusieurs plateformes.

                                            Pour en revenir aux critiques, il y a une qualité que chaque développeur junior doit avoir, c'est l'humilité, il est facile de croire à nos débuts que notre code est meilleur ou originale, en général ce n'est pas le cas.

                                            Les critiques sont peut-être un peu moqueuses voire dures, mais c'est une réponse au paragraphe de l'auteur : 

                                            > c'est la première fois qu'une méthode de chiffrement par substitution qui résiste à une attaque par analyse fréquentielle

                                            Non, bien sûr que non, il suffit de lire le code en diagonal pour voir de grossières erreurs.

                                            Bref comme cela a déjà été dit, il faut poser sa logique puis coder.

                                            • Partager sur Facebook
                                            • Partager sur Twitter

                                            Ancien étudiant OpenClassroom, diplômé en développeur d'application Python

                                              6 mai 2022 à 13:57:42

                                              Principe et fonctionnement



                                              1) (Voir le fichier parametre.py)



                                              Je chosit un groupe de caractère que je veut substituer:


                                              Par exemple je substitue uniquement les lettres minuscule et l'espace


                                              abcdefgh  ....


                                              Je choisis aussi des "lettres spéciaux", ce sont des lettres auquel la longueur des caractères générée vont être plus petite que les autres lettres


                                              Je chosit un groupe de caractère spéciaux:
                                              Exemple:


                                              AZERTYUIOPQSDFGHJKLM1234567890


                                              Je met dans un fichier initpat.txt
                                              (ne pas ouvrir contient actuellement 65824 caractères spéciaux)


                                              Je divise en deux le groupe de caractère
                                              Le groupe A: AZERTYUIOPQSDFG
                                              pour générer mes clés de chiffrement

                                              Le groupe B: HJKLM1234567890
                                              pour ajouter des caractères après la substitution des lettres


                                              2) (Voir le fichier keylib_generator.py)

                                              Je génère mes clés de chiffrement:
                                              Exemple:
                                              (Un tableau de correspondance)


                                              KEY1 = [('a','QSYI'),('b','UIOE'),('c','AZER'),('d','RTY'),('e','RUO'),(' ','ZTROR') ... ]


                                              A) Des fonctions modifie la chaine de caractère (Voir la fonction inverser_phrase)


                                              B) Je fait la subtitution des lettres
                                              Exemple la chaine: abc de
                                              La chaîne devient:

                                              QSYIUIOEAZERZTRORRTYRUO


                                              C) Je rajoute x fois les caractères du groupe B dans n'importe quel position de la chaîne de caractères et cela donne:


                                              5L9Q2SHM0YKI2843298M6LU6480M9K814I708H5MO3J88H4539EMA51Z90JL217929E5J13H3K9929129MLRL7LZ2158L5H3JT2R6ORRT7LY1L057RU0MJ096OK


                                              (Voir la fonction chaos du module MSE.py)


                                              Je mélange avec shuffle les caractères du fichier initpat.txt avant de générer mes clés de chiffrement



                                              Pour chiffrer un prénom il faut qu'il sois dans la list de mot



                                              Tous est paramétrable dans le fichier parametre.py on peut changer de nombre de caractère quand ajoute après après la subtitution.


                                              Changer la longueur maximale et minimale des caractères spéciaux qui vont être générer:


                                              L = 2,4

                                              [ ("a","OG"), ("b","TROG") ....]


                                              Hypothèse pour décoder les messages 


                                              On peut voler les clés de chiffrement de la personne, mais ce dernier peut l'écraser par une autre clé de chiffrement ou bien en utiliser plusieurs

                                              (Voir la fonction gen_many_keylib  du module tool.py)



                                              Ce qu'il faut c'est d'avoir la chance qu'il n'a pas toucher au fichier initpat.txt, donc qu'il n'a pas mélanger ces caractères.


                                              Donc si je repères et enlève les caractères du groupe B, on peut être faire une  analyse fréquentielle ?



                                              Je me serre de l'algo pour, créer des énigmes ou des codes secret, créer des histoires fictive ou des ARG

                                              -
                                              Edité par FLOW LORD 6 mai 2022 à 16:52:36

                                              • Partager sur Facebook
                                              • Partager sur Twitter

                                              https://github.com/flowlord/Multiple-Substitution-Encryption

                                                7 mai 2022 à 1:39:25

                                                FLOW LORD a écrit:
                                                «Exemple la chaine: abc de
                                                La chaîne devient:
                                                QSYIUIOEAZERZTRORRTYRUO
                                                »
                                                Comme on te l'a déjà dit, ce n'est pas une bonne idée que d'augmenter significativement la longueur du message.
                                                As-tu suffisamment de tests pour nous dire par quel facteur les fichiers sont augmentés?
                                                «Pour chiffrer un prénom il faut qu'il sois dans la list de mot
                                                Tous est paramétrable dans le fichier parametre.py on peut changer de nombre de caractère quand ajoute après après la subtitution.»
                                                On doit pouvoir encrypter n'importe quoi sans table de mots ou de codes.
                                                Est-ce que ton programme peut décrypter ce qu'il a lui-même encrypté? C'est un bon test de départ.
                                                Ton code va sûrement déjouer les analyses fréquencielles, mais à quel prix?

                                                • Partager sur Facebook
                                                • Partager sur Twitter

                                                Le Tout est souvent plus grand que la somme de ses parties.

                                                  24 juin 2022 à 16:52:58 - Message modéré pour le motif suivant : Merci d'utiliser votre autre compte


                                                    24 juin 2022 à 17:23:03

                                                    @FLOWLORD Bonjour, conformément au point 7.1 des CGU de ce site, vous ne pouvez avoir qu'un seul compte sur la plateforme.

                                                    Merci de continuer avec votre autre compte : FLOW LORD

                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      24 juin 2022 à 17:25:57

                                                      Si cela t'a amusé et appris des choses, c'est le principal.
                                                      Tu n'as pas répondu à ma question: peux-tu décrypter ce que tu as encrypté?
                                                      Si oui, c'est le principal.
                                                      Tu es libre de prendre nos idées ou pas.
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter

                                                      Le Tout est souvent plus grand que la somme de ses parties.

                                                        6 juillet 2022 à 23:15:39

                                                        PierrotLeFou a écrit:

                                                        Si cela t'a amusé et appris des choses, c'est le principal.
                                                        Tu n'as pas répondu à ma question: peux-tu décrypter ce que tu as encrypté?
                                                        Si oui, c'est le principal.
                                                        Tu es libre de prendre nos idées ou pas.

                                                        Oui, tant que j'ai la clé de chiffrement.



                                                        • Partager sur Facebook
                                                        • Partager sur Twitter

                                                        https://github.com/flowlord/Multiple-Substitution-Encryption

                                                          16 juillet 2022 à 23:00:44

                                                          Pourriez vous être un peu plus indulgent avec lui? :o

                                                          Dire que son code est à revoir est acceptable mais dire qu'il est " extrêmement mauvais" peut être blessant.

                                                          On a tous commencé quelque part ;) C'est en codant que l'ont devient codeur, alors continue! C'est du bon boulot ;)

                                                          Découpe ton code, mets des bons noms de fonctions / variables. Pense en POO, apprends des designs pattern et tu t'améliorera.

                                                          Tu sembles avoir une bonne mentalité, tu ne prends pas mal les critiques, continue comme ça!

                                                          -
                                                          Edité par GDemay 16 juillet 2022 à 23:02:55

                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            17 juillet 2022 à 12:00:07

                                                            GDemay a écrit:

                                                            Pourriez vous être un peu plus indulgent avec lui? :o

                                                            Dire que son code est à revoir est acceptable mais dire qu'il est " extrêmement mauvais" peut être blessant.

                                                            On a tous commencé quelque part ;) C'est en codant que l'ont devient codeur, alors continue! C'est du bon boulot ;)


                                                            Il est quand même arriver avec un postulat de départ d'avoir créer un chiffrement par substitution plus robuste que tous les autres conçus jusqu'ici. Ce qui est bien évidemment faux et qui démontre quand même très peu de documentation et de recherche sur le sujet au préalable. De plus, il a quand même demandé une relecture complète de son code avant de lui répondre. Je pense qu'à partir du moment où on pose des bases aussi exigeantes, il faut s'attendre que les réponses le soient aussi.

                                                            J'ai rien contre son projet, mais ici, c'est quand même une partie du forum fait pour présenter des projets sérieux et/ou orignal normalement plus que des petits projets perso pour s'amuser.

                                                            Quant aux remarques, tu observeras aussi que c'est toujours les mêmes depuis 4 mois quasiment, et que peu de choses ont évoluées en terme de qualité de code. Libre à l'auteur de nous ignorer effectivement, mais je vois encore moins l'intérêt de ce sujet alors...

                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                              21 juillet 2022 à 23:19:57

                                                              Bonjour,

                                                              Pardonnez moi de ma stupidité, lors de mon premier message,

                                                              mais c'est que ce projet me rend dingue (dans le bon sens biensure ;) c'est merveilleux, c'est vraiment ce que j'aime faire et je vais en faire mon métier

                                                              Bref,

                                                              Malgré mon très mauvais gestion de projet et ma programmation médiocre.

                                                              Depuis que j'ai mis le projet en open source, le programme marche et répond exactement à mon besoin de départ:

                                                              Chiffrer du text et seulement sa.

                                                              Le programme marche et naïf que j'était je n'osais pas toucher au code source et le laissé pourrire ce que qui montrais parfois des aberration monstrueuse.

                                                              " Sa marche, donc je en touche pas" ;) du peur de tous foiré.

                                                              Maintenant je fait régulièrement des mise à jour tous les jours pour constamment améliorer le code. Des futures verison feront le jour.

                                                              Le programme a ces propres "règles" même si elle est sécurisée et tous le bla bla ce n'est pas mon but. Maintenant ce que je cherche à faire c'est de le casser, c'est à dire de trouver les messages sans les clés.

                                                              C'est pour cela que j'ai ouvert un projet annexe "MARS ATTACK", ouvert depuis maintenant quelques semaines j'ai déjà trouver une "faille", que j'ai patché par la suite avec une nouvelle version.

                                                              C'est sa que j'aime aussi faire, trouver et recherché, exploiter des faile et les patchés.

                                                              Pour moi je trouve sa dingue et éprouvre une certaine fascination qu'un algorithme, 'une boîte noire' ou tu fait enter du text:

                                                              hello word 

                                                              Et te ressors ceci:

                                                              ␼곹벲꾫ⴐ绁웥p𖡌睄𖠊䟙𝞡牚斈诖䊓循ᴰ𓐳䯓髸嘒蹙橕䧅润ᐰ濘軽ࠌ쯍衶砫〕멍z醙堘丱𐠶󛻄㖽橨賲 뿄츆𐀀ᕡ躯圃ⶏ꤇쌈珠Ǯ⁀鈉㯜륩ꆅꍘ뻻鈏㮝㼖孔耣轣醥𒋒舂땸䉸妕╘讈෢튭𝛺ﵗ䖽좮j튆㉄ლa給鲔 ᄉ譀埱﫼ݥ鎪罼🕛䰇a𓊷⡲Τꤴ⬸垕纾퀿𝑍놐撟𐡠쑳྾ὦ q௟箹脢탊㫉ꛘ𐎛쐹𝕉᭠𒈴兑￘㏓౒餺㇠🏺𓉭㝋𝙼鄗椥彥冼柨ᕦ裡h넵寵쯞휸㹅쩓vⷑ🇽𐤑o밪ಚ𓃰﶐蹹j쉑»㻿䞐 궫욝噪Υ㦦靿븙姆䄄㐨ⷿ혇ݍ蛉뎼豅ᯫ䘰锰൳脢㫉⹦ ぃ⍼繄샂🅔콄艺铠츊쳛关蘈﷡𝕉덩譢᭠𒈴䘹𝚸뼔ථ鸎 ➕兑ᇲ椥嚻勱骆䬊偙ⷑ󲱅靿䄄۪ⷿ𑀭蹨働⽇甯톼뵸 📔嵨刵𓍺લ軺巣𐐷燵𓉵겭觌z䤱뼜埖뎥ꛛ䵖˚Խﶞᮕ𑄪鬌p ⷕ뗘慴蹙橕䧅솿𐨆ࠌ頭꽜쁽멍傁㖽웸鼙䏂츆v珠╄脢瞺㫉𐋏🕓𝕉᭠휨㩔ퟤd컉靦す蝃𒈴🥲𒊣直兑iyᣛ誾椥ⷑ駲 ᓮ凰䄄銖ⷿ䅥簆良阑ẏ량ң晾

                                                              (Exemeple de message)

                                                              Je sortirais des mise à jour du code dans les prochaines jours, mais pour l'instant je manque de temps.

                                                              -
                                                              Edité par FLOW LORD 23 juillet 2022 à 0:18:21

                                                              • Partager sur Facebook
                                                              • Partager sur Twitter

                                                              https://github.com/flowlord/Multiple-Substitution-Encryption

                                                              MSE (Multiples Subtitution Encryption)

                                                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                              • Editeur
                                                              • Markdown