Utilisation d'une fonction et arguments à lui fournir

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. Pièce jointe 631005).
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

Bonjour

Citation:

---

Envoyé par Chaka_Sobek

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. :?

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.

Citation:

---

Envoyé par Chaka_Sobek

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)

Citation:

---

Envoyé par Chaka_Sobek

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:

---

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.

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 ! :)

Citation:

---

Envoyé par Chaka_Sobek

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:

---

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:

---

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)

Citation:

---

Envoyé par Chaka_Sobek

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

---

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

Si j'ai bien compris, dans mon cas avec mon algo Pièce jointe 631051, je mets : #include "md5_small.h" où j'aurais créé auparavant moins md5_small.h sous la forme :

Code:

---

1 2 3 4 5 6 7

#ifndef __MD5_SMALL_H__ #define __MD5_SMALL_H__   void MD5Init (mdContext); (et les autres dépendances de ma fonction md5_small) int md5_small(unsigned char*, unsigned int, unsigned int, unsigned char*, unsigned int);   #endif // __MD5_SMALL_H__

---

et, à partir de ce moment, je pourrai utiliser ma fonction md5_small dans brent.c .

Est-ce bien ça ?

Citation:

---

Envoyé par Chaka_Sobek

Si j'ai bien compris je mets : #include "md5_small.h" où j'aurais créé auparavant moins md5_small.h sous la forme :

Code:

---

1 2 3 4 5 6 7

#ifndef __MD5_SMALL_H__ #define __MD5_SMALL_H__   void MD5Init (mdContext); (et les autres dépendances de ma fonction md5_small) int md5_small(unsigned char*, unsigned int, unsigned int, unsigned char*, unsigned int);   #endif // __MD5_SMALL_H__

---

et, à partir de ce moment, je pourrai utiliser ma fonction md5_small dans brent.c .

Est-ce bien ça ?

---

Si tu utilises juste md5_small() il te faut juste déclarer md5_small() (cf mon exemple). T'as pas besoin de déclarer MD5Init() que tu n'utilises pas (sauf si tu veux tout reconstruire à base de md5_small.h donc déporter toutes les déclarations de md5_small.c dans md5_small.h).
Et si tu la déclares, il te faut la déclarer correctement donc void MD5Init(MD5_CTX*); et de fait il faut connaitre MD_CTX donc lui-aussi le mettre dans le ".h". Grosso-modo tout le début de md5_small.c devrait passer dans le ".h".

Ou alors tu ne fais pas de ".h" que tu ne sais pas faire et tu pars de mon simple exemple xxx.c que tu nommes "brent.c"

Accessoirement quand je vois

Code:

---

1 2 3 4 5

void MD5Init (mdContext) MD5_CTX *mdContext; { ... }

---

et

Code:

---

1 2 3 4 5 6

int main (argc, argv) int argc; char *argv[]; { ... }

---

il est un peu "old-school" ton prof non? Ca fait au-moins 15 ans qu'on n'utilise plus cette forme de déclaration de paramètres !!!

Code:

---

1 2 3 4 5 6 7

void MD5Init (MD_CTX* mdContext) { ... }   int main (int argc, char *argv[]) { ... }

---

D'accord !
Et ce même si md5_small fait appelle à d'autres fonctions ?

Citation:

---

Envoyé par Chaka_Sobek

Et ce même si md5_small fait appelle à d'autres fonctions ?

---

C'est dans le code source de md5_small.c que ça se passe donc oui. Chaque source est compilé indépendament et c'est à la fin qu'a lieu l'édition des liens qui regroupe tous les ".o". Mais à ce moment là, la phase déclaration est finie depuis longtemps.