스프링 시큐리티와 보안 가이드: JWT vs OAuth2 vs Session – 인증 방식 비교와 적용 전략

JWT vs OAuth2 vs Session – 인증 방식 비교와 적용 전략

소개

현대 웹 애플리케이션에서 보안은 필수적인 요소입니다.

특히 스프링 기반 애플리케이션에서는 스프링 시큐리티가 이러한 보안 요구사항을 충족시키는 강력한 프레임워크로 자리 잡고 있습니다.

하지만 다양한 인증 방식(세션, JWT, OAuth2)을 어떤 상황에서 선택해야 할지 결정하는 것은 개발자에게 항상 고민거리입니다.

이 글에서는 스프링 시큐리티의 세 가지 주요 인증 방식인 세션 기반 인증, JWT 인증, OAuth2 인증의 특징과 장단점을 비교하고, 프로젝트 요구사항에 맞는 최적의 인증 전략을 선택하는 방법을 다룹니다.

각 인증 방식의 구현 예제와 함께 실제 프로젝트에 적용할 수 있는 구체적인 전략을 제시합니다.

스프링 시큐리티 기본 개념

스프링 시큐리티는 자바 기반 애플리케이션의 인증(Authentication)과 권한 부여(Authorization)를 처리하는 보안 프레임워크입니다.

다양한 인증 방식을 지원하며, 보안 관련 많은 기능을 쉽게 구현할 수 있도록 도와줍니다.

스프링 시큐리티 핵심 컴포넌트

1. 인증 관리자(AuthenticationManager): 사용자 인증을 처리하는 핵심 인터페이스
2. 사용자 세부 정보 서비스(UserDetailsService): 사용자 정보를 로드하는 인터페이스
3. 접근 결정 관리자(AccessDecisionManager): 리소스 접근 권한을 결정하는 인터페이스
4. 보안 필터 체인(Security Filter Chain): HTTP 요청을 처리하는 필터들의 모음

스프링 시큐리티 기본 설정

스프링 부트 애플리케이션에서 시큐리티를 활성화하는 기본 코드입니다:

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/public/**").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll();
    }

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

이제 각 인증 방식에 대해 자세히 살펴보겠습니다.

세션 기반 인증

세션 기반 인증은 전통적인 웹 애플리케이션에서 가장 널리 사용되는 인증 방식입니다. 사용자가 로그인하면 서버는 세션을 생성하고 세션 ID를 클라이언트에게 쿠키로 전달합니다.

작동 원리

1. 사용자가 아이디와 비밀번호로 로그인합니다.
2. 서버는 사용자 정보를 검증하고 세션을 생성합니다.
3. 세션 ID는 쿠키를 통해 클라이언트에게 전달됩니다.
4. 이후 요청에서 클라이언트는 쿠키를 포함하여 서버에 요청합니다.
5. 서버는 세션 ID를 검증하여 인증된 사용자임을 확인합니다.

스프링 시큐리티에서 세션 인증 구현

@Configuration
@EnableWebSecurity
public class SessionSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/api/public/**").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginProcessingUrl("/api/login")
                .successHandler(new SavedRequestAwareAuthenticationSuccessHandler())
                .failureHandler(new SimpleUrlAuthenticationFailureHandler())
                .and()
            .sessionManagement()
                .maximumSessions(1)
                .expiredUrl("/login?expired")
                .and()
                .invalidSessionUrl("/login?invalid")
                .and()
            .logout()
                .logoutUrl("/api/logout")
                .deleteCookies("JSESSIONID");
    }

    @Bean
    public UserDetailsService userDetailsService() {
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
        manager.createUser(User.withUsername("user")
                .password(passwordEncoder().encode("password"))
                .roles("USER")
                .build());
        return manager;
    }

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

장점

1. 구현 용이성: 스프링 시큐리티에서 기본적으로 제공되는 방식으로 쉽게 구현 가능
2. 상태 관리: 서버에서 사용자 상태를 직접 관리할 수 있음
3. 보안성: 세션 ID만 클라이언트에 노출되므로 상대적으로 안전
4. 세션 무효화: 서버에서 세션을 즉시 무효화할 수 있음

단점

1. 확장성 문제: 다중 서버 환경에서 세션 공유 문제 발생
2. 서버 부하: 세션 정보를 서버 메모리에 저장하면 서버 부하 증가
3. CSRF 취약점: 쿠키 기반이므로 CSRF 공격에 취약
4. 모바일/API 호환성: RESTful API와 모바일 환경에서 사용하기 불편

JWT(JSON Web Token) 인증

JWT는 클라이언트 측에 토큰 형태로 인증 정보를 저장하는 방식입니다. 서버는 상태를 유지하지 않기 때문에 무상태(Stateless) 인증이라고도 합니다.

JWT 구조

JWT는 다음 세 부분으로 구성됩니다:

1. 헤더(Header): 토큰 유형과 서명 알고리즘 정보
2. 페이로드(Payload): 사용자 정보와 권한 등의 클레임(Claim) 정보
3. 서명(Signature): 토큰의 유효성을 검증하기 위한 서명

작동 원리

1. 사용자가 로그인하면 서버는 JWT를 생성합니다.
2. 클라이언트는 JWT를 저장하고(일반적으로 localStorage) 요청 시 Authorization 헤더에 포함합니다.
3. 서버는 JWT의 서명을 검증하여 인증합니다.
4. 검증이 성공하면 페이로드의 정보를 통해 사용자를 식별합니다.

스프링 시큐리티에서 JWT 인증 구현

먼저, 필요한 의존성을 추가합니다:

implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
implementation 'io.jsonwebtoken:jjwt-impl:0.11.5'
implementation 'io.jsonwebtoken:jjwt-jackson:0.11.5'

JWT 관련 클래스 및 설정:

@Component
public class JwtTokenProvider {

    @Value("${jwt.secret}")
    private String jwtSecret;

    @Value("${jwt.expiration}")
    private long jwtExpiration;

    public String generateToken(Authentication authentication) {
        UserDetails userDetails = (UserDetails) authentication.getPrincipal();

        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + jwtExpiration);

        return Jwts.builder()
                .setSubject(userDetails.getUsername())
                .setIssuedAt(new Date())
                .setExpiration(expiryDate)
                .signWith(Keys.hmacShaKeyFor(jwtSecret.getBytes()), SignatureAlgorithm.HS512)
                .compact();
    }

    public String getUsernameFromToken(String token) {
        Claims claims = Jwts.parserBuilder()
                .setSigningKey(Keys.hmacShaKeyFor(jwtSecret.getBytes()))
                .build()
                .parseClaimsJws(token)
                .getBody();

        return claims.getSubject();
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parserBuilder()
                    .setSigningKey(Keys.hmacShaKeyFor(jwtSecret.getBytes()))
                    .build()
                    .parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}

JWT 필터 추가:

public class JwtAuthenticationFilter extends OncePerRequestFilter {

    @Autowired
    private JwtTokenProvider tokenProvider;

    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        try {
            String jwt = getJwtFromRequest(request);

            if (StringUtils.hasText(jwt) && tokenProvider.validateToken(jwt)) {
                String username = tokenProvider.getUsernameFromToken(jwt);

                UserDetails userDetails = userDetailsService.loadUserByUsername(username);
                UsernamePasswordAuthenticationToken authentication = 
                        new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        } catch (Exception e) {
            logger.error("Could not set user authentication in security context", e);
        }

        filterChain.doFilter(request, response);
    }

    private String getJwtFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

시큐리티 설정:

@Configuration
@EnableWebSecurity
public class JwtSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .cors().and().csrf().disable()
            .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
            .authorizeRequests()
                .antMatchers("/api/auth/**").permitAll()
                .anyRequest().authenticated();

        http.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
    }

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

장점

1. 확장성: 서버가 상태를 유지하지 않아 다중 서버 환경에 적합
2. 모바일/API 호환성: RESTful API와 모바일 환경에 적합
3. 서버 부하 감소: 세션 관리 부담이 없어 서버 리소스 절약
4. 사용자 정보 포함: 토큰 자체에 사용자 정보 포함 가능

단점

1. 토큰 크기: 페이로드에 정보가 많으면 토큰 크기가 커짐
2. 보안 취약점: 클라이언트에 토큰이 저장되어 XSS 공격에 취약
3. 토큰 무효화: 발급된 토큰을 즉시 무효화하기 어려움
4. 갱신 관리: 토큰 만료와 갱신 처리가 복잡함

OAuth2 인증

OAuth2는 외부 서비스에 인증을 위임하는 프로토콜로, 소셜 로그인 등에 널리 사용됩니다.

구글, 페이스북, 카카오와 같은 외부 서비스로 로그인하고 그 인증 정보를 이용할 수 있게 해줍니다.

작동 원리

1. 사용자가 애플리케이션에서 외부 서비스(구글 등) 로그인을 선택합니다.
2. 애플리케이션은 사용자를 외부 서비스 인증 페이지로 리다이렉트합니다.
3. 사용자가 외부 서비스에 로그인하고 권한을 승인합니다.
4. 외부 서비스는 인증 코드를 발급하고 애플리케이션으로 리다이렉트합니다.
5. 애플리케이션은 인증 코드를 이용해 액세스 토큰을 요청합니다.
6. 액세스 토큰을 사용하여 사용자 정보를 요청하고 인증 처리합니다.

스프링 시큐리티에서 OAuth2 구현

의존성 추가:

implementation 'org.springframework.boot:spring-boot-starter-oauth2-client'

application.yml 구성:

spring:
  security:
    oauth2:
      client:
        registration:
          google:
            client-id: your-google-client-id
            client-secret: your-google-client-secret
            scope:
              - email
              - profile

          facebook:
            client-id: your-facebook-client-id
            client-secret: your-facebook-client-secret
            scope:
              - email
              - public_profile

          kakao:
            client-id: your-kakao-client-id
            client-secret: your-kakao-client-secret
            client-authentication-method: POST
            authorization-grant-type: authorization_code
            redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}"
            scope:
              - profile_nickname
              - account_email
            client-name: Kakao

보안 설정:

@Configuration
@EnableWebSecurity
public class OAuth2SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private CustomOAuth2UserService customOAuth2UserService;

    @Autowired
    private OAuth2AuthenticationSuccessHandler oAuth2AuthenticationSuccessHandler;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
                .antMatchers("/", "/login/**", "/oauth2/**").permitAll()
                .anyRequest().authenticated()
                .and()
            .oauth2Login()
                .authorizationEndpoint()
                    .baseUri("/oauth2/authorize")
                    .and()
                .redirectionEndpoint()
                    .baseUri("/oauth2/callback/*")
                    .and()
                .userInfoEndpoint()
                    .userService(customOAuth2UserService)
                    .and()
                .successHandler(oAuth2AuthenticationSuccessHandler);
    }
}

커스텀 OAuth2 사용자 서비스:

@Service
public class CustomOAuth2UserService extends DefaultOAuth2UserService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public OAuth2User loadUser(OAuth2UserRequest oAuth2UserRequest) throws OAuth2AuthenticationException {
        OAuth2User oAuth2User = super.loadUser(oAuth2UserRequest);

        try {
            return processOAuth2User(oAuth2UserRequest, oAuth2User);
        } catch (Exception ex) {
            // 예외 처리
            throw new OAuth2AuthenticationProcessingException("OAuth2 인증 처리 중 오류가 발생했습니다: " + ex.getMessage());
        }
    }

    private OAuth2User processOAuth2User(OAuth2UserRequest oAuth2UserRequest, OAuth2User oAuth2User) {
        // OAuth2 공급자로부터 사용자 정보 추출
        OAuth2UserInfo oAuth2UserInfo = OAuth2UserInfoFactory.getOAuth2UserInfo(
                oAuth2UserRequest.getClientRegistration().getRegistrationId(), 
                oAuth2User.getAttributes());

        // 기존 사용자가 있는지 확인
        Optional<User> userOptional = userRepository.findByEmail(oAuth2UserInfo.getEmail());

        User user;
        if (userOptional.isPresent()) {
            // 기존 사용자 업데이트
            user = userOptional.get();
            user = updateExistingUser(user, oAuth2UserInfo);
        } else {
            // 새 사용자 등록
            user = registerNewUser(oAuth2UserRequest, oAuth2UserInfo);
        }

        return UserPrincipal.create(user, oAuth2User.getAttributes());
    }

    private User registerNewUser(OAuth2UserRequest oAuth2UserRequest, OAuth2UserInfo oAuth2UserInfo) {
        User user = new User();

        user.setProvider(AuthProvider.valueOf(oAuth2UserRequest.getClientRegistration().getRegistrationId()));
        user.setProviderId(oAuth2UserInfo.getId());
        user.setName(oAuth2UserInfo.getName());
        user.setEmail(oAuth2UserInfo.getEmail());
        user.setImageUrl(oAuth2UserInfo.getImageUrl());

        return userRepository.save(user);
    }

    private User updateExistingUser(User existingUser, OAuth2UserInfo oAuth2UserInfo) {
        existingUser.setName(oAuth2UserInfo.getName());
        existingUser.setImageUrl(oAuth2UserInfo.getImageUrl());

        return userRepository.save(existingUser);
    }
}

장점

1. 위임된 인증: 인증을 믿을 수 있는 외부 서비스에 위임
2. 사용자 편의성: 별도의 회원가입 없이 기존 계정으로 로그인 가능
3. 보안 강화: 비밀번호 관리 부담 감소
4. 풍부한 사용자 정보: 외부 서비스에서 다양한 사용자 정보 제공

단점

1. 의존성: 외부 서비스에 의존적
2. 구현 복잡성: 다양한 공급자별 설정 필요
3. 개인정보 우려: 사용자 데이터가 외부 서비스에 노출
4. 서비스 제한: 외부 서비스의 API 정책 변경 시 영향

인증 방식 비교

각 인증 방식의 주요 특징을 비교해 보겠습니다:

특징	세션 기반 인증	JWT 인증	OAuth2 인증
상태 관리	서버에 상태 저장 (Stateful)	클라이언트에 상태 저장 (Stateless)	공급자와 클라이언트 모두 상태 관리
확장성	낮음 (세션 공유 문제)	높음	중간
구현 복잡도	낮음	중간	높음
토큰 저장	서버 (세션 데이터)	클라이언트	서버와 클라이언트
로그아웃 처리	쉬움 (세션 삭제)	어려움 (토큰 블랙리스트 필요)	중간
보안 취약점	CSRF 취약	XSS 취약	다양한 취약점 가능
서버 부하	높음 (세션 저장)	낮음	중간
적합한 환경	전통적인 웹 애플리케이션	RESTful API, 모바일 앱	소셜 로그인 지원, 대규모 서비스

사용 사례 및 적용 전략

각 인증 방식이 적합한 사용 사례와 구체적인 적용 전략을 살펴보겠습니다.

세션 기반 인증 적용 사례

1. 전통적인 웹 애플리케이션
   • 사용자 상호작용이 많은 웹사이트
   • 단일 서버 환경
   • 보안이 중요한 금융, 의료 서비스

세션 인증 적용 전략:

// Redis를 활용한 세션 공유 구현
@EnableRedisHttpSession
public class HttpSessionConfig {

    @Bean
    public LettuceConnectionFactory connectionFactory() {
        return new LettuceConnectionFactory();
    }
}

JWT 인증 적용 사례

1. RESTful API 서비스
   • 모바일 애플리케이션 백엔드
   • 마이크로서비스 아키텍처
   • SPA(Single Page Application)

JWT 보안 강화 전략:

// JWT 토큰 갱신 및 블랙리스트 관리
@Service
public class TokenService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public void invalidateToken(String token) {
        // 토큰의 남은 유효 시간 계산
        long expiration = getExpirationFromToken(token);
        long current = System.currentTimeMillis();
        long remainingTime = expiration - current;

        if (remainingTime > 0) {
            // 블랙리스트에 추가
            redisTemplate.opsForValue().set("blacklist:" + token, "true", remainingTime, TimeUnit.MILLISECONDS);
        }
    }

    public boolean isTokenBlacklisted(String token) {
        return Boolean.TRUE.equals(redisTemplate.hasKey("blacklist:" + token));
    }
}

OAuth2 인증 적용 사례

1. 다양한 소셜 로그인이 필요한 서비스
   • 커뮤니티 플랫폼
   • 콘텐츠 구독 서비스
   • 다양한 외부 API를 활용하는 서비스

OAuth2 + JWT 결합 전략:

@Service
public class OAuth2JwtService {

    @Autowired
    private JwtTokenProvider tokenProvider;

    public String createTokenFromOAuth2User(OAuth2User oAuth2User) {
        // OAuth2 사용자 정보에서 필요한 클레임 추출
        Map<String, Object> claims = new HashMap<>();
        claims.put("email", oAuth2User.getAttribute("email"));
        claims.put("name", oAuth2User.getAttribute("name"));
        claims.put("picture", oAuth2User.getAttribute("picture"));

        // OAuth2 정보로 JWT 생성
        return tokenProvider.generateToken(claims);
    }
}

보안 강화 전략

인증 방식과 상관없이 스프링 시큐리티에서 보안을 강화할 수 있는 전략을 알아보겠습니다.

1. HTTPS 강제 적용

@Configuration
public class HttpsConfig {

    @Bean
    public ServletWebServerFactory servletContainer() {
        TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory() {
            @Override
            protected void postProcessContext(Context context) {
                SecurityConstraint securityConstraint = new SecurityConstraint();
                securityConstraint.setUserConstraint("CONFIDENTIAL");
                SecurityCollection collection = new SecurityCollection();
                collection.addPattern("/*");
                securityConstraint.addCollection(collection);
                context.addConstraint(securityConstraint);
            }
        };
        tomcat.addAdditionalTomcatConnectors(redirectConnector());
        return tomcat;
    }

    private Connector redirectConnector() {
        Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
        connector.setScheme("http");
        connector.setPort(8080);
        connector.setSecure(false);
        connector.setRedirectPort(8443);
        return connector;
    }
}

2. CORS 설정

@Configuration
public class CorsConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
                .allowedOrigins("https://yourfrontend.com")
                .allowedMethods("GET", "POST", "PUT", "DELETE")
                .allowedHeaders("*")
                .allowCredentials(true)
                .maxAge(3600);
    }
}

3. 비밀번호 강화 정책

@Component
public class StrongPasswordEncoder extends BCryptPasswordEncoder {

    @Override
    public boolean matches(CharSequence rawPassword, String encodedPassword) {
        // 비밀번호 정책 검증
        if (rawPassword.length() < 8) {
            throw new BadCredentialsException("비밀번호는 8자 이상이어야 합니다.");
        }

        String password = rawPassword.toString();

        // 숫자 포함 여부
        if (!password.matches(".*\\d.*")) {
            throw new BadCredentialsException("비밀번호는 숫자를 포함해야 합니다.");
        }

        // 특수 문자 포함 여부
        if (!password.matches(".*[!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>\\/?].*")) {
            throw new BadCredentialsException("비밀번호는 특수문자를 포함해야 합니다.");
        }

        return super.matches(rawPassword, encodedPassword);
    }
}

4. 레이트 리미팅(Rate Limiting) 적용

@Component
public class RateLimitingFilter extends OncePerRequestFilter {

    private final Map<String, Integer> requestCounts = new ConcurrentHashMap<>();
    private final Map<String, Long> blockUntilTime = new ConcurrentHashMap<>();

    // 최대 요청 수
    private static final int MAX_REQUESTS = 100;
    // 시간 간격 (1분)
    private static final long INTERVAL = 60 * 1000;
    // 차단 시간 (10분)
    private static final long BLOCK_DURATION = 10 * 60 * 1000;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        String ipAddress = getClientIP(request);

        // 차단된 IP인지 확인
        if (blockUntilTime.containsKey(ipAddress)) {
            long blockTime = blockUntilTime.get(ipAddress);
            if (System.currentTimeMillis() < blockTime) {
                response.setStatus(HttpServletResponse.SC_TOO_MANY_REQUESTS);
                response.getWriter().write("요청이 너무 많습니다. 잠시 후 다시 시도해주세요.");
                return;
            } else {
                blockUntilTime.remove(ipAddress);
                requestCounts.remove(ipAddress);
            }
        }

        // 요청 횟수 증가
        int count = requestCounts.getOrDefault(ipAddress, 0) + 1;
        requestCounts.put(ipAddress, count);

        // 요청 횟수가 최대값을 초과하면 차단
        if (count > MAX_REQUESTS) {
            blockUntilTime.put(ipAddress, System.currentTimeMillis() + BLOCK_DURATION);
            response.setStatus(HttpServletResponse.SC_TOO_MANY_REQUESTS);
            response.getWriter().write("요청이 너무 많습니다. 잠시 후 다시 시도해주세요.");
            return;
        }

        // 주기적으로 카운터 초기화 (별도 스케줄러로 구현 가능)
        if (count == 1) {
            new Timer().schedule(new TimerTask() {
                @Override
                public void run() {
                    requestCounts.remove(ipAddress);
                }
            }, INTERVAL);
        }

        filterChain.doFilter(request, response);
    }

    private String getClientIP(HttpServletRequest request) {
        String xfHeader = request.getHeader("X-Forwarded-For");
        if (xfHeader == null) {
            return request.getRemoteAddr();
        }
        return xfHeader.split(",")[0];
    }
}

5. 보안 헤더 설정

@Configuration
public class SecurityHeadersConfig {

    @Bean
    public WebSecurityCustomizer webSecurityCustomizer() {
        return (web) -> web.httpFirewall(allowUrlEncodedSlashHttpFirewall());
    }

    @Bean
    public HttpFirewall allowUrlEncodedSlashHttpFirewall() {
        StrictHttpFirewall firewall = new StrictHttpFirewall();
        firewall.setAllowUrlEncodedSlash(true);
        firewall.setAllowSemicolon(false);
        return firewall;
    }

    @Bean
    public FilterRegistrationBean<Filter> securityHeadersFilter() {
        FilterRegistrationBean<Filter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new OncePerRequestFilter() {
            @Override
            protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
                    throws ServletException, IOException {
                // XSS 방지
                response.setHeader("X-XSS-Protection", "1; mode=block");
                // MIME 스니핑 방지
                response.setHeader("X-Content-Type-Options", "nosniff");
                // 클릭재킹 방지
                response.setHeader("X-Frame-Options", "DENY");
                // HSTS 적용
                response.setHeader("Strict-Transport-Security", "max-age=31536000; includeSubDomains");
                // Content Security Policy
                response.setHeader("Content-Security-Policy", "default-src 'self'");
                // Referrer Policy
                response.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");
                // Feature Policy
                response.setHeader("Feature-Policy", "camera 'none'; microphone 'none'; geolocation 'none'");

                filterChain.doFilter(request, response);
            }
        });
        registrationBean.addUrlPatterns("/*");
        registrationBean.setOrder(Ordered.HIGHEST_PRECEDENCE);
        return registrationBean;
    }
}

결론

스프링 시큐리티는 다양한 인증 방식을 유연하게 구현할 수 있는 강력한 프레임워크입니다.

세션 기반 인증, JWT 인증, OAuth2 인증은 각각 고유한 장단점을 가지고 있으며,

애플리케이션의 특성과 요구사항에 따라 적절한 방식을 선택하는 것이 중요합니다.

세션 기반 인증은 구현이 간단하고 서버에서 상태를 관리할 수 있어 전통적인 웹 애플리케이션에 적합합니다.

하지만 확장성에 제한이 있고 CSRF 공격에 취약할 수 있습니다.

JWT 인증은 서버가 상태를 유지하지 않아 확장성이 뛰어나고 RESTful API와 모바일 환경에 적합합니다.

그러나 토큰 무효화가 어렵고 XSS 공격에 취약할 수 있습니다.

OAuth2 인증은 외부 서비스에 인증을 위임하여 사용자 편의성을 높이고 비밀번호 관리 부담을 줄일 수 있습니다.

다만 외부 서비스에 의존적이고 구현이 복잡할 수 있습니다.

실제 프로젝트에서는 이러한 인증 방식을 단독으로 사용하기보다는 하이브리드 접근 방식을 채택하는 경우가 많습니다.

예를 들어, OAuth2로 사용자를 인증한 후 JWT를 발급하여 내부 시스템에서 인증을 처리하는 방식이 일반적입니다.

또한, 인증 방식과 더불어 HTTPS 강제 적용, CORS 설정, 강력한 비밀번호 정책, 레이트 리미팅, 보안 헤더 설정 등의 추가 보안 조치를 함께 적용하여 애플리케이션의 전반적인 보안 수준을 높이는 것이 중요합니다.

 

결론적으로, 애플리케이션의 요구사항, 인프라 환경, 보안 정책을 종합적으로 고려하여 최적의 인증 전략을 수립하고, 정기적인 보안 감사와 취약점 점검을 통해 지속적으로 보안을 강화해 나가야 합니다.

스프링 시큐리티의 다양한 기능과 확장성을 활용하면 안전하고 견고한 인증 시스템을 구축할 수 있을 것입니다.