签名机制设计#

public class HmacSignatureService {
    
    private static final String ALGORITHM = "HmacSHA256";
    private static final Charset UTF_8 = StandardCharsets.UTF_8;
    
    private final SecretKey secretKey;
    
    public HmacSignatureService(String secret) {
        byte[] keyBytes = Base64.getDecoder().decode(secret);
        this.secretKey = new SecretKeySpec(keyBytes, ALGORITHM);
    }
    
    public String sign(String content) {
        try {
            Mac mac = Mac.getInstance(ALGORITHM);
            mac.init(secretKey);
            byte[] signatureBytes = mac.doFinal(content.getBytes(UTF_8));
            return Base64.getEncoder().encodeToString(signatureBytes);
        } catch (NoSuchAlgorithmException | InvalidKeyException e) {
            throw new SignatureException("Failed to generate signature", e);
        }
    }
    
    public boolean verify(String content, String signature) {
        String expectedSignature = sign(content);
        // 使用恒定时间比较
        return MessageDigest.isEqual(
            expectedSignature.getBytes(UTF_8),
            signature.getBytes(UTF_8)
        );
    }
}

public class SignatureContentBuilder {
    
    public String build(RequestContext context) {
        List<String> parts = new ArrayList<>();
        
        // 1. HTTP Method
        parts.add(context.getMethod());
        
        // 2. Request Path（不含查询参数）
        parts.add(context.getPath());
        
        // 3. 时间戳
        parts.add(String.valueOf(context.getTimestamp()));
        
        // 4. Nonce
        parts.add(context.getNonce());
        
        // 5. 请求体哈希（如果有）
        if (context.getBody() != null && !context.getBody().isEmpty()) {
            parts.add(hashBody(context.getBody()));
        }
        
        // 按约定顺序用换行符连接
        return String.join("\n", parts);
    }
    
    private String hashBody(String body) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest(body.getBytes(UTF_8));
            return Base64.getEncoder().encodeToString(hash);
        } catch (NoSuchAlgorithmException e) {
            throw new SignatureException("SHA-256 not available", e);
        }
    }
}

public class SignatureValidationFilter {
    
    private final HmacSignatureService signatureService;
    private final TimestampValidator timestampValidator;
    private final NonceValidator nonceValidator;
    
    public ValidationResult validate(HttpRequest request, String signature) {
        // 1. 提取签名要素
        String method = request.getMethod();
        String path = request.getPath();
        long timestamp = Long.parseLong(request.getHeader("X-Timestamp"));
        String nonce = request.getHeader("X-Nonce");
        String body = request.getBody();
        
        // 2. 验证时间戳
        ValidationResult timestampResult = timestampValidator.validate(timestamp);
        if (!timestampResult.isAccepted()) {
            return timestampResult;
        }
        
        // 3. 验证 Nonce
        String nonceKey = buildNonceKey(request);
        ValidationResult nonceResult = nonceValidator.validate(nonceKey, nonce);
        if (!nonceResult.isAccepted()) {
            return nonceResult;
        }
        
        // 4. 构造签名内容
        String content = SignatureContentBuilder.builder()
            .method(method)
            .path(path)
            .timestamp(timestamp)
            .nonce(nonce)
            .body(body)
            .build();
        
        // 5. 验证签名
        if (!signatureService.verify(content, signature)) {
            nonceValidator.rollback(nonceKey, nonce); // 回滚 Nonce
            return ValidationResult.rejected("Signature mismatch");
        }
        
        return ValidationResult.accepted();
    }
    
    private String buildNonceKey(HttpRequest request) {
        return String.format("%s:%s:%s",
            request.getHeader("X-Client-Id"),
            request.getPath(),
            nonce);
    }
}

public class RsaSignatureService {
    
    private static final String ALGORITHM = "SHA256withRSA";
    private static final Charset UTF_8 = StandardCharsets.UTF_8;
    
    private final PrivateKey privateKey;
    private final PublicKey publicKey;
    
    public RsaSignatureService(String privateKeyPem, String publicKeyPem) {
        this.privateKey = parsePrivateKey(privateKeyPem);
        this.publicKey = parsePublicKey(publicKeyPem);
    }
    
    public String sign(String content) {
        try {
            Signature signature = Signature.getInstance(ALGORITHM);
            signature.initSign(privateKey);
            signature.update(content.getBytes(UTF_8));
            byte[] signatureBytes = signature.sign();
            return Base64.getEncoder().encodeToString(signatureBytes);
        } catch (Exception e) {
            throw new SignatureException("Failed to sign", e);
        }
    }
    
    public boolean verify(String content, String signatureBase64) {
        try {
            Signature signature = Signature.getInstance(ALGORITHM);
            signature.initVerify(publicKey);
            signature.update(content.getBytes(UTF_8));
            byte[] signatureBytes = Base64.getDecoder().decode(signatureBase64);
            return signature.verify(signatureBytes);
        } catch (Exception e) {
            throw new SignatureException("Failed to verify signature", e);
        }
    }
    
    private PrivateKey parsePrivateKey(String pem) throws Exception {
        String base64 = pem
            .replace("-----BEGIN PRIVATE KEY-----", "")
            .replace("-----END PRIVATE KEY-----", "")
            .replaceAll("\\s", "");
        
        byte[] keyBytes = Base64.getDecoder().decode(base64);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return keyFactory.generatePrivate(keySpec);
    }
    
    private PublicKey parsePublicKey(String pem) throws Exception {
        String base64 = pem
            .replace("-----BEGIN PUBLIC KEY-----", "")
            .replace("-----END PUBLIC KEY-----", "")
            .replaceAll("\\s", "");
        
        byte[] keyBytes = Base64.getDecoder().decode(base64);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return keyFactory.generatePublic(keySpec);
    }
}

public class SecureKeyStorage {
    
    private final String encryptionKeyRef;
    
    // 加密存储签名密钥
    public void storeSigningKey(String clientId, String encryptedKey, 
                               Map<String, String> metadata) {
        // 使用信封加密
        String encryptionKey = getOrCreateEncryptionKey();
        
        // 生成数据加密密钥（DEK）
        String dek = generateDataEncryptionKey();
        
        // 用 DEK 加密签名密钥
        String encryptedSigningKey = aesEncrypt(signingKey, dek);
        
        // 用主密钥（encryptionKey）加密 DEK
        String encryptedDek = aesEncrypt(dek, encryptionKey);
        
        // 存储加密的 DEK 和签名密钥
        store(clientId, encryptedSigningKey, encryptedDek, metadata);
    }
    
    // 解密获取签名密钥
    public SecretKey retrieveSigningKey(String clientId) {
        EncryptedData data = load(clientId);
        
        String encryptionKey = getOrCreateEncryptionKey();
        
        // 解密 DEK
        String dek = aesDecrypt(data.encryptedDek, encryptionKey);
        
        // 用 DEK 解密签名密钥
        String signingKey = aesDecrypt(data.encryptedSigningKey, dek);
        
        return new SecretKeySpec(signingKey.getBytes(), "HmacSHA256");
    }
    
    private String getOrCreateEncryptionKey() {
        // 从 KMS 或 HSM 获取主密钥
        return kmsClient.getKey(encryptionKeyRef);
    }
}

public class KeyRotationService {
    
    private final KeyStorage keyStorage;
    private final Duration gracePeriod;
    
    // 创建新密钥版本
    public KeyVersion createNewVersion(String clientId) {
        String newKey = generateKey();
        int newVersion = keyStorage.getLatestVersion(clientId) + 1;
        
        keyStorage.store(clientId, newKey, newVersion, "pending");
        
        return new KeyVersion(newKey, newVersion);
    }
    
    // 激活新密钥
    public void activateVersion(String clientId, int version) {
        keyStorage.setActiveVersion(clientId, version);
        
        // 发送通知给客户端
        notifyClient(clientId, "New signing key version available", version);
    }
    
    // 验证时支持多版本
    public boolean verifyWithAnyVersion(String content, String signature, 
                                       String clientId) {
        List<Integer> versions = keyStorage.getValidVersions(clientId);
        
        for (int version : versions) {
            try {
                SecretKey key = keyStorage.getKey(clientId, version);
                if (verify(content, signature, key)) {
                    return true;
                }
            } catch (Exception ignored) {
                // 当前版本验证失败，尝试其他版本
            }
        }
        return false;
    }
    
    // 撤销旧密钥
    public void revokeVersion(String clientId, int version) {
        keyStorage.setRevoked(clientId, version);
    }
}

public class KmsKeyService {
    
    private final AWSKMS kmsClient;
    private final String keyId;
    
    public String sign(String content, String keyId) {
        SignRequest request = SignRequest.builder()
            .message(SdkBytes.fromUtf8String(content))
            .messageType(MessageType.RAW)
            .signingAlgorithm(SigningAlgorithmSpec.RSASSA_PKCS1_V1_5_SHA_256)
            .keyId(keyId)
            .build();
        
        SignResult result = kmsClient.sign(request);
        return Base64.getEncoder().encodeToString(result.signature().asByteArray());
    }
    
    public boolean verify(String content, String signature, String keyId) {
        VerifyRequest request = VerifyRequest.builder()
            .message(SdkBytes.fromUtf8String(content))
            .signature(SdkBytes.fromUtf8String(Base64.getDecoder().decode(signature)))
            .messageType(MessageType.RAW)
            .signingAlgorithm(SigningAlgorithmSpec.RSASSA_PKCS1_V1_5_SHA_256)
            .keyId(keyId)
            .build();
        
        return kmsClient.verify(request).signatureValid();
    }
}