import javax.crypto.Cipher;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.KeyFactory;
import java.security.PublicKey;
import java.security.spec.X509EncodedKeySpec;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;

/**
 * RSA PKCS#1 v1.5 加密验证载荷 - Java 完整示例
 * 环境要求: Java 8+
 */
public class RSAEncryptor {
    
    // 2048位密钥 = 256字节，PKCS#1 v1.5 开销 = 11字节，最大明文 = 245字节
    private static final int MAX_ENCRYPT_BLOCK = 245;
    
    /**
     * RSA PKCS#1 v1.5 加密验证载荷
     * 
     * @param jsonPayload JSON 格式的验证载荷字符串
     * @param publicKeyPem PEM 格式公钥字符串
     * @return Base64 编码的加密数据（分段时用 | 分隔）
     * @throws Exception 加密失败时抛出异常
     */
    public static String encryptPayload(String jsonPayload, String publicKeyPem) throws Exception {
        // 步骤 1: 解析 PEM 格式公钥
        // 移除 PEM 头尾标记和换行符
        String publicKeyContent = publicKeyPem
            .replace("-----BEGIN PUBLIC KEY-----", "")
            .replace("-----END PUBLIC KEY-----", "")
            .replaceAll("\\s", "");  // 移除所有空白字符
        
        // 步骤 2: Base64 解码得到公钥字节
        byte[] keyBytes = Base64.getDecoder().decode(publicKeyContent);
        
        // 步骤 3: 构建公钥对象
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        
        // 步骤 4: 初始化加密器
        // 关键：使用 PKCS1Padding 指定 PKCS#1 v1.5 填充和 SHA-256 哈希
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        
        // 步骤 5: 将 JSON 字符串转为 UTF-8 字节数组
        byte[] data = jsonPayload.getBytes(StandardCharsets.UTF_8);
        
        // 步骤 6: 检查是否需要分段加密
        if (data.length <= MAX_ENCRYPT_BLOCK) {
            // 情况 A: 数据长度 ≤ 245 字节，单次加密
            byte[] encrypted = cipher.doFinal(data);
            return Base64.getEncoder().encodeToString(encrypted);
        }
        
        // 情况 B: 数据长度 > 245 字节，需要分段加密
        List<String> encryptedChunks = new ArrayList<>();
        int offset = 0;
        int chunkIndex = 0;
        
        // 步骤 6.1: 按 245 字节切分并逐段加密
        while (offset < data.length) {
            // 计算当前段长度（最后一段可能不足 245 字节）
            int length = Math.min(MAX_ENCRYPT_BLOCK, data.length - offset);
            
            // 复制当前段数据
            byte[] chunk = new byte[length];
            System.arraycopy(data, offset, chunk, 0, length);
            
            // 加密当前段
            byte[] encrypted = cipher.doFinal(chunk);
            
            // 步骤 6.2: Base64 编码并添加到列表
            encryptedChunks.add(Base64.getEncoder().encodeToString(encrypted));
            
            offset += length;
            chunkIndex++;
        }
        
        // 步骤 7: 用管道符连接所有加密段
        return String.join("|", encryptedChunks);
    }
    
    /**
     * 从文件读取公钥
     */
    public static String loadPublicKey(String filePath) throws IOException {
        return new String(Files.readAllBytes(Paths.get(filePath)), StandardCharsets.UTF_8);
    }
    
    // ==================== 完整使用示例 ====================
    
    public static void main(String[] args) {
        try {
            // 1. 读取公钥文件
            String publicKeyPath = "./publickey.pem";
            String publicKey = loadPublicKey(publicKeyPath);
            
            // 2. 构建验证载荷 JSON
            // 注意：实际项目中建议使用 Jackson 或 Gson 库
            long timestamp = System.currentTimeMillis() / 1000;
            String jsonPayload = String.format(
                "{\"license_key\":\"XXXX-XXXX-XXXX-XXXX\"," +
                "\"verify_type\":\"domain\"," +
                "\"verify_value\":\"example.com\"," +
                "\"timestamp\":%d," +
                "\"upload_params\":{\"client_version\":\"1.0.0\",\"os_type\":\"linux\"}}",
                timestamp
            );
            
            // 3. 加密载荷
            String encryptedPayload = encryptPayload(jsonPayload, publicKey);
            System.out.println("加密成功！");
            System.out.println("加密结果长度: " + encryptedPayload.length() + " 字符");
            System.out.println("是否分段: " + (encryptedPayload.contains("|") ? "是" : "否"));
            
            // 4. 发送验证请求（使用 HttpURLConnection 示例）
            String appId = "YOUR_APP_ID";  // 替换为您的应用 ID
            String apiUrl = "https://software.xingqingchuang.com/api/v1/license/verify-encrypted";
            
            // 构建请求体
            String requestBody = String.format(
                "{\"app_id\":\"%s\",\"encrypted_payload\":\"%s\"}",
                appId, encryptedPayload
            );
            
            // 发送 POST 请求
            java.net.URL url = new java.net.URL(apiUrl);
            java.net.HttpURLConnection conn = (java.net.HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setDoOutput(true);
            conn.setConnectTimeout(30000);
            conn.setReadTimeout(30000);
            
            try (java.io.OutputStream os = conn.getOutputStream()) {
                os.write(requestBody.getBytes(StandardCharsets.UTF_8));
            }
            
            // 5. 读取响应
            int responseCode = conn.getResponseCode();
            java.io.InputStream is = responseCode == 200 ? conn.getInputStream() : conn.getErrorStream();
            String response = new String(is.readAllBytes(), StandardCharsets.UTF_8);
            
            System.out.println("响应: " + response);
            
        } catch (Exception e) {
            System.err.println("错误: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

package main

import (
    "bytes"
    "crypto/rand"
    "crypto/rsa"
    "crypto/sha256"
    "crypto/x509"
    "encoding/base64"
    "encoding/json"
    "encoding/pem"
    "fmt"
    "io"
    "net/http"
    "os"
    "strings"
    "time"
)

// 2048位密钥 = 256字节，PKCS#1 v1.5 开销 = 11字节，最大明文 = 245字节
const maxEncryptBlock = 245

// VerifyPayload 验证载荷结构
type VerifyPayload struct {
    LicenseKey   string                 `json:"license_key"`            // 必填：授权码
    VerifyType   string                 `json:"verify_type,omitempty"`  // 可选：验证类型
    VerifyValue  string                 `json:"verify_value,omitempty"` // 可选：验证值
    Timestamp    int64                  `json:"timestamp,omitempty"`    // 可选：时间戳
    UploadParams map[string]interface{} `json:"upload_params,omitempty"`// 可选：自定义参数
}

// EncryptPayload RSA PKCS#1 v1.5 加密验证载荷
//
// 参数:
//   - payload: 验证载荷结构体
//   - publicKeyPem: PEM 格式公钥字符串
//
// 返回:
//   - string: Base64 编码的加密数据（分段时用 | 分隔）
//   - error: 加密失败时返回错误
func EncryptPayload(payload VerifyPayload, publicKeyPem string) (string, error) {
    // 步骤 1: 将载荷序列化为 JSON 字节切片
    jsonData, err := json.Marshal(payload)
    if err != nil {
        return "", fmt.Errorf("JSON 序列化失败: %w", err)
    }

    // 步骤 2: 解析 PEM 格式公钥
    // pem.Decode 返回 PEM 块和剩余数据
    block, _ := pem.Decode([]byte(publicKeyPem))
    if block == nil {
        return "", fmt.Errorf("PEM 解析失败: 无效的 PEM 格式")
    }

    // 步骤 3: 解析 PKIX 格式公钥（X.509 SubjectPublicKeyInfo）
    pub, err := x509.ParsePKIXPublicKey(block.Bytes)
    if err != nil {
        return "", fmt.Errorf("公钥解析失败: %w", err)
    }

    // 步骤 4: 类型断言为 RSA 公钥
    publicKey, ok := pub.(*rsa.PublicKey)
    if !ok {
        return "", fmt.Errorf("公钥类型错误: 期望 RSA 公钥")
    }

    // 步骤 5: 检查是否需要分段加密
    dataLen := len(jsonData)

    if dataLen <= maxEncryptBlock {
        // 情况 A: 数据长度 ≤ 245 字节，单次加密
        // rsa.EncryptPKCS1v15 参数说明:
        //   - rand.Reader: 加密安全随机数生成器
        //   - publicKey: RSA 公钥
        //   - jsonData: 待加密的明文
        encrypted, err := rsa.EncryptPKCS1v15(
            rand.Reader,
            publicKey,
            jsonData,
        )
        if err != nil {
            return "", fmt.Errorf("加密失败: %w", err)
        }
        return base64.StdEncoding.EncodeToString(encrypted), nil
    }

    // 情况 B: 数据长度 > 245 字节，需要分段加密
    var encryptedChunks []string

    // 步骤 5.1: 按 245 字节切分并逐段加密
    for i := 0; i < dataLen; i += maxEncryptBlock {
        // 计算当前段结束位置（最后一段可能不足 245 字节）
        end := i + maxEncryptBlock
        if end > dataLen {
            end = dataLen
        }

        // 获取当前段数据
        chunk := jsonData[i:end]

        // 加密当前段
        encrypted, err := rsa.EncryptPKCS1v15(
            rand.Reader,
            publicKey,
            chunk,
        )
        if err != nil {
            return "", fmt.Errorf("第 %d 段加密失败: %w", i/maxEncryptBlock, err)
        }

        // 步骤 5.2: Base64 编码并添加到切片
        encryptedChunks = append(encryptedChunks, base64.StdEncoding.EncodeToString(encrypted))
    }

    // 步骤 6: 用管道符连接所有加密段
    return strings.Join(encryptedChunks, "|"), nil
}

// LoadPublicKey 从文件加载公钥
func LoadPublicKey(filePath string) (string, error) {
    data, err := os.ReadFile(filePath)
    if err != nil {
        return "", fmt.Errorf("读取公钥文件失败: %w", err)
    }
    return string(data), nil
}

// ==================== 完整使用示例 ====================

func main() {
    // 1. 读取公钥文件
    publicKeyPath := "./publickey.pem"
    publicKey, err := LoadPublicKey(publicKeyPath)
    if err != nil {
        fmt.Printf("错误：%v\n请从开发者中心下载 publickey.pem\n", err)
        os.Exit(1)
    }

    // 2. 构建验证载荷
    payload := VerifyPayload{
        LicenseKey:  "XXXX-XXXX-XXXX-XXXX", // 必填：授权码
        VerifyType:  "domain",               // 可选：验证类型
        VerifyValue: "example.com",          // 可选：验证值
        Timestamp:   time.Now().Unix(),      // 可选：当前时间戳（秒）
        UploadParams: map[string]interface{}{ // 可选：自定义上传参数
            "client_version": "1.0.0",
            "os_type":        "linux",
        },
    }

    // 3. 加密载荷
    encryptedPayload, err := EncryptPayload(payload, publicKey)
    if err != nil {
        fmt.Printf("加密失败: %v\n", err)
        os.Exit(1)
    }

    fmt.Println("加密成功！")
    fmt.Printf("加密结果长度: %d 字符\n", len(encryptedPayload))
    if strings.Contains(encryptedPayload, "|") {
        fmt.Println("是否分段: 是")
    } else {
        fmt.Println("是否分段: 否")
    }

    // 4. 发送验证请求
    appID := "YOUR_APP_ID" // 替换为您的应用 ID
    apiURL := "https://software.xingqingchuang.com/api/v1/license/verify-encrypted"

    // 构建请求体
    requestBody := map[string]string{
        "app_id":            appID,
        "encrypted_payload": encryptedPayload,
    }
    jsonBody, _ := json.Marshal(requestBody)

    // 发送 POST 请求
    resp, err := http.Post(apiURL, "application/json", bytes.NewBuffer(jsonBody))
    if err != nil {
        fmt.Printf("请求失败: %v\n", err)
        os.Exit(1)
    }
    defer resp.Body.Close()

    // 5. 读取并处理响应
    body, _ := io.ReadAll(resp.Body)

    var result map[string]interface{}
    json.Unmarshal(body, &result)

    if valid, ok := result["valid"].(bool); ok && valid {
        fmt.Println("授权验证成功！")
        if expiresAt, ok := result["expires_at"].(string); ok {
            fmt.Printf("到期时间: %s\n", expiresAt)
        }
    } else {
        msg := result["message"]
        code := result["code"]
        fmt.Printf("验证失败: %v (错误码: %v)\n", msg, code)
    }
}

/**
 * RSA PKCS#1 v1.5 加密验证载荷 - C 语言完整示例
 * 
 * 依赖: OpenSSL 1.1.0+
 * 编译: gcc -o rsa_encrypt rsa_encrypt.c -lssl -lcrypto
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/evp.h>
#include <openssl/pem.h>
#include <openssl/err.h>
#include <openssl/rsa.h>

// 2048位密钥 = 256字节，PKCS#1 v1.5 开销 = 11字节，最大明文 = 245字节
#define MAX_ENCRYPT_BLOCK 245
// RSA 2048 加密后的密文长度
#define RSA_CIPHERTEXT_LEN 256

/**
 * Base64 编码
 * 
 * @param input 输入数据
 * @param input_len 输入长度
 * @param output_len 输出长度指针
 * @return Base64 编码后的字符串（需要调用者 free）
 */
char* base64_encode(const unsigned char* input, int input_len, int* output_len) {
    // Base64 编码后长度 = ceil(input_len / 3) * 4 + 1
    int encoded_len = ((input_len + 2) / 3) * 4 + 1;
    char* output = (char*)malloc(encoded_len);
    if (!output) return NULL;
    
    *output_len = EVP_EncodeBlock((unsigned char*)output, input, input_len);
    output[*output_len] = '\0';
    return output;
}

/**
 * 使用 RSA PKCS#1 v1.5 加密单个数据块
 * 
 * @param pkey EVP_PKEY 公钥对象
 * @param data 待加密数据
 * @param data_len 数据长度
 * @param encrypted_len 加密后长度指针
 * @return 加密后的数据（需要调用者 free），失败返回 NULL
 */
unsigned char* encrypt_block(EVP_PKEY* pkey, const unsigned char* data, 
                             size_t data_len, size_t* encrypted_len) {
    EVP_PKEY_CTX* ctx = NULL;
    unsigned char* encrypted = NULL;
    
    // 步骤 1: 创建加密上下文
    ctx = EVP_PKEY_CTX_new(pkey, NULL);
    if (!ctx) {
        fprintf(stderr, "创建加密上下文失败\n");
        return NULL;
    }
    
    // 步骤 2: 初始化加密操作
    if (EVP_PKEY_encrypt_init(ctx) <= 0) {
        fprintf(stderr, "初始化加密失败\n");
        EVP_PKEY_CTX_free(ctx);
        return NULL;
    }
    
    // 步骤 3: 设置 PKCS#1 v1.5 填充方式
    if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0) {
        fprintf(stderr, "设置 PKCS#1 v1.5 填充失败\n");
        EVP_PKEY_CTX_free(ctx);
        return NULL;
    }
    
    // 步骤 4: 设置 哈希算法为 SHA-256
    if (EVP_PKEY_CTX_set_rsa_padding(ctx, EVP_sha256()) <= 0) {
        fprintf(stderr, "设置 哈希算法失败\n");
        EVP_PKEY_CTX_free(ctx);
        return NULL;
    }
    
    // 步骤 5: 设置 MGF1 哈希算法为 SHA-256
    if (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, EVP_sha256()) <= 0) {
        fprintf(stderr, "设置 MGF1 哈希算法失败\n");
        EVP_PKEY_CTX_free(ctx);
        return NULL;
    }
    
    // 步骤 6: 获取加密后数据长度
    if (EVP_PKEY_encrypt(ctx, NULL, encrypted_len, data, data_len) <= 0) {
        fprintf(stderr, "获取加密长度失败\n");
        EVP_PKEY_CTX_free(ctx);
        return NULL;
    }
    
    // 步骤 7: 分配加密结果缓冲区
    encrypted = (unsigned char*)malloc(*encrypted_len);
    if (!encrypted) {
        fprintf(stderr, "内存分配失败\n");
        EVP_PKEY_CTX_free(ctx);
        return NULL;
    }
    
    // 步骤 8: 执行加密
    if (EVP_PKEY_encrypt(ctx, encrypted, encrypted_len, data, data_len) <= 0) {
        fprintf(stderr, "加密失败: ");
        ERR_print_errors_fp(stderr);
        free(encrypted);
        EVP_PKEY_CTX_free(ctx);
        return NULL;
    }
    
    EVP_PKEY_CTX_free(ctx);
    return encrypted;
}

/**
 * RSA PKCS#1 v1.5 加密验证载荷（支持分段加密）
 * 
 * @param json_payload JSON 格式的验证载荷字符串
 * @param public_key_pem PEM 格式公钥字符串
 * @return Base64 编码的加密数据（分段时用 | 分隔），失败返回 NULL
 *         需要调用者 free 返回的字符串
 */
char* encrypt_payload(const char* json_payload, const char* public_key_pem) {
    BIO* bio = NULL;
    EVP_PKEY* pkey = NULL;
    char* result = NULL;
    
    // 步骤 1: 创建内存 BIO 读取 PEM 公钥
    bio = BIO_new_mem_buf(public_key_pem, -1);
    if (!bio) {
        fprintf(stderr, "创建 BIO 失败\n");
        return NULL;
    }
    
    // 步骤 2: 解析 PEM 格式公钥
    pkey = PEM_read_bio_PUBKEY(bio, NULL, NULL, NULL);
    BIO_free(bio);
    if (!pkey) {
        fprintf(stderr, "解析公钥失败: ");
        ERR_print_errors_fp(stderr);
        return NULL;
    }
    
    // 步骤 3: 获取数据长度
    size_t data_len = strlen(json_payload);
    const unsigned char* data = (const unsigned char*)json_payload;
    
    // 步骤 4: 检查是否需要分段加密
    if (data_len <= MAX_ENCRYPT_BLOCK) {
        // 情况 A: 数据长度 ≤ 245 字节，单次加密
        size_t encrypted_len;
        unsigned char* encrypted = encrypt_block(pkey, data, data_len, &encrypted_len);
        if (!encrypted) {
            EVP_PKEY_free(pkey);
            return NULL;
        }
        
        // Base64 编码
        int base64_len;
        result = base64_encode(encrypted, encrypted_len, &base64_len);
        free(encrypted);
        EVP_PKEY_free(pkey);
        return result;
    }
    
    // 情况 B: 数据长度 > 245 字节，需要分段加密
    // 计算分段数量
    size_t num_chunks = (data_len + MAX_ENCRYPT_BLOCK - 1) / MAX_ENCRYPT_BLOCK;
    
    // 预分配结果缓冲区
    // 每段 Base64 约 344 字符 + 分隔符 + 结束符
    size_t result_size = num_chunks * 350 + 1;
    result = (char*)malloc(result_size);
    if (!result) {
        fprintf(stderr, "内存分配失败\n");
        EVP_PKEY_free(pkey);
        return NULL;
    }
    result[0] = '\0';
    
    // 步骤 5: 逐段加密
    size_t offset = 0;
    int chunk_index = 0;
    
    while (offset < data_len) {
        // 计算当前段长度
        size_t chunk_len = data_len - offset;
        if (chunk_len > MAX_ENCRYPT_BLOCK) {
            chunk_len = MAX_ENCRYPT_BLOCK;
        }
        
        // 加密当前段
        size_t encrypted_len;
        unsigned char* encrypted = encrypt_block(pkey, data + offset, chunk_len, &encrypted_len);
        if (!encrypted) {
            fprintf(stderr, "第 %d 段加密失败\n", chunk_index);
            free(result);
            EVP_PKEY_free(pkey);
            return NULL;
        }
        
        // Base64 编码
        int base64_len;
        char* base64_chunk = base64_encode(encrypted, encrypted_len, &base64_len);
        free(encrypted);
        
        if (!base64_chunk) {
            fprintf(stderr, "第 %d 段 Base64 编码失败\n", chunk_index);
            free(result);
            EVP_PKEY_free(pkey);
            return NULL;
        }
        
        // 拼接结果（第一段不加分隔符）
        if (chunk_index > 0) {
            strcat(result, "|");
        }
        strcat(result, base64_chunk);
        free(base64_chunk);
        
        offset += chunk_len;
        chunk_index++;
    }
    
    EVP_PKEY_free(pkey);
    return result;
}

/**
 * 从文件读取公钥
 */
char* load_public_key(const char* file_path) {
    FILE* fp = fopen(file_path, "r");
    if (!fp) {
        fprintf(stderr, "无法打开公钥文件: %s\n", file_path);
        return NULL;
    }
    
    fseek(fp, 0, SEEK_END);
    long file_size = ftell(fp);
    fseek(fp, 0, SEEK_SET);
    
    char* content = (char*)malloc(file_size + 1);
    if (!content) {
        fclose(fp);
        return NULL;
    }
    
    fread(content, 1, file_size, fp);
    content[file_size] = '\0';
    fclose(fp);
    
    return content;
}

// ==================== 完整使用示例 ====================

int main() {
    // 初始化 OpenSSL
    OpenSSL_add_all_algorithms();
    ERR_load_crypto_strings();
    
    // 1. 读取公钥文件
    const char* public_key_path = "./publickey.pem";
    char* public_key = load_public_key(public_key_path);
    if (!public_key) {
        fprintf(stderr, "错误：公钥文件不存在，请从开发者中心下载 publickey.pem\n");
        return 1;
    }
    
    // 2. 构建验证载荷 JSON
    // 注意：实际项目中建议使用 cJSON 等 JSON 库
    time_t timestamp = time(NULL);
    char json_payload[1024];
    snprintf(json_payload, sizeof(json_payload),
        "{\"license_key\":\"XXXX-XXXX-XXXX-XXXX\","
        "\"verify_type\":\"domain\","
        "\"verify_value\":\"example.com\","
        "\"timestamp\":%ld,"
        "\"upload_params\":{\"client_version\":\"1.0.0\",\"os_type\":\"linux\"}}",
        timestamp
    );
    
    printf("原始载荷长度: %zu 字节\n", strlen(json_payload));
    
    // 3. 加密载荷
    char* encrypted_payload = encrypt_payload(json_payload, public_key);
    free(public_key);
    
    if (!encrypted_payload) {
        fprintf(stderr, "加密失败\n");
        return 1;
    }
    
    printf("加密成功！\n");
    printf("加密结果长度: %zu 字符\n", strlen(encrypted_payload));
    printf("是否分段: %s\n", strchr(encrypted_payload, '|') ? "是" : "否");
    
    // 4. 打印加密结果（实际使用时发送到 API）
    printf("\n加密结果:\n%s\n", encrypted_payload);
    
    // 5. 清理
    free(encrypted_payload);
    
    // 清理 OpenSSL
    EVP_cleanup();
    ERR_free_strings();
    
    printf("\n提示: 请将加密结果发送到 /api/v1/license/verify-encrypted 接口\n");
    printf("请求体格式: {\"app_id\":\"YOUR_APP_ID\",\"encrypted_payload\":\"...\"}\n");
    
    return 0;
}