Хэшировал ли пароли в Java Security

Да, работал с хешированием паролей и знаю Security best practices в Java

Причины хеширования паролей

Никогда нельзя хранить пароли в открытом виде. Даже если база данных скомпрометирована, хеширование защищает пользовательские пароли от прямого доступа. Это критическое требование любого сертификата безопасности (OWASP, PCI-DSS, GDPR).

Ключевые принципы:

• Пароль должен быть необратимым
• Один и тот же пароль должен давать разные хеши (salt)
• Хеширование должно быть медленным (замедляет brute-force атаки)
• Нельзя использовать простые алгоритмы (MD5, SHA1 - deprecated)

Spring Security: BCrypt (Recommended)

// Правильный способ - использование BCrypt через Spring Security
@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        // BCrypt с strength 12 (балансирует между скоростью и безопасностью)
        return new BCryptPasswordEncoder(12);
    }
}

@Service
public class UserService {
    
    @Autowired
    private PasswordEncoder passwordEncoder;
    
    @Autowired
    private UserRepository userRepository;
    
    // Регистрация пользователя с хешированием пароля
    public void registerUser(String username, String plainPassword, String email) {
        String hashedPassword = passwordEncoder.encode(plainPassword);
        
        User user = User.builder()
                .username(username)
                .password(hashedPassword)  // Сохраняем хеш, не пароль
                .email(email)
                .build();
        
        userRepository.save(user);
    }
    
    // Проверка пароля при логине
    public boolean authenticateUser(String username, String plainPassword) {
        User user = userRepository.findByUsername(username)
                .orElseThrow(() -> new UserNotFoundException(username));
        
        // matches() - сравнивает plainPassword с хешем в БД
        return passwordEncoder.matches(plainPassword, user.getPassword());
    }
}

Как работает BCrypt

// BCrypt внутренняя механика
public class BCryptExample {
    
    public static void main(String[] args) {
        PasswordEncoder encoder = new BCryptPasswordEncoder(12);
        String plainPassword = "mySecurePassword123";
        
        // Кодирование - каждый раз разный результат благодаря salt
        String hash1 = encoder.encode(plainPassword);
        String hash2 = encoder.encode(plainPassword);
        
        System.out.println("Hash 1: " + hash1);
        System.out.println("Hash 2: " + hash2);
        // Output: разные хеши!
        
        // Проверка - можно сравнить любой хеш с оригинальным паролем
        System.out.println(encoder.matches(plainPassword, hash1));  // true
        System.out.println(encoder.matches(plainPassword, hash2));  // true
        System.out.println(encoder.matches("wrongPassword", hash1));  // false
    }
}

// Структура BCrypt хеша: $2a$12$...
// $2a     - версия алгоритма
// 12     - cost factor (2^12 = 4096 iterations)
// ...    - salt + hash

PBKDF2 (FIPS 140 compliant)

// Когда нужна FIPS 140-2 совместимость (например, government системы)
@Configuration
public class SecurityConfigFIPS {
    
    @Bean
    public PasswordEncoder pbkdf2PasswordEncoder() {
        // PBKDF2 с 600,000+ итерациями (рекомендация NIST)
        return new Pbkdf2PasswordEncoder(
                "secretSalt",           // secret (опционально)
                16,                     // salt length
                600000,                 // iterations (очень важно для security)
                Pbkdf2PasswordEncoder.SecretKeyFactoryAlgorithm.PBKDF2WithHmacSHA256
        );
    }
}

@Service
public class SecureUserService {
    
    @Autowired
    private PasswordEncoder pbkdf2Encoder;
    
    public void registerSecureUser(String username, String plainPassword) {
        // PBKDF2 детерминистичен для одного и того же salt
        // Но с случайным salt для каждого пользователя
        String hashedPassword = pbkdf2Encoder.encode(plainPassword);
        // ...
    }
}

Argon2 (Современный и мощный)

// Argon2 - лучший выбор для новых проектов
@Configuration
public class Argon2Config {
    
    @Bean
    public PasswordEncoder argon2PasswordEncoder() {
        return new Argon2PasswordEncoder(
                16,                    // salt length
                32,                    // hash length
                1,                     // parallelism
                60000,                 // memory (KB)
                2                      // iterations
        );
    }
}

@Service
public class ModernUserService {
    
    @Autowired
    private PasswordEncoder argon2Encoder;
    
    // Argon2 устойчив к GPU и ASIC атакам благодаря memory-hard функции
    public void registerUser(String username, String plainPassword) {
        String hashedPassword = argon2Encoder.encode(plainPassword);
        // Это реально медленная операция (несколько сотен миллисекунд)
        // Но это хорошо для security
        // ...
    }
}

Миграция паролей на более сильный алгоритм

// Иногда нужно мигрировать со старого алгоритма (например, MD5) на новый
@Service
public class PasswordMigrationService {
    
    @Autowired
    private PasswordEncoder bcryptEncoder;
    
    @Autowired
    private UserRepository userRepository;
    
    // Lazy migration при логине
    public boolean authenticateAndMigrate(String username, String plainPassword) {
        User user = userRepository.findByUsername(username)
                .orElseThrow(() -> new UserNotFoundException(username));
        
        // Проверяем старый MD5 хеш
        if (isLegacyMD5Hash(user.getPassword())) {
            if (verifyAgainstMD5(plainPassword, user.getPassword())) {
                // Пароль верный, мигрируем на BCrypt
                String newHash = bcryptEncoder.encode(plainPassword);
                user.setPassword(newHash);
                user.setPasswordAlgorithm("bcrypt");
                userRepository.save(user);
                return true;
            }
            return false;
        }
        
        // Проверяем новый BCrypt хеш
        return bcryptEncoder.matches(plainPassword, user.getPassword());
    }
    
    private boolean isLegacyMD5Hash(String hash) {
        return hash != null && hash.matches("^[a-f0-9]{32}$");  // MD5 pattern
    }
    
    private boolean verifyAgainstMD5(String plainPassword, String hash) {
        String md5Hash = DigestUtils.md5DigestAsHex(plainPassword.getBytes());
        return md5Hash.equals(hash);
    }
}

Безопасное сравнение (Constant-Time)

// Важно! Используй constant-time сравнение для защиты от timing attacks
public class TimingSafeComparison {
    
    public static void main(String[] args) {
        // ПЛОХО - уязвимо для timing attacks
        // String.equals() выходит на первом несовпадении
        String password = "secret123";
        String userInput = "wrong";
        boolean match = password.equals(userInput);  // Timing выдаёт информацию
        
        // ХОРОШО - PasswordEncoder.matches() использует constant-time сравнение
        PasswordEncoder encoder = new BCryptPasswordEncoder();
        String hash = encoder.encode("secret123");
        encoder.matches(userInput, hash);  // Safe - всегда одинаковое время
    }
}

Полный пример Spring Security с хешированием

@Configuration
@EnableWebSecurity
public class SecurityConfiguration {
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(12);
    }
    
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/auth/**").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .permitAll()
            )
            .httpBasic(withDefaults());
        
        return http.build();
    }
    
    @Bean
    public UserDetailsService userDetailsService(UserRepository userRepository) {
        return username -> userRepository.findByUsername(username)
                .map(user -> User.builder()
                        .username(user.getUsername())
                        .password(user.getPassword())  // BCrypt hash
                        .authorities(user.getAuthorities())
                        .accountExpired(false)
                        .credentialsExpired(false)
                        .accountLocked(false)
                        .enabled(true)
                        .build())
                .orElseThrow(() -> new UsernameNotFoundException("User not found"));
    }
}

Что НИКОГДА не делать

// ❌ КРИТИЧЕСКИ ОПАСНО
public class BadPasswordHandling {
    
    // Никогда не сохраняй пароль в открытом виде
    public void wrongWay1(String password) {
        user.setPassword(password);  // ОПАСНО!
    }
    
    // Никогда не используй слабые алгоритмы
    public void wrongWay2(String password) {
        String hash = DigestUtils.md5DigestAsHex(password.getBytes());  // MD5 - ОПАСНО!
        user.setPassword(hash);
    }
    
    // Никогда не хеши без salt
    public void wrongWay3(String password) {
        String hash = DigestUtils.sha256Hex(password);  // SHA256 без salt - ОПАСНО!
    }
    
    // Никогда не логируй пароли
    public void wrongWay4(String password) {
        log.info("User logged in with password: {}", password);  // ОПАСНО!
    }
    
    // Никогда не отправляй пароль по незащищённым каналам
    public void wrongWay5() {
        sendEmailUnencrypted("Your password is: ");  // ОПАСНО!
    }
}

Лучшие практики

1. Используй BCrypt по умолчанию - простой и безопасный
2. Для новых проектов - Argon2 - самый современный
3. Никогда не используй MD5/SHA1 - deprecated
4. Используй Spring Security - правильная реализация из коробки
5. Регулярно обновляй cost factor - по мере роста вычислительной мощности
6. Логируй попытки аутентификации - но НИКОГДА не логируй сам пароль
7. Используй HTTPS - передавай пароли только по защищённым каналам
8. Требуй сильные пароли - валидация на клиенте и сервере

Мой опыт включает миграцию систем с MD5 на BCrypt, реализацию двухфакторной аутентификации, и защиту от распространённых атак на аутентификацию.