Comparaison avec checksum(crc)

Version imprimable

07/03/2008, 14h47
mercure07

Comparaison avec checksum(crc)

salut tt le monde, bon je désire comparer 2 fichiers en utilisant leur checksum.
Est ce que quelqu'un pourrait m'aider par un bout de code.
Merci
07/03/2008, 14h59
ZaaN

soit tu veux implementer toi meme ton CRC et je te conseille d'etudier la thorie relative, soit tu utilise une lib deja faites...

Dans tout les cas tu trouveras plein d'info sur wikipedia (y.c. des sources)
07/03/2008, 17h44
xenozephyr

Salut,

Moi je te déconseille d'utiliser un crc 32bit pour comparer des fichiers car il y a énormément de collisions (2 fichiers diff = même crc)
Tu risque d'avoir de mauvaises surprises.
Le hashage MD5 est beaucoup plus fiable et disponible dans le framework. Et pour encore plus de fiablilité il y a SHA.

a+
07/03/2008, 17h52
tomlev

Citation:

Envoyé par xenozephyr

Salut,

Moi je te déconseille d'utiliser un crc 32bit pour comparer des fichiers car il y a énormément de collisions (2 fichiers diff = même crc)
Tu risque d'avoir de mauvaises surprises.
Le hashage MD5 est beaucoup plus fiable et disponible dans le framework. Et pour encore plus de fiablilité il y a SHA.

a+

+1
voir la classe MD5CryproServiceProvider
07/03/2008, 19h04
Graffito

Citation:

je désire comparer 2 fichiers en utilisant leur checksum.
Est ce que quelqu'un pourrait m'aider par un bout de code.

En dehors d'un exercice imposé ou de programmes de synchro entre 2 machines, la comparaison effective me parait aussi simple/rapide et évite tous les cas de collision (même checksum, fichiers différents).

En fait, seule une différence de checksum est significative : 2 fichiers avec le même checksum pouvant être (rarement) différents.

Avec un peu de recherche j'ai trouvé du code en C que j'ai porté vite fait en C#.
J'ai besoins d'environ 50sec pour faire la somme sur un fichier de 1Go

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
 
static UInt32 CheckSum32bits(Byte[] bytes)
        {
            if (bytes.Length < 4) return (0);
 
            UInt32 result = 0;
            UInt32 quotient = 0x04c11db7;
            Byte octet = 0;
 
            result = (UInt32)(bytes[0] << 24);
            result |= (UInt32)(bytes[1] << 16);
            result |= (UInt32)(bytes[2] << 8);
            result |= bytes[3];
            result = ~result;
 
            for (Int32 i = 4; i < bytes.Length; ++i)
            {
                octet = bytes[i];
                for (Int32 j = 0; j < 8; ++j)
                {
                    if ((result & 0x80000000) == 0)
                        result = (result << 1) ^ quotient ^ (UInt32)(octet >> 7);
                    else
                        result = (result << 1) ^ (UInt32)(octet >> 7);
                    octet <<= 1;
                }
            }
            return (~result);
        }

01/11/2008, 03h04
smyley

Citation:

Envoyé par Graffito

En dehors d'un exercice imposé ou de programmes de synchro entre 2 machines, la comparaison effective me parait aussi simple/rapide et évite tous les cas de collision (même checksum, fichiers différents).

En fait, la méthode de comparaison directe est plus efficace qu'un checksum si ce dernier n'est pas réutilisé. Dans le cas d'archives alors on calcule une seule fois le checksum et après on a terminé. Si par contre c'est une comparaison ponctuelle vaut mieux comparer directement.
Après, on peut toujours faire en sorte que si on trouve deux checksums identiques, rebasculer vers une comparaison directe pour éliminer les doutes possibles.