Ch11. 실전. 책임의 분리

예제 시나리오와 요구사항

• 클라이언트: 백엔드를 이용하는 애플리케이션
• 인증 서버: 사용자 자격 증명 데이터베이스를 포함하는 애플리케이션
  • 사용자의 자격 증명을 기준으로 사용자를 인증하고 SMS를 통해 OTP를 전송
• 비즈니스 논리 서버: 클라이언트가 이용할 엔드포인트를 노출하는 애플리케이션
  • 엔드포인트에 대한 접근에 보안을 적용한다.

클라이언트가 비즈니스 엔드 포인트를 호출하기 위한 단계

1. 비즈니스 논리 서버의 /login 호출, 사용자 이름과 암호를 인증하고 OTP 발급
   • 클라이언트가 사용자 이름과 암호를 인증하면 비즈니스 논리 서버가 OTP에 대한 요청을 인증 서버로 보낸다.
   • 인증이 성공하면 인증 서버가 임의로 생성된 OTP를 SMS를 통해 클라이언트로 보낸다
   • 이러한 사용자 인증 방식을 다단계 인증이라고 한다
2. 사용자 이름과 OTP를 이용해 /login 엔드포인트를 호출한다.
   • 클라이언트가 수신된 SMS의 코드를 확보하면 사용자는 다시 사용자 이름과 코드로 /login 엔드포인트를 호출할 수 있다.
   • 비즈니스 논리 서버는 인증서버로 코드를 검증하며, 코드가 유효하면 클라이언트는 비즈니스 논리 서버의 모든 엔드포인트를 호출하는데 이용할 수 있는 토큰을 받는다.
3. 2단계에서 얻은 토큰을 Http 요청의 Authorization 헤더에 추가하고 다른 엔드포인트를 호출한다.
   • 인증 단계에서 클라이언트는 2단계에서 얻은 토큰을 HTTP 요청의 Authenrization 헤더에 추가해 모든 엔드포인트를 호출할 수 있다.

이러한 사용자 인증 방식을 다단계 인증이라고 하며, 일반적인 인증 방식이다.(사용자는 자격 증명과 다른 식별 수단으로 자신이 누구인지 증명해야 한다)

토큰의 구현과 이용

토큰이란?

• 토큰은 애플리케이션이 사용자를 인증했음을 증명하는 방법을 제공해 사용자가 애플리케이션의 리소스에 액세스 할 수 있게 해 준다(토큰은 일종의 출입 카드)
• 토큰은 접근 권한을 부여하고 특정한 문을 여는 것 같은 작업이 허용되는지 결정한다.
• 토큰을 발급한 후 이를 이식할 수 있어야 한다.

토큰의 장점

• 토큰을 이용하면 요청할 때마다 자격증명을 공유할 필요가 없다.
  • Http Basic 방식은 요청할 때마다 자격 증명을 보내야 하지만, 이는 매번 자격 증명을 노출하는 것으로 옮지 않다.
  • 인증을 위한 첫번째 요청에만 자격 증명을 보내고 인증으로 받은 토큰으로 이후 리소스를 호출하기 위한 권한을 얻기 때문에 한 번만 자격 증명을 보내면 된다.
• 토큰의 수명을 짧게 지정할 수 있다.
  • 사용자 토큰이 탈취 되더라도 영원히 사용 불가능하다
• 자격 증명을 무효로 하지 않고 토큰을 무효로 할 수 있다.
• 클라이언트가 요청할 때 보내야 하는 사용자 권한과 같은 세부 정보를 토큰에 저장할 수도 있다.
  • 토큰에 사용자의 권한과 역할 같은 세부 정보를 저장하여 서버 쪽 세션을 클라이언트 세션으로 대체하여 수평 확장에 높은 유연성을 가질 수 있다.
• 토큰을 이용하면 인증 책임을 시스템의 다른 구성 요소에 위임할 수 있다.

JSON 웹 토큰이란?

• JWT는 Json Web Token에 약자이다.
• JWT는 세 부분으로 구성되고 각 부분은 마침표로(.)로 구분된다.
  • 1 부분: 헤더(Base64로 인코딩 되고 JSON으로 형식이 지정된다.)
    • 토큰과 관련된 메타데이터를 저장한다.
  • 2 부분: 본문(Base64로 인코딩 되고 JSON으로 형식이 지정된다.)
    • 권한 부여에 필요한 세부 정보를 저장할 수 있다.
    • 토큰은 가급적 짧게, 세부 정보를 짧게 유지하는 것이 좋다
      • 토큰이 너무 길면 요청 속도가 느려진다.
      • 토큰에 서명하는 경우 토큰이 길수록 암호화 알고리즘이 서명하는 시간이 길어진다.
  • 3 부분: 디지털 서명(생략 가능)
    • 해당 서명을 이용해 내용이 변경되지 않았는지 확인할 수 있다.
    • 서명이 없으면 네트워크에서 토큰을 전송할 때 누군가가 토큰을 가로채고 내용을 변경하지 않았는지 확신할 수 없다.

인증 서버 구현

노출될 엔드 포인트

• /user/add: 구현을 테스트하기 위해 사용자를 추가한다.
• /user/auth: 사용자를 인증하고 OTP가 포함된 SMS를 보낸다.(실제 SMS가 가는 건 X)
• /otp/check: OTP 값이 인증 서버가 특정 사용자를 위해 이전에 생성한 값인지 확인한다.

Schema.sql

create table if not exists `spring`.`user`(
    `username` varchar(45) null,
    `password` text null,
    primary key (`username`)
    );

create table if not exists `spring`.`otp`(
  `username` varchar(45) not null,
    `code` varchar(45) null,
    primary key (`username`)
    );

 

ProjectConfig

@Configuration
public class ProjectConfig extends WebSecurityConfigurerAdapter {

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable(); //애플리케이션의 엔드포인트를 직접 실행할 수 있게 CSRF 비활성화
        http.authorizeRequests() //인증없이 모든 호출 허용
                .anyRequest().permitAll();
    }
}

 

User

@Entity
@Getter
@Setter
public class User {
    @Id
    private String username;
    private String password;
}

OTP

@Entity
@Getter
@Setter
public class Otp {
    @Id
    private String username;
    private String code;
}

UserRepository

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findUserByUsername(String username);
}

OtpRepository

public interface OtpRepository extends JpaRepository<Otp, Long> {
    Optional<Otp> findOtpByUsername(String username);
}

 

UserService

@Service
@Transactional
@RequiredArgsConstructor
public class UserService {
    private final PasswordEncoder passwordEncoder;
    private final UserRepository userRepository;
    private final OtpRepository otpRepository;

    public void addUser(User user) {
        user.setPassword(passwordEncoder.encode(user.getPassword()));
        userRepository.save(user);
    }

    public void auth(User user) {
        Optional<User> o = userRepository.findUserByUsername(user.getUsername());
        if (o.isPresent()) {
            User u = o.get();
            if (passwordEncoder.matches(user.getPassword(), u.getPassword())) {
                renewOtp(u); //암호가 맞으면 새 OTP 생성
            } else {
                throw new BadCredentialsException("Bad credentials"); //암호가 틀리거나 사용자가 없으면 예외
            }
        } else {
            throw new BadCredentialsException("Bad credentials");//암호가 틀리거나 사용자가 없으면 예외
        }
    }

    private void renewOtp(User u) {
        String code = GenerateCodeUtil.generateCode();
        Optional<Otp> userOtp = otpRepository.findOtpByUsername(u.getUsername());
        if (userOtp.isPresent()) { //있으면 값 업데이트
            Otp otp = userOtp.get();
            otp.setCode(code);
        } else { //OTP 없으면 새로 지정
            Otp otp = new Otp();
            otp.setUsername(u.getUsername());
            otp.setCode(code);
            otpRepository.save(otp);
        }
    }
      public boolean check(Otp otpToValidation){
        Optional<Otp> userOtp = otpRepository.findOtpByUsername(otpToValidation.getUsername());
        if (userOtp.isPresent()) { //데이터베이스에 OTP가 있고 비즈니스 논리 서버에서 받은 OTP와 일치하면 true
            Otp otp = userOtp.get();
            if(otpToValidation.getCode().equals(otp.getCode())){
                return true;
            }
        }
        return false;
    }
}

GenerateCodeUtil

public class GenerateCodeUtil {
    private GenerateCodeUtil() {
    }

    public static String generateCode() {
        String code;
        try {
            SecureRandom random = SecureRandom.getInstanceStrong();
            int c = random.nextInt(9000) + 1000;
            code = String.valueOf(c);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("Problem when generating a random code");
        }
        return code;
    }
}

Controller

@RestController
@RequiredArgsConstructor
public class AuthController {
    private final UserService userService;

    @PostMapping("/user/add")
    public void addUser(@RequestBody User user) {
        userService.addUser(user);
    }

    @PostMapping("/user/auth")
    public void auth(@RequestBody User user) {
        userService.auth(user);
    }

    @PostMapping("/otp/check")
    public void checkOtp(@RequestBody Otp otp, HttpServletResponse response) {
        if (userService.check(otp)) {
            response.setStatus(HttpServletResponse.SC_OK);
        } else {
            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
        }
    }
}

 

비즈니스 논리 서버 구현

• 보호할 리소스에 해당하는 엔드포인트를 만든다.
• 클라이언트가 사용자 자격 증명을 비즈니스 논리 서버로 보내고 로그인하는 첫 번째 인증 단계를 구현한다.
• 클라이언트가 인증 서버에서 사용자가 받은 OTP를 비즈니스 논리 서버로 보내는 두 번째 인증 단계를 구현한다. OTP로 인증되면 클라이언트는 사용자의 리소스에 접근하는데 필요한 JWT를 받는다.
• JWT 기반 권한 부여를 구현한다. 비즈니스 논리 서버가 클라이언트에서 받은 JWT를 검증하고 올바르면 클라이언트가 리소스에 접근할 수 있게 허용한다.

TestController

@RestController
public class TestController {
    @GetMapping("/test")
    public String test() {
        return "test";
    }
}

UsernamePasswordAuthentication

public class UsernamePasswordAuthentication extends UsernamePasswordAuthenticationToken {
    public UsernamePasswordAuthentication(
            Object principal,
            Object credentials,
            Collection<? extends GrantedAuthority> authorities
    ) {
        super(principal, credentials, authorities);
    }

    public UsernamePasswordAuthentication(
            Object principal,
            Object credentials
    ) {
        super(principal, credentials);
    }
}

• 매개 변수가 2개인 생성자를 호출하면 인증 인스턴스가 인증되지 않은 상태로 유지된다.
  • 초기 Authentication 객체를 구축할 때 호출 -> 인증 X
• 매개 변수가 3개인 생성자를 호출하면 Authentication 객체가 인증된다.
  • AuthenticationProvider 객체가 요청을 인증할 때 호출 -> 인증된 객체

OtpAuthentication

 

public class OtpAuthentication extends UsernamePasswordAuthenticationToken {
    public OtpAuthentication(
            Object principal,
            Object credentials,
            Collection<? extends GrantedAuthority> authorities
    ) {
        super(principal, credentials, authorities);
    }

    public OtpAuthentication(
            Object principal,
            Object credentials
    ) {
        super(principal, credentials);
    }
}

 

인증 서버에 대한 프락시 구현

• 인증 서버가 노출하는 Rest 서비스를 호출하는 데 이용할 모델 클래스 User를 정의
• 인증 서버가 노출하는 Rest 엔드포인트를 호출하는 데 이용할 ResTemplate 형식의 빈을 선언
• 사용자 이름/암호 인증과 사용자 이름/otp 인증을 수행하는 메서드 두 개를 정의하는 프락시 클래스를 구현한다.

User

@Getter
@Setter
public class User {
    @Id
    private String username;
    private String password;
    private String code;
}

 

ProjectConfig

@Configuration
public class ProjectConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

AuthenticationServerProxy

@Component
public class AuthenticationServerProxy {

    @Autowired
    private RestTemplate restTemplate;

    @Value("${auth.server.base.url}")
    private String baseUrl;

    public void sendAuth(String username, String password) {
        String url = baseUrl + "/user/auth";

        var body = new User();
        body.setUsername(username);
        body.setPassword(password);

        var request = new HttpEntity<>(body);
        restTemplate.postForEntity(url, request, Void.class);
    }

    public boolean sendOTP(String username, String code) {
        String url = baseUrl + "/otp/check";
        var body = new User();
        body.setUsername(username);
        body.setCode(code);

        var request = new HttpEntity<>(body);
        var response = restTemplate.postForEntity(url, request, Void.class);

        return response.
                getStatusCode()
                .equals(HttpStatus.OK);
    }
}

 

UsernamePasswordAuthenticationProvider

@Component
public class UsernamePasswordAuthenticationProvider implements AuthenticationProvider {
    @Autowired
    private AuthenticationServerProxy proxy;

    @Override
    public Authentication authenticate(Authentication authentication)
            throws AuthenticationException {
        String username = authentication.getName();
        String password = String.valueOf(authentication.getCredentials());
        proxy.sendAuth(username, password); //프록시로 인증 서버를 호출한다. OTP를 보낸다.
        return new UsernamePasswordAuthenticationToken(username, password);
    }

    @Override
    public boolean supports(Class<?> aClass) {
        return UsernamePasswordAuthentication.class.isAssignableFrom(aClass);
    }
}

 

OtpAuthenticationProvider

@Component
public class OtpAuthenticationProvider implements AuthenticationProvider {
    @Autowired
    private AuthenticationServerProxy proxy;

    @Override
    public Authentication authenticate(Authentication authentication)
            throws AuthenticationException {
        String username = authentication.getName();
        String code = String.valueOf(authentication.getCredentials());
        boolean result = proxy.sendOTP(username, code);

        if (result) {
            return new OtpAuthentication(username, code);
        } else {
            throw new BadCredentialsException("Bad credentials");
        }
    }

    @Override
    public boolean supports(Class<?> aClass) {
        return OtpAuthentication.class.isAssignableFrom(aClass);
    }
}

 

InitialAuthenticationFilter

@Component
public class InitialAuthenticationFilter extends OncePerRequestFilter {

    @Autowired
    private AuthenticationManager authenticationManager; //올바른 인증 놀리를 적용하는 AuthenticationManager 주입

    @Value("${jwt.signing.key}")
    private String signingKey;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        String username = request.getHeader("username");
        String password = request.getHeader("password");
        String code = request.getHeader("code");
        if (code == null) { // HTTP 요청에 OTP가 없으면 사용자 이름과 암호로 인증해야 한다.
            Authentication auth = new UsernamePasswordAuthentication(username, password);
            authenticationManager.authenticate(auth); //UsernamePasswordAuthentication의 인스턴스로 AuthenticationManager를 호출한다.
        } else { //OTP 코드가 null이 아닌 경우를 위한 분리 추가, 2번째 인증 단계를 위해 OTP 보냄
            Authentication auth = new OtpAuthentication(username, code);//두번째 인증단계에서는 otpAuthentication 형식의 인스턴스를 만들고 OtpAuthentication으로 보내 올바른 공급자를 찾게 함
            auth = authenticationManager.authenticate(auth);
            SecretKey key = Keys.hmacShaKeyFor(signingKey.getBytes(StandardCharsets.UTF_8));
            String jwt = Jwts.builder()
                    .setClaims(Map.of("username", username))
                    .signWith(key)
                    .compact();
            response.setHeader("Authentication",jwt);
        }
    }

    @Override
    protected boolean shouldNotFilter(HttpServletRequest request) throws ServletException {
        return !request.getServletPath().equals("/login");//login 경로에만 이 필터 적용
    }
}

• doFilterInternal(): 요청이 필터 체인에서 이 필터에 도달할 때 호출
• shouldNotFilter(): /login 경로에 대해서만 해당 Filter 실행하고 나머지는 건너뛴다. 
• 첫 번째 인증 단계를 수행하는 경우: 사용자가 OTP 인증을 보내지 않았으므로 사용자 이름 암호로 인증해야 한다.
• 두 번째 인증 단계를 수행하는 경우:  OTP가 유효할 때만 JWT 토큰이 생성되고 Http 헤더에 포함되도록 한다.

JwtAuthenticationFilter

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    @Value("${jwt.signing.key}")
    private String signingKey;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        String jwt = request.getHeader("Authorization");
        SecretKey key = Keys.hmacShaKeyFor(signingKey.getBytes(StandardCharsets.UTF_8));
        Claims claims = Jwts.parser()
                .setSigningKey(key)
                .build()
                .parseClaimsJws(jwt).getBody();

        String username = String.valueOf(claims.get("username"));
        GrantedAuthority ga = new SimpleGrantedAuthority("user");
        var auth = new UsernamePasswordAuthentication(
                username, null, List.of(ga)
        );
        SecurityContextHolder.getContext().setAuthentication(auth); // SecurityContext에 추가
        filterChain.doFilter(request, response);
    }

    @Override
    protected boolean shouldNotFilter(HttpServletRequest request) throws ServletException {
        return request.getServletPath().equals("/login");
    }
}

• login 경로 이외에 곳에 모두 적용한다.
• 요청에 헤더에 JWT가 있다고 가정하고 서명을 확인해 검증 후 인증된 Authentication 객체를 만들고 SecurityContext에 추가한다.

Configure 등록

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private InitialAuthenticationFilter initialAuthenticationFilter;

    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter;

    @Autowired
    private OtpAuthenticationProvider otpAuthenticationProvider;

    @Autowired
    private UsernamePasswordAuthenticationProvider usernamePasswordAuthenticationProvider;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.authenticationProvider(otpAuthenticationProvider)
                .authenticationProvider(usernamePasswordAuthenticationProvider);
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable();
        http.addFilterAt(
                initialAuthenticationFilter,
                BasicAuthenticationFilter.class
        ).addFilterAfter(
                jwtAuthenticationFilter,
                BasicAuthenticationFilter.class
        );
        
        http.authorizeRequests()
                .anyRequest().authenticated();
    }
    
    @Override
    @Bean
    public AuthenticationManager authenticationManager() throws Exception {
        return super.authenticationManager();
    }

}