Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C Discussion :

Problème de cryptanalyse


Sujet :

C

  1. #1
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2019
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 19
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : octobre 2019
    Messages : 5
    Points : 2
    Points
    2
    Par défaut Problème de cryptanalyse
    Bonjour, je dois faire un devoir sur la cryptanalyse mais je suis bloquer à la fin. On me demande de trouver toutes les permutations possibles d'une clé dont on connait les caractères et de les tester jusqu'a trouver celle qui nous fournit le bon message final (grace a un pattern donné et une autre fonction).
    Pour les permutations j'ai reussi à faire une fonction potable mais comment dois je faire pour tester toute les valeurs?
    Voici ce que j'ai fait pour l'instant.
    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
     
    char *permut(char*a,int l,int r)
    {
        if (l==r)
            {return a;
            }
        else
        {
            int i;
            for(i=0;i<=r;i++)
            {
                swap((a+1),(a+i));
                permut(a,l+1,r);
                swap((a+1),(a+i));
                return a;
            }
        }
    }
    char *test_all_key_permutations(char *encmessage, char *pattern, char *key) {
    int keylenght = strlen(key);
    char tab = decrypt(encmessage,key);
    while (search_pattern(pattern,tab)== (-1))
    {
        key = permut(key,0,keylenght);
        tab = decrypt(encmessage,key);
    }
    return key;
    }

  2. #2
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    7 567
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 7 567
    Points : 21 556
    Points
    21 556
    Billets dans le blog
    1
    Par défaut
    Bonjour

    Il faut que ta fonction "permut" génère toutes les permutations oui mais aussi qu'elle les stocke quelque part (tableau, fichier, etc) pour qu'ensuite tu puisses les récupérer et les tester. Pour l'instant elle ne fait que permuter en RAM. Dommage, d'autres langages comme Python offrent les générateurs ce qui t'aurait permis de faire un truc comme for k in permut(...) mais pas le C.

    Et sinon ça te dirait pas de tabuler et structurer ton code un peu plus proprement ??? Je veux dire que si ça t'intéresse pas plus que ça d'écrire clair et lisible...
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  3. #3
    Expert éminent sénior
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    septembre 2005
    Messages
    27 046
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2005
    Messages : 27 046
    Points : 40 201
    Points
    40 201
    Par défaut
    L'autre solution pour effectuer une action sur chaque permutation (ne serait-ce que les afficher et les compter) serait une fonction callback passée à permut().

    PS: Utilises-tu un algorithme de permutations connu?
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  4. #4
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2019
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 19
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : octobre 2019
    Messages : 5
    Points : 2
    Points
    2
    Par défaut
    Bonjour,

    J'aimerai aussi pouvoir écrire mon code plus lisiblement mais vu que je ne vois pas comment opérer je nage à contre courant et du coup c'est moche en plus s'être faux.

    Pour avoir plus facile, je vais déjà vous fournir ce que j'ai fait jusqu'à présent.


    Voila la fonction main qu'on me fournit:

    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
     
    #include <stdio.h>
    #include <stdlib.h>
    #include "devoir1.h"
     
    int main() {
     
      char truekey[] = "macle";
      char permkey[] = "acelm";
      char pattern[] = "analyse";
      char message[] = "lacryptanalyseestlatechniquequiconsisteadeduireuntexteenclairduntextechiffresanspossederlacledechiffrement";
     
      printf("CHIFFREMENT\n----------\n");
      char *encryptedmess = encrypt(message, truekey);
      printf("Message original:\n%s\n", message);
      printf("Message chiffré:\n%s\n", encryptedmess);
     
      printf("\nDECHIFFREMENT\n----------\n");
      char *decmessage = decrypt(encryptedmess, truekey);
      printf("Message déchiffré:\n%s\n",decmessage);
      free(decmessage);
     
      /* generate and test all keys */
      printf("\nCRYPTANALYSE\n----------------\n");
      char *foundkey = test_all_key_permutations(encryptedmess, pattern, permkey);
      if (foundkey) {
        printf("Clé trouvée = %s\n", foundkey);
        char *decmessage = decrypt(encryptedmess, foundkey);
        printf("Message déchiffrés (contenant le pattern %s):\n%s\n", pattern, decmessage);
        free(decmessage);
      } else
        printf("Clé non trouvée\n");
     
      exit(0);
     
    }
    Et voila tout ce que j'ai fait jusqu'à présent :

    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
    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
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    #include <string.h>
    #include "devoir1.h"
    
    char *lettres = "abcdefghijklmnopqrstuvwxz";
    
    char *encrypt(char *message, char *key) {
      int keylength = strlen(key);
      int messlength = strlen(message);
      int nrows = ceil(messlength*1.0/keylength);
    
      /* allocation d'un tableau pour stocker le message déchiffré */
      char *tab = malloc((nrows*keylength+1)*sizeof(char));
    
      if (!tab) {
        printf("Erreur d'allocation de mémoire dans encrypt\n");
        exit(-1);
      }
    
      /* remplissage du vecteur selon la règle */
      int i;
      for (i = 0; i < messlength; i++)
        tab[(i % keylength)*nrows+(i/keylength)] = message[i];
    
      /* remplissage de la fin aléatoirement */
      for (; i < nrows*keylength; i++)
        tab[(i % keylength)*nrows+(i/keylength)] = lettres[rand() % 26];
      tab[i] = '\0';
    
      /* rotation des colonnes selon la clé */
      for (i = 0; i < keylength; i++) {
        rotate(tab+i*nrows, (key[i]-'m'), nrows);
      }
    
      return tab;
    }
    
    
    int search_pattern(char *pattern, char *message) {
    int n,i,j;
    int messlenght = strlen(message);
    int pattlenght = strlen(pattern);
    for (i=0,j=0;i<messlenght && j<pattlenght;i++)
      {
        if(message[i]==pattern[j])
        {
            if(j==0)
            {n=i;
            }
            j=j+1;
        }
        if(message[i]!=pattern[j])
            {j=0;
             n=0;
            }
      }
    if (j==pattlenght) /* Si la clé à été trouvée alors j aura été incrémenté jusqu'à ce que
                          j soit égal à la taille du pattern. */
        return n; /* On retourne l'emplacement du message où j vaut 0 */
    else
      return -1;
    }
    
    char *decrypt(char *message, char *key) {
      int keylength = strlen(key);
      int messlength = strlen(message);
      int nrows = ceil(messlength*1.0/keylength);
    
      /* allocation d'un tableau pour stocker le message chiffré*/
    
      char *tab = malloc((nrows*keylength+1)*sizeof(char));
    
      /* rotation des colonnes selon la clé */
    
      int i;
      for (i = 0; i < keylength; i++) {
        rotate(message+i*nrows, (-1)*(key[i]-'m'), nrows);
      }
    
      /* On remet les les caractère dans l'ordre selon la règle */
    
      for (i = 0; i < messlength; i++)
      {
          tab[i] = message[(i % keylength)*nrows+(i/keylength)];
      }
      return tab;
    }
    
    char *test_all_key_permutations(char *encmessage, char *pattern, char *key) {
    int keylenght = strlen(key);
    char tab = decrypt(encmessage,key);
    while (search_pattern(pattern,tab)== (-1))
    {
        key = permut(key,0,keylenght);
        tab = decrypt(encmessage,key);
    }
    return key;
    }
    
    void swap(char *a, char *b){
    char c;
    c = *a;
    *a = *b;
    *b = c;
    }
    
    char *permut(char*a,int l,int r)
    {
        if (l==r)
            {return a;
            }
        else
        {
            int i;
            for(i=0;i<=r;i++)
            {
                swap((a+1),(a+i));
                permut(a,l+1,r);
                swap((a+1),(a+i));
            }
        }
    }
    
    void rotate(char *arr, int d, int n) {
    char *T = malloc(n*sizeof(char));
    int i;
    while (d<=(-1)*n || d>=n)
        {
            /* Si le déplacement demander est plus grand que la taille de la chaine
            alors on peut remplacer ce deplacement par le reste de ca division par la taille
            de la chaine */
            d = d%n;
        }
    for(i = 0; i<n; i++)
    {
        T[i]= arr[i];
    }
    for(i=0; i<n;i++)
    {
        if ((i-d)<0) /* Cas ou le déplacement nous fait sortir des limites par la gauche */
        {
            arr[i] = T[n+i-d];
        }
        if ((i-d)>(n-1)) /* Cas où le deplacement nous fait sortir des limites par la droite */
        {
            arr[i] = T[i-d-n];
        }
        if ((i-d)>=0 && (i-d)<=n-1) /* Cas de base */
        {
            arr[i] = T[i-d];
        }
    }
    free(T);
    }

  5. #5
    Expert éminent sénior
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    septembre 2005
    Messages
    27 046
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2005
    Messages : 27 046
    Points : 40 201
    Points
    40 201
    Par défaut
    permut() fait déjà toutes les permutations, selon ce qui ressemble à l'algorithme de permutations de Heap.
    Ce dont tu as besoin, c'est de faire une action à chaque permutation:
    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
    /*
    https://www.developpez.net/forums/d2013339/c-cpp/c/debuter/probleme-cryptanalyse/#post11180349
    */
    #include <stdio.h>
    #include <string.h>
    typedef void (*permutation_callback)(void* context, char* currentValue);
     
    void swap(char *pa, char *pb)
    {
    	char t = *pa;
    	*pa = *pb;
    	*pb = t;
    }
     
    void permut(char*a, int l, int r, permutation_callback pCallback, void* context)
    {
    	if (l==r)
    	{
    		pCallback(context, a);
    		return;
    	}
    	else
    	{
    		int i;
    		for(i=0;i<=r;i++)
    		{
    			swap((a+1), (a+i));
    			permut(a, l+1, r, pCallback, context);
    			swap((a+1), (a+i));
    		}
    	}
    }
     
    void affich(void* context, char* currentValue)
    {
    	printf("Permutation: %s\n", currentValue);
    }
     
    int main(void)
    {
    	char key[] = "abc";
    	permut(key, 0, strlen(key)-1, affich, NULL);
    	return 0;
    }
    Avec ça, il te suffit de remplacer affich() par ton traitement...
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  6. #6
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    7 567
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 7 567
    Points : 21 556
    Points
    21 556
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par Médinoc Voir le message
    L'autre solution pour effectuer une action sur chaque permutation (ne serait-ce que les afficher et les compter) serait une fonction callback passée à permut().
    J'y avais pas pensé (trop longtemps quitté le C moi). Mais ce ne serait pas "au delà" des connaissances du PO qui semble débuter ???

    Citation Envoyé par ZeSkyrex Voir le message
    J'aimerai aussi pouvoir écrire mon code plus lisiblement mais vu que je ne vois pas comment opérer je nage à contre courant et du coup c'est moche en plus s'être faux.
    Pas compliqué de rajouter une tabulation de plus à chaque "if" "for" "while". Mais c'est sûr, quand on a déjà le truc en tête, c'est plus facile. Hé oui, la prog ça passe aussi par un papier et un crayon...

    Citation Envoyé par ZeSkyrex Voir le message
    Pour avoir plus facile, je vais déjà vous fournir ce que j'ai fait jusqu'à présent.
    Pas terrible. Us et abus de variables globales, sortie sauvage si malloc échoue, char tab = decrypt(encmessage,key) où tu stockes allègement un pointeur dans un char, et ce int nrows = ceil(messlength*1.0/keylength); (multiplier par 1 ) Si tu veux un double ben tu as le cast (int nrows = ceil((double)messlength/keylength);) mais surtout tu peux faire preuve d'"a propos" mathématique avec les divisions entières => int nrows = (messlength-1)/keylength + 1; !!!

    Medinoc propose une solution basée sur les pointeurs de fonction, la fonction "permut()" recevant, lors de son appel, un pointeur sur l'action à faire à chaque permutation (principe de "qsort").
    Si c'est pas trop "hors niveau" c'est ce qu'il y a de mieux.

    Sinon moi je vois ceci: char *foundkey = test_all_key_permutations(encryptedmess, pattern, permkey);. De mon point de vue, c'est cette fonction "test_all_key_permutations" qui doit faire les permutations, puis (pour chaque permutation) tenter un déchiffrement et regarder si le pattern est trouvé (enfin elle a aussi le droit de déléguer à une sous-fonction "permut" mais alors "permut" doit recevoir tout ce qu'il faut pour tester chaque permutation).
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  7. #7
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2019
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 19
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : octobre 2019
    Messages : 5
    Points : 2
    Points
    2
    Par défaut
    Je pense que le code proposé est trop compliqué pour moi pour l'instant ... Et puis j'aimerai surtout ne pas juste copier un code, si je le comprend pas il n'y a pas d’intérêt. Du coup j'ai changé mes fonctions et j'arrive à ç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
     
    char *permut(char *encmessage,char *pattern,char*key,int l,int r)
    {
        int keylength = strlen(key);
        int messlength = strlen(encmessage);
        int nrows = ceil(messlength*1.0/keylength);
        char *tab = malloc((nrows*keylength+1)*sizeof(char));
        if (l==r)
            {
             tab = decrypt(encmessage,key);
             if (search_pattern(pattern,tab)!=-1)
             {
                 return key;
             }
            }
        else
        {
            int i;
            for(i=0;i<=r;i++)
            {
                swap((key+1),(key+i));
                permut(encmessage,pattern,key,l+1,r);
                swap((key+1),(key+i));
     
            }
        }
    }
    char *test_all_key_permutations(char *encmessage, char *pattern, char *key) {
    int r = strlen(key);
    char *truekey = permut(encmessage,pattern,key,0,r);
    return truekey;
    }
    Mais quand je compile, ca me renvoie ça et je ne comprend pas vraiment ce que ça veut dire (pour la partie cryptanalyse)...
    Nom : Capture.PNG
Affichages : 45
Taille : 36,4 Ko

  8. #8
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    7 567
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 7 567
    Points : 21 556
    Points
    21 556
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par ZeSkyrex Voir le message
    Mais quand je compile, ca me renvoie ça et je ne comprend pas vraiment ce que ça veut dire (pour la partie cryptanalyse)...
    Ca te dit
    • les fonctions swap() et permut() n'ont pas de prototype
    • la variable "nrows" qui est remplie n'est pas utilisée
    • la fonction permut(), qui n'est pas de type "void" (donc qui est sensée renvoyer un truc), se termine sans rien renvoyer
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

  9. #9
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2019
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 19
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : octobre 2019
    Messages : 5
    Points : 2
    Points
    2
    Par défaut
    Ça je comprends mais pour c’est pour
    Floating point exeption (core dumped)
    que je ne vois pas quel est le problème.

  10. #10
    Expert éminent sénior
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    septembre 2005
    Messages
    27 046
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2005
    Messages : 27 046
    Points : 40 201
    Points
    40 201
    Par défaut
    Dans tout le code que tu as posté, je ne vois qu'une seule opération en virgule flottante, c'est celle-ci:
    int nrows = ceil(messlength*1.0/keylength);
    Si keylength est zéro, il est possible que la division par zéro cause la floating-point exception, ou qu'elle retourne l'infini ou NaN, et je ne suis pas sûr que ceil() l'accepte.
    Donc, assure-toi que keylength ne peut jamais être zéro.
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  11. #11
    Candidat au Club
    Homme Profil pro
    Étudiant
    Inscrit en
    octobre 2019
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 19
    Localisation : Belgique

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : octobre 2019
    Messages : 5
    Points : 2
    Points
    2
    Par défaut
    Bon j'arrive enfin à tester toutes les permutations et trouver la bonne mais j'ai une erreur de segmentation au moment de renvoyer la clé vers la fonction test_all_key_permutation.

    D'où est ce que ça peut venir?

    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
     
    static char *permut(char*key,int l,int r,char*mess,char*pattern)
    {
       int i;
        if (l==r)
            {
               char*tab = decrypt(mess,key);
               int m = search_pattern(pattern,tab);
               if (m!=-1)
               {
                   return key;
               }
            }
        else
        {
            for(i=l;i<=r;i++)
            {
                swap((key+l),(key+i));
                permut(key,l+1,r,mess,pattern);
                swap((key+l),(key+i));
            }
        }
    }
    char *test_all_key_permutations(char *encmessage, char *pattern, char *key) {
     
    int keylength = strlen(key);
    char *tkey = permut(key,0,keylength-1,encmessage,pattern);
    return tkey;
    }

  12. #12
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    7 567
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 7 567
    Points : 21 556
    Points
    21 556
    Billets dans le blog
    1
    Par défaut
    Sans déconner, char*key,int l,int r,char*mess,char*pattern. Tu es sûr de ne pas pouvoir tasser encore un peu ??? Peut-être enlever l'espace entre "int" et "l"...

    Citation Envoyé par ZeSkyrex Voir le message
    D'où est ce que ça peut venir?
    Peut-être du fait que ta fonction "permut()" ne renvoie rien... (ce que te dit d'ailleurs le compilateur). Donc l'appelant récupère un truc au hasard. Sûr que ça ne va pas marcher trop bien s'il s'en sert ensuite comme clef...
    Déjà si la clef ne matche pas, il faudrait renvoyer une valeur particulière pour prévenir l'appelant. De plus, quand tu n'es pas au bout de la récursivité il te faut alors récupérer le retour des appels inférieurs pour les remonter aux instances supérieures (et donc là utiliser la valeur particulière).
    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
    static char *permut(char *key, int l, int r, char *mess, char *pattern)
    {
    	if (l==r)
    		return search_pattern(pattern, decrypt(mess, key)) != -1 ?key :NULL;
     
    	int i;
    	for(i=l; i <= r; i++) {
    		char *c;
    		swap(key+l, key+i);
    		if ((c=permut(key, l+1, r, mess, pattern)) != NULL) return c;
    		swap(key+l, key+i);
    	}
    	return NULL;
    }
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

Discussions similaires

  1. Problème d'installation oracle 8.1.7 sous NT
    Par Anonymous dans le forum Installation
    Réponses: 7
    Dernier message: 02/08/2002, 15h18
  2. Problème d'impression
    Par IngBen dans le forum C++Builder
    Réponses: 7
    Dernier message: 22/05/2002, 12h37
  3. Problème avec la mémoire virtuelle
    Par Anonymous dans le forum CORBA
    Réponses: 13
    Dernier message: 16/04/2002, 17h10
  4. Réponses: 6
    Dernier message: 25/03/2002, 22h11

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo