Ich versuche, ein Salt in Java zu generieren, das mit einem Hashing-Algorithmus für die sichere Speicherung von Passwörtern verwendet wird. Ich benutze den folgenden Code, um das zufällige Salt zu erstellen:

private static String getSalt() throws NoSuchAlgorithmException {
    SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
    byte[] salt = new byte[16];
    sr.nextBytes(salt);
    System.out.println(salt.toString());
    return salt.toString();
}

Welche ein völlig sicheres, zufällig generiertes Salz für meinen Hashing-Algorithmus generieren sollte. Wenn ich den Code jedoch ausführe, wird jedes Mal das gleiche Salz ausgegeben. Dies zeigt an, dass das erzeugte Salz überhaupt nicht zufällig ist.

Für offensichtliche Sicherheitszwecke benötigt jeder Benutzer ein eindeutiges Salt. Wenn ich diesen Code jedoch jedes Mal verwende, wenn ein neues Konto erstellt wird, hat jeder Benutzer dasselbe Salt, was den Zweck zunichte macht, es überhaupt zu haben.

Meine Frage lautet: Warum gibt mir das immer wieder das gleiche Salz und was kann ich tun, um sicherzustellen, dass das erzeugte Salz bei jeder Ausführung des Codes völlig zufällig ist?

BEARBEITEN

Dachte, ich würde den Quellcode des gesamten Hashing-Programms einschließen, das jetzt behoben wurde und ordnungsgemäß funktioniert. Dies ist ein einfacher Prototyp, mit dem simuliert werden kann, wie der Hash beim Erstellen des Kontos generiert und das Kennwort beim Anmelden am System überprüft wird.

package hashingwstest;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
import java.util.Scanner;


public class HashingWSTest {

    public static void main(String[] args) throws NoSuchAlgorithmException {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter Password: ");
        String passwordToHash = sc.nextLine();

        byte[] bytes = getBytes();
        String salt = new String(bytes);

        String securePassword = hash256(passwordToHash, salt);
        System.out.println("Hash successfully generated");

        System.out.print("Enter your password again: ");
        String checkPassword = sc.nextLine();
        String checkHash = hash256(checkPassword,salt);
        if (checkHash.equals(securePassword)) {
            System.out.println("MATCH");
        }
        else {
            System.out.println("NO MATCH");
        }
    }

    private static String hash256(String passwordToHash, String salt) {
        String generatedPassword = null;
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            md.update(salt.getBytes());
            byte[] bytes = md.digest(passwordToHash.getBytes());
            StringBuilder sb = new StringBuilder();

            for (int i=0; i<bytes.length; i++) {
                sb.append(Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1));
            }
            generatedPassword = sb.toString();
        }
        catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return generatedPassword;
    }

    private static byte[] getBytes() throws NoSuchAlgorithmException {
        SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
        byte[] bytes = new byte[16];
        sr.nextBytes(bytes);
        return bytes;
    }
}