Java 示例代码
覆盖「数据安全」两类密钥的核心场景:
- 数据对称加密密钥(AES-256-GCM):userSignature 生成、sessionKey 解密
- 数据签名公私钥(RSASSA-PSS):业务数据签名验签(如
gameSignature)
通用说明
- AES 部分示例分为两层:
- AES-256-GCM 工具类(AES256GCMUtil):通用对称加解密实现,与 SUD SDK 内部加解密机制完全一致,可直接复用到任意 AES-256-GCM 场景;
- 业务封装:基于工具类完成 Payload 构造、字段校验,分别覆盖 userSignature 生成与 sessionKey 解密。
- AES 字节布局统一为:
iv(12) || ciphertext+tag,再整体 Base64 编码(其中tag由 GCM 自动追加在密文末尾,长度 16 字节)。 - RSA 部分(§3 业务数据签名验签)提供独立的
RSAUtil工具类,PSS 参数与 SUD OpenPaaS 服务端签名机制完全一致。 - 示例仅包含核心逻辑,生产环境需补充日志、异常兜底、监控告警等工程化处理。
环境依赖
JDK 8+。
AES 部分基于 JDK 内置加密库,无需额外依赖。
RSA 部分(§3)依赖 BouncyCastle 解析 PEM 格式公私钥:
xml<dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcprov-jdk15on</artifactId> <version>1.70</version> </dependency> <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcpkix-jdk15on</artifactId> <version>1.70</version> </dependency>为避免引入第三方 JSON 库,AES 业务封装示例使用
String.format拼装与正则解析;生产环境推荐替换为 Jackson、Gson 等成熟 JSON 库。
通用 AES-256-GCM 工具
java
import javax.crypto.Cipher;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.SecureRandom;
import java.util.Base64;
public class AES256GCMUtil {
private static final String ALGORITHM = "AES";
private static final String TRANSFORMATION = "AES/GCM/NoPadding";
private static final int IV_LENGTH = 12;
private static final int TAG_SIZE = 128;
public static String encrypt(String plaintext, String keyBase64) throws Exception {
byte[] key = Base64.getDecoder().decode(keyBase64);
byte[] iv = generateIV();
byte[] plainBytes = plaintext.getBytes(StandardCharsets.UTF_8);
Cipher cipher = Cipher.getInstance(TRANSFORMATION);
SecretKeySpec keySpec = new SecretKeySpec(key, ALGORITHM);
GCMParameterSpec gcmSpec = new GCMParameterSpec(TAG_SIZE, iv);
cipher.init(Cipher.ENCRYPT_MODE, keySpec, gcmSpec);
byte[] cipherBytes = cipher.doFinal(plainBytes);
byte[] result = new byte[IV_LENGTH + cipherBytes.length];
System.arraycopy(iv, 0, result, 0, iv.length);
System.arraycopy(cipherBytes, 0, result, iv.length, cipherBytes.length);
return Base64.getEncoder().encodeToString(result);
}
public static byte[] decrypt(String encryptedBase64, String keyBase64) throws Exception {
byte[] key = Base64.getDecoder().decode(keyBase64);
byte[] encryptedBytes = Base64.getDecoder().decode(encryptedBase64);
byte[] iv = new byte[IV_LENGTH];
System.arraycopy(encryptedBytes, 0, iv, 0, IV_LENGTH);
byte[] cipherBytes = new byte[encryptedBytes.length - IV_LENGTH];
System.arraycopy(encryptedBytes, IV_LENGTH, cipherBytes, 0, cipherBytes.length);
Cipher cipher = Cipher.getInstance(TRANSFORMATION);
SecretKeySpec keySpec = new SecretKeySpec(key, ALGORITHM);
GCMParameterSpec gcmSpec = new GCMParameterSpec(TAG_SIZE, iv);
cipher.init(Cipher.DECRYPT_MODE, keySpec, gcmSpec);
return cipher.doFinal(cipherBytes);
}
private static byte[] generateIV() {
byte[] iv = new byte[IV_LENGTH];
new SecureRandom().nextBytes(iv);
return iv;
}
}1. userSignature 生成
基于 AES256GCMUtil 构造鉴权 Payload 并加密:
java
import java.time.Instant;
public class UserSignatureGenerator {
private static final String SIGNATURE_VERSION = "1";
public static String generate(String userId, long expiresAt, String base64Key) throws Exception {
if (userId == null || userId.isEmpty()) {
throw new IllegalArgumentException("user_id 不能为空");
}
if (expiresAt <= Instant.now().getEpochSecond()) {
throw new IllegalArgumentException("expires_at 必须为大于当前时间的 Unix 时间戳(秒)");
}
String payload = String.format(
"{\"version\":\"%s\",\"user_id\":\"%s\",\"expires_at\":%d}",
SIGNATURE_VERSION, escapeJsonString(userId), expiresAt
);
return AES256GCMUtil.encrypt(payload, base64Key);
}
private static String escapeJsonString(String s) {
return s.replace("\\", "\\\\").replace("\"", "\\\"");
}
public static void main(String[] args) throws Exception {
String base64Key = "你的Base64编码的32字节AES密钥";
String userId = "user_123456";
long expiresAt = Instant.now().getEpochSecond() + 24 * 3600;
String userSignature = generate(userId, expiresAt, base64Key);
System.out.println("userSignature: " + userSignature);
}
}2. sessionKey 解密
基于 AES256GCMUtil 解密并校验载荷字段:
java
import java.nio.charset.StandardCharsets;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class SessionKeyDecryptor {
public static class SessionPayload {
public final String userId;
public final String sessionKey;
public SessionPayload(String userId, String sessionKey) {
this.userId = userId;
this.sessionKey = sessionKey;
}
}
public static SessionPayload decrypt(String encryptedSessionKey, String base64Key, String expectedUserId) throws Exception {
byte[] plaintextBytes = AES256GCMUtil.decrypt(encryptedSessionKey, base64Key);
String payload = new String(plaintextBytes, StandardCharsets.UTF_8);
String userId = extractStringField(payload, "user_id");
String sessionKey = extractStringField(payload, "session_key");
if (userId == null || sessionKey == null) {
throw new IllegalStateException("载荷缺少必要字段 user_id / session_key");
}
if (expectedUserId != null && !expectedUserId.equals(userId)) {
throw new IllegalStateException("user_id 不一致: 期望 " + expectedUserId + ", 实际 " + userId);
}
return new SessionPayload(userId, sessionKey);
}
private static String extractStringField(String json, String field) {
Pattern p = Pattern.compile("\"" + Pattern.quote(field) + "\"\\s*:\\s*\"((?:\\\\.|[^\"\\\\])*)\"");
Matcher m = p.matcher(json);
if (!m.find()) return null;
return m.group(1).replace("\\\"", "\"").replace("\\\\", "\\");
}
public static void main(String[] args) throws Exception {
String encryptedSessionKey = "Base64编码的encrypted_session_key";
String base64Key = "你的Base64编码的32字节AES密钥";
String expectedUserId = "user_123456";
SessionPayload payload = decrypt(encryptedSessionKey, base64Key, expectedUserId);
System.out.println("user_id: " + payload.userId + ", session_key: " + payload.sessionKey);
}
}3. 业务数据签名验签
基于「数据签名公私钥」对 SUD OpenPaaS 下发的业务数据载荷(如 gameSignature)进行 RSASSA-PSS 验签,PSS 参数为 SHA-256 / MGF1-SHA-256 / salt=32 / trailer=1,签名值以 Base64 编码。
3.1 通用 RSA 签名/验签工具
java
import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.openssl.PEMKeyPair;
import org.bouncycastle.openssl.PEMParser;
import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;
import java.io.StringReader;
import java.nio.charset.StandardCharsets;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Security;
import java.security.Signature;
import java.security.spec.MGF1ParameterSpec;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.PSSParameterSpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
public class RSAUtil {
private static final String ALGORITHM = "RSA";
private static final String SIGNATURE_ALGORITHM = "RSASSA-PSS";
private static final PSSParameterSpec PSS_SPEC =
new PSSParameterSpec("SHA-256", "MGF1", MGF1ParameterSpec.SHA256, 32, 1);
static {
if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
Security.addProvider(new BouncyCastleProvider());
}
}
/** 使用应用私钥对内容签名,返回 Base64 字符串。 */
public static String sign(String content, String privateKeyPem) throws Exception {
PrivateKey privateKey = readPrivateKey(privateKeyPem);
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
signature.setParameter(PSS_SPEC);
signature.initSign(privateKey);
signature.update(content.getBytes(StandardCharsets.UTF_8));
return Base64.getEncoder().encodeToString(signature.sign());
}
/** 使用 SUD OpenPaaS 下发的公钥验证签名。 */
public static boolean verify(String content, String signValueBase64, String publicKeyPem) throws Exception {
PublicKey publicKey = readPublicKey(publicKeyPem);
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
signature.setParameter(PSS_SPEC);
signature.initVerify(publicKey);
signature.update(content.getBytes(StandardCharsets.UTF_8));
return signature.verify(Base64.getDecoder().decode(signValueBase64));
}
private static PrivateKey readPrivateKey(String key) throws Exception {
try (PEMParser pemParser = new PEMParser(new StringReader(key))) {
Object object = pemParser.readObject();
JcaPEMKeyConverter converter = new JcaPEMKeyConverter()
.setProvider(BouncyCastleProvider.PROVIDER_NAME);
if (object instanceof PEMKeyPair) {
return converter.getKeyPair((PEMKeyPair) object).getPrivate();
}
if (object instanceof PrivateKeyInfo) {
return converter.getPrivateKey((PrivateKeyInfo) object);
}
} catch (Exception ignore) {
// 回退到原始 Base64 PKCS#8
}
byte[] decoded = Base64.getDecoder().decode(key.replaceAll("\\s", ""));
return KeyFactory.getInstance(ALGORITHM).generatePrivate(new PKCS8EncodedKeySpec(decoded));
}
private static PublicKey readPublicKey(String key) throws Exception {
try (PEMParser pemParser = new PEMParser(new StringReader(key))) {
Object object = pemParser.readObject();
JcaPEMKeyConverter converter = new JcaPEMKeyConverter()
.setProvider(BouncyCastleProvider.PROVIDER_NAME);
if (object instanceof SubjectPublicKeyInfo) {
return converter.getPublicKey((SubjectPublicKeyInfo) object);
}
} catch (Exception ignore) {
// 回退到原始 Base64 X.509
}
byte[] decoded = Base64.getDecoder().decode(key.replaceAll("\\s", ""));
return KeyFactory.getInstance(ALGORITHM).generatePublic(new X509EncodedKeySpec(decoded));
}
}3.2 调用示例
java
// publicKeyPem:从 SUD OpenPaaS 管理后台获取的应用公钥(PEM 字符串)
// content: 按对应业务文档(如 gameSignature)拼接的"待验签内容"
// signature: 业务数据载荷中携带的签名值(Base64)
boolean ok = RSAUtil.verify(content, signature, publicKeyPem);
if (!ok) {
throw new IllegalArgumentException("数据验签失败,请勿信任该业务数据内容");
}