以加密的方式接入模型推理功能

private static SecretKey generateAesSecretKey() throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        SecureRandom secureRandom = new SecureRandom();
        keyGen.init(256, secureRandom);
        return keyGen.generateKey();
}

def generate_aes_secret_key():
    """生成256位AES密钥"""
    return os.urandom(32)  # 32字节 = 256位

private static final int GCM_IV_LENGTH = 12; // 12 字节 IV
private static byte[] generateIv() {
    byte[] iv = new byte[GCM_IV_LENGTH];
    SecureRandom secureRandom = new SecureRandom(); // 随机生成确保唯一性
    secureRandom.nextBytes(iv);
    return iv;
}

# 常量定义
GCM_IV_LENGTH = 12       # 12字节IV
def generate_iv():
    """生成12字节随机IV"""
    return os.urandom(GCM_IV_LENGTH)

curl --location "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-g..." \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header "Content-Type: application/json" \
--data '{
    "model": "qwen-plus",
    "input":{
        "messages":[
            {
                "role": "system",
                "content": "You are a helpful assistant."
            },
            {
                "role": "user",
                "content": "你是谁? "
            }
        ]
    },
    "parameters": {
        "result_format": "message"
    }
}'

private static final int GCM_TAG_LENGTH = 128; // 128 位 Tag(16 字节)
private static String encryptInputWithAes(SecretKey aesSecretKey,byte[] iv, String input) throws Exception {
        byte[] content = input.getBytes(StandardCharsets.UTF_8);
        Cipher aesCipher = Cipher.getInstance("AES/GCM/NoPadding");
        GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(GCM_TAG_LENGTH, iv);
        aesCipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(aesSecretKey.getEncoded(), "AES"), gcmParameterSpec);
        byte[] encryptedBytes = aesCipher.doFinal(content);
        return Base64.encodeBase64String(encryptedBytes);
}

def encrypt_input_with_aes(aes_key, iv, plaintext):
    """使用AES-GCM加密数据"""
    # 创建AES-GCM加密器
    aesgcm = Cipher(
        algorithms.AES(aes_key),
        modes.GCM(iv, tag=None),
        backend=default_backend()
    ).encryptor()
    # 关联数据设为空（根据需求可调整）
    aesgcm.authenticate_additional_data(b'')
    # 加密数据
    ciphertext = aesgcm.update(plaintext.encode('utf-8')) + aesgcm.finalize()
    # 获取认证标签
    tag = aesgcm.tag
    # 组合密文和标签
    encrypted_data = ciphertext + tag
    # 返回Base64编码结果
    return base64.b64encode(encrypted_data).decode('utf-8')

private static String encryptAesKeyWithRsaPublicKey(SecretKey aesSecretKey, String publicKey) throws Exception {
        byte[] aesKeyBytes = aesSecretKey.getEncoded();
        String base64AesKey = Base64.encodeBase64String(aesKeyBytes);
        byte[] publicKeyBytes = Base64.decodeBase64(publicKey);
        X509EncodedKeySpec spec = new X509EncodedKeySpec(publicKeyBytes);
        KeyFactory kf = KeyFactory.getInstance("RSA");
        PublicKey pubKey = kf.generatePublic(spec);
        Cipher rsaCipher = Cipher.getInstance("RSA");
        rsaCipher.init(Cipher.ENCRYPT_MODE, pubKey);
        byte[] encryptedBytes = rsaCipher.doFinal(base64AesKey.getBytes());
        return Base64.encodeBase64String(encryptedBytes);
}

def encrypt_aes_key_with_rsa(aes_key, public_key_str):
    """使用RSA公钥加密AES密钥"""
    # 解码Base64格式的公钥
    public_key_bytes = base64.b64decode(public_key_str)
    # 加载公钥
    public_key = serialization.load_der_public_key(
        public_key_bytes,
        backend=default_backend()
    )
    # 先对AES密钥进行Base64编码
    base64_aes_key = base64.b64encode(aes_key).decode('utf-8')
    # 使用RSA加密
    encrypted_bytes = public_key.encrypt(
        base64_aes_key.encode('utf-8'),
        padding.PKCS1v15()
    )
    # 返回Base64编码的加密结果
    return base64.b64encode(encrypted_bytes).decode('utf-8')

curl --location "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header "Content-Type: application/json" \
--header "X-DashScope-EncryptionKey: {\"public_key_id\": \"17xxx0\", \"encrypt_key\": \"F3WT...sR9UGIw==\", \"iv\": \"oxxxlouK/\"}" \
--data '{
    "model": "qwen-plus",
    "input":"+J2aT8GNBUD9rFBsBL0dRP60fZpmDuUAAoHQPXoGUL7/xskvxY9BMyJWm2rtNK2siPHkW12p9wgQEaEZcdM5xp3zCKlUvzCw",
    "parameters": {
        "result_format": "message"
    }
}'

private static String decryptResponseWithAes(SecretKey aesSecretKey, byte[] iv, String response) throws Exception {
        JSONObject responseJson = JSONObject.parseObject(response, JSONObject.class);
        String encryptedOutput = responseJson.getString("output");
        Cipher aesCipher = Cipher.getInstance("AES/GCM/NoPadding");
        GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(GCM_TAG_LENGTH, iv);
        aesCipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(aesSecretKey.getEncoded(), "AES"), gcmParameterSpec);
        byte[] decryptedBytes = aesCipher.doFinal(Base64.decodeBase64(encryptedOutput));
        return new String(decryptedBytes);
}

def decrypt_response_with_aes(aes_key, iv, response_data):
    """使用AES-GCM解密响应"""
    # 提取加密的输出
    encrypted_output = response_data.get("output")
    if not encrypted_output:
        raise ValueError("Response missing 'output' field")
    # 解码Base64数据
    encrypted_data = base64.b64decode(encrypted_output)
    # 分离密文和标签（标签长度16字节）
    ciphertext = encrypted_data[:-16]
    tag = encrypted_data[-16:]
    # 创建AES-GCM解密器
    aesgcm = Cipher(
        algorithms.AES(aes_key),
        modes.GCM(iv, tag),
        backend=default_backend()
    ).decryptor()
    # 验证关联数据（与加密时一致）
    aesgcm.authenticate_additional_data(b'')
    # 解密数据
    decrypted_bytes = aesgcm.update(ciphertext) + aesgcm.finalize()
    return decrypted_bytes.decode('utf-8')

{
    "choices": [
        {
            "finish_reason": "stop",
            "message": {
                "role": "assistant",
                "content": "我是Qwen，由阿里云开发的超大规模语言模型。我的目标是帮助用户更高效地获取信息、解决各种问题并激发创造力。无论是回答问题、提供信息还是进行创意性的讨论，我都会尽力提供支持。有什么我可以帮到你的吗？"
            }
        }
    ]
}