décodage de chaines en base64

Version imprimable

Bonjour,

Je souhaite créer un programme en C qui déchiffre des chaines de caractère codées en base64.

Il y a juste le décodage qui m'intéresse.

Après mettre pas mal renseigné sur le net, j'ai pondu 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
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
 
#include <malloc.h>
 
#include <stdio.h>
 
#include <malloc.h>
 
 
 
/*
 
** Décodage d'une chaine de caracteres
 
*/
 
 
char * base64_pdecode(const char *, char *);
 
 
 
/*
 
** Procédure de décodage
 
*/
 
 
 
void base64_decoding_process(B64_CHUNK *);
 
 
 
/*
 
** Fonction permettant la vérification des bons caracteres
 
*/
 
 
void base64_chr_real(char *);
 
 
typedef struct b64_chunk
 
{
 
/*
 
** longeur de la chaine, comme on aura besoin d'aller de 0 a 3, on utilise un
 
** unsigned char plutot qu'un unsigned int pour gagner 3 octets sur un une
 
** plateforme 32 bits.
 
*/
 
 
    int len;
 
 
/*
 
** Buffers d'encodage et de décodage.
 
*/
 
 
    char enc[4];
 
    char dec[3];
 
}B64_CHUNK;
 
 
 
char * base64_pdecode(const char *in, char *out)
 
{
 
    int i, o;
 
    B64_CHUNK *chunk;
 
 
 
    chunk = malloc(sizeof(*chunk));
 
 
 
    for (i = 0, o = 0; in[i];)
 
    {
 
        for (chunk->len = 0; chunk->len < 4 && in[i];)
 
        {
 
            chunk->enc[chunk->len] = in[i++];
 
 
 
            base64_chr_real(chunk->enc + chunk->len);
 
 
 
            if (chunk->enc[chunk->len] >= 0)
 
            {
 
                chunk->len++;
 
            }
 
        }
 
 
 
        base64_decoding_process(chunk);
 
 
 
        for (chunk->len = 0; chunk->len < 3 && chunk->dec[chunk->len];)
 
        {
 
            out[o++] = chunk->dec[chunk->len++];
 
        }
 
    }
 
    out[o] = '\0';
 
 
 
    free(chunk);
    return out;
 
}
 
 
main(){
 
	char *test = NULL;
	char *entree = "bgdshtbghtrz";
 
	base64_pdecode(entree, test);
 
	printf("Le mot déchiffré donne : %s \n\n",test);
 
}

Mais le compilateur (gcc) me donne cette erreur :

Code:

1
2
 
erreur: expected ‘)’ before ‘*’ token

à la ligne :

Code:

1
2
 
void base64_decoding_process(B64_CHUNK *);

Je ne comprend pas. Si quelqu'un comprend, je suis prenneur !!!

Merci d'avance

10/07/2009, 08h57
Mac LAK

Normal : vu tes #include, il ne connait tout simplement pas le type "B64_CHUNK"... Il te manque soit un typedef (si tu le refais à la main), soit l'include adéquat, mais AVANT cette déclaration de prototype.

D'ailleurs, tu as deux "#include <malloc.h>" dans ton code...
10/07/2009, 09h35
charlix

Bonjour,

merci pour ta réponse, je recherche les librairies manquantes.
10/07/2009, 09h49
Mac LAK

Ben tu définis toi-même B64_CHUNK, mais APRÈS la déclaration de prototype, ce qui n'est pas bon.

Soit tu mets cette déclaration dans un .H séparé, soit tu la "remontes" dans le fichier, mais pas besoin de librairies supplémentaires.

J'ai trouvé une fonction directement sur internet qui fait ca très bien. Pour ceux que cela intéresse, voici ce code:

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
 
int decode64 (char *buffer)
{
    int  car;      // caractère du fichier
 
    char valcar [4];   // valeur après conversion des caractères
    int  i;            // compteur
 
    int  posorig;  // position dans la ligne passée en paramètre
    int  posdest;  // position dans la nouvelle ligne générée
 
 
 
    // initialisations
    posorig = 0;
    posdest = 0;
 
 
    // tant que non fin de ligne
    while (buffer [posorig] > ' ' && buffer [posorig] != '=')
 
    {
        // décoder la valeur de 4 caractères
        for (i = 0; i < 4 && buffer [posorig] != '='; i++)
 
        {
            // récupérer un caractère dans la ligne
            car = buffer [posorig++];
 
 
            // décoder ce caractère
            if ('A' <= car && car <= 'Z')
 
                valcar [i] = car - 'A';
            else if ('a' <= car && car <= 'z')
 
                valcar [i] = car + 26 - 'a';
            else if ('0' <= car && car <= '9')
 
                valcar [i] = car + 52 - '0';
            else if (car == '+')
 
                valcar [i] = 62;
            else if (car == '/')
 
                valcar [i] = 63;
        }
 
        // recopier les caractères correspondants dans le buffer
 
        buffer [posdest++] = (valcar [0] << 2) | (valcar [1] >> 4);
 
 
        // sauf si indicateur de fin de message
        if (i > 2)
 
        {
            buffer [posdest++] = (valcar [1] << 4) | (valcar [2] >> 2);
 
 
            if (i > 3)
                buffer [posdest++] = (valcar [2] << 6) | (valcar [3]);
 
        }
    }
 
    // terminer le buffer
    buffer [posdest] = '\0';
 
 
    // et retourner le nombre de caractères obtenus
    return (posdest);
}

Voilà.

Tchao

charlix