/**
 * @param jsonString json字串，格式示例：{"field_1":"value_1","field_2":"value_2"}
 * @param publicKey  公钥，格式示例：MIGfMA0GCSqGSIb3DQEBAQUAA4GNADC....
 * @return 加密后的请求参数，包含加密后的数据字段
 * @throws Exception 加密过程中可能抛出的异常
 */
public static Map<String, String> encryptRequestBody(String jsonString, String publicKey) throws Exception {
    // 将json字符串转换为字节数组
    byte[] data = jsonString.getBytes(StandardCharsets.UTF_8);

    // 通过Base64解码获取公钥字节数组
    byte[] keyBytes = Base64.getDecoder().decode(publicKey);

    // 使用公钥字节数组创建X509EncodedKeySpec对象
    X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

    // 使用KeyFactory生成公钥对象
    KeyFactory keyFactory = KeyFactory.getInstance("RSA"); // 加密算法
    Key publicK = keyFactory.generatePublic(x509KeySpec);

    // 初始化Cipher对象，用于RSA加密
    Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
    cipher.init(Cipher.ENCRYPT_MODE, publicK);

    int inputLen = data.length;
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    int offSet = 0;
    byte[] cache;

    // 对数据进行分段加密，每次加密块的大小不超过MAX_ENCRYPT_BLOCK
    int MAX_ENCRYPT_BLOCK = 117;   // RSA加密的最大块大小，PKCS1填充方式下为117字节
    while (inputLen - offSet > 0) {
        int len = Math.min(MAX_ENCRYPT_BLOCK, inputLen - offSet);
        cache = cipher.doFinal(data, offSet, len);
        out.write(cache);
        offSet += len;
    }

    // 获取加密后的字节数组
    byte[] encryptedData = out.toByteArray();
    out.close();

    // 将加密后的字节数组进行Base64编码，转换为字符串
    String base64String = Base64.getEncoder().encodeToString(encryptedData);

    // 创建一个Map，将Base64编码后的加密数据作为参数放入Map中
    Map<String, String> encryptParam = new HashMap<>();
    encryptParam.put("data", base64String);

    // 返回包含加密数据的Map
    return encryptParam;
}

public static void main(String[] args) throws Exception {
  String account = "用户名";
  String password = "password";

  // 手動拼接 JSON
  String jsonString = "{"
  + "\"account\":\"" + account + "\","
  + "\"password\":\"" + password + "\""
  + "}";

  System.out.println(jsonString);

  String base64PublicKey = 'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A...'; // 替換為你的 base64 公鑰內容

  OkHttpClient client = new OkHttpClient().newBuilder()
  .build();

  MediaType mediaType = MediaType.parse("application/json");
  RequestBody body = RequestBody.create(mediaType, encryptRequestBody( jsonString , base64PublicKey ));



  Request request = new Request.Builder()
  .url("your-api-endpoint")
  .method("POST", body )
  .addHeader("businessAccount", "我方提供的总代唯一标识")
  .addHeader("site", "XAgent 商户后台中的代理线路标识")
  .addHeader("Content-Type", "application/json")
  .build();
  Response response = client.newCall(request).execute();
}

<?php
// 假設 json 資料與 base64 公鑰字串
$jsonString = json_encode([
    'account'=> '用户名',
    'password'=> 'password'
]);

$base64PublicKey = 'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A...'; // 替換為你的 base64 公鑰內容

// 1. 將 base64 公鑰解碼並封裝成 PEM 格式
$pubKeyFormatted = "-----BEGIN PUBLIC KEY-----\n" .
    chunk_split($base64PublicKey, 64, "\n") .
    "-----END PUBLIC KEY-----";

// 2. 載入公鑰
$publicKey = openssl_pkey_get_public($pubKeyFormatted);
if (!$publicKey) {
    die("公鑰格式錯誤");
}

// 3. 將 JSON 字串轉為位元組（UTF-8）
$data = $jsonString;

// 4. RSA 1024-bit 公鑰 -> 明文限制 117 bytes (PKCS1 padding)
$chunkSize = 117;
$offset = 0;
$encrypted = '';

while ($offset < strlen($data)) {
    $chunk = substr($data, $offset, $chunkSize);
    $encryptedChunk = '';
    if (!openssl_public_encrypt($chunk, $encryptedChunk, $publicKey, OPENSSL_PKCS1_PADDING)) {
        die("加密失敗");
    }
    $encrypted .= $encryptedChunk;
    $offset += $chunkSize;
}

// 5. 最終結果：Base64 編碼後輸出
$encryptedBase64 = base64_encode($encrypted);
echo "加密結果（Base64）:\n" . $encryptedBase64;
// HTTP POST 请求函数
function httpPost($encryptedBase64) {
    $url = 'your-api-endpoint'; // 替换为您的API接口地址

    $options = array(
        'http' => array(
            'header' => "businessAccount: 我方提供的总代唯一标识\r\n" .
            "site: XAgent 商户后台中的代理线路标识\r\n" .
            "Content-Type: application/json\r\n",
            'method'  => 'POST',
            'content' => json_encode([
                'data'=> $encryptedBase64
            ])
        )
    );

    $context  = stream_context_create($options);
    $result = file_get_contents($url, false, $context);

    return $result;
}
?>

import base64
from json import dumps
import requests
from Crypto.Cipher import PKCS1_v1_5
from Crypto.PublicKey import RSA
def rsa_encrypt_chunked(data: bytes, public_key_pem: str) -> bytes:
    """
    使用 RSA 公钥 (PKCS#1) 分段加密数据。
    :param data: 需要加密的原始数据 (bytes)
    :param public_key_pem: 公钥字符串 (PEM 格式)
    :return: 加密后的原始 bytes (未进行 Base64 编码)
    """
    key = RSA.importKey(public_key_pem)
    cipher_rsa = PKCS1_v1_5.new(key)
    def get_rsa_chunk_size(public_key_pem: str) -> int:
        """
        计算 RSA 加密时单次最大加密数据的大小。
        :param public_key_pem: 公钥字符串 (PEM 格式)
        :return: 可加密的最大字节数
        """
        key = RSA.importKey(public_key_pem)
        key_bits = key.size_in_bits()  # 获取密钥的位数
        key_bytes = key_bits // 8  # 转换为字节
        return key_bytes - 11  # PKCS#1 v1.5 需要扣除 11 字节填充
    offset = 0
    encrypted_data = b""
    chunk_size = get_rsa_chunk_size(public_key_pem)  # 计算分块大小
    while offset < len(data):
        chunk = data[offset: offset + chunk_size]  # 获取当前分块数据
        encrypted_chunk = cipher_rsa.encrypt(chunk)  # 使用 RSA 加密
        encrypted_data += encrypted_chunk  # 拼接加密后的数据
        offset += chunk_size  # 移动偏移量
    return encrypted_data
if __name__ == "__main__":
    # 业务账号唯一标识
    business_account = "我方提供的总代唯一标识"
    # 代理线路标识
    site = "XAgent 商户后台中的代理线路标识"
    # RSA 公钥
    public_key_str = """-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-----END PUBLIC KEY-----"""
    # 需要加密的参数
    payload = {"account": "用户名", "password": "password"}
    data_bytes = dumps(payload).encode("utf-8")  # 将字典转换为 JSON 并编码为字节
    # 分段加密数据
    encrypted_bytes = rsa_encrypt_chunked(data_bytes, public_key_str)
    # 对加密数据进行 Base64 编码
    encrypted_b64 = base64.b64encode(encrypted_bytes).decode("utf-8")
    # 发送请求的参数
    encrypt_param = {"data": encrypted_b64}
    # 请求头
    headers = {
        "Content-Type": "application/json",
        "businessAccount": business_account,
        "site": site
    }
    # 接口地址
    url = "https://xxxx.xxx.xxxx.xxxx/v3/xxxxx/xxxx/xxxx"
    # 发送 POST 请求
    response = requests.post(url, json=encrypt_param, headers=headers)
    print("Response:", response.text)

package main

import (
    "bytes"
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "encoding/base64"
    "encoding/json"
    "encoding/pem"
    "fmt"
    "net/http"
)

func main() {
    // 参数
    param := map[string]string{
        "account":  "用户名",
        "password": "password",
    }

    // JSON 编码
    jsonData, err := json.Marshal(param)
    if err != nil {
        fmt.Println("JSON Marshal error:", err)
        return
    }

    // RSA 加密
    publicKey := `-----BEGIN PUBLIC KEY-----
your-public-key-here
-----END PUBLIC KEY-----`

    encodedData, err := rsaEncrypt(jsonData, publicKey)
    if err != nil {
        fmt.Println("RSA Encryption error:", err)
        return
    }

    // Base64 编码
    base64String := base64.StdEncoding.EncodeToString(encodedData)
    fmt.Println("encoded:", base64String)

    // 构建请求参数
    encryptParam := map[string]string{
        "data": base64String,
    }

    // 调用接口
    req, err := http.NewRequest("POST", "your-api-endpoint", encryptParam)
    if err != nil {
        fmt.Println("HTTP Post error:", err)
    }

    // 设置请求头
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("site", "XAgent 商户后台中的代理线路标识")
    req.Header.Set(businessAccount", "我方提供的总代唯一标识")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("HTTP Post get response error:", err)
    }

    fmt.Println("Response:", resp)
}

const crypto = require('crypto');
const axios = require('axios');

// 参数
const param = {
  account: '用户名',
  password: 'password'
};

// JSON 编码
const jsonData = JSON.stringify(param);

// RSA 加密
const publicKey = `-----BEGIN PUBLIC KEY-----
your-public-key-here
-----END PUBLIC KEY-----`;
const buffer = Buffer.from(jsonData, 'utf8');
const encryptedData = crypto.publicEncrypt(publicKey, buffer);

// Base64 编码
const base64String = encryptedData.toString('base64');
console.log("encoded: " + base64String);

// 构建请求参数
const encryptParam = {
  data: base64String
};

// 调用接口
var endpoint = 'your-api-endpoint';
let config = {
  method: 'post',
  maxBodyLength: Infinity,
  url: endpoint,
  headers: {
    'businessAccount': '我方提供的总代唯一标识',
    'site': 'XAgent 商户后台中的代理线路标识',
    'Content-Type': 'application/json'
  },
  data : encryptParam
};

axios.request(config)
  .then((response) => {
    console.log(JSON.stringify(response.data));
  }

# input sample
curl --location 'https://xagent-open-api-uat-hh.ncfc.cc/v3/single/user/login' \
--header 'businessAccount: testaccount' \
--header 'site: default' \
--header 'Content-Type: application/json' \
--data '{
"data":"afafCuR6SHzSHFMjOEm44FdKkDPL9KMpeJEVfeolaUFI6RDHRlpL+BDRYGnniSHcEeKycmaKblh0w5fH8xVMTrssep1VmlSuIDd6VZJX+LQgWpjs7ExpAK4aD9O1NqssfcYbgtVUAzuAanbk3AStWtp8MFi7X7jkzm5WeeuCkX8tgXt3CEBfczlegzKiLZoYhdobLXbBaMo0auj8ZxWiQobnP4vL2Q/19sd0kIzkaYgryYpDa4e9PbR2QMwnowXOgfJ5hYh//+YAybgGq1NzHfc4N2AWK3QGFk2H8rHqVMgnyBeTBSE+hWqyXauDfl4yq43rGU+MqekEB0Dz2utY3A=="
}'

# input sample
curl --location 'https://xagent-open-api-uat-hh.ncfc.cc/v3/transfer/user/balance' \
--header 'businessAccount: testaccount' \
--header 'site: default' \
--header 'Content-Type: application/json' \
--data '{
"data":"aKVH/5WJ6dEbJ5AJYCd5SBIMEGZuTAOfQVADRlRhdkirBpxDFdLyefnpZ8MsL/Ub8ArkY83NoOJrQJAcLkA9HdKnvfDn+3g7yLmPTNXBvAdNdg0y4muFsAEe8FdEHedYYk0AZVfGqKGHlzm+t8wwbUlbtnmfqQwXyUSMoH3Sy6M="
}'

# input sample
curl --location 'https://xagent-open-api-uat-hh.ncfc.cc/v3/transfer/user/transfer' \
--header 'businessAccount: testaccount' \
--header 'site: default' \
--header 'Content-Type: application/json' \
--data '{
"data":"W1po3lRSZsBV6aHzoEEgmadgZx7kKZlMsROUj4W42VxWfIZRw2Mfdo+NSJUs2bZoCRc30r3Tpw4uiJtNIVY9U6eA07Ur4ss5ejyfHZJK5CIFKtpx0jDOhr2Ok1mCqkuA31jG+rsrh8Bh0OaCG9Rts6ztZO+MYgdnI/d0GY2BBSJKBYWH7dLNCgjwxjrHgii/ufzDck5RxhfHVBbHDnuUr5KAu2O5iW1WwItqoOCz2YvA591EifHMNgBt7cKVxdFujvISjTjpGqXC8oJF1QWTPkLGGX0WuSeZksS4toC576c9DN1D/vFy8Q2kiyaA29YttCX2kKOOUGAuM/rdGFhpmg=="
}'

# input sample
curl --location 'https://xagent-open-api-uat-hh.ncfc.cc/v3/transfer/bet/betting' \
--header 'businessAccount: testaccount' \
--header 'site: default' \
--header 'Content-Type: application/json' \
--data '{
"data":"SNQQ39/jXIZkpmq16SK4ujLLVNnrbjM4KZ/LV0xJrcwbzyQRN1SuPvOMP5D8jtP5LGrs4cGjzSbD6MHThlUsPSEdplPa9yxnSzKXKGcoGtXgpqNryEY10iCQEJaFN0Cw43+u83jBUle6hPryf5Rj5fn9jLilumaTQYQeRLj1u20="
}'

# input sample
curl --location 'https://xagent-open-api-uat-hh.ncfc.cc/v3/transfer/user/transfer-search' \
--header 'businessAccount: testaccount' \
--header 'site: default' \
--header 'Content-Type: application/json' \
--data '{
"data":"QB8pXcVHA2Iu7iEMooxQvwzsFAYQqPYYNg8969dnUkjteud0w6YSR65NktMSY6Ql9LUto1OMHOw8v7FEwHOTJ6KxpJPbVuvwyp7vxpjLhZ3wFQ4zECOPxEKYrXVo6gaDDAUBbe9F8kaUqxWUXlQxjWrqMXbCHn1hsQC4caVyLMA="
}'

# input sample
curl --location 'https://xagent-open-api-uat-hh.ncfc.cc/v3/transfer/game/list-gamecode' \
--header 'businessAccount: testaccount' \
--header 'site: default' \
--header 'Content-Type: application/json' \
--data '{
"data":"G4HEngPlnZ85x449qYvOsqeV2KjlgXTAjmWF2tUjRFSuOiVMvtFnxvEIwqEz7a1QCUrqaBPKWCOnAUs+OAkv61vApOhI9gZ9pU1o5fy7V+g0Q9Y4WYlD48chxr5KwFI5E9peTJaUaje+n50YBOgFhzKhfN3muQeJbEMIdYWB42A="
}'

# input sample
curl --location 'https://xagent-open-api-uat-hh.ncfc.cc/v3/transfer/game/list-gametype' \
--header 'businessAccount: testaccount' \
--header 'site: default' \
--header 'Content-Type: application/json' \
--data '{
"data":"JWBtLQ47oLSCHOYr+UaXwMZEdkw/s3moTstrFBFAwzukvW0lh57aeVXEqjLjMXxHOnObn/QmnMlUUygBSgCSlRY9J5T6HevQ2F5TmM4ESlRN1v1WeF++RKLSkuk45aOl2XywB9DcpVV8O9aorsByuhZ4MSUgo8fhePty3EnFN3w="
}'

# input sample
curl --location 'https://xagent-open-api-uat-hh.ncfc.cc/v3/transfer/game/pgKickOut' \
--header 'businessAccount: testaccount' \
--header 'site: default' \
--header 'Content-Type: application/json' \
--data '{
"data":"jAmvMbJ4ZgPt6GDnp9x0jAirH2qr3RiVLPXqm5xX+t2LzuY6lx9FttA7pA/iRksJXpvRuDfJouKSo3VtcjKkeV6qg39Ft1b8+yVdnZNjwC+peir7AMUbcx/61Unx6zTqt1K0n4RX89NGd7Y/kt9gYjShZQLtceqc0NR1FypJe34="
}'

# input sample
curl --location 'https://xagent-open-api-uat-hh.ncfc.cc/v3/transfer/game/pgSnapshot' \
--header 'businessAccount: testaccount' \
--header 'site: default' \
--header 'Content-Type: application/json' \
--data '{
"data":"Z2R6/LFNXDvne7A2hXDx8WF6rTXZmihVIu1ZtoI9KIykueP5DFRX4VWeP0CZUXVxTLTlrx6Vr8xGk7O/G8RtEhqjDDx4Zka3wN0t19rIRsJyB3xMdBxBqHW8M6qk9Ou7IcFt+S0/PnkceEZjPdEDRWBs5bNQwSZ6x+mjKNSnA88="
}'