Discussion :

[tardash]

bonjour.

sa fait longtemps que je m'interesse a la cryptographie et mon but est de creer une petite app 100% sûr pour crypter des messages.
j'ai crée une classe pour crypté les message donc j'aimerai que vous me donniez votre avis et/ou que vous essayiez de trouver un moyen de decrypter mes message cryptés.
je la clé pour decrypter.

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Lcrypt
{
    public static class Cryptage
    {
        private static List<string> Tableau;
        private static string Crypte;
        static int indice;
 
        public static string Crypter(string phrase)
        {
            indice = new Random((int)DateTime.Now.Ticks).Next(2, 100);
            Crypte = (((indice * indice) / 2) + 6).ToString() + "|";
            Tableau = new List<string>();
            foreach (char ch in phrase)
                Tableau.Add(ch.ToString());
            crypteur();
            return Crypte;
        }
 
        private static void crypteur()
        {
            int essaie = 0;
            for (int i = 0; i < Tableau.Count; i++)
            {
                if (int.TryParse(Tableau[i], out essaie))
                    Crypte += retournerLettre((Convert.ToInt32(Tableau[i]))) + "|";
                else
                {
                    if (RenvoyerChiffre(Tableau[i]) == 0)
                    {
                        if (Tableau[i] == "|")
                            Crypte += "k|";
                        else
                            Crypte += Tableau[i] + "|";
                    }
                    else
                        Crypte += ((((RenvoyerChiffre(Tableau[i]) * indice) / 2) + 6) * 7).ToString() + "|";
                }
            }
        }
 
 
        private static int RenvoyerChiffre(string a)
        {
            switch (a)
            {
                case "a":
                    return 1;
                case "b":
                    return 2;
                case "c":
                    return 3;
                case "d":
                    return 4;
                case "e":
                    return 5;
                case "f":
                    return 6;
                case "g":
                    return 7;
                case "h":
                    return 8;
                case "i":
                    return 9;
                case "j":
                    return 10;
                case "k":
                    return 11;
                case "l":
                    return 12;
                case "m":
                    return 13;
                case "n":
                    return 14;
                case "o":
                    return 15;
                case "p":
                    return 16;
                case "q":
                    return 17;
                case "r":
                    return 18;
                case "s":
                    return 19;
                case "t":
                    return 20;
                case "u":
                    return 21;
                case "v":
                    return 22;
                case "w":
                    return 23;
                case "x":
                    return 24;
                case "y":
                    return 25;
                case "z":
                    return 26;
                case "A":
                    return 27;
                case "B":
                    return 28;
                case "C":
                    return 29;
                case "D":
                    return 30;
                case "E":
                    return 31;
                case "F":
                    return 32;
                case "G":
                    return 33;
                case "H":
                    return 34;
                case "I":
                    return 35;
                case "J":
                    return 36;
                case "K":
                    return 37;
                case "L":
                    return 38;
                case "M":
                    return 39;
                case "N":
                    return 40;
                case "O":
                    return 41;
                case "P":
                    return 42;
                case "Q":
                    return 43;
                case "R":
                    return 44;
                case "S":
                    return 45;
                case "T":
                    return 46;
                case "U":
                    return 47;
                case "V":
                    return 48;
                case "W":
                    return 49;
                case "X":
                    return 50;
                case "Y":
                    return 51;
                case "Z":
                    return 52;
                default:
                    return 0;
            }
        }
 
        private static string retournerLettre(int a)
        {
            switch (a)
            {
                case 1:
                    return "a";
                case 2:
                    return "b";
                case 3:
                    return "c";
                case 4:
                    return "d";
                case 5:
                    return "e";
                case 6:
                    return "f";
                case 7:
                    return "g";
                case 8:
                    return "h";
                case 9:
                    return "i";
                case 0:
                    return "j";
                default:
                    return null;
            }
        }
    }
}

faites pas trop attention aux nom des variables...

[Sehnsucht]

https://chiffrer.info/

[Pol63]

ca fait longtemps que je m'interesse a la cryptographie

on dirait pas pourtant
ca c'est ce qu'on peut coder à 12 ans après seulement 5 minutes de recherche sur ce qui se faisait dans les années 50...
(pendant la 2ème guerre mondiale ce genre de chiffrement n'avait pas tenu et sans avoir besoin de la clé)

mais tout le monde a commencé en bas de l'échelle ^^
par contre faut rester réaliste et pas espérer pondre un truc mieux que des mathématiciens avec des dizaines d'années d'expérience, et dans le Framework .net il y a tout ce qu'il faut pour chiffrer convenablement

[tardash]

j'ai du passer par apprendre a programmer ( j'ai commencé par c# mais je connais d'autre langages ) pour vous dire que je connais encore rien a rien sur la cryptographie. j'ai juste entendu parler de la methodes de cesar, je suis vraiment vraiment au debut du game donc pour moi c'est deja un exploit !

je vais continuer sur ma lancé !

si vous avez des conseils ou des orientations je suis a 100% preneur !

merci d'avance

[Noxen]

Moi je te conseille de lire "Histoire des codes secrets (De l'Egypte des Pharaons à l'Ordinateur Quantique)" de Simon Singh, qui dresse de façon entraînante un panorama rapide de l'évolution des techniques permettant la dissimulation des messages, des origines à nos jours.

[François DORIN]

Pourquoi est-il fortement recommandé de ne JAMAIS créer d'algorithme de chiffrement soi-même ? Parce qu'il est très facile de faire quelque chose de cassable facilement.

Il m'a fallu 10min pour écrire la routine de déchiffrement :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public static string Dechiffrer(string encrypted)
        {
            string alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
            string[] chars = encrypted.Split('|');
            StringBuilder builder = new StringBuilder();
            int key = Convert.ToInt32(Math.Sqrt((int.Parse(chars[0]) - 6) * 2));
 
            for(int i = 1; i < chars.Length - 1; ++i)
            {
                string s = chars[i];
                if (int.TryParse(s, out int entier))
                {
                    int orig = (entier / 7 - 6) * 2 / key;
                    builder.Append(alphabet[orig - 1]);
                }
                else if (alphabet.Contains(s))
                {
                    if (s == "k")
                    {
                        builder.Append("|");
                    }
                    else
                    {
                        int index = alphabet.IndexOf(s);
                        builder.Append((index + 1) % 10);
                    }
                }
                else
                {
                    builder.Append(s);
                }
            }
 
            return builder.ToString();
        }

10 minutes, car j'ai du passer 5min à comprendre pourquoi une fois sur 2 le déchiffrement ne fonctionnait pas comme voulu. La réponse est simple : une fois sur deux (si ta variable "indice" est impaire), ta fonction de chiffrement est foireuse car non bijective.

Donc, d'une part, l'algo est d'une telle simplicité que n'importe quel hacker peut le résoudre en moins de temps qu'il ne m'en a fallu pour le faire.

Et si tu penses qu'avoir l'algo m'a aidé, je le concède. Mais si une personne dispose ne serait-ce que de l'exécutable, alors il est très aisé de le décompiler pour avoir l'algo de chiffrement et en déduire l'algo de déchiffrement. Quoi qu'il en soit, la sécurité par l’offuscation n'est jamais une bonne idée (il faut que l'algorithme soit suffisamment robuste pour qu'un texte ne puisse pas être déchiffrer, même en connaissant l'algo).

De plus, ton algo est sensible aux analyses statistiques (un caractère est toujours encodé de la même manière). Donc avec un texte un peu long, il est très facile de retrouver le texte d'origine, même sans connaissance a priori de l'algo, ni de la clé.

Enfin, la clé que tu génères est en réalité un sel (si c'était une clé, elle ne serait pas présente dans le texte chiffré). Si l'usage d'un sel est effectivement une bonne chose, tu en réduis considérablement l'utilité en forçant un sel compris entre 2 et 100. De ce fait, il existe au plus 99 tables de codage différentes. Donc un attaquant ayant suffisamment de textes à déchiffrer pourra trouver toutes les tables rapidement, et ainsi déchiffrer TOUS les messages, quel que soit leur longueur.

Et pour conclure, certains caractères ne sont tout simplement pas chiffrés. Notamment, pour les langues basées sur un alphabet non latin ou à base d’idéogrammes, ton algo ne sert strictement à rien.

Ultime remarque, ton algorithme augmente considérablement la taille initiale du message (environ x3 !)

[tardash]

merci noxen, je vais commander le livre.

10 min?! impressionnant ! il m'a fallu 4h pour creer la cle de chiffrement je suis deçu

je suis conscient que 2 a 100 n'est pas tres large mais je du faire sa parce que le message devenait beaucoup trop long. et le fait d'avoir un nombre aléatoire pour la clé me paraissait efficace parce qu'on a plusieurs combinaison pour un seul message.

c'est tres motivant! merci