Sécurité

// 1. Infrastructure : Validation format
@Controller("/api/users")
public class UserController {
 
    @Post
    public UserResponse createUser(
        @Body @Valid UserRequest request  // ← @Valid déclenche la validation
    ) {
        // Si validation échoue, 400 Bad Request automatique
    }
}
 
// 2. DTO avec annotations de validation
@Data
public class UserRequest {
    @NotBlank(message = "Email cannot be empty")
    @Email(message = "Email must be valid")
    private String email;
 
    @NotBlank(message = "Password cannot be empty")
    @Size(min = 8, max = 100, message = "Password must be 8-100 characters")
    @Pattern(
        regexp = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).*$",
        message = "Password must contain lowercase, uppercase and digit"
    )
    private String password;
}
 
// 3. Domain : Value Object avec validation métier
@Value
public class Email {
    String value;
 
    public Email(String value) {
        if (value == null || !value.matches("^[A-Za-z0-9+_.-]+@(.+)$")) {
            throw new IllegalArgumentException("Invalid email format");
        }
        if (isDisposableEmail(value)) {
            throw new IllegalArgumentException("Disposable emails are not allowed");
        }
        this.value = value.toLowerCase();
    }
 
    private boolean isDisposableEmail(String email) {
        // Logique métier : bloquer les emails jetables
        return email.endsWith("@tempmail.com");
    }
}

// ❌ DANGEREUX : Injection SQL possible
@Singleton
public class UserRepository {
    public User findByEmail(String email) {
        String query = "SELECT * FROM users WHERE email = '" + email + "'";
        // Si email = "'; DROP TABLE users; --"
        // Query devient : SELECT * FROM users WHERE email = ''; DROP TABLE users; --'
        return jdbcTemplate.queryForObject(query, User.class);
    }
}

// ✅ SÉCURISÉ : Paramètres préparés
@Singleton
public class UserRepository {
    public User findByEmail(String email) {
        String query = "SELECT * FROM users WHERE email = ?";
        return jdbcTemplate.queryForObject(query, User.class, email);
        // Email est automatiquement échappé
    }
}

// ❌ DANGEREUX : XSS possible
@Controller
public class CommentController {
    @Post
    public String addComment(@Body String comment) {
        // Si comment = "<script>alert('XSS')</script>"
        return "<div>" + comment + "</div>";  // ❌ Script exécuté !
    }
}

// ✅ SÉCURISÉ : Échapper le HTML
@Controller
@RequiredArgsConstructor
public class CommentController {
    private final HtmlUtils htmlUtils;
 
    @Post
    public String addComment(@Body String comment) {
        String sanitized = htmlUtils.htmlEscape(comment);
        return "<div>" + sanitized + "</div>";
        // <script> devient &lt;script&gt; (affiché, pas exécuté)
    }
}

// ❌ DANGEREUX : Command injection
@Controller
public class FileController {
    @Get("/download")
    public File download(@QueryValue String filename) {
        Runtime.getRuntime().exec("cat " + filename);
        // Si filename = "file.txt; rm -rf /"
        // Commande devient : cat file.txt; rm -rf /
    }
}

// ✅ SÉCURISÉ : Valider et sanitizer le chemin
@Controller
public class FileController {
    @Get("/download")
    public File download(@QueryValue @Pattern(regexp = "^[a-zA-Z0-9._-]+$") String filename) {
        // Validation : seulement caractères alphanumériques + . _ -
        Path path = Paths.get("/safe/directory", filename).normalize();
 
        // Vérifier que le fichier est bien dans le dossier autorisé
        if (!path.startsWith("/safe/directory")) {
            throw new SecurityException("Path traversal detected");
        }
 
        return path.toFile();
    }
}

<!-- pom.xml -->
<dependency>
    <groupId>io.micronaut.security</groupId>
    <artifactId>micronaut-security-jwt</artifactId>
</dependency>

# application.yml
micronaut:
  security:
    authentication: bearer
    token:
      jwt:
        signatures:
          secret:
            generator:
              secret: "${JWT_SECRET:changeme}"

// 1. Login endpoint
@Controller("/api/auth")
public class AuthController {
 
    @Inject
    TokenGenerator tokenGenerator;
 
    @Post("/login")
    public HttpResponse<TokenResponse> login(@Body LoginRequest request) {
        // Vérifier email/password (hashé avec BCrypt)
        if (!isValidCredentials(request.email(), request.password())) {
            return HttpResponse.unauthorized();
        }
 
        // Générer JWT
        String token = tokenGenerator.generateToken(Map.of(
            "sub", request.email(),
            "roles", List.of("USER")
        ));
 
        return HttpResponse.ok(new TokenResponse(token));
    }
 
    private boolean isValidCredentials(String email, String password) {
        // Récupérer l'utilisateur depuis la BDD
        User user = userRepository.findByEmail(email)
            .orElse(null);
 
        if (user == null) {
            return false;
        }
 
        // Vérifier le password hashé avec BCrypt
        return BCrypt.checkpw(password, user.getPasswordHash());
    }
}
 
// 2. Endpoint protégé
@Controller("/api/users")
@Secured(SecurityRule.IS_AUTHENTICATED)  // ← Nécessite authentification
public class UserController {
 
    @Get("/me")
    public UserResponse getCurrentUser(Authentication authentication) {
        String email = authentication.getName();
        return userService.getUserByEmail(email);
    }
 
    @Delete("/{id}")
    @Secured({"ADMIN"})  // ← Nécessite rôle ADMIN
    public void deleteUser(@PathVariable Long id) {
        userService.delete(id);
    }
}

// ❌ Injection SQL
@Singleton
public class TrendRepositoryAdapter implements TrendRepository {
 
    @Override
    public List<TrendResult> search(String keyword) {
        String sql = "SELECT * FROM trends WHERE keyword = '" + keyword + "'";
        return jdbcTemplate.query(sql, rowMapper);
        // keyword = "'; DELETE FROM trends; --" = CATASTROPHE
    }
}

// ✅ Paramètres préparés
@Singleton
public class TrendRepositoryAdapter implements TrendRepository {
 
    @Override
    public List<TrendResult> search(String keyword) {
        String sql = "SELECT * FROM trends WHERE keyword = ?";
        return jdbcTemplate.query(sql, rowMapper, keyword);
        // keyword est automatiquement échappé
    }
}

// ❌ DANGEREUX : Mots de passe en clair
@Singleton
public class UserService {
    public boolean authenticate(String email, String password) {
        User user = userRepository.findByEmail(email);
        return user.getPassword().equals(password);  // ❌ Clair !
    }
}
 
// ❌ DANGEREUX : Session jamais expirée
@Controller
public class SessionController {
    @Post("/login")
    public void login() {
        session.put("userId", userId);
        // Pas d'expiration = session infinie !
    }
}

// ✅ BON : BCrypt pour hasher les mots de passe
@Singleton
public class UserService {
 
    public User register(String email, String password) {
        // Hasher le mot de passe avec BCrypt (salt automatique)
        String passwordHash = BCrypt.hashpw(password, BCrypt.gensalt(12));
 
        return userRepository.save(new User(email, passwordHash));
    }
 
    public boolean authenticate(String email, String password) {
        User user = userRepository.findByEmail(email)
            .orElseThrow(() -> new AuthenticationException("Invalid credentials"));
 
        // Vérifier le hash
        if (!BCrypt.checkpw(password, user.getPasswordHash())) {
            throw new AuthenticationException("Invalid credentials");
        }
 
        return true;
    }
}
 
// ✅ BON : JWT avec expiration
@Singleton
public class TokenService {
 
    public String generateToken(User user) {
        Instant now = Instant.now();
 
        return Jwts.builder()
            .setSubject(user.getEmail())
            .setIssuedAt(Date.from(now))
            .setExpiration(Date.from(now.plus(1, ChronoUnit.HOURS)))  // ✅ Expire dans 1h
            .signWith(secretKey)
            .compact();
    }
}

<dependency>
    <groupId>org.mindrot</groupId>
    <artifactId>jbcrypt</artifactId>
    <version>0.4</version>
</dependency>

// ❌ DANGEREUX : Password dans les logs
@Controller
public class AuthController {
 
    @Post("/login")
    public void login(@Body LoginRequest request) {
        log.info("Login attempt: {}", request);
        // Log: Login attempt: LoginRequest(email=user@example.com, password=secret123)
        // ❌ Password en clair dans les logs !
    }
}
 
// ❌ DANGEREUX : Password dans la réponse
@Data
public class UserResponse {
    private String email;
    private String passwordHash;  // ❌ Ne doit JAMAIS être exposé !
}

// ✅ BON : Masquer le password dans les logs
@Data
public class LoginRequest {
    private String email;
 
    @JsonProperty(access = JsonProperty.Access.WRITE_ONLY)  // ✅ Sérialisé uniquement en entrée
    private String password;
 
    @Override
    public String toString() {
        return "LoginRequest(email=" + email + ", password=****)";  // ✅ Masqué
    }
}
 
// ✅ BON : DTO sans données sensibles
@Data
public class UserResponse {
    private Long id;
    private String email;
    private LocalDateTime createdAt;
    // ❌ PAS de passwordHash, tokens, clés API
}
 
// ✅ BON : Mapper Domain → DTO en excluant les données sensibles
public class UserMapper {
    public static UserResponse toDto(User user) {
        return new UserResponse(
            user.getId(),
            user.getEmail(),
            user.getCreatedAt()
            // passwordHash n'est PAS mappé
        );
    }
}

# application.yml
micronaut:
  server:
    cors:
      enabled: true
      configurations:
        web:
          allowed-origins:
            - "*"  # ❌ Accepte TOUS les domaines (CSRF, XSS)
  security:
    enabled: false  # ❌ Sécurité désactivée

// ❌ Secrets hardcodés
public class ApiClient {
    private static final String API_KEY = "sk_live_abc123";  // ❌ En clair dans le code !
}

# application.yml
micronaut:
  server:
    cors:
      enabled: true
      configurations:
        web:
          allowed-origins:
            - "https://myapp.com"  # ✅ Domaine spécifique uniquement
          allowed-methods:
            - GET
            - POST
          allowed-headers:
            - Content-Type
            - Authorization
          max-age: 3600
  security:
    enabled: true  # ✅ Sécurité activée
    authentication: bearer

// ✅ Secrets dans les variables d'environnement
@Singleton
public class ApiClient {
 
    @Value("${api.trends.key}")  // ✅ Variable d'environnement
    private String apiKey;
 
    public String callApi() {
        // Utiliser apiKey de manière sécurisée
    }
}

# .env (jamais committé dans Git !)
API_TRENDS_KEY=sk_live_abc123
 
# .gitignore
.env

// ❌ DANGEREUX : N'importe qui peut supprimer n'importe quel utilisateur
@Controller("/api/users")
public class UserController {
 
    @Delete("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.delete(id);
        // ❌ Pas de vérification : utilisateur A peut supprimer utilisateur B !
    }
}

// ✅ BON : Vérifier les permissions
@Controller("/api/users")
@Secured(SecurityRule.IS_AUTHENTICATED)
public class UserController {
 
    @Delete("/{id}")
    public void deleteUser(
        @PathVariable Long id,
        Authentication authentication
    ) {
        String currentUserEmail = authentication.getName();
        User currentUser = userService.getUserByEmail(currentUserEmail);
 
        // Vérifier : soit c'est son propre compte, soit il est admin
        if (!currentUser.getId().equals(id) && !currentUser.isAdmin()) {
            throw new ForbiddenException("You cannot delete this user");
        }
 
        userService.delete(id);
    }
 
    @Put("/{id}/role")
    @Secured({"ADMIN"})  // ✅ Seulement les admins
    public void updateRole(@PathVariable Long id, @Body String newRole) {
        userService.updateRole(id, newRole);
    }
}

// Domain : Règle métier
@Value
public class User {
    Long id;
    Email email;
    Role role;
 
    public boolean canDelete(User target) {
        // Règle métier : on peut supprimer soi-même ou si admin
        return this.id.equals(target.id) || this.role == Role.ADMIN;
    }
}
 
// Application : Use case avec vérification
@Singleton
@RequiredArgsConstructor
public class DeleteUserUseCase {
    private final UserRepository userRepository;
 
    public void execute(Long targetId, Long currentUserId) {
        User currentUser = userRepository.findById(currentUserId)
            .orElseThrow();
        User targetUser = userRepository.findById(targetId)
            .orElseThrow();
 
        // ✅ Vérifier avec la règle métier du domain
        if (!currentUser.canDelete(targetUser)) {
            throw new ForbiddenException("Cannot delete this user");
        }
 
        userRepository.delete(targetId);
    }
}