Empreinte d'un fichier

Version imprimable

20/04/2007, 19h33
KeKeMaN

Empreinte d'un fichier

Bonjour,

J'essai de mettre en pratique le code proposé par Razgriz permettant de créer une empreinte pour vérifier l'intégrité d'un fichier (dans mon cas après téléchargement via P2P).
Le problème c'est que je trouve pas la doc ... et je vois pas bien comment l'utiliser ... :aie:

Merci d'avance
21/04/2007, 14h51
adiGuba

Salut,

Citation:

Envoyé par KeKeMaN

le code proposé par Razgriz

Quel code ?

a++
21/04/2007, 15h02
KeKeMaN

Celui-ci :
http://www.developpez.net/forums/sho...02#post1071802

Je l'ai contacté par mail, mais il m'a dit d'ouvrir un poste pour que ca puisse servir à tout le monde ..

Merci !

A ce que j'en vois c'est pas la mort à utiliser
Code:

1 2 3 4 MessageInprint inprint = new MessageInprint(MessageInprint.SHA1); //on peut également utiliser MessageInprint.MD5 inprint.getInprint("FichierDontOnVeutLEmpreinte","FichierOùSeraStockéeLEmpreinte");
Et l'empreinte sera dans le fichier dont on a passé l'adresse dans le deuxième param...

22/04/2007, 11h42
Razgriz
Ben voilà tu vois c'est pas la mort, la doc est claire je crois, si tu veux juste obtenir le condensé pour un String pas stocké en fichier* il suffit de rajoutter une méthode comme suit (la classe sur le site n'étant pas la dernière version, celle que je possède dans ma librairie a plus de fonctionnaités) :
Code:

1 2 3 4 5 6 public String getInprint(String msg) { byte[] bytes = msg.getBytes(); return computeDigest(bytes); }
Pour vérifier si un String ou fichier x n'est pas celui dont tu as le condensé tu obtiens le condensé de x et tu compare les deux condensés avec la méthode equals.

------------------------------------------
* Pour par exemple stocker des mots de passe : écrire les mots de passe, même cryptés, dans un fichier n'est pas très sécurisé. Pour cela on obtiens le condensé de hachage MD5 ou SHA-1 tu mot de passe et on stocke le condensé. Si un utilisateur se conencte et entre un mot de passe, on obtiens le condensé de ce mot de passe et on compare avec le condensé de mot de passe de cet utilisateur stocké. Le hachage étant une fonction qu'on accepte injective (i.e. forall x, y, x != y => f(x) != f(y) ) si les condensés sont différents il y a une probabilité extrèmement forte ( > 99.99 %) que les mots de passe étaient à l'origine différents.
22/04/2007, 15h10
KeKeMaN

Merci je vais regarder ca !
En faite je veux m'en servir comme générateur d'identifiant unique d'un fichier, et de plus elle me permettrait dans une application de type P2P de savoir si le fichier a été correctement téléchargé et qu'il n'a pas été modifié en cours de route :)

Citation:

Envoyé par Razgriz

(la classe sur le site n'étant pas la dernière version, celle que je possède dans ma librairie a plus de fonctionnaités)

Et dans tous les hasards des cas, y a pas moyen que tu postes la nouvelle ;)

En tout cas merci !!
22/04/2007, 15h19
Razgriz

La méthode getInprint que je viens de passer est utile, les méthode suivante sont des templates pour lecture/écriture/comparaison de fichiers avec condensé le tout étant sécurisé, ce n'est pas très interressant, et surout utile que dans certains cas particuliers...

Je viens de faire mon pti botin avec ta classe.
J'ai remarqué que plus le fichier était gros, plus ca mettait du temps .. et des fois ca plante :

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
30
31
32
33
34
 
Exception in thread "AWT-EventQueue-0" java.lang.OutOfMemoryError: Java heap space
	at java.util.Arrays.copyOf(Unknown Source)
	at java.io.ByteArrayOutputStream.write(Unknown Source)
	at security.MessageInprint.loadBytes(MessageInprint.java:72)
	at security.MessageInprint.getInprint(MessageInprint.java:62)
	at interfaceGraphique.EcouteurBarreMenu.ajouterFichier(EcouteurBarreMenu.java:82)
	at interfaceGraphique.EcouteurBarreMenu.actionPerformed(EcouteurBarreMenu.java:49)
	at javax.swing.AbstractButton.fireActionPerformed(Unknown Source)
	at javax.swing.AbstractButton$Handler.actionPerformed(Unknown Source)
	at javax.swing.DefaultButtonModel.fireActionPerformed(Unknown Source)
	at javax.swing.DefaultButtonModel.setPressed(Unknown Source)
	at javax.swing.AbstractButton.doClick(Unknown Source)
	at javax.swing.plaf.basic.BasicMenuItemUI.doClick(Unknown Source)
	at javax.swing.plaf.basic.BasicMenuItemUI$Handler.mouseReleased(Unknown Source)
	at java.awt.Component.processMouseEvent(Unknown Source)
	at javax.swing.JComponent.processMouseEvent(Unknown Source)
	at java.awt.Component.processEvent(Unknown Source)
	at java.awt.Container.processEvent(Unknown Source)
	at java.awt.Component.dispatchEventImpl(Unknown Source)
	at java.awt.Container.dispatchEventImpl(Unknown Source)
	at java.awt.Component.dispatchEvent(Unknown Source)
	at java.awt.LightweightDispatcher.retargetMouseEvent(Unknown Source)
	at java.awt.LightweightDispatcher.processMouseEvent(Unknown Source)
	at java.awt.LightweightDispatcher.dispatchEvent(Unknown Source)
	at java.awt.Container.dispatchEventImpl(Unknown Source)
	at java.awt.Window.dispatchEventImpl(Unknown Source)
	at java.awt.Component.dispatchEvent(Unknown Source)
	at java.awt.EventQueue.dispatchEvent(Unknown Source)
	at java.awt.EventDispatchThread.pumpOneEventForFilters(Unknown Source)
	at java.awt.EventDispatchThread.pumpEventsForFilter(Unknown Source)
	at java.awt.EventDispatchThread.pumpEventsForHierarchy(Unknown Source)
	at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
	at java.awt.EventDispatchThread.pumpEvents(Unknown Source)

C'est moi qui est fait une erreur ou koi ?

PS : Ici le fichier fait 60mo

25/04/2007, 09h23
sinok
Assez simple, par défaut la JVM tourne avec 64 MO de mémoire, donc charger un fichier de 60 MO aura bien tendance à créer une OutOfMemoryError.

Par contre il existe un paramèter permettant de changer la taile max de mémoire allouée à la JVM.

Si tu veux pouvoir changer ce paramètre, tu dois pouvoir le faire dans ton IDE

et sinon en ligne de commande en utilisant le paramètre -Xmx et en lui accolant la taille de mémoire maximale que tu désire allouer à ta JVM

par exemple pour allouer 256 Mo de mémoire vive à la JVM:
Code:

1 2 java -Xmx256M

Augmenter la mémoire de la JVM n'est pas une bonne solution pour ce problème.
En effet, celui-ci vient du fait que le fichier est chargé en totalité avant d'être "hashé" (donc si la taille du fichier > mémoire max de la JVM ça plante). Il vaut mieux le faire petit à petit (en utilisant la méthode update(byte[] input, int offset, int len)).

J'ai commencé à reprendre le code de Razgriz en vue d'une future intégration dans la rubrique Sources Java.

Voilà ce que ça donne pour l'instant (cette classe sera très certainement encore modifiée, mais il y a déjà l'algo réglant ton problème) :

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
/*
 * Hasher.java
 */
 
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
 
/**
 *
 * @author Romain Absil, Yann D'Isanto
 */
public class Hasher {
 
    private MessageDigest algorithm;
 
    /**
     * SHA-1 algorithm.
     **/
    public static final String SHA1 = "SHA-1";
    /**
     * SHA-256 algorithm.
     **/
    public static final String SHA256 = "SHA-256";
    /**
     * SHA-384 algorithm.
     **/
    public static final String SHA384 = "SHA-384";
    /**
     * SHA-512 algorithm.
     **/
    public static final String SHA512 = "SHA-512";
    /**
     * MD2 algorithm.
     **/
    public static final String MD2 = "MD2";
    /**
     * MD5 algorithm.
     **/
    public static final String MD5 = "MD5";
 
 
    public Hasher() {
        try {
            this.algorithm = MessageDigest.getInstance(MD5);
        } catch (NoSuchAlgorithmException ex) {
            ex.printStackTrace();
        }
    }
 
    /**
     * Create a Hasher that will uses the specified algorithm.
     * @param algorithm the algorithm
     */
    public Hasher(MessageDigest algorithm) {
        this.algorithm = algorithm;
    }
 
    /**
     * Create a Hasher that will uses the specified algorithm.
     * @param algorithm the algorithm
     */
    public Hasher(String algorithm) throws NoSuchAlgorithmException {
        this.algorithm = MessageDigest.getInstance(algorithm);
    }
 
    /**
     * Set the algorithm.
     * @param algorithm the algorithm
     */
    public void setAlgorithm(MessageDigest algorithm) {
        this.algorithm = algorithm;
    }
 
    /**
     * Set the algorithm.
     * @param algorithm the algorithm
     */
    public void setAlgorithm(String algorithm) throws NoSuchAlgorithmException {
        setAlgorithm(MessageDigest.getInstance(algorithm));
    }
 
    /**
     * Returns the algorithm.
     * @return the algorithm
     */
    public MessageDigest getAlgorithm() {
        return algorithm;
    }
 
    /**
     * Hashes the file denoted by the specified location
     * @param pathname file location
     * @return the hash as a bytes array
     */
    public byte[] hash(String pathname) throws FileNotFoundException, IOException {
        return hash(new File(pathname));
    }
 
    /**
     * Hashes the specified file.
     * @param file the file to hash
     * @return the hash as a bytes array
     */
    public byte[] hash(File file) throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream(file);
        byte[] hash = null;
        try {
            hash = hash(fis);
        } finally {
            fis.close();
        }
        return hash;
    }
 
    /**
     * Hashes the specified input stream.
     * @param is the input stream to hash
     * @return the hash as a bytes array
     */
    public byte[] hash(InputStream is) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(is);
        algorithm.reset();
        byte[] data = new byte[2048];
        int nbRead = 0;
        while((nbRead = bis.read(data)) > 0) {
            algorithm.update(data, 0, nbRead);
        }
        bis = null;
        return algorithm.digest();
    }
 
    /**
     * Hashes the file denoted by the specified location
     * @param pathname file location
     * @return the hash as a String
     */
    public String hashToString(String pathname) throws FileNotFoundException, IOException {
        return hashToString(hash(pathname));
    }
 
    /**
     * Hashes the specified file.
     * @param file the file to hash
     * @return the hash as a String
     */
    public String hashToString(File file) throws FileNotFoundException, IOException {
        return hashToString(hash(file));
    }
 
    /**
     * Hashes the specified input stream.
     * @param is the input stream to hash
     * @return the hash as a String
     */
    public String hashToString(InputStream is) throws IOException {
        return hashToString(hash(is));
    }
 
    /**
     * Returns the specified bytes array hash as a String
     * @param hash the hash as a bytes array
     * @return the hash as a String
     */
    public String hashToString(byte[] hash) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < hash.length; i++) {
            int v = hash[i] & 0xFF;
            if(v < 16) {
                sb.append("0");
            }
            sb.append(Integer.toString(v, 16));
        }
        return sb.toString();
    }
 
}

Voici un exemple d'utilisation :

Code:

1
2
3
4
5
6
 
static public void main(String[] args) throws Exception {
    Hasher hasher = new Hasher();
    byte[] hash = hasher.hash("fichier");
    System.out.println(hasher.hashToString(hash));        
}

J'ai fait un essai avec un fichier d'environ 715 Mo et cela marche avec un temps d'exécution d'environ 2 à 3 min, et ce sans augmenter la mémoire de la JVM ;).

25/04/2007, 12h22
KeKeMaN

Cela reste 2 à 3 min .. Je pense pas qu'au niveau utilisateur, lors de l'ajout d'un fichier et de la création de l'empreinte, il pourrait attendre autant de temps ..

Enfin merci beaucoup, je vais regarder tout ca ..
25/04/2007, 12h56
le y@m's

En fait ce temps était celui du premier lancement, après ça va plus vite.
Voici quelques temps mesurés (premier lancement non compris) :
12 Mo :arrow: 250 ms
54 Mo :arrow: 860 ms
715 Mo :arrow: 18s
28/04/2007, 13h19
KeKeMaN

oki doki !!
merci beaucoup pour ces temps ...

je pensais pour faire attendre les utilisateurs de mettre en place une barre de progression :) mais est-ce possible ??

merci d'avance !!
02/05/2007, 09h31
le y@m's

Citation:

Envoyé par KeKeMaN

je pensais pour faire attendre les utilisateurs de mettre en place une barre de progression :) mais est-ce possible ??

Voici un tutoriel qui devrait t'intéresser :arrow: Attendre avec style en utilisant Swing ;).
02/05/2007, 10h26
KeKeMaN

ha merci je vais regarder :lol:
02/05/2007, 17h13
Razgriz
Franchement le y@ms j'applaudis des deux mains pour ta classe, c'est vraiment bien fait, et clairement plus pratique que la mienne;)
Bravo.

Mais si je peux me permettre il existe une méthode encore plus rapide, sans modifier ma classe.

Soit un fichier F de taille k
Soit n tq k % n = 0

Hachage :
Code:

1 2 3 4 Pour i allant de n à k par pas de n f_{i/n} <-- lecture de F de i-n à n écrire le condensé de hachage de f_{i/n}.
Pour vérifier si un fichier a été modifié ou correspond à l'origine :
Code:

1 2 3 4 Pour i allant de n à k par pas de n si f_{i/n} != condensé de hachage de F lu de i-n à n retourner faux retourner vrai
Ca tourne plus vite, mais ça génère beaucoup de fichiers.
02/05/2007, 17h26
le y@m's

C'est effectivement une façon de vérifier l'intégrité d'un fichier.
Mais cela consiste à faire les empreintes de morceaux de fichiers et non une seule empreinte pour un fichier (ce qui ce fait le plus souvent).

De plus, je ne suis pas sûr que cela soit réellement plus performant du fait de la multiplication des ouverture/fermeture de fichiers (coûteux en ressources) (mais bon je ne l'affirme pas, il faudrait faire des tests pour comparer).
15/06/2009, 11h23
SpecialCharacter

Je vous remercie pour votre contribution, ça en aura aidé plus d'un (dont moi même)
Merci également pour la source correspondante :ccool: