Skip to content

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("数据验签失败,请勿信任该业务数据内容");
}