OWASP Top 10 — Vulnérabilités critiques applicatives

// ❌ MAUVAIS CONTRÔLEUR
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // Requête brute — vulnérable si pas de bind paramètre
    @Query("SELECT u FROM User u WHERE u.email = :email AND u.status = :status")
    List<User> findByEmailAndStatus(@Param("email") String email,
                                    @Param("status") String status);
}
 
// ✅ TOUT PASSER PAR DES BIND PARAMETERS
@RestController
public class UserController {
    @GetMapping("/users/search")
    public List<User> search(@RequestParam String email,
                             @RequestParam String status) {
        return userRepository.findByEmailAndStatus(email, status);
    }
}

@Configuration
@EnableMethodSecurity
public class SecurityConfig {
 
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .requestMatchers("/api/**").authenticated()
                .anyRequest().permitAll()
            )
            .csrf(csrf -> csrf.disable()); // À réactiver pour les formulaires
        return http.build();
    }
}
 
@Service
public class OrderService {
 
    @PreAuthorize("#userId == authentication.principal.id")
    public Order getOrder(Long orderId, Long userId) {
        // L'utilisateur ne peut lire que SES propres commandes
        return orderRepository.findById(orderId)
            .orElseThrow(() -> new NotFoundException("Commande introuvable"));
    }
}

import org.springframework.util.HtmlUtils;
 
@RestController
public class CommentController {
 
    @PostMapping("/comments")
    public String createComment(@RequestBody String rawComment) {
        // Échappement HTML systématique
        String safeComment = HtmlUtils.htmlEscape(rawComment);
        return commentRepository.save(safeComment).toString();
    }
}

@RestController
@RequestMapping("/api/data")
public class DataService {
 
    // ✅ Utiliser Jackson avec un type explicite et validation stricte
    @PostMapping("/import")
    public Result importData(@RequestBody MySafeDto payload) {
        return service.process(payload);
    }
 
    // ❌ Jamais de readValue(Object.class) ou de Map non typé
    //    avec une entrée utilisateur brute.
}

// ❌ Bind laxiste — des champs non attendus sont ignorés silencieusement
@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    // Si le JSON contient "unknownField", il est ignoré sans avertissement
}
 
// ✅ Bind strict — toute propriété inattendue provoque une erreur
@ConfigurationProperties(prefix = "app")
@Data
public class StrictAppProperties {
    private String name;
 
    @PostConstruct
    public void validate() {
        if (name == null || name.isBlank()) {
            throw new IllegalStateException("app.name est requis");
        }
    }
}

@Configuration
@EnableMethodSecurity
public class SecurityConfig {
 
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/auth/**").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .failureUrl("/login?error=true")
            )
            .sessionManagement(session -> session
                .maximumSessions(1) // Une session par utilisateur
            );
        return http.build();
    }
}

# Vérifier les dépendances obsolètes ou vulnérables
mvn dependency:analyze
 
# Liste des dépendances avec versions connues vulnérables
mvn org.owasp:dependency-check-maven:check

@Service
public class UserService {
 
    public UserDto getUser(Long id) {
        User user = userRepository.findById(id)
            .orElseThrow(() -> new NotFoundException("Utilisateur introuvable"));
 
        // Masquer les données sensibles avant le retour
        return new UserDto(
            user.getId(),
            user.getEmail(),
            maskPhone(user.getPhone()),
            null // passwordHash — jamais dans la réponse
        );
    }
 
    private String maskPhone(String phone) {
        if (phone == null) return null;
        return phone.replaceAll("(?<=....).*", "****");
    }
}

@RestController
public class ApiController {
 
    private static final Logger log = LoggerFactory.getLogger(ApiController.class);
 
    @PostMapping("/api/transfer")
    public Result transfer(@RequestBody TransferRequest req) {
        log.info("Transfert initié : from={}, to={}, amount={}",
            req.getFrom(), req.getTo(), req.getAmount());
 
        try {
            service.transfer(req);
            log.info("Transfert effectué avec succès");
            return Result.success();
        } catch (Exception e) {
            log.error("Échec du transfert : {}, cause={}", req, e.getMessage());
            return Result.error("Échec du transfert");
        }
    }
}