Création programme de cryptage

Version imprimable

Bonjour à tous,

Je suis un étudiant en dernière année secondaire et j'ai décidé de produire un programme de cryptage pour mon travail de fin d'étude.
J'ai suivi un cours de programmation en C pour avoir de bonnes bases mais le problème est que je ne sais pas du tout comment m'y prendre pour démarrer ce programme. Mon professeur guide ne m'aide vraiment pas et la présentation est pour bientôt... Je ne sais pas si quelqu'un serait d'accord de m'aider mais je vais tout de même vous soumettre mon idée:
Je souhaiterais faire un programme de cryptage où je demanderais à l'utilisateur de rentrer la phrase à crypter de la manière suivante. Tous les doublons de cette phrase (ou ce texte) seraient supprimés, ensuite toutes les lettres seraient reclassées dans l'ordre alphabétique. Je suis conscient que ce forum n'existe pas pour que quelqu'un fasse mon travail mais me permette d'avancer et de m'aider dans ce travail. J'ai pas mal de notion mais je ne les ai jamais misent en pratique, d'où l'introduction de cette discussion.

Voici déjà le peut que j'ai été capable de produire pour l'instant:
Code:

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 #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 main(int argc, char *argv[]) { char phD[100]; printf("Bonjour, veuillez rentrer la phrase a crypter:\n"); fgets(phD,sizeof phD,stdin); // fget("%s", phraseDepart); nett(phD); printf("Votre phrase est: %s\n",phD); return 0; }
En vous remerciant pour votre compréhension et aide,
TomelD98.

C'est déjà un bon début, tu as une saisie correctement sécurisée. Même si pour celle-ci, il te manque encore de "finir de lire la ligne" tapée au clavier, sinon elle dépassera dans ta saisie suivante:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 static void nett(char *mdp) //fonction pour virer le \n a la fin qui gene { char *p = strchr(mdp, '\n'); if (p) { *p = 0; } else { //Si pas trouvé dans la chaîne, c'est qu'il est encore dans stdin int c; while((c=getchar())!=EOF && c!='\n') { } } }
Pour la suite, il faut procéder par étapes:

L'étape suivante, c'est la suppression des doublons et le tri des lettres par ordre alphabétique.
Tu constateras rapidement, d'ailleurs, qu'il est plus facile de faire ça dans l'autre ordre! Car une fois triées, les lettre en double seront toutes rassemblées, facilitant leur suppression (il suffira de ne copier une lettre vers sa destination que si elle diffère de la précédente).

16/02/2016, 19h01
TomelD98

Création programme cryptage

D'accord, mais comment est-ce que je fais ça ? Parce que je connais les différentes fonctions et tout mais je n'arrive pas à les mettre en pratique... Je sais que toutes les lettres que je tape ont une adresse (qui correspond à un nombre). Pour les remettre dans l'ordre alphabétique je dois lui demander de classer ces nombres dans l'ordre croissant. Pour les doublons je dois demander à l'ordinateur de supprimer les nombre qui revienne plusieurs fois mais alors comment je peux faire ça informatiquement parlant ?
16/02/2016, 19h05
Médinoc

L'algorithme de suppression de doublons dans une liste triée, s'il n'est pas fait "sur place", est trivial: Il suffit de copier vers un autre buffer, en vérifiant à chaque fois si la valeur actuelle est identique à la précédente.

Pour le tri, et bien... Il existe de nombreux algorithmes de tri. Cela doit facilement se trouver sur internet, ne serait-ce que wikipédia.
16/02/2016, 19h40
TomelD98
Je ne sais pas si ceci est correct:
Code:

1 2 3 4 5 6 for (i=26;i>0;i--) { k=rand()%i; table_code[i-1]=alphabet[k]; for (j=k;j<i;j++) alphabet[j]=alphabet[j+1];
Cet algorithme trie les lettres dans l'ordre et supprime les doublons si je ne me trompe pas... J'ai vraiment du mal à trouver...
16/02/2016, 20h01
Matt_Houston

Je ne comprends pas comment tu comptes décrypter le message. Lorsque tu auras terminé ton traitement l'information sera perdue, non ?
16/02/2016, 20h11
Médinoc
Citation:
Envoyé par TomelD98

Je ne sais pas si ceci est correct:

Code:

1 2 3 4 5 6 for (i=26;i>0;i--) { k=rand()%i; table_code[i-1]=alphabet[k]; for (j=k;j<i;j++) alphabet[j]=alphabet[j+1];

Cet algorithme trie les lettres dans l'ordre et supprime les doublons si je ne me trompe pas... J'ai vraiment du mal à trouver...
Ceci n'est pas un algorithme de tri, bien au contraire: il fait un mélange aléatoire!
17/02/2016, 14h56
TomelD98

Effectivement ce n'est absolument pas ce qu'il me faut... Mais je ne comprend pas comment je peux faire ça en code... J'ai juste la théorie et c'est tout. C'est un peu embarassant :(
17/02/2016, 15h00
Matt_Houston

Est-ce que ton système fonctionne déjà sur le papier ?
17/02/2016, 15h21
TomelD98

C'est à dire ? Tout ce que je sais c'est que le programme dois trier les lettres de ma phrase\mon texte dans l'ordre alphabétique et qu'ensuite je dois lui demander de supprimer les doublons. C'est comparer a chaque fois les valeurs de chaque lettre (leur adresse donc) et les mettre dans l'ordre mais mon soucis c'est que je sais en français ce que je dois faire mais le retraduire en code ben je bloque sévèrement... Je n'ai jamais fais d'exercices sur la comparaison de valeurs et tout donc voilà... En gros je ne connais que certaines fonctions de base (comme printf, scanf) ainsi que les boucles de base (for, while, if...). Il faut savoir que je ne suis qu'un parfait débutant qui n'a jamais fais de pratique... :?
17/02/2016, 15h24
Médinoc

https://fr.wikipedia.org/wiki/Algorithme_de_tri
17/02/2016, 15h31
ternel

C'est quoi le résultat de ton programme sur ce message?

Eh bien en gros, tout ce que j'ai c'est ceci:
Code:

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 #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 main(int argc, char *argv[]) { char phD[100]; printf("Bonjour, veuillez rentrer la phrase a crypter:\n"); fgets(phD,sizeof phD,stdin); // fget("%s", phraseDepart); nett(phD); printf("Votre phrase est: %s\n",phD); for(phD ) return 0; }
Il faut savoir que la fonction fgets ne vient pas de moi ni le prototype de la fonction qui supprime le \0 à la fin du tableau... C'est mon professeur guide qui m'a dit d'utiliser ça alors que je suis sûr que je n'ai jamais vu cette fonction dans mon cours...

17/02/2016, 15h46
Matt_Houston

Je pense que ce qu'on cherche tous à savoir, c'est ce que tu attends de ton programme en entrée et en sortie. Tu as un cas d'utilisation, un exemple ?
17/02/2016, 15h53
TomelD98

D'accord j'ai compris, je vous donne un exemple:
En fait, je souhaite créer un programme de cryptage et expliquer les étapes pour le concevoir et le présenter lors de mon oral. Du coup le programme fonctionnerait de la manière suivante:
Je rentre la phrase suivante:"Je m'appelle Barry".
Le programme devra trier toutes les lettres dans l'ordre alphabétique et supprimer les doublons de sorte que mon message "secret" soit incompréhensible pour quelqu'un d'autre. Après le professeur qui me guide à pensé remettre les lettres dans un autre ordre mais il me le demandera seulement lorsque je lui aurai montrer comment trier les lettres dans l'ordre alphabétique et supprimer les doublons...
Mon but est de présenter comment on code un programme de cryptage et l'utiliser devant eux pour leur montrer le résultat à la fin.
17/02/2016, 16h08
ternel
Donc, quel est la phrase produite par le programme si je lui donne "Rien n'est impossible."
Et la question suivante sera: comment as-tu déterminé cette réponse?

Prenons le problème par le début:

comment tries-tu...
- ab
- ba
- aba
- aba
- ababbaaba
- abc
- cab
- Rien
- AaaA
- Rien n'est impossible.
17/02/2016, 16h08
Matt_Houston

Ok, donc je te repose la question : comment comptes-tu déchiffrer le message ?

Si j'ai bien compris la procédure que tu as en tête, je vois pas comment récupérer l'information d'origine. Ce n'est pas du chiffrement, c'est du hachage. ;)
17/02/2016, 16h15
TomelD98

@leternel: La phrase produite serait donc: BEILMNOPRST. J'ai déterminé cette réponse en classant toutes les lettres dans l'ordre alphabétique et j'ai supprimer les doublons.
@Matt_Houston: Eh bien... C'est une très bonne réponse puisque je ne sais pas y répondre... Vous avez raison je ne saurais pas récupérer l'information d'origine. C'est quoi le hachage alors ?
17/02/2016, 16h23
ternel

Le hachage (hashing) constiste à calculer un nombre caractéristique du texte.
Une bonne formule de hash possède la propriété que deux textes peu différents produisent des nombres très différents.
Deux textes sont forcément différents s'ils n'ont pas le même hash.

Un tel algorithme est le MD5. On peut aussi parler de CRC.

Et contrairement au chiffrage, ce n'est pas une opération réversible.
17/02/2016, 16h27
TomelD98

D'accord, donc il faut croire que mon professeur cherche simplement à me faire faire un simple programme de cryptage sans décryptage alors... Donc comment est-ce que je pourrais le retraduire en code ? :calim2:
17/02/2016, 16h39
ternel

Et si tu lui demandais?
17/02/2016, 16h44
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...
17/02/2016, 16h50
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).

 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:

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.
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).
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).
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.
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.
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:

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:

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

Suite

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

Code:

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:

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 ?

27/02/2016, 12h49
Médinoc

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

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.

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

Code:

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à :D

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:

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 :D

02/03/2016, 09h56
Matt_Houston
Code:

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 ?

Code:

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...

03/03/2016, 08h29
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.
05/03/2016, 20h36
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