Comment calculer le hash MD5 d'un gros fichier en C?

Je suis en train d'écrire en C, en utilisant bibliothèque OpenSSL.

Comment puis-je calculer le hash d'un fichier volumineux à l'aide de md5?

Que je sais, j'ai besoin de charger un fichier entier à la RAM en tant que char tableau, puis d'appeler la fonction de hachage. Mais que faire si le fichier est de 4 go de temps? Sonne comme une mauvaise idée.

RÉSOLU: Grâce à askovpenj'ai trouvé mon bug. J'ai utilisé

while ((bytes = fread (data, 1, 1024, inFile)) != 0)
    MD5_Update (&mdContext, data, 1024);

pas

while ((bytes = fread (data, 1, 1024, inFile)) != 0)
    MD5_Update (&mdContext, data, bytes);

source d'informationauteur user1256821

c hash md5

exemple

gcc -g -Wall -o file file.c -lssl -lcrypto

#include <stdio.h>
#include <openssl/md5.h>

int main()
{
    unsigned char c[MD5_DIGEST_LENGTH];
    char *filename="file.c";
    int i;
    FILE *inFile = fopen (filename, "rb");
    MD5_CTX mdContext;
    int bytes;
    unsigned char data[1024];

    if (inFile == NULL) {
        printf ("%s can't be opened.\n", filename);
        return 0;
    }

    MD5_Init (&mdContext);
    while ((bytes = fread (data, 1, 1024, inFile)) != 0)
        MD5_Update (&mdContext, data, bytes);
    MD5_Final (c,&mdContext);
    for(i = 0; i < MD5_DIGEST_LENGTH; i++) printf("%02x", c[i]);
    printf (" %s\n", filename);
    fclose (inFile);
    return 0;
}

résultat:

$ md5sum file.c
25a904b0e512ee546b3f47574703d9fc  file.c
$ ./file
25a904b0e512ee546b3f47574703d9fc file.c

6

D'abord, MD5 est un algorithme de hachage. Il n'a pas de chiffrer quoi que ce soit.

De toute façon, vous pouvez lire le fichier en morceaux de la taille que vous voulez. Appel MD5_Init une fois, puis d'appeler MD5_Update avec chaque morceau de données lues à partir du fichier. Lorsque vous avez terminé, appelez MD5_Final pour obtenir le résultat.
3

Vous n'avez pas à charger tout le fichier en mémoire à la fois. Vous pouvez utiliser les fonctions MD5_Init(), MD5_Update() et MD5_Final() de les traiter dans des morceaux de produire de la valeur de hachage. Si vous êtes inquiet au sujet de faire un "atomique" de l'opération, il peut être nécessaire de verrouiller le fichier pour empêcher quelqu'un d'autre de le changer lors de l'opération.

Haut réponse est correcte, mais ne pas oublier quelque chose: La valeur de la table de hachage sera différente pour chaque taille de la mémoire tampon utilisée. La valeur sera uniforme dans tous les hachages, de sorte que la même taille de mémoire tampon de produire le même hachage à chaque fois, cependant, si ce hash est comparée à une valeur de hachage de données à un moment plus tard, la même taille de la mémoire tampon doit être utilisé pour chaque appel.

En outre, si vous voulez vous assurer que votre digest code fonctionne correctement, et vous allez en ligne pour comparer vos hachage en ligne avec le hachage des sites web, il semble qu'ils utilisent une longueur de la mémoire tampon de 1. Cela apporte également une pensée intéressante: Il est parfaitement acceptable d'utiliser une longueur de la mémoire tampon de 1 à hash d'un fichier de grande taille, il va juste prendre plus de temps (duh).

Donc ma règle d'or est que si c'est uniquement pour un usage interne, alors je peux régler la longueur de la mémoire tampon en conséquence pour un gros fichier, mais si il y a de bien avec d'autres systèmes, puis réglez la longueur de la mémoire tampon de 1 et de traiter avec le temps conséquence.

int hashTargetFile(FILE* fp, unsigned char** md_value, int *md_len) {

    #define FILE_BUFFER_LENGTH 1

    EVP_MD_CTX *mdctx;
    const EVP_MD *md;
    int diglen; //digest length
    int arrlen = sizeof(char)*EVP_MAX_MD_SIZE + 1;
    int arrlen2 = sizeof(char)*FILE_BUFFER_LENGTH + 1;
    unsigned char *digest_value = (char*)malloc(arrlen);
    char *data = (char*)malloc(arrlen2);
    size_t bytes; //# of bytes read from file

    mdctx = EVP_MD_CTX_new();
    md = EVP_sha512();

    if (!mdctx) {
        fprintf(stderr, "Error while creating digest context.\n");
        return 0;
    }

    if (!EVP_DigestInit_ex(mdctx, md, NULL)) {
        fprintf(stderr, "Error while initializing digest context.\n");
        return 0;
    }

    while (bytes = fread(data, 1, FILE_BUFFER_LENGTH, fp) != 0) {
        if (!EVP_DigestUpdate(mdctx, data, bytes)) {
            fprintf(stderr, "Error while digesting file.\n");
            return 0;
        }
    }

    if (!EVP_DigestFinal_ex(mdctx, digest_value, &diglen)) {
        fprintf(stderr, "Error while finalizing digest.\n");
        return 0;
    }

    *md_value = digest_value;
    *md_len = diglen;

    EVP_MD_CTX_free(mdctx);

    return 1;
}

Vous devez vous connecter pour publier un commentaire.