Quarkus 보안

Quarkus 보안 검토

인증, 권한 부여 및 입력 검증을 통해 Quarkus 애플리케이션을 보호하기 위한 모범 사례입니다.

활성화 시점

• 인증 추가 (JWT, OIDC, Basic Auth)
• @RolesAllowed 또는 SecurityIdentity를 사용한 권한 부여 구현
• 사용자 입력 검증 (Bean Validation, 사용자 정의 검증기)
• CORS 또는 보안 헤더 구성
• 비밀 관리 (Vault, 환경 변수, 구성 소스)
• 속도 제한 또는 무차별 대입 공격 방지 추가
• CVE에 대한 의존성 스캔
• MicroProfile JWT 또는 SmallRye JWT 작업

인증

JWT 인증

// JWT로 보호되는 리소스
@Path("/api/protected")
@Authenticated
public class ProtectedResource {

  @Inject
  JsonWebToken jwt;

  @Inject
  SecurityIdentity securityIdentity;

  @GET
  public Response getData() {
    String username = jwt.getName();
    Set<String> roles = jwt.getGroups();
    return Response.ok(Map.of(
        "username", username,
        "roles", roles,
        "principal", securityIdentity.getPrincipal().getName()
    )).build();
  }
}

설정 (application.properties):

mp.jwt.verify.publickey.location=publicKey.pem
mp.jwt.verify.issuer=https://auth.example.com

# OIDC
quarkus.oidc.auth-server-url=https://auth.example.com/realms/myrealm
quarkus.oidc.client-id=backend-service
quarkus.oidc.credentials.secret=${OIDC_SECRET}

사용자 정의 인증 필터

@Provider
@Priority(Priorities.AUTHENTICATION)
public class CustomAuthFilter implements ContainerRequestFilter {

  @Inject
  SecurityIdentity identity;

  @Override
  public void filter(ContainerRequestContext requestContext) {
    String authHeader = requestContext.getHeaderString(HttpHeaders.AUTHORIZATION);

    // 헤더가 없거나 잘못된 경우 즉시 거부
    if (authHeader == null || !authHeader.startsWith("Bearer ")) {
      requestContext.abortWith(Response.status(Response.Status.UNAUTHORIZED).build());
      return;
    }

    String token = authHeader.substring(7);
    if (!validateToken(token)) {
      requestContext.abortWith(Response.status(Response.Status.UNAUTHORIZED).build());
    }
  }

  private boolean validateToken(String token) {
    // 토큰 검증 로직
    return true;
  }
}

권한 부여

역할 기반 접근 제어 (RBAC)

@Path("/api/admin")
@RolesAllowed("ADMIN")
public class AdminResource {

  @GET
  @Path("/users")
  public List<UserDto> listUsers() {
    return userService.findAll();
  }

  @DELETE
  @Path("/users/{id}")
  @RolesAllowed({"ADMIN", "SUPER_ADMIN"})
  public Response deleteUser(@PathParam("id") Long id) {
    userService.delete(id);
    return Response.noContent().build();
  }
}

@Path("/api/users")
public class UserResource {

  @Inject
  SecurityIdentity securityIdentity;

  @GET
  @Path("/{id}")
  @RolesAllowed("USER")
  public Response getUser(@PathParam("id") Long id) {
    // 소유권 확인
    if (!securityIdentity.hasRole("ADMIN") &&
        !isOwner(id, securityIdentity.getPrincipal().getName())) {
      return Response.status(Response.Status.FORBIDDEN).build();
    }
    return Response.ok(userService.findById(id)).build();
  }

  private boolean isOwner(Long userId, String username) {
    return userService.isOwner(userId, username);
  }
}

프로그래매틱 보안

@ApplicationScoped
public class SecurityService {

  @Inject
  SecurityIdentity securityIdentity;

  public boolean canAccessResource(Long resourceId) {
    if (securityIdentity.isAnonymous()) {
      return false;
    }

    if (securityIdentity.hasRole("ADMIN")) {
      return true;
    }

    String userId = securityIdentity.getPrincipal().getName();
    return resourceRepository.isOwner(resourceId, userId);
  }
}

입력 검증

Bean Validation

// 나쁨: 검증 없음
@POST
public Response createUser(UserDto dto) {
  return Response.ok(userService.create(dto)).build();
}

// 좋음: 검증된 DTO
public record CreateUserDto(
    @NotBlank @Size(max = 100) String name,
    @NotBlank @Email String email,
    @NotNull @Min(18) @Max(150) Integer age,
    @Pattern(regexp = "^\\+?[1-9]\\d{1,14}$") String phone
) {}

@POST
@Path("/users")
public Response createUser(@Valid CreateUserDto dto) {
  User user = userService.create(dto);
  return Response.status(Response.Status.CREATED).entity(user).build();
}

사용자 정의 검증기

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = UsernameValidator.class)
public @interface ValidUsername {
  String message() default "유효하지 않은 사용자 이름 형식";
  Class<?>[] groups() default {};
  Class<? extends Payload>[] payload() default {};
}

public class UsernameValidator implements ConstraintValidator<ValidUsername, String> {
  @Override
  public boolean isValid(String value, ConstraintValidatorContext context) {
    if (value == null) return false;
    return value.matches("^[a-zA-Z0-9_-]{3,20}$");
  }
}

// 사용법
public record CreateUserDto(
    @ValidUsername String username,
    @NotBlank @Email String email
) {}

SQL 인젝션 방지

Panache Active Record (기본적으로 안전)

// 좋음: Panache의 매개변수화된 쿼리
List<User> users = User.list("email = ?1 and active = ?2", email, true);

Optional<User> user = User.find("username", username).firstResultOptional();

// 좋음: 명명된 매개변수
List<User> users = User.list("email = :email and age > :minAge",
    Parameters.with("email", email).and("minAge", 18));

네이티브 쿼리 (매개변수 사용)

// 나쁨: 문자열 연결
@Query(value = "SELECT * FROM users WHERE name = '" + name + "'", nativeQuery = true)

// 좋음: 매개변수화된 네이티브 쿼리
@Entity
public class User extends PanacheEntity {
  public static List<User> findByEmailNative(String email) {
    return getEntityManager()
        .createNativeQuery("SELECT * FROM users WHERE email = :email", User.class)
        .setParameter("email", email)
        .getResultList();
  }
}

비밀번호 해싱

@ApplicationScoped
public class PasswordService {

  public String hash(String plainPassword) {
    return BcryptUtil.bcryptHash(plainPassword);
  }

  public boolean verify(String plainPassword, String hashedPassword) {
    return BcryptUtil.matches(plainPassword, hashedPassword);
  }
}

// 서비스에서 사용
@ApplicationScoped
public class UserService {
  @Inject
  PasswordService passwordService;

  @Transactional
  public User register(CreateUserDto dto) {
    String hashedPassword = passwordService.hash(dto.password());
    User user = new User();
    user.email = dto.email();
    user.password = hashedPassword;
    user.persist();
    return user;
  }

  public boolean authenticate(String email, String password) {
    return User.find("email", email)
        .firstResultOptional()
        .map(u -> passwordService.verify(password, u.password))
        .orElse(false);
  }
}

CORS 설정

# application.properties
quarkus.http.cors=true
quarkus.http.cors.origins=https://app.example.com,https://admin.example.com
quarkus.http.cors.methods=GET,POST,PUT,DELETE
quarkus.http.cors.headers=accept,authorization,content-type,x-requested-with
quarkus.http.cors.exposed-headers=Content-Disposition
quarkus.http.cors.access-control-max-age=24H
quarkus.http.cors.access-control-allow-credentials=true

비밀 관리

# application.properties - 여기에 비밀을 절대 저장하지 마세요

# 환경 변수 사용
quarkus.datasource.username=${DB_USER}
quarkus.datasource.password=${DB_PASSWORD}
quarkus.oidc.credentials.secret=${OIDC_CLIENT_SECRET}

# 또는 Vault 사용
quarkus.vault.url=https://vault.example.com
quarkus.vault.authentication.kubernetes.role=my-role

HashiCorp Vault 통합

@ApplicationScoped
public class SecretService {

  @ConfigProperty(name = "api-key")
  String apiKey; // Vault에서 가져옴

  public String getSecret(String key) {
    return ConfigProvider.getConfig().getValue(key, String.class);
  }
}

속도 제한

보안 참고: X-Forwarded-For를 직접 사용하지 마십시오. 클라이언트가 위조할 수 있습니다. 서블릿 요청의 실제 원격 주소를 사용하거나, 가능한 경우 인증된 ID(API 키, JWT 주제)를 사용하십시오.

@ApplicationScoped
public class RateLimitFilter implements ContainerRequestFilter {
  private final Map<String, RateLimiter> limiters = new ConcurrentHashMap<>();

  @Inject
  HttpServletRequest servletRequest;

  @Override
  public void filter(ContainerRequestContext requestContext) {
    String clientId = getClientIdentifier();
    RateLimiter limiter = limiters.computeIfAbsent(clientId,
        k -> RateLimiter.create(100.0)); // 초당 100개 요청

    if (!limiter.tryAcquire()) {
      requestContext.abortWith(
          Response.status(429)
              .entity(Map.of("error", "요청이 너무 많습니다"))
              .build()
      );
    }
  }

  private String getClientIdentifier() {
    // 컨테이너가 제공하는 원격 주소 사용 (X-Forwarded-For 아님).
    // 신뢰할 수 있는 프록시 뒤에 있는 경우 quarkus.http.proxy.proxy-address-forwarding=true를 설정하여
    // getRemoteAddr()가 실제 클라이언트 IP를 반환하도록 하십시오.
    return servletRequest.getRemoteAddr();
  }
}

보안 헤더

@Provider
public class SecurityHeadersFilter implements ContainerResponseFilter {

  @Override
  public void filter(ContainerRequestContext request, ContainerResponseContext response) {
    MultivaluedMap<String, Object> headers = response.getHeaders();

    // 클릭재킹 방지
    headers.putSingle("X-Frame-Options", "DENY");

    // XSS 보호
    headers.putSingle("X-Content-Type-Options", "nosniff");
    headers.putSingle("X-XSS-Protection", "1; mode=block");

    // HSTS
    headers.putSingle("Strict-Transport-Security", "max-age=31536000; includeSubDomains");

    // CSP — script-src에 'unsafe-inline'을 사용하지 마십시오. XSS 보호를 무력화합니다.
    // 대신 nonce 또는 해시를 사용하십시오. style-src에 'unsafe-inline'을 사용하는 것은
    // CSS 프레임워크에서 필요한 경우 허용되지만, 가능하면 nonce를 사용하는 것이 좋습니다.
    headers.putSingle("Content-Security-Policy",
        "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'");
  }
}

감사 로깅

@ApplicationScoped
public class AuditService {
  private static final Logger LOG = Logger.getLogger(AuditService.class);

  @Inject
  SecurityIdentity securityIdentity;

  public void logAccess(String resource, String action) {
    String user = securityIdentity.isAnonymous()
        ? "anonymous"
        : securityIdentity.getPrincipal().getName();

    LOG.infof("AUDIT: user=%s action=%s resource=%s timestamp=%s",
        user, action, resource, Instant.now());
  }
}

// 리소스에서 사용
@Path("/api/sensitive")
public class SensitiveResource {
  @Inject
  AuditService auditService;

  @GET
  @RolesAllowed("ADMIN")
  public Response getData() {
    auditService.logAccess("sensitive-data", "READ");
    return Response.ok(data).build();
  }
}

의존성 보안 스캐닝

# Maven
mvn org.owasp:dependency-check-maven:check

# Gradle
./gradlew dependencyCheckAnalyze

# Quarkus 확장 확인
quarkus extension list --installable

모범 사례

• 프로덕션에서는 항상 HTTPS 사용
• 상태 비저장 인증을 위해 JWT 또는 OIDC 활성화
• 선언적 권한 부여를 위해 @RolesAllowed 사용
• Bean Validation으로 모든 입력 검증
• 비밀번호는 BCrypt로 해시 (절대 평문 저장 금지)
• 비밀은 Vault 또는 환경 변수에 저장
• SQL 인젝션 방지를 위해 매개변수화된 쿼리 사용
• 모든 응답에 보안 헤더 추가
• 공개 엔드포인트에 속도 제한 구현
• 민감한 작업 감사
• 의존성을 최신 상태로 유지하고 CVE 스캔
• 프로그래매틱 검사를 위해 SecurityIdentity 사용
• 적절한 CORS 정책 설정
• 인증 및 권한 부여 경로 테스트