J'essaie donc de comparer mon mot de passe d'origine à un mot de passe salé. Je sais comment comparer un mot de passe de hachage, je prends le mot de passe d'origine, ajoutez-le et cela fonctionne. Cependant, je ne sais pas comparer le sel.

public static String saltPassword(String password) throws NoSuchAlgorithmException{
     String salt = getSalt();
     return password + salt;
 }
public static String getSalt(){
     Random r = new SecureRandom();
     byte[] saltBytes = new byte[32];
     r.nextBytes(saltBytes);
     return Base64.getEncoder().encodeToString(saltBytes);
 }

Que dois-je faire pour comparer le mot de passe d'origine avec celui-ci?

C'est littéralement ce que mon devoir dit, "Comparez le mot de passe généré avec le sel stocké et le mot de passe haché".

1
student guy 29 mars 2020 à 07:26

3 réponses

Meilleure réponse

Vous devez également stocker le sel. Salt est utilisé pour empêcher la génération du même mot de passe haché lorsque deux utilisateurs choisissent le même mot de passe. quelque chose comme les codes suivants peuvent être utilisés pour enregistrer le mot de passe en tant que hashedPassord et vérifier le mot de passe saisi. Il n'est pas complet mais peut être utilisé comme exemple de code.

private static void savePassword(String rawPassword) throws InvalidKeySpecException, NoSuchAlgorithmException {
    byte[] salt = getSalt();
    String hashedPassword = getHashedPassword(rawPassword, salt);
    String encodedSalt = base64Encode(salt);

    /* todo: store hashPassword and encodedSalt */
}

private static boolean verifyPassword(String rawPassword, String hashedPassword, String encodedSalt) throws InvalidKeySpecException, NoSuchAlgorithmException {
    return Objects.equals(hashedPassword, getHashedPassword(rawPassword, base64Decode(encodedSalt)));
}

private static String getHashedPassword(String rawPassword, byte[] salt) throws NoSuchAlgorithmException, InvalidKeySpecException {
    KeySpec spec = new PBEKeySpec(rawPassword.toCharArray(), salt, 65536, 128);
    SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
    byte[] hash = factory.generateSecret(spec).getEncoded();
    return base64Encode(hash);
}

private static byte[] getSalt() {
    Random r = new SecureRandom();
    byte[] saltBytes = new byte[32];
    r.nextBytes(saltBytes);
    return saltBytes;
}

private static String base64Encode(byte[] src) {
    return Base64.getEncoder().encodeToString(src);
}

private static byte[] base64Decode(String src) {
    return Base64.getDecoder().decode(src);
}
2
Mohsen Zamani 29 mars 2020 à 06:40

Comment comparer Salt avec un mot de passe généré?

Que dois-je faire pour comparer le mot de passe d'origine avec celui-ci?

La réponse est que vous ne faites pas non plus ces choses.

Pour enregistrer le mot de passe d'origine, procédez comme suit:

  1. Obtenez un 1 sel
  2. Combinez le mot de passe d'origine avec le sel
  3. Hash ça.
  4. Conservez le sel et le haschich.

Vous supprimez ensuite le mot de passe d'origine.

Pour vérifier qu'un mot de passe fourni, vous procédez comme suit:

  1. Recherchez le hachage stocké et le sel correspondant qui ont été créés lors de l'inscription; voir au dessus.
  2. Combinez le mot de passe et le sel fournis de la même manière que ci-dessus.
  3. Hash comme ci-dessus.
  4. Comparez le hachage résultant avec le hachage stocké. S'ils sont identiques, le mot de passe fourni est le bon mot de passe.

Comme vous pouvez le voir, vous ne comparez ni le sel ni le mot de passe d'origine avec quoi que ce soit.

Mais il est également essentiel d'utiliser le même sel lors de la génération des hachages pour le mot de passe d'origine et le mot de passe que vous vérifiez. Sinon, la vérification du mot de passe ne fonctionne pas.


1 - Le sel n'est qu'un nombre ou une chaîne. Idéalement, les valeurs de sel devraient être différentes. Le but du sel est d'éviter une soi-disant attaque "rainbow table" pour récupérer le mot de passe d'origine provenant d'un hachage de mot de passe volé (non salé). S'il y a (disons) un million de valeurs de sel possibles, alors les méchants doivent générer un million de tables arc-en-ciel différentes. La génération et le stockage de nombreuses tables arc-en-ciel deviennent peu pratiques.

0
Stephen C 29 mars 2020 à 06:59

Ok, voici ce que j'ai. J'adorerais chercher un mot de passe stocké mais mon professeur ne le fait pas de cette façon dans sa vidéo de solution

public static String saltPassword(String password) throws NoSuchAlgorithmException{
     String salt = getSalt();
     return hashPassword(password + salt);
 }
 public static String getSalt(){
     Random r = new SecureRandom();
     byte[] saltBytes = new byte[32];
     r.nextBytes(saltBytes);
     return Base64.getEncoder().encodeToString(saltBytes);
 }
 public static String generatePassword(){
        String charSet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-+!@#$%";
        String password = "";
        int start = 0;
        int stop = 0;
        int minLength = 8;

        for (int i = 0; i <= minLength; i++) {
                // get a random character from the chars string
                start = getRandomNumber(charSet.length());
                stop = start + 1;
                password += charSet.substring(start, stop);
        }        
        return password;
    }
    private static int getRandomNumber(int maxValue){
        double randomNumber;
        randomNumber = Math.floor(Math.random() * maxValue);

        return (int)randomNumber;
    }
    public static String hashPassword(String password)throws NoSuchAlgorithmException{
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        md.update(password.getBytes());
        byte[] mdArray = md.digest();
        StringBuilder sb = new StringBuilder(mdArray.length * 2);
        for (byte b : mdArray){
            int v = b & 0xff;
            if(v < 16){
                sb.append('0');
            }
            sb.append(Integer.toHexString(v));
        }
        return sb.toString();   
    }

Ensuite, pour le créer, je vais aller

    String newPassword = PasswordUtil.generatePassword();
    String hashedPassword = "";
    String saltedPassword = "";

try{
            hashedPassword = PasswordUtil.hashPassword(newPassword);
        }
        catch(NoSuchAlgorithmException e){
            System.out.println();
        }
        try{
            saltedPassword = PasswordUtil.saltPassword(hashedPassword);
        }
        catch(NoSuchAlgorithmException e) {
            System.out.println();
        }

Que se passe-t-il ensuite?

C'est le mot de passe haché:

50f99d2a635cc9bac7e001506789b55a7c603d93c89d362cc5d95ab257fc2666

Et c'est le haschich avec le sel

e954fbc2309cc359cd603effb6d0644947a3253110ad6c3b2416dd49168331a3
0
student guy 29 mars 2020 à 05:19