Password Management & Encoding

@Configuration
public class PasswordConfig {
 
    @Bean
    public PasswordEncoder passwordEncoder() {
        String encodingId = "argon2";
 
        Map<String, PasswordEncoder> encoders = new HashMap<>();
        // saltLength, hashLength, parallelism, memory (KB), iterations.
        // Tune so verification takes 250-500ms on production hardware.
        encoders.put("argon2", new Argon2PasswordEncoder(16, 32, 1, 1 << 16, 3));
        // Legacy algorithms stay registered so existing hashes still verify.
        encoders.put("bcrypt", new BCryptPasswordEncoder(12));
        encoders.put("scrypt", SCryptPasswordEncoder.defaultsForSpringSecurity_v5_8());
 
        var delegating = new DelegatingPasswordEncoder(encodingId, encoders);
        // Hashes stored before prefixes existed are assumed BCrypt rather than
        // throwing. Remove this once the migration is complete.
        delegating.setDefaultPasswordEncoderForMatches(new BCryptPasswordEncoder(10));
        return delegating;
    }
}

{argon2}$argon2id$v=19$m=65536,t=3,p=1$c29tZXNhbHQ$RdescudvJCsgt3ub+b+dWRWJTmaaJObG
{bcrypt}$2a$12$GhvMmNVjRW29ulnudl.LbuAnUtN/LRfe1JsBm1Xu6LE3059z5Tr8m

@Component
public class HashUpgradeListener {
 
    private final UserRepository users;
    private final PasswordEncoder encoder;
 
    @EventListener
    public void onSuccess(AuthenticationSuccessEvent event) {
        Authentication auth = event.getAuthentication();
        String rawPassword = String.valueOf(auth.getCredentials());
        if (!StringUtils.hasText(rawPassword)) return;
 
        users.findByEmailIgnoreCase(auth.getName()).ifPresent(user -> {
            if (encoder.upgradeEncoding(user.passwordHash())) {
                user.setPasswordHash(encoder.encode(rawPassword));
                users.save(user);
                log.info("upgraded password hash for user {}", user.id());
            }
        });
    }
}

@Component
public class PasswordPolicy {
 
    private final PasswordValidator validator = new PasswordValidator(List.of(
            new LengthRule(12, 128),
            new WhitespaceRule(WhitespaceRule.Whitespace.TAB),
            // Reject sequences and repeats, which look complex and are not.
            new RepeatCharacterRegexRule(4),
            new IllegalSequenceRule(EnglishSequenceData.Alphabetical, 5, false),
            new IllegalSequenceRule(EnglishSequenceData.Numerical, 5, false),
            new UsernameRule(true, true)));
 
    private final BreachedPasswordChecker breached;
 
    public void assertAcceptable(String password, String username) {
        var result = validator.validate(new PasswordData(username, password));
        if (!result.isValid()) {
            throw new WeakPasswordException(validator.getMessages(result));
        }
        if (breached.isBreached(password)) {
            throw new WeakPasswordException(List.of(
                "This password has appeared in a known data breach. Please choose another."));
        }
    }
}

@Component
public class BreachedPasswordChecker {
 
    private final RestClient client;
 
    public boolean isBreached(String password) {
        String sha1 = DigestUtils.sha1Hex(password).toUpperCase(Locale.ROOT);
        String prefix = sha1.substring(0, 5);
        String suffix = sha1.substring(5);
 
        try {
            String body = client.get()
                    .uri("https://api.pwnedpasswords.com/range/{prefix}", prefix)
                    .retrieve().body(String.class);
 
            return body != null && body.lines()
                    .anyMatch(line -> line.startsWith(suffix));
 
        } catch (RestClientException ex) {
            // Fail open: a third-party outage must not block registration.
            log.warn("breach check unavailable", ex);
            return false;
        }
    }
}