Manipuler le binaire et l'hexa

Version imprimable

31/07/2009, 10h42
kilifu

Manipuler le binaire et l'hexa
Bonjour,

voila tout est dans le titre, j'ai un peu cherché mais je n'ai rien trouvé qui puisse m'aider. En faite je voudrai utiliser une librairie crypto (OpenSSL) et pour cela je suis souvant amené à utiliser de l'hexa ( pour les clés de chiffrement), je doit chiffrer\dechiffrer des fichiers binaire, selon les fonctions de la lib que j'utilise il me faut la clé en binaire. Bref je voudrai savoir un maximum de chose pour gérer l'hexa et le binaire, y a t'il des variables speciales ?

Par exemple : pour une clé de chiffrement j'ai 1212121212121212, normalement c'est de l'hexa si je la declare comme ça c'est bon ?
Code:

1 2 3 4 typedef unsigned char DES_cblock[8]; // ça c'est dans la lib que j'utilise DES_cblock blk1 = {0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12};
Mais je ne comprend pas pourquoi le tableau ne fait que 8 Octet (il n'y a pas besoin du '\0' ?)

Quand j'ouvre un fichier binaire (avec word par exemple) je me retrouve avec plein de caracteres bizarre genre "•Z *èW¦2',Iu’ÖåZ¬¨ w5‘z½WFªù" ça represente quoi en faite ? c'est la representation ASCII du binaire ? comment je peu les utiliser ? Pour decrypter je dois prendre des blocks (de 8 bits je croi) comment faire pour avoir c'est block ? Si par exeple je lis le fichier avec la fonction read() de iostram et que je lui demande le lire 1 octet (avec un sizeof(char) par exemple) ça marche, rien n'explose ? Peut on l'affiché sous la forme "01010111" ou sous la forme hexa ?

Voila autant de questions que je me pose et que du coups je vous pose ^^. Je voudrai comprendre tous ça, donc si vous avez des tutos ou si vous pouviez m'expliquer.

Note : je suis sous Window XP et j'utilise Visual Studio C++ 6

Salut, et bienvenue sur le forum

Un tableau de (unsigned) char ne doit se terminer par un '\0' que si le tableau représente une chaine de caractères...

Ce n'est pas le cas ici: Tu ne prend pas le tableau comme une série de caractères représentant un terme particulier ("bonjour") mais comme un tableau représentant huit valeurs numériques particulières, même si ces huit valeurs sont identique dans ton exemple (0x12, équivalent à 00001100 en binaire ou à 18 en décimal et correspondant à... un caractère qui n'a pas vocation à être affiché ;))

Pour le reste de la question (à quoi correspondent les caractères lus en ouvrant le fichier sous word), le mot clé de la réponse est cryptage:

Lorsque tu envoie un texte "en clair" à OpenSSL, il va utiliser un algorithme permettant de crypter ce texte sur base de la clé de cryptage utilisée.

Le résultat obtenu ne pourra alors être réellement lu qu'après... avoir été décrypté (être passé dans la "moulinette" qui inverse le processus).

Ce résultat a de grandes chances de présenter une suite de caractères "sans queue ni tête" dont une partie des caractères sont d'ailleurs susceptibles de ne pas pouvoir être affichés (parce que les caractères correspondant aux valeurs s'étendant de 0 à 31 inclue de la table ASCII ne sont pas affichables)

Lorsque tu veux récupérer ce résultat depuis un fichier, il faut penser à ouvrir ce fichier en "mode binaire" au lieu de l'ouvir en mode texte (même si ces deux termes sont particulièrement mal choisis).

Le code pour ouvrir un fichier en binaire est
std::ofstream ofs("fichier.ext",std::ios_base::binary);
Il ne sert à rien de passer par un sizeof(char), car cette valeur renvoie systématiquement ... 1 (sizeof(char)==1 et tous les autres types dépendent de cette valeur originelle ;))

Si tu veux récupérer 8 bytes, il te suffit donc, effectivement d'utiliser la fonction read sous une forme proche de
Code:

1 2 3 unsigned char tab[8]; /* ofs est le fichier ouvert plus haut :D */ ofs.read(tab,8);
Si tu veux afficher la valeur hexadécimale de chacun des caractères lus, il faudra formater le texte de sortie à l'aide de std::hex, sous une forme proche de
/* formatons cout pour l'affichage hexadécimal */
std::cout<<std::hex;
Code:

1 2 3 4 5 /* tab est notre tableau de 8 caractères déclaré plus haut */ for(int i=0;i</;++i) { std::cout<<tab[i]<<" "; }
voire, sous la forme de
Code:

1 2 3 4 5 6 /* formatons cout pour l'affichage hexadécimal */ std::cout<<std::hex; /* injectons le contenu du tableau (tab est toujours le tableau * déclaré plus haut ) */ std::copy(tab, tab+8, std::ostream_iterator<unsigned char>(std::cout, " "));
Si, enfin, tu souhaites effectuer un affichage binaire des différentes valeurs, le plus facile sera de passer par un std::bitset, mais le binaire n'étant qu'une convention d'affichage comme l'hexadécimal, mais bien plus compliquée à interprété (de notre point de vue d'humain), il faut vraiment voir si c'est ce que tu souhaites ;)

31/07/2009, 13h46
kilifu
Merci pour ces explication, beacoup de choses sont un peu plus claire maintenant par contre, je n'ai pas compris :

Quand tu fais :
Code:

1 2 3 4 std::ofstream ofs("fichier.ext",std::ios_base::binary); unsigned char tab[8]; ofs.read(tab,8); // read() n'accepte pas le unsigned je croi (enfin c'est bon je cast ça devrai passer)
c'est bien pris en compte comme un tableau et pas comme une chaine ?( pas besoin du '\0' ? ). Mais à lors je me demande comment on fais pour lire le fichier en entier ? puisque on le lis en binaire y a pas des caracteres speciaux (comme les '\n', '\0' ou autres) , je veux dire comment on ce ballade dans ces fichiers ? Aussi je du mal a concevoir: le 8 dans le read(), il represente quoi ? ( 8 bits, 8 Octets ou 8 caractere ?)

Aussi une fois que tu à fait :
Code:

1 2 std::cout<<std::hex;
Tout les std::cout suivant seront formaté en hexa ? comment on repasse en normale (j'ai vu std::dec et std::oct c'est l'un d'eux ?)
31/07/2009, 14h13
koala01
Citation:
Envoyé par kilifu

Merci pour ces explication, beacoup de choses sont un peu plus claire maintenant par contre, je n'ai pas compris :

Quand tu fais :

Code:

1 2 3 4 std::ofstream ofs("fichier.ext",std::ios_base::binary); unsigned char tab[8]; ofs.read(tab,8);

c'est bien pris en compte comme un tableau et pas comme une chaine ?( pas besoin du '\0' ? ).
Effectivement, tu dois penser au fait que, comme tes caractères ont été manipulé (par la fonction de cryptage), tu ne peux pas les considérer comme étant des caractères imprimables, qui, dans le meilleur des cas, donnerait une chaine de caractères ne voulant strictement rien dire, mais que tu dois les considérer comme... des valeurs codées sur la taille d'un byte ;)

Il n'y a donc aucun besoin de prévoir un '\0' en fait de tableau ;)

Citation:

Mais à lors je me demande comment on fais pour lire le fichier en entier ? puisque on le lis en binaire y a pas des caracteres speciaux (comme les '\n', '\0' ou autres) , je veux dire comment on ce ballade dans ces fichiers ?

Ici, je me suis basé sur ce que tu voulais: lire 8 caractères à la fois...

Si tu veux lire l'ensemble du fichier, je te conseille de faire un tour par la FAQ (dont les différents exemples sont adaptés ;) et principalement par la page relative à l'utilisation des fichiers

Citation:

Aussi je du mal a concevoir: le 8 dans le read(), il represente quoi ? ( 8 bits, 8 Octets ou 8 caractere ?)

la fonction read prend en deuxième paramètre le nombre de bytes à lire.

Un byte est ce que l'on traduit communément (mais de manière erronée) par octet et correspond... à un caractère (signed / unsigned char) ;)
Citation:
Aussi une fois que tu à fait :

Code:

1 2 std::cout<<std::hex;

Tout les std::cout suivant seront formaté en hexa ? comment on repasse en normale (j'ai vu std::dec et std::oct c'est l'un d'eux ?)
C'est effectivement l'un des deux (std::dec si tu veux repasser en décimal ;))

Tu trouvera un tas d'information intéressante concernant le formatage de flux sur l'entrée de la FAQ qui y est consacrée ;)

Ceci dit, un conseil (plein de bon sens) généralement donné est de manipuler de préférence les différents conteneurs de la STL plutôt que des tableau "C style".

Nous préférerons donc souvent utiliser par exemple la classe vector, disponible dans l'espace de noms std par simple inclusion du fichier d'en-tête <vector> lorsqu'il est question de manipuler des caractères pour les utiliser en tant que valeur numérique et la classe string, elle aussi disponible dans l'espace de noms std (mais par l'inclusion du fichier d'en-tête <string> cette fois) lorsqu'il s'agit de manipuler des chaines de caractères en les considérant comme telles ;)

Cela permet, justement, de se défaire de cette ambiguïté qui est due au fait que le type (unsigned / signed) char peut représenter deux chose différentes, à savoir:
- une valeur numérique, codée sur un certain nombre de bits
- un caractère qui, couplé à d'autres, permet de représenter un terme que nous connaissons ("voiture" par exemple)
31/07/2009, 17h33
kilifu

GG Merci à toi, j'ai reussi à crypter et à decrypter mais fichiers et je n'ai plus de souci pour les clées hexa et tout.

Un grand merci a toi