Discussion :

[Chaka_Sobek]

Bonjour à tous,

Je me permets de poster ici mon problème qui, je pense, est simple à résoudre malgré que je bute dessus.
Dans le cadre d'un projet, je dois utiliser une fonction de hashage de taille réduite (ici md5) afin de détecter les cycles dans cette dernière (via l'algo de brent).
On me fournit une fonction md5_small (c.f. md5_small.c).
Mon algo de brent est ok cependant je n'arrive pas à utiliser cette fonction, et ce, même en faisant des tests en dehors de mon algo de brent.
Je veux simplement donner quelque chose à ma fonction de hashage ainsi que la taille du hashé de sortie.
J'ai fait un gcc -c md5_small.c -o test puis ./test avec des entrées mais cela me renvoie "cannot execute binary file : Exec format error"

Quelqu'un pourrait-il me donner un coup de main en m'expliquant ce qu'il faut que je donne à ma fonction pour qu'elle fonctionne et me renvoie un hashé de la taille voulue ?

Merci par avance de vos retours

Chaka

[Sve@r]

Bonjour

J'ai fait un gcc -c md5_small.c -o test puis ./test avec des entrées mais cela me renvoie "cannot execute binary file : Exec format error"

Normal, l'option "-c" de gcc demande à s'arrêter au module objet, module qu'on pourra alors associer avec d'autres pour former l'exécutable. Mais un module en lui-même n'est pas exécutable (détails que tu es censé savoir à ce niveau).

Tu veux créer un exécutable tu demandes gcc md5_small.c -o test. Sauf que pour qu'il y ait exécutable il faut qu'il y ait main() et la fonction main() est désactivée via un #if 0 suivi d'un #endif. Donc faut supprimer ces directives de pré-compilation pour ouvrir le main(). Mais pareil, le main fait appel à d'autres fonctions toutes désactivées de la même façon. Donc faut parcourir le source et supprimer toutes ces directives pour pouvoir enfin compiler ce code en un programme que tu pourras ensuite appeler en lui passant le fichier à hasher.

Ceci dit, j'ai testé mes fichiers via ce programme puis via le programme standard Linux "md5" et les résultats ne sont pas les mêmes.

[Chaka_Sobek]

Bonjour,

Et merci pour ta réponse.

En ayant retiré les #if 0, j'obtiens quelque chose de fonctionnel (du moins qui me renvoie quelque chose). Comme tu as pu le dire, j'ai l'impression que les hash ne correspondent pas au "vrai md5"...
Par ailleurs, de ce que j'avais compris, le professeur avait pris une fonction déjà existante sur le web et l'avait personnalisé. Il nous avait également indiqué que la taille des hash étaient modifiable dans la ligne de commande cependant je n'y parviens pas.
Mes camarades, qui font de l'info, ne se sont pas encore penchés dessus c'est pourquoi je plonge la tête (et suffoque) dans le code malgré mon petit niveau d'info en tant que matheux.

Ne puis-je pas uniquement utiliser la fonction md5_small définie dans mon fichier md5_small.c ? Car j'imagine que seulement ceci m'est nécessaire d'autant plus que, j'ose espérer, le professeur ne se serait pas embêter à mettre des #if 0 partout pour la "personnaliser" .

Merci par avance.

[Sve@r]

Il nous avait également indiqué que la taille des hash étaient modifiable dans la ligne de commande cependant je n'y parviens pas.

Ce n'est pas indiqué.
Il est indiqué les options suivantes

• filename (hash d'un fichier)
• -sstring (hash d'une string)
• -t (statistiques sur la vitesse de traitement)
• -x (suite de tests)

Ne puis-je pas uniquement utiliser la fonction md5_small définie dans mon fichier md5_small.c ?

Bien sûr. Te suffit d'écrire ton propre code dans ton fichier "xxx.c", code qui pourra appeler n'importe quelle fonction du fichier "md5_small.c", puis compiler ainsi

• gcc -c md5_small.c
• gcc -c xxx.c
• gcc xxx.o md5_small.o -o xxx

Et si tu crées un Makefile dans lesquelles les dépendances sont bien écrites, tu pourras alors compiler avec la commande make qui ne recompilera que la branche qui a été modifiée (si modifications futures). C'est le principe de la compilation séparée.
Exemple de Makefile

Code Makefile :

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
CC=gcc
CFLAGS=-Wall -Werror
 
EXEC=xxx
 
SOURCEFILES=\
	md5_small.c\
	xxx.c
 
OBJECTFILES=$(SOURCEFILES:.c=.o)
 
all:
	make $(EXEC)
 
clean:
	rm -f $(OBJECTFILES)
 
new:
	@make clean
	@make all
 
xxx:$(OBJECTFILES)
	$(CC) $(CFLAGS) $(OBJECTFILES) -o $@

J'ai toutefois essayé cette fonction sans trop savoir ni à quoi elle sert ni pouvoir interpréter ce qu'elle sort. En plus elle prend deux paramètres "hash_byte_length" et "hash_byte_size" avec le second devant être obligatoirement égal à 8 fois la taille du premier ce qui est idiot (dans ce cas, on crée la fonction avec seulement un des deux paramètres et qui calcule automatiquement le second par rapport au premier !!!). Mis à part ces remarques il semble effectivement qu'elle puisse créer des hash de taille variable.

[Chaka_Sobek]

Merci beaucoup pour tes messages.

Je pense donc utiliser le makefile au vu de ce que tu m'as dit.
Cependant, ne les ayant jamais utilisés, une question me vient : aucun .h n'est créé et donc comment dois-je me débrouiller pour utiliser la fonction d'un autre fichier (md5_small.c ici) dans mon fichier (brent.c) ? Si je le créé avant, ce .h, cela ne va-t-il pas poser problème avec le makefile ? (désolé si la question est idiote... je suis un néophyte )

Encore merci !

[Sve@r]

Cependant, ne les ayant jamais utilisés, une question me vient : aucun .h n'est créé et donc comment dois-je me débrouiller pour utiliser la fonction d'un autre fichier (md5_small.c ici) dans mon fichier (brent.c) ?

Un ".h" est un truc bien pratique mais pas obligatoire. Tu dois juste déclarer la fonction avant de l'utiliser
Exemple (le xxx.c que j'ai utilisé pour tester)

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
#include <stdio.h>
 
int md5_small(unsigned char*, unsigned int, unsigned int, unsigned char*, unsigned int);
 
int main() {
	unsigned char hash[100];
	md5_small(hash, 10, 80, (unsigned char*)"Hello", 5);
	printf("hash=[%s]\n", hash);
}

Evidemment si tu veux utiliser d'autres fonctions, et ce dans plusieurs sources (dans le cadre d'un projet par exemple) il te faut déclarer toutes les fonctions que tu utilises et partout où tu les utilises, d'où le ".h" dans lequel elles seront déclarées et que tu n'as alors plus qu'à inclure.
Exemple md5_small.h

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
#ifndef __MD5_SMALL_H__
#define __MD5_SMALL_H__
 
int md5_small(unsigned char*, unsigned int, unsigned int, unsigned char*, unsigned int);
 
#endif // __MD5_SMALL_H__

Dans le .c on écrit #include <md5_small.h> et dans le Makedile on rajoute "-I." dans les CFLAGS pour que le compilateur aille chercher les includes dans le dossier "." (et pour bien faire il faudrait rajouter le ".h" à la chaine de compilation pour que make puisse gérer les évolutions)

(désolé si la question est idiote... je suis un néophyte )

Encore une fois, tu n'es pas censé l'être.