Skip to main content
Agent skill

Quarkus Security

Quarkus security implementation patterns: JWT and OIDC authentication, @RolesAllowed RBAC and SecurityIdentity checks, Bean Validation and custom validators, parameterized Panache queries, BCrypt password hashing, CORS and security headers, rate limiting, audit logging, Vault or environment-variable secrets, and dependency CVE scanning. Use when adding authentication or authorization, validating input, managing secrets, or hardening a Quarkus application.

Get started

Get the complete skill folder, including its scripts and reference files.

·

When to use this skill

Use Quarkus Security when an AI agent needs a reusable SKILL.md workflow for this job: Quarkus security implementation patterns: JWT and OIDC authentication, @RolesAllowed RBAC and SecurityIdentity checks, Bean Validation and custom validators, parameterized Panache queries, BCrypt password hashing, CORS and security headers, rate limiting, audit logging, Vault or environment-variable secrets, and dependency CVE scanning. Use when adding authentication or authorization, validating input, managing secrets, or hardening a Quarkus application.

When not to use it

Skip Quarkus Security when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.

How to install

Where will you use it?

Install scope
Claude Code folder setup
mkdir -p ~/.claude/skills/quarkus-security
# Save SKILL.md to ~/.claude/skills/quarkus-security/SKILL.md
  1. Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/quarkus-security/SKILL.md. For a shared project, commit the folder at .claude/skills/quarkus-security/ instead.
  2. Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
  3. For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.

Full install guide for Claude, Cursor, and Codex →

Try a starter prompt

After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.

Starter prompt
Use the Quarkus Security skill for this task: Use Quarkus Security when this documented workflow matches the task. Confirm any required inputs or files before making changes.

What supports this recommendation?

76/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.

Documentation
85/100
Practical detail
76/100
Source evidence
63/100
Source signals
72/100
Model compatibility evidence
  • claudeuntested

    No model-specific signal or recorded compatibility test was found.

  • chatgptuntested

    No model-specific signal or recorded compatibility test was found.

  • geminiuntested

    No model-specific signal or recorded compatibility test was found.

  • copilotuntested

    No model-specific signal or recorded compatibility test was found.

  • llamauntested

    No model-specific signal or recorded compatibility test was found.

  • perplexityuntested

    No model-specific signal or recorded compatibility test was found.

  • mistraluntested

    No model-specific signal or recorded compatibility test was found.

  • grokuntested

    No model-specific signal or recorded compatibility test was found.

Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.

What this skill does

# Quarkus Security Review

Best practices for securing Quarkus applications with authentication, authorization, and input validation.

## When to Activate

- Adding authentication (JWT, OIDC, Basic Auth) - Implementing authorization with @RolesAllowed or SecurityIdentity - Validating user input (Bean Validation, custom validators) - Configuring CORS or security headers - Managing secrets (Vault, environment variables, config sources) - Adding rate limiting or brute-force protection - Scanning dependencies for CVEs - Working with MicroProfile JWT or SmallRye JWT

## Authentication

### JWT Authentication

```java // Resource protected with 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(); } } ```

Configuration (application.properties): ```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} ```

### Custom Authentication Filter

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

@Inject SecurityIdentity identity;

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

// Reject immediately if header is absent or malformed 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) { // Token validation logic return true; } } ```

## Authorization

### Role-Based Access Control

```java @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) { // Check ownership 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); } } ```

### Programmatic Security

```java @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); } } ```

## Input Validation

### Bean Validation

```java // BAD: No validation @POST public Response createUser(UserDto dto) { return Response.ok(userService.create(dto)).build(); }

// GOOD: Validated 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(); } ```

### Custom Validators

```java @Target({ElementType.FIELD, ElementType.PARAMETER}) @Retention(RetentionPolicy.RUNTIME) @Constraint(validatedBy = UsernameValidator.class) public @interface ValidUsername { String message() default "Invalid username format"; 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}$"); } }

// Usage public record CreateUserDto( @ValidUsername String username, @NotBlank @Email String email ) {} ```

## SQL Injection Prevention

### Panache Active Record (Safe by Default)

```java // GOOD: Parameterized queries with Panache List<User> users = User.list("email = ?1 and active = ?2", email, true);

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

// GOOD: Named parameters List<User> users = User.list("email = :email and age > :minAge", Parameters.with("email", email).and("minAge", 18)); ```

### Native Queries (Use Parameters)

```java // BAD: String concatenation @Query(value = "SELECT * FROM users WHERE name = '" + name + "'", nativeQuery = true)

// GOOD: Parameterized native query @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(); } } ```

## Password Hashing

```java @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); } }

// In service @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 Configuration

```properties # 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 ```

## Secrets Management

```properties # application.properties - NO SECRETS HERE

# Use environment variables quarkus.datasource.username=${DB_USER} quarkus.datasource.password=${DB_PASSWORD} quarkus.oidc.credentials.secret=${OIDC_CLIENT_SECRET}

# Or use Vault quarkus.vault.url=https://vault.example.com quarkus.vault.authentication.kubernetes.role=my-role ```

### HashiCorp Vault Integration

```java @ApplicationScoped public class SecretService {

@ConfigProperty(name = "api-key") String apiKey; // Fetched from Vault

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

## Rate Limiting

**Security Note**: Never use `X-Forwarded-For` directly — clients can spoof it. Use the actual remote address from the servlet request, or an authenticated identity (API key, JWT subject) when available.

```java @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 requests per second

if (!limiter.tryAcquire()) { requestContext.abortWith( Response.status(429) .entity(Map.of("error", "Too many requests")) .build() ); } }

private String getClientIdentifier() { // Use the container-provided remote address (not X-Forwarded-For). // If behind a trusted proxy, configure quarkus.http.proxy.proxy-address-forwarding=true // so getRemoteAddr() returns the real client IP. return servletRequest.getRemoteAddr(); } } ```

## Security Headers

```java @Provider public class SecurityHeadersFilter implements ContainerResponseFilter {

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

// Prevent clickjacking headers.putSingle("X-Frame-Options", "DENY");

// XSS protection 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 — avoid 'unsafe-inline' for script-src as it negates XSS protection; // use nonces or hashes instead. 'unsafe-inline' for style-src is acceptable // when CSS frameworks require it, but prefer nonces where possible. headers.putSingle("Content-Security-Policy", "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'"); } } ```

## Audit Logging

```java @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()); } }

// Usage in resource @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(); } } ```

## Dependency Security Scanning

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

# Gradle ./gradlew dependencyCheckAnalyze

# Check Quarkus extensions quarkus extension list --installable ```

## Best Practices

- Always use HTTPS in production - Enable JWT or OIDC for stateless authentication - Use `@RolesAllowed` for declarative authorization - Validate all input with Bean Validation - Hash passwords with BCrypt (never plaintext) - Store secrets in Vault or environment variables - Use parameterized queries to prevent SQL injection - Add security headers to all responses - Implement rate limiting for public endpoints - Audit sensitive operations - Keep dependencies updated and scan for CVEs - Use SecurityIdentity for programmatic checks - Set appropriate CORS policies - Test authentication and authorization paths

Intended uses

  • Use Quarkus Security when this documented workflow matches the task.

Implementation notes

  • Always use HTTPS in production
  • Enable JWT or OIDC for stateless authentication
  • Use @RolesAllowed for declarative authorization
  • Validate all input with Bean Validation
  • Hash passwords with BCrypt (never plaintext)
  • Store secrets in Vault or environment variables
  • Use parameterized queries to prevent SQL injection
  • Add security headers to all responses
  • Implement rate limiting for public endpoints
  • Audit sensitive operations
  • Keep dependencies updated and scan for CVEs
  • Use SecurityIdentity for programmatic checks
  • Set appropriate CORS policies
  • Test authentication and authorization paths

Try it, then tell us how it went

A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.