Weak Password Hash

import java.security.MessageDigest;

public class WeakHashingExample {
    // FLAW: Weak for password hashing, no salt...
    public static String hashPassword(String password) throws Exception {
        MessageDigest sha1 = MessageDigest.getInstance("SHA-256");
        byte[] hashedBytes = sha1.digest(password.getBytes());
        return bytesToHex(hashedBytes);
    }

    public

    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
}

import org.bouncycastle.crypto.generators.Argon2BytesGenerator;
import org.bouncycastle.crypto.params.Argon2Parameters;
import java.security.MessageDigest;
import java.util.Base64;
import java.security.SecureRandom;

public class Argon2Hashing {

    public static String hashPassword(String password, byte[] salt) {
        // Set realistic values for Argon2 parameters
        int parallelism = 2; // Use 2 threads
        int memory = 47104; // Use 46 MiB of memory
        int iterations = 3; // Run 3 iterations
        int hashLength = 32; // Generate a 32 byte (256 bit) hash

        var generator = new Argon2BytesGenerator();

        // You need to generate a random salt, one per password
        var builder = new Argon2Parameters.Builder(Argon2Parameters.ARGON2_id)
            .withSalt(salt)
            .withParallelism(parallelism) // Parallelism factor
            .withMemoryAsKB(memory) // Memory cost
            .withIterations(iterations); // Number of iterations

        generator.init(builder.build());
        byte[] result = new byte[hashLength];
        generator.generateBytes(password.toCharArray(), result);
        return Base64.getEncoder().encodeToString(result);
    }

    public static boolean verifyPassword(String password, String hashedPassword, byte[] salt) {
        String generatedHash = hashPassword(password, salt);
        byte[] decoded = Base64.getDecoder().decode(generatedHash);
        byte[] decodedHashed = Base64.getDecoder().decode(hashedPassword);
        return MessageDigest.isEqual(decoded, decodedHashed);
    }

    public static byte[] randomSalt() {
        SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
        byte[] salt = new byte[32];
        sr.nextBytes(salt);
        return salt;
    }
}

@Configuration
public class SecurityConfig {
    @Bean public PasswordEncoder passwordEncoder() {
        // salt length = 32 bytes, hash length = 64 bytes,
        // parallelism = 1, memory = 47104 (46 MiB), iterations = 3
        return new Argon2PasswordEncoder(32, 64, 1, 47104, 3);
    }
}

@Service
public class UserService {
    private final PasswordEncoder passwordEncoder;

    public UserService(PasswordEncoder passwordEncoder) {
        this.passwordEncoder = passwordEncoder;
    }

    public void createUser(String username, String password) {
        String hashedPassword = passwordEncoder.encode(password);
        // Save user with hashed password
        // ...
    }

    public boolean verifyPassword(String password, String storedHash) {
        return passwordEncoder.matches(password, storedHash);
    }
}

  # The thresholds used for each of the hashing algorithms
  thresholds:
    # Argon2d iterations
    - argon2.iterations: 3
    # Argon2d memory to use (in KiB)
    - argon2.mem: 12
    # Argon2d threads
    - argon2.parallel: 1

    # Scrypt parameters explained in https://words.filippo.io/the-scrypt-parameters/.
    # Recommended values are N=2^17, r=8, p=1
    # scrypt cpu factor (N), 131072 means 2^17 (recommended value for 2024)
    - scrypt.cpu: 131072
    # scrypt memory factor (r): the hash is 2r wider wrt. the core hash function (Salsa20 core). 8 means 1024 bytes
    # The real memory usage is 𝑁 × 2𝑟 × 64 = (128 × 𝑁 × 𝑟) bytes
    - scrypt.mem: 8
    # scrypt parallelization parameter (p), number of instances of mixing function that runs independently for salt to the final PBKDF2.
    - scrypt.parallel: 1

    # bcrypt strength
    - bcrypt.strength: 10

    # PBKDF2 iterations. NIST recommends 600,000 iterations for HMAC-SHA-256 as of 2020.
    # Never use less than 10,000
    - pbkdf2: 600000

    # Iterations for Legacy password hashing based on "fast" hash functions such as SHA-256
    - fast.hash: 150000