Algorithme de chiffrement utilisant césar

Version imprimable

Bonjour, je cherche a mettre en place un algorithme de chiffrement utilisant césar mais à la compilation j'ai un probleme que je n'arrive pas a dterminer....merci d'avance pour votre aide !
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 ///////////////////////////////////////// ///// chiffrement utilisant cesar ////// /////////////////////////////////////// char* cesar_crypt(int decallage, char * texte) { int i; int c; char* crypt; int cp = decallage; size_t sz = strlen(texte) + 1; crypt = malloc(sz); for(i=0; i < sz ; i++) { c = texte[i]; c = (char(int((c-'a') + (cp-'a'))%26) + 'a'); crypt[i] = c; } return crypt; free(crypt); }

quelque petite remarque :

Code:

1
2
3
4
5
6
7
 
int main()
{
    ...
    return crypt;
    free(crypt);
}

free(crypt); ne sera jamais atteint.

Il y a beaucoup de chose bizarre dans ce code.

Code:

1
2
 
int cp = decallage;

Inutile de declarer une autre variable pour la valeur de decallage; Tu peux directement utilisé la variable "decallage".

Code:

1
2
3
 
        c = texte[i];
        c = (char(int((c-'a') + (decallage-'a'))%26) + 'a');

Cela est bizarre, tu fais deux affectation coup sur coup:

Code:

1
2
 
        c = (char(int((texte[i]-'a') + (decallage-'a'))%26) + 'a');

Cela fait la meme chose.

Bref, il y a beaucoup de chose pour lequel je ne vois pas ce que tu veux faire.
Le code me semble hasardeux.
Voici ce que je te propose :

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void cesar_crypt (int decallage, char *texte)
{
    /* Explication de la conversion pour un caractere minuscule 
    
        texte[i] - 'a'                           -> on recupere un nombre represantante le caractere contenue 
                                                    dans texte[i] (0=a, 1=b, ...)
        (texte[i] - 'a') + decallage             -> on lui applique le decallage
        ((texte[i] - 'a') + decallage)%26        -> on fait %26 pour revenir au debut si on a depasser 'z'
        'a' + ((texte[i] - 'a') + decallage)%26  -> on retrouve le bon caractere en ajoutant 'a'
    */
 
 
 
    int i;
    for(i=0 ; i<strlen(texte) ; i++)
        /* Si le caractere est une minuscule */
        if ('a' <= texte[i] && texte[i] <= 'z')
            texte[i] = 'a' + ((texte[i] - 'a') + decallage)%26;
        else
            /* Si le caractere est une majuscule */
            if ('A' <= texte[i] && texte[i] <= 'Z')
                texte[i] = 'A' + ((texte[i] - 'A') + decallage)%26;
            else
                /* Si le caractere est un chiffre */
                if ('0' <= texte[i] && texte[i] <= '9')
                    texte[i] = '0' + ((texte[i] - '0') + decallage)%10;
                else
                {
                    /* Caractere qui n'est ni une lettre, ni un chiffre.
                        A toi de voir les actions a faire ici  */
                }
}
 
 
int main()
{
    char Test[] = "aBcDeF";
 
    cesar_crypt(2, Test);
 
    printf("%s\n\n", Test);
 
    return EXIT_SUCCESS;
}

30/10/2009, 17h13
diogene

Citation:

Envoyé par KaNDeL

Bonjour, je cherche a mettre en place un algorithme de chiffrement utilisant césar mais à la compilation j'ai un probleme que je n'arrive pas a dterminer....

Le problème est sur cette ligne :

Code:

c = (char(int((c-'a') + (cp-'a'))%26) + 'a');

Je suppose que ces char et int ont pour objectif de faire un transtypage. En C le transtypage se fait par (nouveau_type) valeur pas par nouveau_type(valeur).

D'ailleurs, le transtypage en int est inutile : c, cp, 'a' et 26 sont des int. Cette expression est déjà un int.

Code:

c = (char) ((c-'a' + cp-'a')%26 + 'a');

A noter que
- Le test sur la validité du malloc est absent
- La chaîne crypt n'a pas de zéro terminal
30/10/2009, 22h28
SofEvans

Citation:

Envoyé par diogene

D'ailleurs, le transtypage en int est inutile : c, cp, 'a' et 26 sont des int. Cette expression est déjà un int.

Code:

c = (char) ((c-'a' + cp-'a')%26 + 'a');

Ce qui est bizarre, c'est que c est un int, alors pourquoi faire un transtipage en char ?
30/10/2009, 23h38
Sve@r
Citation:
Envoyé par KaNDeL

Code:

1 2 3 4 5 6 7 char* cesar_crypt(int decallage, char * texte) { ... return crypt; free(crypt); }
Déjà le free ne se fera jamais. Mais même si les lignes étaient inversées, alors ce serait pire que tout. Tu renverrais une zone libérée (donc contenu perdu) alors que justement le contenu (la chaine cryptée) est utilisé par l'appelant. Crash assuré

D'une façon générale, quand on veut créer une chaine, alors
1) soit on passe à la fonction la zone destinée à recevoir la chaine
2) soit on alloue et on remplit la chaine dans la fonction puis on renvoie le pointeur alloué. Charge alors à l'appelant de libérer ledit pointeur quand il n'en a plus besoin. C'est par exemple le cas de strdup().
31/10/2009, 12h38
diogene
SofEvans :

Citation:

Ce qui est bizarre, c'est que c est un int, alors pourquoi faire un transtipage en char ?

Ici, ça ne sert à rien. Mais dans le cas général, la conversion int->char->int peut n'être pas neutre.
Par exemple, pour un char de 8 bits, le code suivant :
Code:

1 2 int i= 256; int j = (char) i;
donnera pour j une valeur différente de celle de i
31/10/2009, 12h55
SofEvans

J'y crois pas :aie:

Effectivement, un char va de -128 à 127.

Si on fait on trantype par un char, un modulo implicite est fait, c'est fourbe !

Comme quoi, caster pour faire disparaitre un warning est dangereux, surtout si les deux type n'ont pas le meme nombre d'octet.
31/10/2009, 13h52
gl
Citation:

Envoyé par SofEvans

Effectivement, un char va de -128 à 127.

Juste une petite précision, la plage garantie pour un signed char est -127 (et non -128) à 127.
Cependant :
- la plage réelle sur une implémentation peut être plus étendue (c'est effectivement souvent -128 à 127, mais ça peut être plus important).
- contrairement aux autres types entiers, char peut être signé ou non en fonction des environnements.
Dans tous les cas, il faut voir dans limits.h les valeurs exactes correspondantes à l'environnement utilisé.
31/10/2009, 14h29
diogene

SofEvans :

Citation:

Si on fait on trantype par un char, un modulo implicite est fait, c'est fourbe !

C'est pire que ça : le résultat peut dépendre de l'implémentation si char est signé. Heureusement, si char équivaut à unsigned char, le résultat est indépendant de l'implémentation (opération du type modulo).
31/10/2009, 15h23
Médinoc

mais le fait que le char soit signé ou non dépend justement de l'implémentation, non?

Il me semble qu'en fait, pour un char tout court, la seule plage garantie est 0-127. Après, il faut utiliser explicitement un signed char ou unsigned char...

D'ailleurs, en C++, du moins sous Visual, c'est considéré comme trois types différents.
31/10/2009, 18h24
diogene

Citation:

mais le fait que le char soit signé ou non dépend justement de l'implémentation, non?

Oui et je me suis mal exprimé.
Je voulais dire que sur les implémentations où char était unsigned le résultat obtenu était le même sur toutes ces implémentations alors que sur les implémentations où char était signed ce n'était pas forcément le cas.

Citation:

Il me semble qu'en fait, pour un char tout court, la seule plage garantie est 0-127. Après, il faut utiliser explicitement un signed char ou unsigned char...

D'ailleurs, en C++, du moins sous Visual, c'est considéré comme trois types différents

Oui, ce sont trois types différents, mais la norme dit :

Citation:

The implementation shall define char to have the same range, representation, and behavior as either signed char or unsigned char

Je crois d'ailleurs que souvent une option du compilateur permet de choisir.