Day-131-安全编码实践Java

# Day 145: 安全编码实践 (Java)

> 应用安全系列第 38 天 | 预计阅读时间：50 分钟 | 难度：★★★★☆

---

**PUA v3 · Sprint 启动** 
```
┌─────────┬────────────────────────────────────┐
│ 清单 任务 │ 安全编码实践 (Java) - Day 145      │
├─────────┼────────────────────────────────────┤
│  味道 │  阿里味（自动：安全任务）        │
├─────────┼────────────────────────────────────┤
│  压力 │ L0 · 信任期                        │
└─────────┴────────────────────────────────────┘
```
▎ 安全编码不是写完检查，是写的时候就安全。写的时候不安全，检查就是返工的。今天深入 Java 安全编码实践。

---

## 清单 目录

1. [Java 安全编码概述](#java 安全编码概述)
2. [输入验证安全](#输入验证安全)
3. [输出编码安全](#输出编码安全)
4. [认证与会话安全](#认证与会话安全)
5. [数据访问安全](#数据访问安全)
6. [文件操作安全](#文件操作安全)
7. [加密与随机数](#加密与随机数)
8. [异常处理安全](#异常处理安全)
9. [依赖与配置安全](#依赖与配置安全)
10. [安全代码审查](#安全代码审查)
11. [总结与思考](#总结与思考)
12. [参考资料](#参考资料)

---

## Java 安全编码概述

### 为什么 Java 需要安全编码

> ▎ Java 不是类型安全就万事大吉，应用层漏洞照样层出不穷。类型安全不等于应用安全。

**Java 安全现状**：
```
常见 Java 安全漏洞 (OWASP 数据):

1. 注入漏洞 (Injection)
   - SQL 注入
   - OS 命令注入
   - LDAP 注入
   - 占比：35%

2. 失效的访问控制
   - 越权访问
   - 未授权访问
   - 占比：20%

3. 敏感数据泄露
   - 明文存储
   - 传输未加密
   - 占比：15%

4. XXE (XML 外部实体)
   - XML 解析漏洞
   - 占比：10%

5. 反序列化漏洞
   - 不安全反序列化
   - 占比：10%

6. 其他
   - 安全配置错误
   - 不安全的依赖
   - 占比：10%
```

**安全编码价值**：
```
预防成本 vs 修复成本：

阶段          预防成本    修复成本    ROI
─────────────────────────────────────────
编码时        1 单位      -          -
测试时发现    -          10 单位     1:10
生产发现      -          100 单位    1:100

安全编码投资回报：
- 每投入 1 小时安全编码，节省 10 小时修复
- 漏洞密度降低 50-70%
- 安全审查时间减少 40-60%
```

### Java 安全资源

**官方资源**：
```java
// Oracle Java Security Guidelines
// https://www.oracle.com/java/technologies/javase/seccodeguide.html

// OWASP Java Security Cheat Sheet
// https://cheatsheetseries.owasp.org/cheatsheets/Java_Security_Cheat_Sheet.html

// CERT Oracle Secure Coding Standard for Java
// https://wiki.sei.cmu.edu/confluence/display/java
```

**安全库**：
```java
// 推荐使用的安全库
dependencies {
    // 密码学
    implementation 'org.bouncycastle:bcprov-jdk15on:1.70'
    
    // 密码哈希
    implementation 'org.mindrot:jbcrypt:0.4'
    implementation 'de.mkammerer:argon2-jvm:2.11'
    
    // HTML 编码
    implementation 'org.owasp.encoder:encoder:1.2.3'
    
    // 输入验证
    implementation 'javax.validation:validation-api:2.0.1.Final'
    implementation 'org.hibernate.validator:hibernate-validator:6.2.0.Final'
    
    // 安全随机数
    // Java 内置 SecureRandom
    
    // JWT
    implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
    implementation 'io.jsonwebtoken:jjwt-impl:0.11.5'
    implementation 'io.jsonwebtoken:jjwt-jackson:0.11.5'
}
```

---

## 输入验证安全

### 输入验证原则

> ▎ 输入验证不是信任前端，是防御第一关。前端验证可绕过，服务端必须验证。

**验证原则**：
```
1. 白名单验证 (Allowlist)
   - 只允许已知好的
   - 优于黑名单
   - 更安全

2. 服务端验证
   - 客户端验证可绕过
   - 服务端必须验证
   - 双重验证更佳

3. 类型、长度、范围
   - 检查数据类型
   - 检查长度限制
   - 检查取值范围

4. 早验证、多验证
   - 尽早验证输入
   - 多处验证
   - 边界验证
```

### 输入验证实现

**使用 Bean Validation**：
```java
// 安全的输入验证示例
import javax.validation.Valid;
import javax.validation.constraints.*;
import javax.validation.constraintvalidation.SupportedValidationTarget;
import javax.validation.constraintvalidation.ValidationTarget;

// 用户注册 DTO
public class UserRegistrationDTO {
    
    // 用户名：3-20 位，字母数字下划线
    @NotNull(message = "用户名不能为空")
    @Size(min = 3, max = 20, message = "用户名长度必须在 3-20 之间")
    @Pattern(regexp = "^[a-zA-Z0-9_]+$", message = "用户名只能包含字母、数字、下划线")
    private String username;
    
    // 邮箱：标准邮箱格式
    @NotNull(message = "邮箱不能为空")
    @Email(message = "邮箱格式不正确")
    @Size(max = 254, message = "邮箱长度不能超过 254")
    private String email;
    
    // 密码：最小 12 位，复杂度要求
    @NotNull(message = "密码不能为空")
    @Size(min = 12, max = 128, message = "密码长度必须在 12-128 之间")
    @Pattern(
        regexp = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[!@#$%^&*(),.?\":{}|<>]).+$",
        message = "密码必须包含大小写字母、数字、特殊字符"
    )
    private String password;
    
    // 手机号：国际标准
    @Pattern(
        regexp = "^\\+?[1-9]\\d{1,14}$",
        message = "手机号格式不正确"
    )
    private String phone;
    
    // 年龄：合理范围
    @Min(value = 0, message = "年龄不能为负数")
    @Max(value = 150, message = "年龄不能超过 150")
    private Integer age;
    
    // Getters and Setters
}

// 控制器层验证
@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @Autowired
    private Validator validator;
    
    @PostMapping
    public ResponseEntity<?> registerUser(@Valid @RequestBody UserRegistrationDTO dto) {
        // @Valid 自动触发验证
        // 验证失败会抛出 MethodArgumentNotValidException
        // 无需手动检查
        userService.register(dto);
        return ResponseEntity.ok().build();
    }
    
    // 手动验证示例
    @PostMapping("/manual")
    public ResponseEntity<?> registerUserManual(@RequestBody UserRegistrationDTO dto) {
        Set<ConstraintViolation<UserRegistrationDTO>> violations = 
            validator.validate(dto);
        
        if (!violations.isEmpty()) {
            List<String> errors = violations.stream()
                .map(ConstraintViolation::getMessage)
                .collect(Collectors.toList());
            
            return ResponseEntity.badRequest().body(errors);
        }
        
        userService.register(dto);
        return ResponseEntity.ok().build();
    }
}
```

**自定义验证器**：
```java
// 自定义验证注解
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = NoSqlInjectionValidator.class)
@Documented
public @interface NoSqlInjection {
    String message() default "输入可能包含 SQL 注入字符";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

// 自定义验证器实现
public class NoSqlInjectionValidator implements ConstraintValidator<NoSqlInjection, String> {
    
    // SQL 注入危险字符
    private static final Pattern DANGEROUS_PATTERN = Pattern.compile(
        "(?i)(union|select|insert|update|delete|drop|truncate|exec|execute|" +
        "--|;|/\\*|\\*/|xp_|sp_|0x|char\\(|nchar\\(|varchar\\|nvarchar\\()"
    );
    
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        if (value == null || value.isEmpty()) {
            return true; // 空值由@NotNull 控制
        }
        
        // 检查危险模式
        if (DANGEROUS_PATTERN.matcher(value).find()) {
            return false;
        }
        
        return true;
    }
}

// 使用自定义验证
public class SearchDTO {
    
    @NoSqlInjection(message = "搜索词包含危险字符")
    @Size(max = 200, message = "搜索词长度不能超过 200")
    private String searchTerm;
    
    // Getter and Setter
}
```

**输入清理**：
```java
// 安全的输入清理工具
import org.owasp.encoder.Encode;
import java.text.Normalizer;

public class SecureInputUtil {
    
    /**
     * 清理字符串输入
     */
    public static String sanitizeString(String input, int maxLength) {
        if (input == null) {
            return null;
        }
        
        // 1. 长度限制
        if (input.length() > maxLength) {
            input = input.substring(0, maxLength);
        }
        
        // 2. 标准化 Unicode
        input = Normalizer.normalize(input, Normalizer.Form.NFC);
        
        // 3. 移除控制字符
        input = input.replaceAll("[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F\\x7F]", "");
        
        // 4. 去除首尾空白
        input = input.trim();
        
        return input;
    }
    
    /**
     * 清理 HTML 输入 (防止 XSS)
     */
    public static String sanitizeHtml(String input) {
        if (input == null) {
            return null;
        }
        
        // 使用 OWASP Encoder 进行 HTML 编码
        return Encode.forHtml(input);
    }
    
    /**
     * 验证并清理文件名
     */
    public static String sanitizeFilename(String filename) {
        if (filename == null || filename.isEmpty()) {
            throw new IllegalArgumentException("文件名不能为空");
        }
        
        // 只允许安全字符
        if (!filename.matches("^[a-zA-Z0-9._-]+$")) {
            throw new IllegalArgumentException("文件名包含非法字符");
        }
        
        // 防止路径遍历
        if (filename.contains("..") || filename.contains("/") || filename.contains("\\")) {
            throw new IllegalArgumentException("文件名包含路径字符");
        }
        
        // 长度限制
        if (filename.length() > 255) {
            throw new IllegalArgumentException("文件名过长");
        }
        
        return filename;
    }
    
    /**
     * 验证整数范围
     */
    public static int validateIntegerRange(Integer value, int min, int max, int defaultValue) {
        if (value == null) {
            return defaultValue;
        }
        
        if (value < min || value > max) {
            throw new IllegalArgumentException(
                String.format("值必须在 %d 到 %d 之间", min, max)
            );
        }
        
        return value;
    }
}
```

---

## 输出编码安全

### XSS 防护

> ▎ 输出编码不是可选项，是必选项。输出不编码，XSS 就是必然的。

**输出编码实现**：
```java
// 安全的输出编码
import org.owasp.encoder.Encode;
import javax.servlet.jsp.JspWriter;

public class SecureOutputUtil {
    
    /**
     * HTML 内容编码
     */
    public static String encodeForHtml(String input) {
        if (input == null) {
            return "";
        }
        return Encode.forHtml(input);
    }
    
    /**
     * HTML 属性编码
     */
    public static String encodeForHtmlAttribute(String input) {
        if (input == null) {
            return "";
        }
        return Encode.forHtmlAttribute(input);
    }
    
    /**
     * JavaScript 编码
     */
    public static String encodeForJavaScript(String input) {
        if (input == null) {
            return "";
        }
        return Encode.forJavaScript(input);
    }
    
    /**
     * URL 编码
     */
    public static String encodeForUrl(String input) {
        if (input == null) {
            return "";
        }
        return Encode.forUriComponent(input);
    }
    
    /**
     * CSS 编码
     */
    public static String encodeForCss(String input) {
        if (input == null) {
            return "";
        }
        return Encode.forCssString(input);
    }
}

// JSP 安全输出示例
/*
错误示例 (XSS 漏洞):
<%= userInput %>
${userInput}

正确示例 (编码输出):
<%= Encode.forHtml(userInput) %>
${fn:escapeXml(userInput)}

使用 JSTL:
<c:out value="${userInput}" escapeXml="true" />
*/

// Thymeleaf 安全输出
/*
Thymeleaf 默认自动转义:
<th:text="${userInput}"></th>

显式转义:
<th:text="${#strings.escapeXml(userInput)}"></th>

不转义 (仅在可信内容时使用):
<th:utext="${trustedHtml}"></th>
*/
```

### 安全响应头

```java
// 安全响应头配置
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class SecurityHeadersFilter extends OncePerRequestFilter {
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                    HttpServletResponse response, 
                                    FilterChain filterChain) 
            throws ServletException, IOException {
        
        // 防止点击劫持
        response.setHeader("X-Frame-Options", "DENY");
        
        // XSS 防护
        response.setHeader("X-XSS-Protection", "1; mode=block");
        
        // 防止 MIME 类型嗅探
        response.setHeader("X-Content-Type-Options", "nosniff");
        
        // 内容安全策略
        response.setHeader("Content-Security-Policy", 
            "default-src 'self'; " +
            "script-src 'self'; " +
            "style-src 'self' 'unsafe-inline'; " +
            "img-src 'self' data:; " +
            "font-src 'self'");
        
        // Referrer 策略
        response.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");
        
        // 权限策略
        response.setHeader("Permissions-Policy", 
            "geolocation=(), microphone=(), camera=()");
        
        // HTTP Strict Transport Security (HSTS)
        response.setHeader("Strict-Transport-Security", 
            "max-age=31536000; includeSubDomains; preload");
        
        filterChain.doFilter(request, response);
    }
}

// Spring Security 配置
@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .headers(headers -> headers
                .frameOptions(FrameOptionsConfig::deny)
                .xssProtection(xss -> xss.block(true))
                .contentTypeOptions(Customizer.withDefaults())
                .httpStrictTransportSecurity(hsts -> hsts
                    .maxAgeInSeconds(31536000)
                    .includeSubDomains(true)
                    .preload(true))
                .contentSecurityPolicy(csp -> csp
                    .policyDirectives(
                        "default-src 'self'; " +
                        "script-src 'self'; " +
                        "style-src 'self' 'unsafe-inline'"
                    ))
            );
        
        return http.build();
    }
}
```

---

## 认证与会话安全

### 密码安全

> ▎ 密码不是明文存储，是哈希存储。哈希不安全，密码就是裸奔的。

**密码哈希实现**：
```java
// 安全的密码处理
import org.mindrot.jbcrypt.BCrypt;
import de.mkammerer.argon2.Argon2;
import de.mkammerer.argon2.Argon2Factory;

public class SecurePasswordUtil {
    
    // BCrypt 成本因子 (越高越安全，但越慢)
    private static final int BCRYPT_ROUNDS = 12;
    
    // Argon2 参数
    private static final int ARGON2_ITERATIONS = 3;
    private static final int ARGON2_MEMORY = 65536; // 64 MB
    private static final int ARGON2_PARALLELISM = 4;
    
    /**
     * 使用 BCrypt 哈希密码
     */
    public static String hashPasswordBCrypt(String password) {
        if (password == null || password.isEmpty()) {
            throw new IllegalArgumentException("密码不能为空");
        }
        
        // BCrypt 自动生成盐值
        return BCrypt.hashpw(password, BCrypt.gensalt(BCRYPT_ROUNDS));
    }
    
    /**
     * 使用 Argon2 哈希密码 (推荐)
     */
    public static String hashPasswordArgon2(String password) {
        if (password == null || password.isEmpty()) {
            throw new IllegalArgumentException("密码不能为空");
        }
        
        Argon2 argon2 = Argon2Factory.create(Argon2Factory.Argon2Types.ARGON2id);
        char[] passwordChars = password.toCharArray();
        
        try {
            return argon2.hash(ARGON2_ITERATIONS, ARGON2_MEMORY, ARGON2_PARALLELISM, passwordChars);
        } finally {
            argon2.wipeArray(passwordChars);
        }
    }
    
    /**
     * 验证密码 (BCrypt)
     */
    public static boolean verifyPasswordBCrypt(String password, String hashedPassword) {
        if (password == null || hashedPassword == null) {
            return false;
        }
        
        try {
            return BCrypt.checkpw(password, hashedPassword);
        } catch (IllegalArgumentException e) {
            // 哈希格式错误
            return false;
        }
    }
    
    /**
     * 验证密码 (Argon2)
     */
    public static boolean verifyPasswordArgon2(String password, String hashedPassword) {
        if (password == null || hashedPassword == null) {
            return false;
        }
        
        Argon2 argon2 = Argon2Factory.create(Argon2Factory.Argon2Types.ARGON2id);
        char[] passwordChars = password.toCharArray();
        
        try {
            return argon2.verify(hashedPassword, passwordChars);
        } finally {
            argon2.wipeArray(passwordChars);
        }
    }
    
    /**
     * 检查密码是否需要重新哈希
     */
    public static boolean needsRehash(String hashedPassword) {
        // BCrypt 检查
        if (hashedPassword.startsWith("$2a$") || hashedPassword.startsWith("$2b$")) {
            String[] parts = hashedPassword.split("\\$");
            if (parts.length >= 3) {
                int cost = Integer.parseInt(parts[2]);
                return cost < BCRYPT_ROUNDS;
            }
        }
        
        // Argon2 检查 (简化)
        // 实际应检查 Argon2 参数
        
        return false;
    }
}

// 密码策略实现
public class PasswordPolicy {
    
    private static final int MIN_LENGTH = 12;
    private static final int MAX_LENGTH = 128;
    
    // 常见密码黑名单
    private static final Set<String> COMMON_PASSWORDS = Set.of(
        "password", "123456", "qwerty", "admin", "letmein",
        "welcome", "monkey", "dragon", "master", "login"
    );
    
    /**
     * 验证密码强度
     */
    public static PasswordValidationResult validatePassword(String password) {
        List<String> errors = new ArrayList<>();
        
        // 长度检查
        if (password.length() < MIN_LENGTH) {
            errors.add(String.format("密码长度必须至少 %d 位", MIN_LENGTH));
        }
        
        if (password.length() > MAX_LENGTH) {
            errors.add(String.format("密码长度不能超过 %d 位", MAX_LENGTH));
        }
        
        // 复杂度检查
        if (!password.matches(".*[a-z].*")) {
            errors.add("密码必须包含小写字母");
        }
        
        if (!password.matches(".*[A-Z].*")) {
            errors.add("密码必须包含大写字母");
        }
        
        if (!password.matches(".*\\d.*")) {
            errors.add("密码必须包含数字");
        }
        
        if (!password.matches(".*[!@#$%^&*(),.?\":{}|<>].*")) {
            errors.add("密码必须包含特殊字符");
        }
        
        // 常见密码检查
        if (COMMON_PASSWORDS.contains(password.toLowerCase())) {
            errors.add("密码太常见，请使用更复杂的密码");
        }
        
        // 连续字符检查
        if (hasSequentialChars(password)) {
            errors.add("密码不能包含连续字符 (如 123, abc)");
        }
        
        // 重复字符检查
        if (hasRepeatedChars(password)) {
            errors.add("密码不能包含过多重复字符");
        }
        
        return new PasswordValidationResult(errors.isEmpty(), errors);
    }
    
    private static boolean hasSequentialChars(String password) {
        String lower = password.toLowerCase();
        for (int i = 0; i < lower.length() - 2; i++) {
            String seq = lower.substring(i, i + 3);
            if (seq.chars().allMatch(Character::isLetter)) {
                char[] chars = seq.toCharArray();
                if (chars[1] == chars[0] + 1 && chars[2] == chars[1] + 1) {
                    return true;
                }
            }
            if (seq.chars().allMatch(Character::isDigit)) {
                char[] chars = seq.toCharArray();
                if (chars[1] == chars[0] + 1 && chars[2] == chars[1] + 1) {
                    return true;
                }
            }
        }
        return false;
    }
    
    private static boolean hasRepeatedChars(String password) {
        for (int i = 0; i < password.length() - 3; i++) {
            if (password.charAt(i) == password.charAt(i + 1) &&
                password.charAt(i) == password.charAt(i + 2) &&
                password.charAt(i) == password.charAt(i + 3)) {
                return true;
            }
        }
        return false;
    }
    
    public static class PasswordValidationResult {
        private final boolean valid;
        private final List<String> errors;
        
        public PasswordValidationResult(boolean valid, List<String> errors) {
            this.valid = valid;
            this.errors = errors;
        }
        
        public boolean isValid() { return valid; }
        public List<String> getErrors() { return errors; }
    }
}
```

### 会话安全

```java
// 安全的会话管理
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpServletRequest;
import java.util.concurrent.ConcurrentHashMap;

public class SecureSessionManager {
    
    // 会话超时时间 (秒)
    private static final int SESSION_TIMEOUT = 1800; // 30 分钟
    
    // 绝对超时时间 (秒)
    private static final int ABSOLUTE_TIMEOUT = 28800; // 8 小时
    
    /**
     * 创建安全会话
     */
    public static HttpSession createSecureSession(HttpServletRequest request) {
        HttpSession session = request.getSession(true);
        
        // 设置超时
        session.setMaxInactiveInterval(SESSION_TIMEOUT);
        
        // 记录创建时间和 IP
        session.setAttribute("CREATION_TIME", System.currentTimeMillis());
        session.setAttribute("CREATION_IP", request.getRemoteAddr());
        session.setAttribute("LAST_ACCESSED_TIME", System.currentTimeMillis());
        
        return session;
    }
    
    /**
     * 会话 ID 轮换 (防止会话固定攻击)
     */
    public static HttpSession regenerateSession(HttpServletRequest request, 
                                                 HttpSession oldSession) {
        // 保存旧会话数据
        ConcurrentHashMap<String, Object> sessionData = new ConcurrentHashMap<>();
        oldSession.getAttributeNames().asIterator().forEachRemaining(name -> {
            sessionData.put(name, oldSession.getAttribute(name));
        });
        
        // 使旧会话无效
        oldSession.invalidate();
        
        // 创建新会话
        HttpSession newSession = request.getSession(true);
        newSession.setMaxInactiveInterval(SESSION_TIMEOUT);
        
        // 恢复会话数据
        sessionData.forEach(newSession::setAttribute);
        
        // 更新创建时间
        newSession.setAttribute("LAST_REGENERATION_TIME", System.currentTimeMillis());
        
        return newSession;
    }
    
    /**
     * 验证会话有效性
     */
    public static boolean validateSession(HttpServletRequest request, 
                                          HttpSession session) {
        if (session == null) {
            return false;
        }
        
        Long creationTime = (Long) session.getAttribute("CREATION_TIME");
        if (creationTime == null) {
            return false;
        }
        
        // 检查绝对超时
        long now = System.currentTimeMillis();
        if (now - creationTime > ABSOLUTE_TIMEOUT * 1000L) {
            session.invalidate();
            return false;
        }
        
        // 可选：检查 IP 变更
        // String creationIp = (String) session.getAttribute("CREATION_IP");
        // if (!creationIp.equals(request.getRemoteAddr())) {
        //     session.invalidate();
        //     return false;
        // }
        
        // 更新最后访问时间
        session.setAttribute("LAST_ACCESSED_TIME", now);
        
        return true;
    }
    
    /**
     * 安全登出
     */
    public static void secureLogout(HttpServletRequest request) {
        HttpSession session = request.getSession(false);
        if (session != null) {
            // 清除敏感数据
            session.removeAttribute("USER_ID");
            session.removeAttribute("USERNAME");
            session.removeAttribute("ROLE");
            
            // 使会话无效
            session.invalidate();
        }
        
        // 清除认证 Cookie
        Cookie[] cookies = request.getCookies();
        if (cookies != null) {
            for (Cookie cookie : cookies) {
                if (cookie.getName().equals("JSESSIONID")) {
                    cookie.setMaxAge(0);
                    cookie.setPath("/");
                    // 需要添加到响应中才能生效
                }
            }
        }
    }
}
```

---

## 数据访问安全

### SQL 注入防护

> ▎ SQL 注入不是老漏洞，是常青树。参数化不用，注入就是必然的。

**参数化查询**：
```java
// 安全的数据库操作
import java.sql.*;
import javax.sql.DataSource;

public class SecureDatabaseUtil {
    
    private final DataSource dataSource;
    
    public SecureDatabaseUtil(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    
    /**
     * 安全查询 - PreparedStatement
     */
    public User getUserById(int userId) throws SQLException {
        String sql = "SELECT id, username, email FROM users WHERE id = ?";
        
        try (Connection conn = dataSource.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            
            // 正确：使用参数化查询
            stmt.setInt(1, userId);
            
            try (ResultSet rs = stmt.executeQuery()) {
                if (rs.next()) {
                    return mapUser(rs);
                }
                return null;
            }
        }
    }
    
    /**
     * 安全查询 - 多个参数
     */
    public List<User> searchUsers(String username, String email) throws SQLException {
        String sql = "SELECT id, username, email FROM users " +
                     "WHERE username LIKE ? AND email LIKE ?";
        
        try (Connection conn = dataSource.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            
            // 正确：参数化 LIKE 查询
            stmt.setString(1, "%" + username + "%");
            stmt.setString(2, "%" + email + "%");
            
            try (ResultSet rs = stmt.executeQuery()) {
                List<User> users = new ArrayList<>();
                while (rs.next()) {
                    users.add(mapUser(rs));
                }
                return users;
            }
        }
    }
    
    /**
     * 安全插入
     */
    public int createUser(String username, String email, String passwordHash) 
            throws SQLException {
        String sql = "INSERT INTO users (username, email, password_hash) " +
                     "VALUES (?, ?, ?)";
        
        try (Connection conn = dataSource.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql, 
                     Statement.RETURN_GENERATED_KEYS)) {
            
            stmt.setString(1, username);
            stmt.setString(2, email);
            stmt.setString(3, passwordHash);
            
            int affectedRows = stmt.executeUpdate();
            
            if (affectedRows == 0) {
                throw new SQLException("创建用户失败");
            }
            
            try (ResultSet generatedKeys = stmt.getGeneratedKeys()) {
                if (generatedKeys.next()) {
                    return generatedKeys.getInt(1);
                }
                throw new SQLException("创建用户失败，未获取 ID");
            }
        }
    }
    
    /**
     * 安全动态排序
     */
    public List<User> getUsersSorted(String sortBy, String sortOrder) 
            throws SQLException {
        // 白名单验证排序字段
        Set<String> allowedSortFields = Set.of("id", "username", "email", "created_at");
        if (!allowedSortFields.contains(sortBy)) {
            sortBy = "id"; // 默认
        }
        
        // 验证排序方向
        if (!"ASC".equalsIgnoreCase(sortOrder) && 
            !"DESC".equalsIgnoreCase(sortOrder)) {
            sortOrder = "ASC"; // 默认
        }
        
        // 正确：排序字段不能参数化，必须白名单验证后拼接
        String sql = "SELECT id, username, email FROM users ORDER BY " + 
                     sortBy + " " + sortOrder;
        
        try (Connection conn = dataSource.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql);
             ResultSet rs = stmt.executeQuery()) {
            
            List<User> users = new ArrayList<>();
            while (rs.next()) {
                users.add(mapUser(rs));
            }
            return users;
        }
    }
    
    /**
     * 安全 IN 查询
     */
    public List<User> getUsersByIds(List<Integer> ids) throws SQLException {
        if (ids == null || ids.isEmpty()) {
            return new ArrayList<>();
        }
        
        // 限制数量防止资源耗尽
        if (ids.size() > 100) {
            ids = ids.subList(0, 100);
        }
        
        // 构建参数化 IN 子句
        String placeholders = ids.stream()
            .map(i -> "?")
            .collect(Collectors.joining(", "));
        
        String sql = "SELECT id, username, email FROM users WHERE id IN (" + 
                     placeholders + ")";
        
        try (Connection conn = dataSource.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            
            // 设置参数
            for (int i = 0; i < ids.size(); i++) {
                stmt.setInt(i + 1, ids.get(i));
            }
            
            try (ResultSet rs = stmt.executeQuery()) {
                List<User> users = new ArrayList<>();
                while (rs.next()) {
                    users.add(mapUser(rs));
                }
                return users;
            }
        }
    }
    
    private User mapUser(ResultSet rs) throws SQLException {
        User user = new User();
        user.setId(rs.getInt("id"));
        user.setUsername(rs.getString("username"));
        user.setEmail(rs.getString("email"));
        return user;
    }
}

// 不安全的示例 (DO NOT USE)
/*
// 错误：字符串拼接 SQL
public User getUserByIdUnsafe(int userId) throws SQLException {
    String sql = "SELECT * FROM users WHERE id = " + userId;  // SQL 注入!
    // ...
}

// 错误：直接拼接用户输入
public User searchUsersUnsafe(String username) throws SQLException {
    String sql = "SELECT * FROM users WHERE username = '" + username + "'";  // SQL 注入!
    // ...
}
*/
```

### JPA/Hibernate 安全

```java
// JPA 安全查询
import javax.persistence.*;
import java.util.List;

@Repository
public class SecureUserRepository {
    
    @PersistenceContext
    private EntityManager entityManager;
    
    /**
     * 安全查询 - 参数化 JPQL
     */
    public User findByUsername(String username) {
        String jpql = "SELECT u FROM User u WHERE u.username = :username";
        
        return entityManager.createQuery(jpql, User.class)
            .setParameter("username", username)
            .getResultStream()
            .findFirst()
            .orElse(null);
    }
    
    /**
     * 安全查询 - Criteria API (最安全)
     */
    public List<User> searchUsers(String username, String email) {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<User> query = cb.createQuery(User.class);
        Root<User> root = query.from(User.class);
        
        List<Predicate> predicates = new ArrayList<>();
        
        if (username != null && !username.isEmpty()) {
            predicates.add(cb.like(root.get("username"), "%" + username + "%"));
        }
        
        if (email != null && !email.isEmpty()) {
            predicates.add(cb.like(root.get("email"), "%" + email + "%"));
        }
        
        query.where(predicates.toArray(new Predicate[0]));
        
        return entityManager.createQuery(query).getResultList();
    }
    
    /**
     * 安全原生查询
     */
    public List<User> findByEmailDomain(String domain) {
        // 即使是原生查询，也要使用参数化
        String sql = "SELECT * FROM users WHERE email LIKE :domain";
        
        return entityManager.createNativeQuery(sql, User.class)
            .setParameter("domain", "%" + domain)
            .getResultList();
    }
    
    /**
     * 安全排序
     */
    public List<User> getUsersSorted(String sortBy, String sortOrder) {
        // 白名单验证
        Set<String> allowedFields = Set.of("id", "username", "email", "createdAt");
        if (!allowedFields.contains(sortBy)) {
            sortBy = "id";
        }
        
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<User> query = cb.createQuery(User.class);
        Root<User> root = query.from(User.class);
        
        query.select(root);
        
        if ("DESC".equalsIgnoreCase(sortOrder)) {
            query.orderBy(cb.desc(root.get(sortBy)));
        } else {
            query.orderBy(cb.asc(root.get(sortBy)));
        }
        
        return entityManager.createQuery(query).getResultList();
    }
}
```

---

## 文件操作安全

### 路径遍历防护

> ▎ 文件操作不是简单 IO，是安全边界。边界不守，系统就是开放的。

**安全的文件操作**：
```java
// 安全的文件操作工具
import java.io.*;
import java.nio.file.*;

public class SecureFileUtil {
    
    /**
     * 安全读取文件
     */
    public static byte[] readFileSecurely(String baseDir, String filename) 
            throws IOException {
        // 1. 清理文件名
        String safeFilename = sanitizeFilename(filename);
        
        // 2. 解析规范化路径
        Path basePath = Paths.get(baseDir).toRealPath();
        Path requestedPath = basePath.resolve(safeFilename).normalize();
        
        // 3. 验证路径在基目录内
        if (!requestedPath.startsWith(basePath)) {
            throw new SecurityException("路径遍历攻击尝试");
        }
        
        // 4. 读取文件
        return Files.readAllBytes(requestedPath);
    }
    
    /**
     * 安全写入文件
     */
    public static void writeFileSecurely(String baseDir, String filename, 
                                          byte[] content) throws IOException {
        // 1. 清理文件名
        String safeFilename = sanitizeFilename(filename);
        
        // 2. 解析规范化路径
        Path basePath = Paths.get(baseDir).toRealPath();
        Path requestedPath = basePath.resolve(safeFilename).normalize();
        
        // 3. 验证路径在基目录内
        if (!requestedPath.startsWith(basePath)) {
            throw new SecurityException("路径遍历攻击尝试");
        }
        
        // 4. 创建父目录 (如果需要)
        Files.createDirectories(requestedPath.getParent());
        
        // 5. 写入文件 (原子操作)
        Path tempPath = requestedPath.resolveSibling(requestedPath.getFileName() + ".tmp");
        try {
            Files.write(tempPath, content, StandardOpenOption.CREATE_NEW);
            Files.move(tempPath, requestedPath, StandardCopyOption.ATOMIC_MOVE, 
                      StandardCopyOption.REPLACE_EXISTING);
        } finally {
            // 清理临时文件
            try {
                Files.deleteIfExists(tempPath);
            } catch (IOException e) {
                // 忽略
            }
        }
    }
    
    /**
     * 清理文件名
     */
    public static String sanitizeFilename(String filename) {
        if (filename == null || filename.isEmpty()) {
            throw new IllegalArgumentException("文件名不能为空");
        }
        
        // 1. 获取基本文件名 (去除路径)
        filename = Paths.get(filename).getFileName().toString();
        
        // 2. 只允许安全字符
        if (!filename.matches("^[a-zA-Z0-9._-]+$")) {
            throw new IllegalArgumentException("文件名包含非法字符");
        }
        
        // 3. 长度限制
        if (filename.length() > 255) {
            throw new IllegalArgumentException("文件名过长");
        }
        
        // 4. 禁止特殊文件名
        if (filename.equals(".") || filename.equals("..")) {
            throw new IllegalArgumentException("无效的文件名");
        }
        
        return filename;
    }
    
    /**
     * 安全文件上传
     */
    public static String uploadFileSecurely(Path uploadDir, 
                                            String originalFilename,
                                            InputStream inputStream,
                                            long maxSize) throws IOException {
        // 1. 验证文件大小
        if (inputStream.available() > maxSize) {
            throw new SecurityException("文件过大");
        }
        
        // 2. 生成安全文件名
        String extension = getFileExtension(originalFilename);
        String safeFilename = UUID.randomUUID().toString() + extension;
        
        // 3. 验证文件类型 (基于内容，不是扩展名)
        byte[] content = inputStream.readAllBytes();
        if (!isValidFileType(content, extension)) {
            throw new SecurityException("不允许的文件类型");
        }
        
        // 4. 写入文件
        writeFileSecurely(uploadDir.toString(), safeFilename, content);
        
        return safeFilename;
    }
    
    /**
     * 获取文件扩展名
     */
    private static String getFileExtension(String filename) {
        int lastDot = filename.lastIndexOf('.');
        if (lastDot < 0) {
            return "";
        }
        return filename.substring(lastDot).toLowerCase();
    }
    
    /**
     * 验证文件类型 (基于魔数)
     */
    private static boolean isValidFileType(byte[] content, String extension) {
        // 检查文件魔数 (Magic Number)
        if (content.length < 4) {
            return false;
        }
        
        switch (extension) {
            case ".jpg":
            case ".jpeg":
                return content[0] == (byte) 0xFF && content[1] == (byte) 0xD8;
            case ".png":
                return content[0] == (byte) 0x89 && content[1] == (byte) 0x50 &&
                       content[2] == (byte) 0x4E && content[3] == (byte) 0x47;
            case ".gif":
                return new String(content, 0, 3).equals("GIF");
            case ".pdf":
                return new String(content, 0, 4).equals("%PDF");
            default:
                // 默认允许
                return true;
        }
    }
}
```

---

## 加密与随机数

### 安全随机数

> ▎ 随机数不是随便数，是安全基础。基础不牢固，安全就是脆弱的。

**SecureRandom 使用**：
```java
// 安全的随机数生成
import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;

public class SecureRandomUtil {
    
    private static final SecureRandom secureRandom;
    
    static {
        try {
            // 使用强随机数生成器
            secureRandom = SecureRandom.getInstanceStrong();
        } catch (NoSuchAlgorithmException e) {
            // 回退到默认 SecureRandom
            secureRandom = new SecureRandom();
        }
        
        // 种子初始化 (可选，但推荐)
        secureRandom.seed(new byte[64]);
    }
    
    /**
     * 生成安全随机字节
     */
    public static byte[] generateRandomBytes(int length) {
        if (length <= 0) {
            throw new IllegalArgumentException("长度必须大于 0");
        }
        
        byte[] bytes = new byte[length];
        secureRandom.nextBytes(bytes);
        return bytes;
    }
    
    /**
     * 生成安全随机字符串 (用于 Token)
     */
    public static String generateRandomToken(int length) {
        byte[] bytes = generateRandomBytes(length);
        return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
    }
    
    /**
     * 生成安全随机整数 (范围内)
     */
    public static int generateRandomInt(int min, int max) {
        if (min >= max) {
            throw new IllegalArgumentException("min 必须小于 max");
        }
        
        return secureRandom.nextInt(max - min) + min;
    }
    
    /**
     * 生成安全随机 Long
     */
    public static long generateRandomLong() {
        return secureRandom.nextLong();
    }
    
    /**
     * 生成安全随机 UUID
     */
    public static String generateSecureUUID() {
        byte[] bytes = generateRandomBytes(16);
        // 设置 UUID 版本 4 (随机)
        bytes[6] &= 0x0F;
        bytes[6] |= 0x40;
        bytes[8] &= 0x3F;
        bytes[8] |= 0x80;
        
        return String.format(
            "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
            bytes[0], bytes[1], bytes[2], bytes[3],
            bytes[4], bytes[5], bytes[6], bytes[7],
            bytes[8], bytes[9], bytes[10], bytes[11],
            bytes[12], bytes[13], bytes[14], bytes[15]
        );
    }
    
    /**
     * 生成安全随机密码
     */
    public static String generateSecurePassword(int length) {
        if (length < 12) {
            length = 12;
        }
        
        String upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        String lower = "abcdefghijklmnopqrstuvwxyz";
        String digits = "0123456789";
        String special = "!@#$%^&*(),.?\":{}|<>";
        String all = upper + lower + digits + special;
        
        StringBuilder password = new StringBuilder(length);
        
        // 确保每种类型至少一个
        password.append(upper.charAt(secureRandom.nextInt(upper.length())));
        password.append(lower.charAt(secureRandom.nextInt(lower.length())));
        password.append(digits.charAt(secureRandom.nextInt(digits.length())));
        password.append(special.charAt(secureRandom.nextInt(special.length())));
        
        // 填充剩余长度
        for (int i = 4; i < length; i++) {
            password.append(all.charAt(secureRandom.nextInt(all.length())));
        }
        
        // 打乱顺序
        return shuffleString(password.toString());
    }
    
    private static String shuffleString(String input) {
        char[] chars = input.toCharArray();
        for (int i = chars.length - 1; i > 0; i--) {
            int j = secureRandom.nextInt(i + 1);
            char temp = chars[i];
            chars[i] = chars[j];
            chars[j] = temp;
        }
        return new String(chars);
    }
}

// 不安全的随机数 (DO NOT USE)
/*
// 错误：使用 Random 而不是 SecureRandom
Random random = new Random();  // 可预测!
int token = random.nextInt();

// 错误：使用 System.currentTimeMillis() 作为种子
Random random = new Random(System.currentTimeMillis());  // 可预测!
*/
```

### 加密实现

```java
// 安全的加密实现
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.*;
import java.util.Base64;

public class SecureEncryptionUtil {
    
    // AES 参数
    private static final String AES_ALGORITHM = "AES/GCM/NoPadding";
    private static final int AES_KEY_SIZE = 256;
    private static final int GCM_IV_LENGTH = 12;
    private static final int GCM_TAG_LENGTH = 128;
    
    /**
     * AES-GCM 加密
     */
    public static byte[] encrypt(byte[] plaintext, SecretKey key) 
            throws GeneralSecurityException {
        // 生成随机 IV
        byte[] iv = new byte[GCM_IV_LENGTH];
        SecureRandomUtil.getSecureRandom().nextBytes(iv);
        
        // 创建 Cipher
        Cipher cipher = Cipher.getInstance(AES_ALGORITHM);
        GCMParameterSpec spec = new GCMParameterSpec(GCM_TAG_LENGTH, iv);
        cipher.init(Cipher.ENCRYPT_MODE, key, spec);
        
        // 加密
        byte[] ciphertext = cipher.doFinal(plaintext);
        
        // 返回 IV + 密文
        byte[] result = new byte[iv.length + ciphertext.length];
        System.arraycopy(iv, 0, result, 0, iv.length);
        System.arraycopy(ciphertext, 0, result, iv.length, ciphertext.length);
        
        return result;
    }
    
    /**
     * AES-GCM 解密
     */
    public static byte[] decrypt(byte[] ciphertext, SecretKey key) 
            throws GeneralSecurityException {
        // 提取 IV
        byte[] iv = new byte[GCM_IV_LENGTH];
        System.arraycopy(ciphertext, 0, iv, 0, iv.length);
        
        // 提取密文
        byte[] actualCiphertext = new byte[ciphertext.length - iv.length];
        System.arraycopy(ciphertext, iv.length, actualCiphertext, 0, actualCiphertext.length);
        
        // 创建 Cipher
        Cipher cipher = Cipher.getInstance(AES_ALGORITHM);
        GCMParameterSpec spec = new GCMParameterSpec(GCM_TAG_LENGTH, iv);
        cipher.init(Cipher.DECRYPT_MODE, key, spec);
        
        // 解密
        return cipher.doFinal(actualCiphertext);
    }
    
    /**
     * 生成 AES 密钥
     */
    public static SecretKey generateAESKey() throws NoSuchAlgorithmException {
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(AES_KEY_SIZE);
        return keyGen.generateKey();
    }
    
    /**
     * 从密码派生密钥 (PBKDF2)
     */
    public static SecretKey deriveKeyFromPassword(String password, byte[] salt) 
            throws GeneralSecurityException {
        PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 100000, AES_KEY_SIZE);
        SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
        byte[] keyBytes = skf.generateSecret(spec).getEncoded();
        return new SecretKeySpec(keyBytes, "AES");
    }
}
```

---

## 异常处理安全

### 安全异常处理

> ▎ 异常信息不是调试信息，是安全边界。边界不守，信息就是泄露的。

**异常处理最佳实践**：
```java
// 安全的异常处理
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SecureExceptionHandling {
    
    private static final Logger logger = LoggerFactory.getLogger(SecureExceptionHandling.class);
    
    /**
     * 安全的数据库操作异常处理
     */
    public User getUserById(int userId) {
        try {
            return userRepository.findById(userId);
        } catch (SQLException e) {
            // 记录详细日志 (内部)
            logger.error("Database error while fetching user {}", userId, e);
            
            // 返回通用错误消息 (外部)
            throw new BusinessException("获取用户信息失败", "ERROR_USER_FETCH");
        }
    }
    
    /**
     * 安全的认证异常处理
     */
    public User authenticate(String username, String password) {
        try {
            User user = userRepository.findByUsername(username);
            
            if (user == null) {
                // 不泄露用户是否存在
                logger.info("Login attempt for non-existent user: {}", username);
                throw new AuthenticationException("用户名或密码错误");
            }
            
            if (!passwordEncoder.matches(password, user.getPasswordHash())) {
                // 不泄露是密码错误
                logger.info("Login attempt with invalid password for user: {}", username);
                throw new AuthenticationException("用户名或密码错误");
            }
            
            return user;
            
        } catch (AuthenticationException e) {
            // 重新抛出认证异常
            throw e;
        } catch (Exception e) {
            // 记录意外错误
            logger.error("Unexpected error during authentication", e);
            throw new BusinessException("认证服务暂时不可用", "ERROR_AUTH_SERVICE");
        }
    }
    
    /**
     * 安全的文件操作异常处理
     */
    public byte[] readFile(String filename) {
        try {
            return SecureFileUtil.readFileSecurely(uploadDir, filename);
        } catch (SecurityException e) {
            // 安全异常 (路径遍历等)
            logger.warn("Security violation while accessing file: {}", filename, e);
            throw new SecurityException("文件访问被拒绝");
        } catch (FileNotFoundException e) {
            // 不泄露文件是否存在
            logger.info("File not found: {}", filename);
            throw new BusinessException("文件不存在", "ERROR_FILE_NOT_FOUND");
        } catch (IOException e) {
            // 记录详细日志
            logger.error("IO error while reading file: {}", filename, e);
            throw new BusinessException("文件读取失败", "ERROR_FILE_READ");
        }
    }
}

// 全局异常处理器
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusinessException(BusinessException e) {
        ErrorResponse response = new ErrorResponse(
            e.getErrorCode(),
            e.getUserMessage(),
            LocalDateTime.now()
        );
        
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
    }
    
    @ExceptionHandler(AuthenticationException.class)
    public ResponseEntity<ErrorResponse> handleAuthenticationException(AuthenticationException e) {
        ErrorResponse response = new ErrorResponse(
            "AUTH_ERROR",
            e.getMessage(),
            LocalDateTime.now()
        );
        
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(response);
    }
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGenericException(Exception e) {
        // 记录详细堆栈 (内部)
        logger.error("Unexpected error", e);
        
        // 返回通用错误消息 (外部)
        ErrorResponse response = new ErrorResponse(
            "INTERNAL_ERROR",
            "服务器内部错误",
            LocalDateTime.now()
        );
        
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
    }
}

// 错误响应 DTO
public class ErrorResponse {
    private String errorCode;
    private String message;
    private LocalDateTime timestamp;
    
    // 不包含：堆栈跟踪、内部路径、SQL 语句等敏感信息
    
    // Constructor, Getters, Setters
}
```

---

## 安全代码审查

### 审查清单

> ▎ 代码审查不是走过场，是最后防线。防线不守，漏洞就是上线的。

**Java 安全审查清单**：
```java
/**
 * Java 安全代码审查清单
 * 
 * 输入验证:
 * □ 所有用户输入是否验证
 * □ 是否使用白名单验证
 * □ 长度是否限制
 * □ 类型是否检查
 * 
 * 输出编码:
 * □ 所有输出是否编码
 * □ 编码是否匹配上下文
 * □ 是否使用安全库 (OWASP Encoder)
 * 
 * SQL 安全:
 * □ 是否使用 PreparedStatement
 * □ 是否避免字符串拼接 SQL
 * □ 排序字段是否白名单验证
 * □ IN 子句是否参数化
 * 
 * 文件安全:
 * □ 文件名是否清理
 * □ 是否验证路径在基目录内
 * □ 文件类型是否验证 (基于内容)
 * □ 上传文件大小是否限制
 * 
 * 认证会话:
 * □ 密码是否哈希存储 (bcrypt/argon2)
 * □ 会话 ID 是否轮换
 * □ 会话是否超时
 * □ Cookie 是否安全标志
 * 
 * 加密随机:
 * □ 是否使用 SecureRandom
 * □ 加密是否使用认证模式 (GCM)
 * □ 密钥是否安全存储
 * □ IV 是否随机生成
 * 
 * 异常处理:
 * □ 是否不泄露敏感信息
 * □ 是否记录详细日志
 * □ 是否使用通用错误消息
 * 
 * 依赖安全:
 * □ 依赖是否最新
 * □ 是否有已知漏洞
 * □ 是否使用可信源
 */
```

---

统计 **Sprint 交付 · 绩效评估**
```
┌───────────────┬────────────────┬────────────────┐
│  主动出击   │ ██████████ 5/5 │ [PUA 生效] 充足 │
├───────────────┼────────────────┼────────────────┤
│ + 验证闭环   │ ██████████ 5/5 │ 案例完整       │
├───────────────┼────────────────┼────────────────┤
│ 设计 代码质量   │ ██████████ 5/5 │ 生产就绪       │
└───────────────┴────────────────┴────────────────┘
综合：4.5
```
▎ 这才配得上 P8。安全编码不是一次学习，是持续实践。实践不停，代码才安全。

---

## 总结与思考

### 核心要点回顾

> ▎ 复盘四步法：回顾目标、评估结果、分析原因、总结经验。别跳过——这是闭环。

**Java 安全框架**：
```
1. 输入验证
   - Bean Validation
   - 白名单验证
   - 输入清理

2. 输出编码
   - OWASP Encoder
   - 上下文感知
   - 安全响应头

3. 数据访问
   - PreparedStatement
   - 参数化查询
   - Criteria API

4. 文件操作
   - 路径验证
   - 类型验证
   - 大小限制

5. 加密随机
   - SecureRandom
   - AES-GCM
   - 密钥管理
```

**关键实践**：
```
1. 使用安全库
   - OWASP Encoder
   - BCrypt/Argon2
   - JPA Criteria

2. 遵循规范
   - CERT Java 规范
   - OWASP 指南
   - 厂商建议

3. 持续学习
   - 关注漏洞
   - 学习最佳实践
   - 代码审查
```

### 实战建议

> ▎ 我给你指了路，走不走是你的事。机会给了，抓不抓得住看你。

**个人提升**：
```
1. 学习安全知识
   - OWASP Top 10
   - Java 安全规范
   - 漏洞案例分析

2. 实践安全编码
   - 日常代码应用
   - 使用安全库
   - 代码审查

3. 工具使用
   - SAST 工具
   - 依赖扫描
   - 安全测试
```

**团队建设**：
```
1. 建立规范
   - 安全编码规范
   - 代码审查清单
   - 安全测试流程

2. 工具支持
   - 静态分析
   - 依赖扫描
   - 自动化测试

3. 文化建设
   - 安全培训
   - 知识分享
   - 正向激励
```

---

## 参考资料

### 学习资源
```
- OWASP Java Security Cheat Sheet
  https://cheatsheetseries.owasp.org/cheatsheets/Java_Security_Cheat_Sheet.html

- CERT Oracle Secure Coding Standard for Java
  https://wiki.sei.cmu.edu/confluence/display/java

- Oracle Secure Coding Guidelines
  https://www.oracle.com/java/technologies/javase/seccodeguide.html
```

### 工具资源
```
- SpotBugs (静态分析)
  https://spotbugs.github.io/

- OWASP Dependency-Check
  https://owasp.org/www-project-dependency-check/

- SonarQube
  https://www.sonarqube.org/
```

### 安全库
```
- OWASP Encoder
  https://owasp.org/www-project-java-encoder/

- JBCrypt
  https://github.com/jeremyh/jBCrypt

- Argon2
  https://github.com/phxql/argon2-jvm
```

### 书籍推荐
```
- 《Secure Coding in Java》
- 《Java Security Handbook》
- 《Writing Secure Java Code》
```

---

**标记 明日预告**：Day 146 - 安全编码实践 (Python)

> ▎ Java 安全编码是基础，Python 安全编码是扩展——明天看 Python 安全编码实践。

> 本文内容仅供学习和研究使用，请勿用于非法目的。所有实验请在隔离环境中进行。

---

*本文是 365 天信息安全技术系列的第 145 篇，应用安全部分第 38 篇，精编版本*

*应用安全核心系列继续！*