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 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?
mkdir -p ~/.claude/skills/quarkus-security # Save SKILL.md to ~/.claude/skills/quarkus-security/SKILL.md
- 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.
- 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.
- 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.
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.