비밀번호 해시 역할

./gradlew test --tests board.member.PasswordHasherTest --tests board.member.LoginServiceTest

package board.member;

public interface PasswordHasher {
    String hash(String rawPassword);
    boolean matches(String rawPassword, String encodedPasswordHash);
}

package board.member;

import java.util.Objects;

public final class TestPasswordHasher implements PasswordHasher {
    private static final int MAX_RAW_PASSWORD_LENGTH = 1_024;
    private static final int MAX_ENCODED_LENGTH = 64;

    @Override
    public String hash(String rawPassword) {
        Objects.requireNonNull(rawPassword, "rawPassword must not be null");
        if (rawPassword.length() > MAX_RAW_PASSWORD_LENGTH) {
            throw new IllegalArgumentException("rawPassword is too long");
        }
        return "{test}" + Integer.toHexString(rawPassword.hashCode());
    }

    @Override
    public boolean matches(String rawPassword, String encodedPasswordHash) {
        if (rawPassword == null
                || rawPassword.length() > MAX_RAW_PASSWORD_LENGTH
                || encodedPasswordHash == null
                || encodedPasswordHash.length() > MAX_ENCODED_LENGTH) {
            return false;
        }
        return encodedPasswordHash.equals(hash(rawPassword));
    }
}

package board.member;

public record PasswordHashSettings(
        int iterations,
        int saltLengthBytes,
        int hashLengthBytes
) {
    public static final int MIN_ITERATIONS = 600_000;
    public static final int MAX_ITERATIONS = 5_000_000;
    public PasswordHashSettings {
        if (iterations < MIN_ITERATIONS || iterations > MAX_ITERATIONS
                || saltLengthBytes < 16 || saltLengthBytes > 64
                || hashLengthBytes < 32 || hashLengthBytes > 64) {
            throw new IllegalArgumentException(
                    "password hash settings are outside supported ranges");
        }
    }

    public static PasswordHashSettings productionDefaults() {
        return new PasswordHashSettings(600_000, 16, 32);
    }

}

package board.member;

import java.security.GeneralSecurityException;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Base64;
import java.util.Objects;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;

public final class Pbkdf2PasswordHasher implements PasswordHasher {
    private static final String ALGORITHM = "PBKDF2WithHmacSHA256";
    private static final String FORMAT = "pbkdf2-sha256";
    private static final String VERSION = "v1";
    private static final int MAX_RAW_PASSWORD_LENGTH = 1_024;
    private static final int MAX_ENCODED_LENGTH = 512;
    private static final Base64.Encoder ENCODER =
            Base64.getUrlEncoder().withoutPadding();
    private static final Base64.Decoder DECODER = Base64.getUrlDecoder();

    private final PasswordHashSettings settings;
    private final SecureRandom random;

    public Pbkdf2PasswordHasher(PasswordHashSettings settings) {
        this(settings, new SecureRandom());
    }

    Pbkdf2PasswordHasher(PasswordHashSettings settings, SecureRandom random) {
        this.settings = Objects.requireNonNull(
                settings, "settings must not be null");
        this.random = Objects.requireNonNull(
                random, "random must not be null");
    }

    @Override
    public String hash(String rawPassword) {
        requireHashInput(rawPassword);
        byte[] salt = new byte[settings.saltLengthBytes()];
        random.nextBytes(salt);
        byte[] derived = null;
        try {
            derived = derive(rawPassword, salt, settings.iterations());
            return "$%s$%s$%d$%s$%s".formatted(
                    FORMAT, VERSION,
                    settings.iterations(),
                    ENCODER.encodeToString(salt),
                    ENCODER.encodeToString(derived));
        } finally {
            clear(salt);
            clear(derived);
        }
    }

    @Override
    public boolean matches(String rawPassword, String encodedPasswordHash) {
        if (rawPassword == null
                || rawPassword.length() > MAX_RAW_PASSWORD_LENGTH) {
            return false;
        }
        ParsedHash parsed = parse(encodedPasswordHash);
        if (parsed == null) {
            return false;
        }

        byte[] derived = null;
        try {
            derived = derive(rawPassword, parsed.salt(), parsed.iterations());
            return MessageDigest.isEqual(parsed.hash(), derived);
        } finally {
            clear(derived);
            clear(parsed.salt());
            clear(parsed.hash());
        }
    }

    private ParsedHash parse(String encodedPasswordHash) {
        if (encodedPasswordHash == null
                || encodedPasswordHash.length() > MAX_ENCODED_LENGTH) {
            return null;
        }
        String[] parts = encodedPasswordHash.split("\\$", -1);
        if (parts.length != 6
                || !parts[0].isEmpty()
                || !FORMAT.equals(parts[1])
                || !VERSION.equals(parts[2])
                || !parts[3].matches("[1-9][0-9]{0,7}")) {
            return null;
        }

        int iterations = Integer.parseInt(parts[3]);
        if (iterations < PasswordHashSettings.MIN_ITERATIONS
                || iterations > PasswordHashSettings.MAX_ITERATIONS) {
            return null;
        }

        byte[] salt = decodeCanonical(parts[4]);
        byte[] hash = decodeCanonical(parts[5]);
        if (salt == null || hash == null
                || salt.length != settings.saltLengthBytes()
                || hash.length != settings.hashLengthBytes()) {
            clear(salt);
            clear(hash);
            return null;
        }
        return new ParsedHash(iterations, salt, hash);
    }

    private static byte[] decodeCanonical(String encoded) {
        try {
            byte[] decoded = DECODER.decode(encoded);
            if (!ENCODER.encodeToString(decoded).equals(encoded)) {
                clear(decoded);
                return null;
            }
            return decoded;
        } catch (IllegalArgumentException ignored) {
            return null;
        }
    }

    private byte[] derive(String rawPassword, byte[] salt, int iterations) {
        char[] password = rawPassword.toCharArray();
        var spec = new PBEKeySpec(password, salt, iterations,
                settings.hashLengthBytes() * Byte.SIZE);
        try {
            return SecretKeyFactory.getInstance(ALGORITHM)
                    .generateSecret(spec)
                    .getEncoded();
        } catch (GeneralSecurityException exception) {
            throw new IllegalStateException(
                    "PBKDF2 is unavailable", exception);
        } finally {
            spec.clearPassword();
            Arrays.fill(password, '\0');
        }
    }

    private static void requireHashInput(String rawPassword) {
        Objects.requireNonNull(rawPassword, "rawPassword must not be null");
        if (rawPassword.length() > MAX_RAW_PASSWORD_LENGTH) {
            throw new IllegalArgumentException("rawPassword is too long");
        }
    }

    private static void clear(byte[] value) {
        if (value != null) {
            Arrays.fill(value, (byte) 0);
        }
    }

    private record ParsedHash(int iterations, byte[] salt, byte[] hash) { }
}

package board.member;

public final class InvalidCredentialsException extends RuntimeException {
    public InvalidCredentialsException() { super("invalid credentials"); }
}

package board.member;

import java.util.Locale;
import java.util.Objects;
import java.util.Optional;

public final class LoginService {
    private static final int MAX_EMAIL_LENGTH = 254;
    private static final String DUMMY_RAW_PASSWORD =
            "dummy-password-for-timing-equalization";

    private final MemberRepository members;
    private final PasswordHasher passwordHasher;
    private final String dummyPasswordHash;

    public LoginService(MemberRepository members, PasswordHasher passwordHasher) {
        this.members = Objects.requireNonNull(
                members, "members must not be null");
        this.passwordHasher = Objects.requireNonNull(
                passwordHasher, "passwordHasher must not be null");
        this.dummyPasswordHash = passwordHasher.hash(DUMMY_RAW_PASSWORD);
    }

    public long authenticate(String email, String rawPassword) {
        Optional<Member> member = findMember(email);
        String encodedHash = member.map(Member::passwordHash)
                .orElse(dummyPasswordHash);

        boolean passwordMatches = passwordHasher.matches(rawPassword, encodedHash);
        if (member.isEmpty() || !passwordMatches) {
            throw new InvalidCredentialsException();
        }
        return member.orElseThrow().id();
    }

    private Optional<Member> findMember(String email) {
        if (email == null || email.length() > MAX_EMAIL_LENGTH) {
            return Optional.empty();
        }
        String normalized = email.strip().toLowerCase(Locale.ROOT);
        if (normalized.isEmpty() || normalized.length() > MAX_EMAIL_LENGTH) {
            return Optional.empty();
        }
        return members.findByEmail(normalized);
    }
}

package board.member;

import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Base64;
import java.util.List;
import org.junit.jupiter.api.Test;

import static org.assertj.core.api.Assertions.assertThat;

final class PasswordHasherTest {
    private static final String RAW_PASSWORD = "secret-1234";
    private static final PasswordHashSettings TEST_SETTINGS =
            new PasswordHashSettings(600_000, 16, 32);

    @Test
    void 두_구현이_같은_규칙을_지킨다() {
        for (PasswordHasher hasher : List.of(
                new TestPasswordHasher(),
                new Pbkdf2PasswordHasher(TEST_SETTINGS))) {
            var spacedRaw = " raw password: 1234 ";
            var encoded = hasher.hash(spacedRaw);

            assertThat(encoded).isNotBlank().doesNotContain(spacedRaw);
            assertThat(List.of(
                    hasher.matches(spacedRaw, encoded),
                    hasher.matches("wrong", encoded),
                    hasher.matches("raw password: 1234", encoded),
                    hasher.matches(RAW_PASSWORD, null),
                    hasher.matches(RAW_PASSWORD, "{unknown}value")))
                    .containsExactly(true, false, false, false, false);
        }
    }

    @Test
    void 같은_원문도_salt가_달라_인코딩이_다르다() {
        var hasher = new Pbkdf2PasswordHasher(
                TEST_SETTINGS, new SequenceSecureRandom());
        var first = hasher.hash(RAW_PASSWORD);
        var second = hasher.hash(RAW_PASSWORD);

        assertThat(first).isNotEqualTo(second);
        assertThat(hasher.matches(RAW_PASSWORD, first)).isTrue();
    }

    @Test
    void 잘못된_버전_비용_인코딩_길이는_파싱에서_거절한다() {
        var hasher = new Pbkdf2PasswordHasher(TEST_SETTINGS);
        var encoded = hasher.hash(RAW_PASSWORD);
        var parts = encoded.split("\\$", -1);
        var encoder = Base64.getUrlEncoder().withoutPadding();
        var rejected = List.of(
                encoded.replace("$v1$", "$v2$"),
                encoded.replace("$600000$", "$599999$"),
                encoded.replace("$600000$", "$5000001$"),
                encodedWith(parts, parts[4] + "==", parts[5]),
                encodedWith(parts,
                        encoder.encodeToString(new byte[15]), parts[5]),
                encodedWith(parts, parts[4],
                        encoder.encodeToString(new byte[31])));

        assertThat(rejected).allSatisfy(candidate ->
                assertThat(hasher.matches(RAW_PASSWORD, candidate)).isFalse());
    }

    private static String encodedWith(String[] parts, String salt, String hash) {
        return "$%s$%s$%s$%s$%s".formatted(
                parts[1], parts[2], parts[3], salt, hash);
    }

    private static final class SequenceSecureRandom extends SecureRandom {
        private int nextValue;

        @Override
        public void nextBytes(byte[] bytes) {
            Arrays.fill(bytes, (byte) nextValue);
            nextValue += 1;
        }
    }
}

package board.member;

import org.junit.jupiter.api.Test;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

final class LoginServiceTest {
    private static final String EMAIL = "[email protected]";
    private static final String RAW_PASSWORD = "secret-1234";
    private static final String DUMMY_RAW_PASSWORD =
            "dummy-password-for-timing-equalization";

    @Test
    void 올바른_비밀번호는_회원_ID를_반환한다() {
        var members = new MemoryMemberRepository();
        var recording = new RecordingPasswordHasher();
        Member saved = members.save(Member.signUp(
                EMAIL, "회원", recording.hash(RAW_PASSWORD)));
        var login = new LoginService(members, recording);

        long memberId = login.authenticate(
                " [email protected] ", RAW_PASSWORD);

        assertThat(memberId).isEqualTo(saved.id());
        assertThat(recording.matchesCalls).isEqualTo(1);
    }

    @Test
    void 네_실패는_같은_예외와_한_번의_matches로_수렴한다() {
        String dummyHash = assertFailure(
                null, "[email protected]", RAW_PASSWORD);
        assertThat(new TestPasswordHasher().matches(
                DUMMY_RAW_PASSWORD, dummyHash)).isTrue();
        assertFailure(null, "İ".repeat(254), RAW_PASSWORD);
        String correctHash = new TestPasswordHasher()
                .hash("correct-password");
        assertFailure(correctHash, EMAIL, "wrong-password");
        assertFailure("{broken}", EMAIL, RAW_PASSWORD);
    }

    private static String assertFailure(
            String storedHash, String email, String rawPassword
    ) {
        var members = new MemoryMemberRepository();
        if (storedHash != null) {
            members.save(Member.signUp(EMAIL, "회원", storedHash));
        }
        var recording = new RecordingPasswordHasher();
        var login = new LoginService(members, recording);

        assertThatThrownBy(() -> login.authenticate(email, rawPassword))
                .isInstanceOf(InvalidCredentialsException.class)
                .hasMessage("invalid credentials");
        assertThat(recording.matchesCalls).isEqualTo(1);
        return recording.lastEncodedHash;
    }

    private static final class RecordingPasswordHasher
            implements PasswordHasher {
        private final PasswordHasher delegate = new TestPasswordHasher();
        private int matchesCalls;
        private String lastEncodedHash;

        @Override
        public String hash(String rawPassword) {
            return delegate.hash(rawPassword);
        }

        @Override
        public boolean matches(String rawPassword, String encodedPasswordHash) {
            matchesCalls += 1;
            lastEncodedHash = encodedPasswordHash;
            return delegate.matches(rawPassword, encodedPasswordHash);
        }
    }
}