Comment convertir une valeur char* en hexa

Version imprimable

Bonjour,

J'explique mon problème qui est très simple :

Je souhaite à partir d'une chaine codé en base64 récupérer sa valeur décoder en Hexa (correspondance table ASCII).

Avec le code suivant (je ne mets pas tout, juste ce qu'il faut) :

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
 
int decode_base64 (char *buffer)
{
    int  car;
    char valcar [4];
    int  i;
    int  posorig;
    int  posdest;
 
    posorig = 0;
    posdest = 0;
    while (buffer [posorig] > ' ' && buffer [posorig] != '=')
    {
        for (i = 0; i < 4 && buffer [posorig] != '='; i++)
        {
            car = buffer [posorig++];
            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;
            }
        buffer [posdest++] = (valcar [0] << 2) | (valcar [1] >> 4);
        if (i > 2)
        {
            buffer [posdest++] = (valcar [1] << 4) | (valcar [2] >> 2);
            if (i > 3)
                buffer [posdest++] = (valcar [2] << 6) | (valcar [3]);
        }
    }
    buffer [posdest] = '\0';
    return (posdest);
}

J'envoie à ma fonction une chaine char* : MQ0w

Je voudrai qu'elle me retourne : 8474 30

Pour le moment, j'obtiens l'équivalent de l'hexa mais en char dans la variable buffer, ce qui donne, et c'est normal, un résultat non affichable.

Merci pour votre aide

27/10/2015, 08h34
ternel

C'est parce que char sert à représenter des caractères.

Les types ayant un sens "entier" sont signed char et unsigned char. Ce dernier étant probablement celui que tu veux.

Par ailleurs, il faudrait retourner dans la doc, mais je crois que le std::hex dans #include <iomanip> sert exactement à cela.

Bonjour,

Merci pour ta réponse.

Effectivement, j'ai pu résoudre une partie mon problème en passant en entré de la fonction : unsigned char* .

Avec l'ajout du code ci-dessous, j'affiche exactement ce que je veux :
Code:

1 2 3 4 5 6 7 8 9 for (j = 0; j < posdest; j++) { unsigned int num; num = buffer[j]; if ((num == 0) || (num <= 15)) printf("0%X", num); else printf("%X", num); }
L'affichage est bon mais je souhaite avoir le résultat en valeur de retour de ma fonction.

Je vais regarder du coté de la doc que tu indiques.

27/10/2015, 14h05
ternel

pour avoir un retour, essaye sprintf, qui écrit dans un tableau (ou malloc) de char

J'ai écrit le code suivant, il fonctionne mais j'ai un peu de mal avec la taille du malloc.

J'ai mis 1000000 un peu au hasard...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
    char* result;
    char* result_in_string;
 
    result_in_string = malloc(sizeof(*result_in_string) * (1000000 + 1));
    for (j = 0; j < posdest; j++)
        {
            result = malloc((3) * sizeof(*result));
            num = buffer[j];
            if ((num == 0) || (num <= 15))
                sprintf(result, "0%X", num);
            else
                sprintf(result, "%X", num);
            printf("%s\n", result);
            result_in_string = strcat(result_in_string, result);
        }
        printf("print : %s\n", result_in_string);

27/10/2015, 16h13
ternel

tu peux faire une estimation.
en base 64, chaque caractère représente une valeur parmi 64. Donc, il faut 2 chiffres en base 16 (qui permettent de représenter 16*16 = 256 valeurs).
Il te suffit d'allouer le double de la longueur de la chaine en entrée (+1 pour le 0)

En faite, le soucie que je rencontre est que j'ai toujours des caractères qui s'ajoute au début de ma chaine : ��n 308204(...)

Avec une très grande valeur sur le malloc, cela supprime le problème.

Je remets le code en entier ci-dessous :

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
int decode_base64 (unsigned char *buffer)
{
    unsigned int  car;      
    unsigned char valcar [4]; 
    int  i, j;
    int  posorig;
    int  posdest;
    unsigned int num;
    char* result;
    char* result_in_string;
 
    posorig = 0;
    posdest = 0;
    while (buffer [posorig] > ' ' && buffer [posorig] != '=')
    {
        for (i = 0; i < 4 && buffer [posorig] != '='; i++)
        {
            car = buffer [posorig++];
            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;
            }
        buffer [posdest++] = (valcar [0] << 2) | (valcar [1] >> 4);
        if (i > 2)
        {
            buffer [posdest++] = (valcar [1] << 4) | (valcar [2] >> 2);
            if (i > 3)
                buffer [posdest++] = (valcar [2] << 6) | (valcar [3]);
        }
    }
    buffer [posdest] = '\0';
 
    result_in_string = malloc(sizeof(*result_in_string) * (strlen(buffer)*2 + 1));
    for (j = 0; j < posdest; j++)
        {
            result = malloc((3) * sizeof(*result));
            num = buffer[j];
            if ((num == 0) || (num <= 15))
                sprintf(result, "0%X", num);
            else
                sprintf(result, "%X", num);
            result_in_string = strcat(result_in_string, result);
        }
        printf("%s\n", result_in_string);
 
    return (posdest);
}

27/10/2015, 16h34
zendel

Bon, je me suis livré à un petit travail de fourmis pour trouver à partir de qu'elle valeur provient l'erreur.

Erreur :
result_in_string = malloc(sizeof(*result_in_string) * (567 + 1));

Pas d'erreur :
result_in_string = malloc(sizeof(*result_in_string) * (568 + 1));
27/10/2015, 17h59
BufferBob

Citation:

Envoyé par leternel

en base 64, chaque caractère représente une valeur parmi 64. Donc, il faut 2 chiffres en base 16 (qui permettent de représenter 16*16 = 256 valeurs).
Il te suffit d'allouer le double de la longueur de la chaine en entrée (+1 pour le 0)

hum hum, base64 les octets sont encodés 3 par 3, chaque bloc de 3 octets est encodé sur 4 digits base64, donc en réalité il suffit de multiplier par 4/3 et rajouter 4 octets à l'allocation, le dernier bloc contiendra forcément 0, 2 (X=) ou 3 (X==) digits base64, le 4e octet du dernier bloc est donc obligatoirement un \0

si on a un message à encoder de 1000 octets de long, on peut donc se contenter d'allouer 1337 octets, le 1337ème octet contiendra obligatoirement un 0, et en l'occurrence comme 1000*4/3 tombe juste c'est les 4 derniers octets (1334, 1335, 1336 et 1337) que l'on pourra éventuellement mettre à 0
(comme de toutes façons on initialise le buffer avec des zéros au départ pour ensuite écrire dedans, à l'arrivée on se retrouve simplement avec un buffer rempli et 4 zéros pour le terminer au lieu d'un)
28/10/2015, 08h28
ternel

En effet, c'est encore mieux.
Mais tout est mieux qu'un gros 1Mo fixe.

Au passage, du devrais séparer les différentes tâches de ta fonction, car là tu fais deux choses différentes.
Exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 size_t decode_base64(const char *chaineBase64, unsigned char **ppBuffer) { size_t tailleBuffer = calculer_taille_decodee(chaineBase64); *ppBuffer = calloc(tailleBuffer, sizeof **ppBuffer); /*Faire le décodage ici*/ /*...*/ } void affiche_hexadecimal(const unsigned char *donneesBrutes, size_t taille) { size_t i; for(i=0 ; i<taille ; ++i) { printf("%02X", donneesBrutes[i]); /*Et pourquoi pas un retour à la ligne tous les 16 octets?*/ if((i+1) % 16 == 0) putchar('\n'); else putchar(' '); } }
Et encore, on pourrait aussi faire une fonction qui construit une chaîne de caractères pour l'affichage hexadécimal, plutôt que l'afficher directement sur la sortie standard.

04/11/2015, 16h43
zendel

Merci à tous pour vos indications.

Je passe en résolu.