Discussion :

[ternel]

Et si tu lui demandais?

[TomelD98]

C'est ce que j'ai fais mais il ne me répond pas et ça me rend malade de ne pas avancer, ça fait des semaines que j'essaie d'avancer et de chercher mais je ne trouve rien nulle part...

[Médinoc]

Trier les lettres dans l'ordre alphabétique et supprimer les doublons n'est pas un vrai cryptage: Cela supprime de l'information de manière non-récupérable.

Par contre, il existe un algorithme de cryptage qui exige que la "clé" n'ait pas de doublons: Le chiffre à mot-clé (par contre, celui-ci ne passe pas par un tri et donc il faut utiliser une méthode plus difficile pour supprimer les doublons).

[sambia39]


Bonsoir

Honnêtement, avant de s'attaquer au code ou à d'autres problèmes techniques, il faut se documenter et comprendre certaines notions en cryptographie : Le principe du chiffrement et déchiffrement les algorithmes utilisés pour le chiffrement, lequel choisir ou en créer sur la base de ceux déjà existants...
Ce n'est qu'après ses différentes étapes que l'on peut se concentrer sur l'implémentation de l'algorithme (codes) et les diverses erreurs de programmation. Si l'on commence dès le départ à écrire du code sans même prendre le temps d'avoir une idée précise sur la cryptographie et ses différente méthodes de chiffrement, vous irez dans la mauvaise direction. Pire encore, on parlera uniquement des erreurs de programmation et de la façon d'écrire le code (en clair un pointeur vert l'hors sujet).

Voici quelques définitions simplifiées de certains termes cryptographiques:

• Un cryptogramme est un message chiffré.
• Le clair (ou message clair), qui est la communication que l'on désire faire et chiffrer, est la même communication en clair modifiée par le chiffrement (le déchiffrement est l'inverse du chiffrement).
• Une substitution est un procédé dans lequel les lettres du message en clair sont remplacées par d'autres lettres, par des chiffres ou des symboles quelconques.

Viennent ensuite des méthodes comme :

• La substitution : procédé dans lequel les lettres du clair sont remplacées par des chiffres ou des symboles quelconques.
• La substitution simple est un procédé dans lequel les lettres du clair sont représentées par une simple lettre, chiffre ou symbole du chiffré.
  Exemple, si le texte clair est « BONJOUR » le texte chiffré sera « CPOKPVS » dans cet exemple de substitution simple on remplace la lettre actuelle par la lettre suivante.
• La substitution simple avec suppression de fréquence (représentation multiple de lettre d'apparition) est celle dans laquelle les lettres très fréquentes comme « O » dans le cas de notre exemple précédent, se répètent souvent. On parle alors de fréquence d'apparition. Dans la langue française, la lettre qui apparaît le plus souvent est la lettre « E ».
  La méthode utilisée pour connaître ces fréquences d'apparition est appelée "Analyse fréquentielle", plus communément "analyse de fréquence". C'est l'une des méthodes de la cryptanalyse science qui permet de connaître la fréquence d'apparition d'une lettre et qui consiste à essayer de déchiffrer un message chiffré sans posséder la clé de chiffrement. Ce procédé dans lequel on tente de comprendre ou déchiffrer un message en particulier, est appelé « Attaque » et ce terme est associé à différents types de techniques simples au plus complexes pour tenter de déchiffrer un message.
  Voici quelque type d'attaque:

1. Attaque sur texte chiffré seul : Consiste a utiliser l'exemplaire d'un texte chiffré et deviner ou émettre des hypothèses sur le contenue du message clair.
2. Attaque à texte clair connu : Le principe est le même que le précédent sauf qu'en plus du message chiffré il y a une partie avec un message clair non chiffré facilitant le déchiffrement du message branche de la cryptanalyse linéaire (crée et utilisé pour casser à l'origine l'algorithme de chiffrement symétrique DES).
3. Attaque à texte clair choisi : Méthode qui consiste à posséder l'un des messages en clair et, sur cette base de message clair, en va pouvoir créer diverses versions chiffrées. Les messages utilisent un algorithme dont les mécanismes ne sont pas connus, il s'agit de la cryptanalyse différentielle (l'étude sur la façon dont les différences entre les données en entrée fournies affectent ou modifient les données en sortie, dont le but est de découvrir une prédiction de l'algorithme afin de trouver la clé secrète qui a permis le chiffrement. Celle-ci est moins efficace que l'attaque par texte clair connu).
4. Attaque à texte chiffré choisi : Contraire de l'attaque à texte clair c'est-à-dire que sur la base des messages chiffrés en essaye de trouver la version claire de certains ou portion de message clair pour établir une attaque.
5. L'attaque par force brute : Consiste à tester toutes les solutions possibles de mots de passe ou de clés de déchiffrement et c'est la seule technique efficace permettant de déchiffrer un message et même les plus complexes et sophistiqués.
6. L'attaque par dictionnaire: Plus simple mais efficace, consiste à tester tous les mots d'une liste comme mot de référence ou mots-clés. Voir un exemple d'attaque par dictionnaire sur un fichier chiffré avec "crypt".

• Une substitution à double clés est un procédé dans lequel les lettres du clair son représentées par des chiffres et par des lettres qui varient selon un système dont la base est un mot-clef.
• Le sur-chiffrement appelé également double chiffrement consiste à chiffrer un texte par substitution simple ou double puis rechiffrer a l'aide d'une table qui a pour rôle d'opérer sur le second chiffrement par groupe de 2 voir 3 lettres à la fois.
  Elle mélange substitution et transposition : les lettres restent les mêmes mais sont mélangées selon une convention préétablie (c'est l'ancêtre de la machine egnima).
• Le chiffrement combiné ou superposition de procédés est un double chiffrement comprenant transposition et substitution.

Il existe tant d'autres techniques, je n'en n'ai cité que quelques-unes en m'efforçant de ne pas aborder certaines notions complexes comme le chiffrement asymétrique ou encore la cryptographie quantique.

Pour un débutant sur un petit projet, il est bien plus simple d'aborder des notions élémentaires telles que le cryptosystème classique ou élémentaire et leurs algorithmes que je vous conseille de lire comme :

• Le chiffrement de césar
• Le chiffrement de vigénère
• Le carer de polype.
• Le chiffrement de José de Bronckhorst.
• Le système de chiffrement de Beaufort.
• Le système de chiffrement de Saint-Cyr.
• Le système de chiffrement de Gronsfeld.
• Le système de chiffrement de Porta etc.

Pour résumer la chose, il faut retenir que chiffrer un message, c'est transformer un texte clair en un texte chiffré .
Le déchiffrer c'est le retransformer en clair. Décrypter un chiffre ou un code c'est essayer de découvrir la façon dont il était fait.
Sur la base de ces définitions à vous de comprendre ce qu'est un chiffrement et un cryptage.

Voici un exemple de programme simple de chiffrement utilisant la substitution simple décrite plus haut, basée sur le décalage de caractères.
Phrase clair : « BONJOUR DEVELLOPEZ » ( B+1 = C etc. )
Phrase chiffrée : « CPOKPVS EFWFMMPQFA »

Exemple:

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
 
/*
*  File: source.c
*  Version: 0.0.1 GPL V3.
*  Created by SAMBIA39 on 18/02/2016 - 19:34:46.
*  Copyright (c) 2016 SAMBIA39 and DEVELOPPEZ.NET
*/ 
 
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
 
//type booléen
typedef enum e_bool{
    false,
    true
}bool;
 
/*
 *  Fonction qui joue similaire à perror 
 */
void f_fatal_err( char *p_msg ){
    extern int errno;
    extern const int sys_nerr;
    extern const char *const sys_errlist[];
 
    fprintf( stderr, "Erreur N°(%d)\t\t:%s\n", errno, p_msg );
    if( 0 < errno && sys_nerr > errno )
        fprintf( stderr, "Description erreur\t:%s\n", sys_errlist[errno] );
    else
        fprintf( stderr, "Description erreur\t:Erreur inconnue\n" );
 
    exit( EXIT_FAILURE );
}
 
/*
 *  Fonction qui permet de ne pas appliquer 
 *  de chiffrement sur certains caractères. 
 *  /!\Attention cette fonction est à revoir il peut y avoir 
 *  une erreur d'implémentation de la logique voulue.
 */
bool f_ignore_c_str( int c ){
 
    return ( ( 0 == isspace(c) ) ? true : ( 0 == isxdigit( c ) ? false :
        ( 0 == iscntrl(c)) ? true : ( 0 == ispunct(c)) ? true : 
            (0 == isgraph(c) ) ? true : ( 33 >= c && 47 >= c) ? false:
                (58 >= c && 64 >= c) ? false : ( 91 >= c && 96 <= c) ? false :
                    (123 >= c && c < 128) ? true : false) );
}
 
/*
 *  Fonction qui permet de mettre 
 *  les caractère en majuscules 
 */
char *f_get_upper_str( char *ptr ){
 
    char *p = ptr;
    register int i = 0;
 
    while( p[i] ){
        p[i] = toupper( p[i] );
        i = i+1;
    }
    return p;
}
 
/*
 *  Fonction qui se charge de chiffrer 
 *  caractère par caractère elle renvoie    
 *  en fin de chiffrement le message crypté.
 */
char *f_get_cypher_str( char *p_str ){
 
    char *p = NULL;
    register int i = 0;
    p = f_get_upper_str( p_str );
    while( p[i] ){
        if( 'Z' == p[i] )
            p[i] = 'A';
        else{
            if( false == f_ignore_c_str(p[i] ) )
                p[i] = p[i];
            else
                p[i] = p[i]+1;
        }
        i = i + 1;
    }
    return p;
}
 
/*
 *  Fonction qui se charge de déchiffrer 
 *  caractère par caractère elle renvoie 
 *  en fin de déchiffrement le message décrypté.
 */
char *f_get_no_cypher_str( char *p_str ){
 
    char *p = NULL;
    register int i = 0;
    p = f_get_upper_str( p_str );
    while( p[i] ){
        if( 'A' == p[i] )
            p[i] = 'Z';
        else{
            if( false == f_ignore_c_str(p[i] ) )
                p[i] = p[i];
            else
                p[i] = p[i]-1;
        }
        i = i + 1;
    }
    return p;
}
 
/*
 *  Fonction principale
 */
int main( void ){
 
    //Les déclarations
    char *p = NULL;
    extern int errno;
    extern char *strdup();
 
    //Teste réussite d'allocation mémoire
    errno = 0;
    if( NULL == (p = strdup( "Bonsoir à tous de la part de sambia39" ) ) )
        f_fatal_err( "Allocation(1)" );
 
    /*
     *  Affichage
     */
    fprintf( stdout, "Texte brut\t:%s\n", p );
    p = f_get_cypher_str( p );
    //
    fprintf( stdout, "Texte chiffré\t:%s\n", p );
    p = f_get_no_cypher_str(p);
    fprintf( stdout, "Texte clair\t:%s\n", p );
 
 
    /*
     * Libération de la mémoire allouée
     */ 
    free( p );
    p = NULL;
 
    return EXIT_SUCCESS;
}

Attention le code ci-dessus est à revoir il car il peut comporter des erreurs

Code OUT :

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

1
2
3
4
Texte brut      :Bonsoir à tous de la part de sambia39
Texte chiffré   :CPOTPJS ġ UPVT EF MB QBSU EF TBNCJB4:
Texte clair      :BONSOIR à TOUS DE LA PART DE SAMBIA39

Comme votre but est de réaliser un programme qui crypte des données (projet de fin d'année) je vous conseille fortement de vous pencher sur un système existant comme le chiffrement de césar, exposer le principe avec un exemple concret et si possible fournir un programme qui permet de casser le chiffrement en utilisant une analyse fréquentielle.

Et si vous vous sentez apte à aller plus loin, voici un message chiffré «*SYMQGZKYXXHUZH*».
A vous de deviner quelle est la méthode utilisée pour chiffrer le message, quelle est le message qui se cache derrière le texte chiffré, mais aussi trouver la clef de chiffrement.

À bientôt

[TomelD98]

Donc, après pas mal de recherches et prises de tête avec mon professeur guide je suis parvenu à ça:

Code :

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
static void nett(char *mdp) //fonction pour virer le \0 a la fin qui gene
{
    char *p = strchr(mdp, '\n');
    if (p)
    {
        *p = 0;
    }
}
int i,j;
 
int main(int argc, char *argv[])
{
 
char phD[30];
 
printf("Bonjour, veuillez rentrer la phrase a crypter:\n");
fgets(phD,sizeof phD,stdin); // fgets("%s", phraseDepart);
nett(phD);
printf("Votre phrase est: %s\n",phD);
 
int longphD =0; //Initialisation variable longueur chaine caracteres
longphD = strlen(phD); //On recupere la longueur de la chaine longphD
printf("La chaine %s fait %d caracteres de long", phD, longphD); //Apres on l'affiche...
 
for(i=0,i<-1,i++); //Première boucle qui va trier tous les caractères du tableau dans l'ordre alphabétique
{
    for(j=i+1,j<-1,j++);
    if(phD[j]<phD[i]);
    {
        temp=phD[i];
        phD[i]=phD[j];
        phD[j]=temp;
    }
printf("phD est: %s \n", phD);
}
for (i=0, i<-2,i++); //Deuxième boucle qui va tester chaque valeur du tableau et supprimer celles qui sont en double.
{
    for(j=i+1, j<-2, j++)
    if(phD[j]=phD[i])
    {
        phD[j]=phD[i]; //Là, on remplace le "I" par "I" pour avoir uniquement une seule des deux valeurs.
    }
printf("phD= %s \n", phD);
 
}
return 0;
}

Maintenant je dois supprimer les doublons. C'est à dire que je dois faire tester toutes les lettres du tableau et dès que j'ai un égalité, je dois déplacer toutes les autre lettres du tableau vers la droite pour n'en avoir plus qu'un.
Je prend pour exemple le mot bonjour retrier dans l'odre alphabétique:"bjnooru". Après je dois avoir: "bjnoru". Et ça doit être utilisable pour une phrase avec des espaces remise dans l'ordre alphabétique.

J'ai déjà fait ça:

Code :

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

1
2
3
4
5
6
7
for (i=0, i<-2,i++); //Deuxième boucle qui va tester chaque valeur du tableau et supprimer celles qui sont en double.
{
    for(j=i+1, j<-2, j++)
    if(phD[j]=phD[i])
    {
        phD[j]=phD[i]; //Là, on remplace le "I" par "I" pour avoir uniquement une seule des deux valeurs.
    }

Mais apparement ce n'est pas juste. Je ne sais même pas le vérifier parce que je n'arrive pas à lancer le programme. Il y a trop de fautes... Quelqu'un pourrait m'aider ?

[Médinoc]

Ce serait bien que tu postes les erreurs, quand tu dis qu'il y en a...

J'en vois au moins une: Une boucle for utilise des points-virgules, et non des virgules.

De plus, du devrais faire des fonctions pour ton tri et ta suppression de doublons.

Et finalement, je te rappelle que ce code ne crypte rien du tout, et détruit l'information à la place.

[TomelD98]

Ah oui pardon j'ai oublié de l'inclure dans mon message précédent:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
 
-------------- Build: Debug in Tests (compiler: GNU GCC Compiler)---------------
 
mingw32-gcc.exe -Wall -g  -c C:\Users\Thomas\Desktop\Thomas\TFE\Cryptage\main.c -o obj\Debug\main.o
C:\Users\Thomas\Desktop\Thomas\TFE\Cryptage\main.c: In function 'main':
C:\Users\Thomas\Desktop\Thomas\TFE\Cryptage\main.c:34:9: error: 'temp' undeclared (first use in this function)
C:\Users\Thomas\Desktop\Thomas\TFE\Cryptage\main.c:34:9: note: each undeclared identifier is reported only once for each function it appears in
C:\Users\Thomas\Desktop\Thomas\TFE\Cryptage\main.c:43:5: warning: suggest parentheses around assignment used as truth value [-Wparentheses]
Process terminated with status 1 (0 minute(s), 0 second(s))
1 error(s), 1 warning(s) (0 minute(s), 0 second(s))

La plus grosse erreur était effectivement l'utilisation de ";" au lieu de "," pour la fonction for. Merci Médinoc !
Voilà

[TomelD98]

Voilà, j'ai trouvé le reste. Maintenant je n'arrive pas à supprimer les doublons... J'ai déjà écrit ça mais ne fonctionne pas du tout:

Code :

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

1
2
3
4
5
6
7
for (i=0;i<15;i++) //Deuxième boucle qui va tester chaque valeur du tableau et supprimer celles qui sont en double.
{
    for(j=i+1;j<15;j++)
    if(phD[i]==phD[j])
    {
        phD[i]=phD[j]; //Là, on remplace le "i" par "j" pour avoir uniquement une seule des deux valeurs.
    }

Mais le truc c'est que ça ne change rien et je dois en fait décaler toutes les lettres d'une case vers la gauche.

Par exemple:
J'ai la chaine: a b b f j l.
Les cases 1 et 2 de mon tableau ont la même valeur. Donc j'aimerais décaler toutes les cases à partir de la 2 vers la gauche pour n'avoir plus qu'une seule fois le caractère b.
Voilà je ne sais pas si vous pourriez m'éclairer la lanterne

[Matt_Houston]

Code :

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

1
2
3
4
    if(phD[i]==phD[j])
    {
        phD[i]=phD[j]; //Là, on remplace le "i" par "j" pour avoir uniquement une seule des deux valeurs.
    }

Que penses-tu que ce code fasse ? C'est une vraie question : en écrivant cela tu t'attendais à un comportement précis. Quelles sont d'après toi les opérations qui sont réalisées par la machine ?

[TomelD98]

Code :

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

1
2
3
4
5
6
7
for (i=0;i<lonGphD;i++) //Deuxième boucle qui va tester chaque valeur du tableau et supprimer celles qui sont en double.
{
    for(j=i+1;j<lonGphD;j++)
    if(phD[i]==phD[j])
    {
        phD[j]=phD[i]; //Là, on remplace le "i" par "j" pour avoir uniquement une seule des deux valeurs.
    }

Eh bien pour moi la machine dis que si jamais les cases dites "i " et "j" ont la même valeur, alors la valeur de la case "j" devra être égale a "i" mais même ça, ça ne fonctionne pas... Ici, je n'ai pas cherché à ce que toutes les cases soient décalées je voulais déjà essayer avec une seule case...

[ternel]

Ce que tu écris, c'est que si un truc en vaut un autre, tu modifie autre avec la valeur du truc.
Ca tombe mal, puisque justement la valeur de truc est déjà celle de autre.

Ce n'est pas exactement ce que tu veux.
Pour supprimer les doublons, normalement, si tu trouves un doublon, tu supprimes la valeur du tableau, en décalant ce qui est après et en considérant le tableau comme plus court d'une valeur.

[sambia39]

Bonsoir
Honnêtement tout message chiffré par votre procéder de chiffrement ne permet pas par la suite de restituer les documents, mots, phrases d'origine.
Concrètement qu'est-ce que vous voulez faire comme méthode de chiffrement ?.
(si vous continuez dans votre lancé autant être honnête avec vous, la méthode utilisée ne marchera pas.)
à bientôt