Hash de mot de passes avec sel

Bonjour à tous!

Je suis en train de développer une petite application type client-server (android et java pour le server)

Tout fonctionne correctement (inscription, login etc...) je souhaiterai maintenant sécuriser le mot de passe, ayant lu un article très intéressant sur le sujet: https://crackstation.net/hashing-security.htm
J'ai bien compris en théorie, mais au niveau du code je ne comprend pas trop...
Je souhaite donc utiliser sha512, avec un sel. J'ai du mal à comprendre l'exemple qu'il y a dans le site (surtout qu'ils utilisent hmac avec sha1 si j'ai bien compris)
Voilà je vous serai donc très reconnaissant si vous aviez un bon tuto, ou carrément un fichier help déjà tout fait ou on lui donne juste le mot de passe en paramètre.

J'ai également une autre question, cette fois peut être plus lié aux base de données, mais je souhaite par la suite, anonymiser les données liées à un utilisateur... (la plupart des application nous disent que les données récoltées restent anonyme) je souhaiterai donc faire pareil sur ma base. Avez vous des conseil?

Je vous remercie de votre attention!

Bonjour,

Voici une version qui devrait faire ce que tu veux :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
 
public class Test {
 
	public static void main(String[] args) {
		System.out.println(hashPass("MotDePassEnClair", "MonSaltEnClair"));
	}
 
	public static String hashPass(String pass, String sel) {
		String hash;
		MessageDigest md = null;
		try {
			md = MessageDigest.getInstance("SHA-256");
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		// La classe Base64 est spécifique à Java8. Il existe des version Apache en Librairie pour les versions avant.
		hash = Base64.getEncoder().encodeToString(md.digest((pass + sel).getBytes()));
		return hash;
	}
}

Cependant,

Il n'est pas recommandé d'avoir le mot de pas stocké en clair dans la JVM. C'est pour cela que JPasswordField ne retourne pas de String mais un Byte[].
Il serai donc préférable d'utiliser des Byte[] de bout en bout.

Ce qui donnerai par exemple le code suivant :

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
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
 
public class Test {
 
	public static void main(String[] args) {
		byte[] password = "MotDePassEnClair".getBytes();
		byte[] salt = "MonSaltEnClair".getBytes();
		System.out.println(hashPass(password, salt));
		System.out.println(hashPass("MotDePassEnClair", "MonSaltEnClair"));
	}
 
	private static String hashPass(byte[] password, byte[] salt) {
		MessageDigest md = null;
		try {
			md = MessageDigest.getInstance("SHA-256");
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return Base64.getEncoder().encodeToString(md.digest(combine(salt, password)));
	}
 
	public static String hashPass(String pass, String sel) {
		String hash;
		MessageDigest md = null;
		try {
			md = MessageDigest.getInstance("SHA-256");
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		hash = Base64.getEncoder().encodeToString(md.digest((sel + pass).getBytes()));
		return hash;
	}
 
	public static byte[] combine(byte[] a, byte[] b) {
		byte[] c = new byte[a.length + b.length];
		System.arraycopy(a, 0, c, 0, a.length);
		System.arraycopy(b, 0, c, a.length, b.length);
		return c;
	}
 
}

J'ai laissé la version uniquement avec des String pour constaté que c'est bien la même chose qui sort des deux fonctions.

A noter que le code de base vient de la discutions suivante :
http://www.developpez.net/forums/d16...age-sha-256-a/

Il ne faut pas oublier qu'il va te falloir avoir un générateur de salt pour chaque nouveau mot de passe et le stocker avec le hash du mot de passe.

Ce qui donnerait une version pseudo final :

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
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
 
public class Test {
 
	public static void main(String[] args) throws NoSuchAlgorithmException {
		byte[] salt = getRandomSalt();
		System.out.println(Base64.getEncoder().encodeToString(salt));
		byte[] password = "MotDePassEnClair".getBytes();
		System.out.println(hashPass(password, salt));
		System.out.println(hashPass("MotDePassEnClair", salt));
	}
 
	private static byte[] getRandomSalt() throws NoSuchAlgorithmException {
		// Uses a secure Random not a simple Random
		// Salt generation 64 bits long
		byte[] bSalt = new byte[8];
 
		SecureRandom.getInstance("SHA1PRNG").nextBytes(bSalt);
		return bSalt;
	}
 
	private static String hashPass(byte[] password, byte[] salt) {
		MessageDigest md = null;
		try {
			md = MessageDigest.getInstance("SHA-256");
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return Base64.getEncoder().encodeToString(md.digest(combine(salt, password)));
	}
 
	private static String hashPass(String password, byte[] salt) {
		return hashPass(password.getBytes(),salt);
	}
 
	public static byte[] combine(byte[] a, byte[] b) {
		byte[] c = new byte[a.length + b.length];
		System.arraycopy(a, 0, c, 0, a.length);
		System.arraycopy(b, 0, c, a.length, b.length);
		return c;
	}
 
}

A noter que j'ai pompé le random sur ce site :
https://www.owasp.org/index.php/Hashing_Java
Il me semble qu'il raconte des choses intéressante sur le sujet.

En général une base de donnée anonymisé est une base de donnée où on a altérée les informations utilisateur permettant une identification. Genre le nom et le prénom. Mais, c'est tout un autre sujet.

Cordialement,
Patrick Kolodziejczyk.

Attention quand même à getBytes sans arguments... c'est dépendant du système donc pas top top... préférer la version qui précise le charset à utiliser

Donc, remplacer les getBytes() par des getBytes("UTF-8").
Merci pour la relecture !

Cordialement,
Patrick Kolodziejczyk.

Merci infiniement!!!! Je vais lire le site owasp sur le sujet, en tous cas merci!