{
  "app_key":     "你的64位AppKe...",
  "card_code":   "用户输入的卡密",
  "device_hash": "16-64位设备指纹（少于16位会被拒）",
  "action":      "verify"            // 可选，心跳传 heartbeat
}

{
  "app_key":        "你的64位AppKe...",
  "encrypted_data": "Base64( hmac[32] ‖ iv[16] ‖ ciphertext )"
}
// 明文内容里必须带 _ts（Unix 秒，10 位），服务端允许 ±300 秒

// 应用开了「响应加密」时，整个 JSON 只剩这一个字段，
// 解密前拿不到 code / msg / data，连错误信息都是密文
{
  "encrypted_data": "Base64( iv[12] ‖ tag[16] ‖ ciphertext )"
}
// 解密后才是正常的 { code, msg, data }

// —— PHP ——
$bin = base64_decode($enc);
$iv  = substr($bin, 0, 12);
$tag = substr($bin, 12, 16);
$ct  = substr($bin, 28);
$pt  = openssl_decrypt($ct, 'aes-256-gcm', hex2bin($appKey), OPENSSL_RAW_DATA, $iv, $tag);

{
  "code": 200,
  "msg":  "OK",
  "data": {
    "expire_time": "2026-11-30 23:59:59",
    "card_type":   "month",
    "custom_data": "",
    "variables":   { "hb_interval": "300" },
    "notice":      "应用公告内容"          // 可选：后台没填公告时为 null
  }
}

后台「程序管理 → 公告管理」里填的文本，会在验证成功和心跳的响应里一并下发，字段名 data.notice。 后台没填就返回 null，不需要额外请求接口，也不用改请求参数。

// 响应里的位置
{
  "code": 200,
  "data": {
    "expire_time": "2026-11-30 23:59:59",
    "notice":      "【重要】服务迁移通知，请重新登录"   // 没公告时是 null
  }
}

只传 app_key、不传卡密，就是「拉公告 / 变量 / 版本」接口。启动软件时先调一次，用户还没输卡密也能看到公告。

// 请求（不需要 card_code，也不需要 device_hash）
{ "app_key": "你的64位AppKe..." }

// 响应
{
  "code": 200,
  "data": {
    "notice":    "【公告】本软件已更新到 2.1.0",
    "variables": { "kf_qq": "123456789", "min_version": "2.0.0" },
    "update":    { "version": "2.1.0", "url": "", "force": 0 }
  }
}

// —— PHP ——
function getNotice(string $api, string $appKey): array {
    $raw = http_post_json($api, ['app_key' => $appKey]);
    $r = json_decode((string)$raw, true);
    if (!is_array($r))            return ['success' => false, 'notice' => null, 'error' => '解析失败'];
    if ((int)$r['code'] !== 200) return ['success' => false, 'notice' => null, 'error' => $r['msg']];
    return ['success' => true, 'notice' => $r['data']['notice'] ?? null, 'error' => null];
}

后台「程序管理 → 管理 → 更新配置」里可以给每个程序单独填新版本下载地址、强制更新开关。 这些值会在验证成功、心跳、以及只传 app_key 的轻量调用三种响应里一并下发，字段名 data.update。 不填就不下发（update.url 为空字符串），客户端可以完全忽略这个字段。

// 响应里的位置
{
  "code": 200,
  "data": {
    "expire_time": "2026-11-30 23:59:59",
    "update": {
      "version": "2.2.0",                              // 后台「程序管理 → 编辑」里填的版本号
      "url":     "https://dl.example.com/app-v2.2.0.apk",  // 更新配置里填的下载地址，没填是 ""
      "log":     "修复若干问题",                        // 程序备注，可当更新日志
      "force":   1                                       // 1=强制更新，0=可选
    }
  }
}

// 伪代码：拿到响应后先做这一步，再走正常业务
update = data.update
if (update.url != "") {                  // 后台没配置就什么都不做
    remote  = version_tuple(update.version)   // "2.2.0" -> [2,2,0]
    current = version_tuple(LOCAL_VERSION)    // 客户端自己的版本
    if (remote > current) {
        if (update.force == 1) {
            // 强制：弹不可取消的对话框，只能点「去更新」
            show_blocking_dialog("必须更新到 " + update.version, update.url, update.log)
            return  // 不继续业务
        } else {
            // 可选：弹一个能关闭的提示
            show_optional_dialog("有新版本 " + update.version, update.url, update.log)
            // 继续正常业务
        }
    }
}

同一个 AppKey，后台这些开关改一下，接口的校验规则和返回结构就会变。 客户端如果写死了某种行为，开关一改就会出问题 —— 所以对接前先确认下表里的值。

后台 →「程序管理」→ 点应用名进「程序设置」/「传输设置」，每个开关旁边都有说明。 改完立即生效，不需要客户端重新发版。

不注册账号，用户直接输卡密就能用。这是最省事的模式 —— 一把卡密对应一台设备， 换设备要解绑。后台可以按小时 / 天 / 周 / 月 / 季 / 年 / 永久卖卡，也可以在「生成卡密」里 指定任意小时数。

卡密验证 card_code + device_hash

if (($r['code'] ?? 0) === 200) {
    $expire = $r['data']['expire_time'];
    // 通过：进主界面，把卡密和到期时间存起来
} else {
    die('验证失败：' . ($r['msg'] ?? '网络错误'));
}

卡密心跳 heartbeat(card_code, device_hash)

结构和验证接口一样（code / msg / data.expire_time / data.notice / data.update）。 失败时 code=403，客户端应该立刻退回输卡密界面，把本地存的卡密清掉。

解除设备绑定 unbind(card_code)

除了卡密，还支持注册账号 → 用卡密充值 → 账号登录。两种模式可以同时用，老用户继续输卡密，新用户注册账号。 所有请求都发往同一个 /Verifyfile/api.php，只用 action 区分。

用户注册 user_register(username, password, confirm_password)

// 请求
{
  "app_key":          "你的64位AppKe...",
  "action":           "user_register",
  "username":         "zhangsan",
  "password":         "abc123456",
  "confirm_password": "abc123456"
}

// 响应
{ "code": 200, "msg": "注册成功", "data": { "username": "zhangsan", "id": 2 } }

卡密充值 recharge(username, card_code)

// 请求
{
  "app_key":   "你的64位AppKe...",
  "action":    "recharge",
  "username":  "zhangsan",
  "card_code": "TK3S2UF79TZ2WYSSJE"
}

// 响应
{
  "code": 200, "msg": "充值成功",
  "data": {
    "expire_time": "2026-11-29 14:54:24",
    "added_hours": 720,
    "card_type":   "月卡"
  }
}

用户登录 user_login(username, password, device_hash)

// 请求
{
  "app_key":     "你的64位AppKe...",
  "action":      "user_login",
  "username":    "zhangsan",
  "password":    "abc123456",
  "device_hash": "设备指纹"
}

// 响应
{
  "code": 200, "msg": "登录成功",
  "data": {
    "expire_time": "2026-11-29 14:54:24",
    "statecode":   "eba30d6d6a058bc4f1a2...",
    "notice":      "【公告】账号模式也能收到公告"
  }
}

用户心跳 user_heartbeat(username, password, statecode)

// 请求
{
  "app_key":   "你的64位AppKe...",
  "action":    "user_heartbeat",
  "username":  "zhangsan",
  "password":  "abc123456",
  "statecode": "eba30d6d6a058bc4f1a2..."
}

// 响应
{ "code": 200, "msg": "心跳成功", "data": { "expire_time": "2026-11-29 14:54:24", "notice": "【公告】..." } }

用户公告（跟着登录/心跳下发）

// 登录 / 心跳的 data 里都会带这个字段
{
  "code": 200,
  "data": {
    "expire_time": "2026-11-29 14:54:24",
    "statecode":   "eba30d6d6a058bc4f1a2...",
    "notice":      "【公告】服务器今晚 23:00 迁移"   // 没公告时为 null
  }
}

账号解绑 IP ip_unbind_user(username, password)

{
  "app_key":  "你的64位AppKe...",
  "action":   "ip_unbind_user",
  "username": "zhangsan",
  "password": "abc123456"
}

// 响应
{ "code": 200, "msg": "IP 解绑成功", "data": { "old_ip": "112.19.228.181" } }

卡密解绑 IP ip_unbind(card_code, device_hash?)

{
  "app_key":     "你的64位AppKe...",
  "action":      "ip_unbind",
  "card_code":   "TK3S2UF79TZ2WYSSJE",
  "device_hash": "可选的设备指纹"
}

// 响应
{ "code": 200, "msg": "IP 解绑成功", "data": { "old_ip": "112.19.228.181" } }

管理端接口（发卡网 / 后台对接）

这一组接口用 api_token 鉴权，不走 AppKey 签名，也不绑定某个程序。至少还要传一个合法 app_key 用于加密通道，请求体同样要 encrypted_data 加密。

• api_token — 后台「系统配置」里的对接通信密钥。没传或错了直接 403。
• app_key — 任取一个已存在程序的 AppKey，只为走加密通道。

generate — 批量发卡

{
  "action": "generate",
  "api_token": "你的对接密钥",
  "app_id": 12,
  "count": 5,
  "card_type": "month",
  "prefix": "VIP",
  "notes": "发卡网订单 #1234"
}

• card_type — hour / day / week / month / season / year / permanent
• 成功返回 data.cards（卡密数组）和 data.card_string（换行拼接整串）

ban / unban — 封卡 / 解封

{"action":"ban","api_token":"...","card_code":"ABC123"}
{"action":"unban","api_token":"...","card_code":"ABC123"}

• 封禁后客户端验证返回「此卡密已被管理员封禁」，解封恢复可用

del_card — 彻底删卡

{"action":"del_card","api_token":"...","card_code":"ABC123"}

• 删除后不可恢复，卡的设备绑定记录一并清除

kick — 强制下线

{"action":"kick","api_token":"...","card_code":"ABC123"}

• 踢掉当前绑定的设备并解绑，卡还能在别的设备上重新激活

ban_machine / blacklist — 拉黑机器码

{
  "action": "ban_machine",
  "api_token": "你的对接密钥",
  "device_hash": "客户端上报的设备特征码",
  "reason": "外挂检测",
  "client_ip": "1.2.3.4"
}

• device_hash 必填，client_ip 选填（PHP 中转时代理真实访客 IP）
• 拉黑后该设备的所有验证请求直接返回「访问受限」
• 拉黑记录归属到 app_key 对应的程序，开发者能在「防御与拉黑」里看到自己程序的

unbind — 解绑设备（不需要 api_token）

{"action":"unbind","app_key":"...","card_code":"ABC123"}

• 和 kick 的区别：unbind 由用户自助发起，会按「程序配置 → 解绑扣时」扣掉相应时长；kick 是管理员强制，不扣时间
• 扣多少由程序配置的 unbind_penalty 决定，配 0 表示不扣时；支持小数（如 2.5 小时）
• 程序若关闭了「机器码 / IP 解绑」（unbind_enabled=0），unbind 会被拒绝：该程序已关闭自助解绑，请联系管理员
• 配了「解绑次数限制」时，超出会返回：解绑次数已达上限（N 小时内最多 M 次）
• 成功响应里的 data.penalty_hours 是本次实际扣掉的小时数，可用于提示用户

三个最容易踩的格式坑

• _ts 必须是秒，不是毫秒：10 位整数（如 1761912000）。传 13 位毫秒（如 1761912000123）会被判成「请求已过期」，因为差值直接超出 ±300 秒窗口
• device_hash 长度必须 16–64 字符：短于 16 或长于 64 返回 设备码格式不正确。用 SHA-256 十六进制串（64 位）或 UUID（36 位）都合适
• app_key 必须 64 位十六进制：不是 Base64，也不是截断的短串。长度不对会直接判 应用身份标识无效

时间字段说明（expire_time / added_hours）

// —— 通用判断：年份 >= 2099 即永久 ——

// PHP
$isPermanent = strpos($expireStr, '2099-') === 0;

• 接口返回的是到期时刻，不是剩余秒数；需要剩余时间就用「到期时刻 − 当前时刻」自己算
• 永久卡（2099）算出来的剩余天数没有意义，界面上直接显示「永久」
• expire_time 为 null 时不要参与任何时间计算，按「未充值」分支处理
• recharge 接口额外返回 data.added_hours（整数，本次充值的时长小时数），可用于提示「已增加 N 小时」
• 永久卡不能用于 recharge（时长无限无法累加），文档前面已说明；账号体系里请改用月卡/年卡

错误码速查

• 400 — 参数错误 / 参数类型不对（传了数组或对象）/ 加密格式不对 / 时间戳过期 / 业务前置条件不满足
• 403 — 鉴权失败 / 卡密被封 / 程序被禁用 / 账号到期 / 卡密已冻结 / 解绑被拒
• 429 — 触发频率限制，客户端应退避重试
• 500 — 服务端异常

状态文案对照（客户端可直接展示 msg）

调用示例

// —— PHP ——
$r1 = gy_call($api, $appKey, ['action'=>'ip_unbind_user', 'username'=>$u, 'password'=>$p]);
$r2 = gy_call($api, $appKey, ['action'=>'ip_unbind', 'card_code'=>$card]);

错误处理（客户端要做的分流）

// —— PHP ——
$lg = gy_call($api, $appKey, ['action'=>'user_login', 'username'=>$u, 'password'=>$p, 'device_hash'=>$mc]);
if (($lg['code'] ?? 0) === 200) { enterMain($lg['data']['expire_time'], $lg['data']['statecode']); }
elseif (strpos($lg['msg'] ?? '', '未充值') !== false || strpos($lg['msg'] ?? '', '已到期') !== false) { showRecharge(); }
elseif (strpos($lg['msg'] ?? '', '其他设备') !== false) { showUnbind(); }
else { showToast($lg['msg'] ?? '登录失败'); }

// —— PHP ——
$reg = gy_call($api, $appKey, ['action'=>'user_register', 'username'=>$u, 'password'=>$p, 'confirm_password'=>$p]);
$rc  = gy_call($api, $appKey, ['action'=>'recharge', 'username'=>$u, 'card_code'=>$card]);
$lg  = gy_call($api, $appKey, ['action'=>'user_login', 'username'=>$u, 'password'=>$p, 'device_hash'=>$mc]);
$hb  = gy_call($api, $appKey, ['action'=>'user_heartbeat', 'username'=>$u, 'password'=>$p, 'statecode'=>$lg['data']['statecode']]);

<?php
$api    = 'https://yihaiyun.cn/Verifyfile/api.php';
$appKey = '你的64位AppKey';

// 请求加密：Base64( hmac[32] ‖ iv[16] ‖ ciphertext )
function gy_encrypt(array $params, string $appKey): string {
    $params['_ts'] = time();
    $master = hex2bin($appKey);
    $encKey = hash_hmac('sha256', 'enc', $master, true);
    $macKey = hash_hmac('sha256', 'mac', $master, true);

    $iv = random_bytes(16);
    $ct = openssl_encrypt(json_encode($params, JSON_UNESCAPED_UNICODE | JSON_HEX_TAG | JSON_HEX_APOS | JSON_HEX_QUOT),
                         'aes-256-cbc', $encKey, OPENSSL_RAW_DATA, $iv);
    $mac = hash_hmac('sha256', $iv . $ct, $macKey, true);
    return base64_encode($mac . $iv . $ct);
}

// 响应解密：Base64( iv[12] ‖ tag[16] ‖ ciphertext )
function gy_decrypt(string $raw, string $appKey): ?array {
    $j = json_decode($raw, true);
    if (!is_array($j)) return null;
    if (!isset($j['encrypted_data'])) return $j;   // 明文直接用

    $bin = base64_decode($j['encrypted_data']);
    $plain = openssl_decrypt(substr($bin, 28), 'aes-256-gcm',
                            hex2bin($appKey), OPENSSL_RAW_DATA,
                            substr($bin, 0, 12), substr($bin, 12, 16));
    return $plain === false ? null : json_decode($plain, true);
}

// 发起请求
function gy_call(string $url, string $appKey, array $params, bool $encrypt = true): ?array {
    $body = $encrypt
        ? ['app_key' => $appKey, 'encrypted_data' => gy_encrypt($params, $appKey)]
        : array_merge($params, ['app_key' => $appKey]);

    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => json_encode($body),
        CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 15,
    ]);
    $raw = curl_exec($ch);
    curl_close($ch);
    return $raw === false ? null : gy_decrypt($raw, $appKey);
}

// 用法
$r = gy_call($api, $appKey, [
    'card_code'   => '用户输入的卡密',
    'device_hash' => '16-64位设备指纹',
]);

if (!$r)                die("响应解析失败\n");
if ((int)$r['code'] !== 200)  die("验证失败：" . $r['msg'] . "\n");
echo "到期时间：{$r['data']['expire_time']}\n";

// 公告：后台填了才有，非空就弹
$notice = $r['data']['notice'] ?? null;
if ($notice !== null && $notice !== '') {
    echo "公告：{$notice}\n";
}

// 放在启动页或主页的 onCreate 里，验证通过前先显示加载层
class VerifyActivity : AppCompatActivity() {
    override fun onCreate(s: Bundle?) {
        super.onCreate(s)
        setContentView(R.layout.activity_verify)

        // 本地没存过卡密 → 先让用户输，别拿空串去验证
        val saved = prefs.getString("card", "").orEmpty()
        if (saved.isEmpty()) { showBlockingDialog("还没有绑定卡密，请先输入"); return }

        lifecycleScope.launch(Dispatchers.IO) {
            val r = gyCall(JSONObject().apply {
                put("card_code",   saved)
                put("device_hash", deviceHash())
            })
            withContext(Dispatchers.Main) {
                if (r != null && r.optInt("code") == 200) {
                    // ✅ 通过：把到期时间存一份，下次启动先看缓存
                    val d = r.optJSONObject("data")
                    prefs.edit()
                        .putString("expire", d?.optString("expire_time"))
                        .apply()
                    startActivity(Intent(this@VerifyActivity, MainActivity::class.java))
                    finish()
                } else {
                    // ❌ 不通过：停在当前页，只留「重新输入卡密」和「退出」
                    showBlockingDialog(r?.optString("msg") ?: "网络错误")
                }
            }
        }
    }
}

// 阻塞式提示：只有「重新输入」和「退出」，没有「取消」
// 这个页面由输卡界面 startActivity 进来；「重新输入」清掉本地卡密后退回，让输卡界面重新收
private fun showBlockingDialog(msg: String) {
    AlertDialog.Builder(this)
        .setTitle("验证未通过")
        .setMessage(msg)
        .setCancelable(false)
        .setPositiveButton("重新输入") { _, _ ->
            prefs.edit().remove("card").remove("expire").apply()
            finish()
        }
        .setNegativeButton("退出") { _, _ -> finishAffinity() }
        .show()
}

// 用户点「解锁高级功能」时才弹，不打断正常使用
fun requireVerify(onPass: () -> Unit) {
    if (prefs.getLong("expire", 0) > System.currentTimeMillis()) { onPass(); return }
    if (isFinishing || isDestroyed) return

    val dlg = AlertDialog.Builder(this)
        .setTitle("请输入卡密")
        .setView(R.layout.dialog_card_input)
        .setCancelable(true)            // 弹窗模式允许取消
        .setPositiveButton("验证", null)
        .create()

    dlg.setOnShowListener {
        dlg.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener {
            val code = dlg.findViewById<EditText>(R.id.etCard).text.toString().trim()
            if (code.isEmpty()) { toast("请输入卡密"); return@setOnClickListener }

            lifecycleScope.launch(Dispatchers.IO) {
                val r = gyCall(JSONObject().apply {
                    put("card_code", code); put("device_hash", deviceHash())
                })
                withContext(Dispatchers.Main) {
                    if (r != null && r.optInt("code") == 200) {
                        val data = r.getJSONObject("data")
                        prefs.edit()
                            .putString("card", code)
                            .putLong("expire", parseTime(data.optString("expire_time")))
                            .apply()
                        // 顺便把公告弹出来（后台填了才有）
                        data.optString("notice").takeIf { it.isNotBlank() }?.let { n ->
                            AlertDialog.Builder(this@MainActivity).setTitle("公告").setMessage(n).setPositiveButton("知道了", null).show()
                        }
                        dlg.dismiss()
                        onPass()
                    } else {
                        toast(r?.optString("msg") ?: "网络错误")
                    }
                }
            }
        }
    }
    dlg.show()
}

final class VerifyViewController: UIViewController {
    private let cardField = UITextField()
    private let tipLabel  = UILabel()

    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .systemBackground
        // 两块 UI：输入框 + 按钮，简单摆一下
        cardField.placeholder = "请输入卡密"
        cardField.borderStyle = .roundedRect
        let go = UIButton(type: .system)
        go.setTitle("验证", for: .normal)
        go.addTarget(self, action: #selector(doVerify), for: .touchUpInside)

        let stack = UIStackView(arrangedSubviews: [cardField, go, tipLabel])
        stack.axis = .vertical; stack.spacing = 16
        stack.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(stack)
        NSLayoutConstraint.activate([
            stack.centerYAnchor.constraint(equalTo: view.centerYAnchor),
            stack.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 32),
            stack.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -32),
        ])
    }

    @objc private func doVerify() {
        let code = cardField.text?.trimmingCharacters(in: .whitespaces) ?? ""
        guard !code.isEmpty else { tipLabel.text = "请输入卡密"; return }
        tipLabel.text = "验证中…"
        cardField.isEnabled = false

        DispatchQueue.global().async {
            let r = gyCall(["card_code": code, "device_hash": DeviceHash.machine()])
            DispatchQueue.main.async {
                if let r, (r["code"] as? Int) == 200 {
                    // ✅ 通过：换成主界面
                    let data = r["data"] as? [String: Any]
                    UserDefaults.standard.set(data?["expire_time"], forKey: "expire")
                    UserDefaults.standard.set(code, forKey: "card")
                    self.view.window?.rootViewController = MainViewController()
                } else {
                    self.cardField.isEnabled = true
                    self.tipLabel.text = (r?["msg"] as? String) ?? "网络错误"
                }
            }
        }
    }
}

// 在任意界面调用，弹完就关，不影响其他功能
func requireVerify(from vc: UIViewController, onPass: @escaping () -> Void) {
    let alert = UIAlertController(title: "需要验证", message: "请输入卡密解锁此功能", preferredStyle: .alert)
    alert.addTextField { $0.placeholder = "卡密"; $0.autocapitalizationType = .allCharacters }

    let go = UIAlertAction(title: "验证", style: .default) { _  in
        let code = alert.textFields?.first?.text?.trimmingCharacters(in: .whitespaces) ?? ""
        guard !code.isEmpty else { return }

        DispatchQueue.global().async {
            let r = gyCall(["card_code": code, "device_hash": DeviceHash.machine()])
            DispatchQueue.main.async {
                if let r, (r["code"] as? Int) == 200 {
                    let d = r["data"] as? [String: Any]
                    UserDefaults.standard.set(code, forKey: "card")
                    // 到期时间也存一份，下次进来先看本地缓存，不用每次都弹
                    UserDefaults.standard.set(d?["expire_time"], forKey: "expire")
                    onPass()
                    // 公告：有就再弹一个
                    if let n = d?["notice"] as? String, !n.isEmpty {
                        let notice = UIAlertController(title: "公告", message: n, preferredStyle: .alert)
                        notice.addAction(UIAlertAction(title: "知道了", style: .default))
                        vc.present(notice, animated: true)
                    }
                } else {
                    let fail = UIAlertController(
                        title: "验证失败",
                        message: (r?["msg"] as? String) ?? "网络错误",
                        preferredStyle: .alert)
                    fail.addAction(UIAlertAction(title: "好", style: .default))
                    vc.present(fail, animated: true)
                }
            }
        }
    }

    alert.addAction(go)
    alert.addAction(UIAlertAction(title: "取消", style: .cancel))
    vc.present(alert, animated: true)
}

// 场景：把验证做成 .so，Java/Kotlin 层不碰密钥，防止反编译直接读字符串

// ---- native-lib.cpp ----
#include <jni.h>
#include <string>
// 复用上面 C/C++ 示例里的 gyEncrypt / gyDecrypt / httpPost

extern "C" JNIEXPORT jboolean JNICALL
Java_com_yourapp_Gy_nativeVerify(JNIEnv* env, jclass, jstring jCard, jstring jDevice) {
    const char* card   = env->GetStringUTFChars(jCard, nullptr);
    const char* device = env->GetStringUTFChars(jDevice, nullptr);

    std::string json = std::string("{\"card_code\":\"") + card + "\",\"device_hash\":\"" + device + "\"}";
    std::string body = "{\"app_key\":\"" + std::string(APP_KEY) + "\",\"encrypted_data\":\"" + gyEncrypt(json, g_master) + "\"}";
    std::string resp = httpPost(API, body);

    env->ReleaseStringUTFChars(jCard, card);
    env->ReleaseStringUTFChars(jDevice, device);
    return resp.find("\"code\":200") != std::string::npos ? JNI_TRUE : JNI_FALSE;
}

// ---- CMakeLists.txt ----
# find_package(CURL REQUIRED)
# find_package(OpenSSL REQUIRED)
# target_link_libraries(native-lib CURL::libcurl OpenSSL::SSL OpenSSL::Crypto)

// ---- Kotlin 侧 ----
object Gy {
    init { System.loadLibrary("native-lib") }
    external fun nativeVerify(card: String, device: String): Boolean
}

// 场景：挂机脚本、CI 流水线、服务端定时校验
// 返回码约定：0 = 验证通过，1 = 验证失败，2 = 网络错误

int wmain(int argc, wchar_t** argv) {
    if (argc < 2) {
        std::cout << "用法: demo.exe <卡密>\n";
        return 1;
    }

    std::string card   = toUtf8(argv[1]);
    std::string device = machineCode();   // 见「设备指纹」章节

    std::string json = std::string("{\"_ts\":") + std::to_string(time(nullptr))
                     + ",\"card_code\":\"" + card + "\",\"device_hash\":\"" + device + "\"}";
    std::string body = "{\"app_key\":\"" + std::string(APP_KEY) + "\",\"encrypted_data\":\"" + gyEncrypt(json, g_master) + "\"}";

    std::string resp = httpPost(API, body);
    if (resp.empty()) { std::cerr << "网络错误\n"; return 2; }

    auto b64 = extractEncrypted(resp);          // 从 {"encrypted_data":"..."} 里取出
    std::string plain = gyDecrypt(b64, g_master);

    if (plain.find("\"code\":200") == std::string::npos) {
        std::cerr << "验证失败: " << plain << "\n";
        return 1;
    }

    std::cout << "验证通过\n";
    std::cout << "响应: " << plain << "\n";
    return 0;
}

// 全屏：盖住整页，验证通过才移除遮罩
function showFullscreen(failed) {
  const mask = document.createElement('div');
  mask.id = 'gy-mask';
  mask.style.cssText = 'position:fixed;inset:0;background:#fff;z-index:99999;display:flex;' +
                       'align-items:center;justify-content:center;flex-direction:column;gap:12px;';
  mask.innerHTML = '<h3>请输入卡密</h3><input id="gy-card"><button id="gy-go">验证</button><p id="gy-tip"></p>';
  document.body.appendChild(mask);

  document.getElementById('gy-go').onclick = async () => {
    const code = document.getElementById('gy-card').value.trim();
    const r = await gyCall({ card_code: code, device_hash: deviceHash() });
    if (r.code == 200) { mask.remove(); initApp(); }
    else { document.getElementById('gy-tip').textContent = r.msg; }
  };
}

// 弹窗：只在点按钮时弹
async function requireVerify() {
  const code = prompt('请输入卡密');
  if (!code) return false;
  const r = await gyCall({ card_code: code, device_hash: deviceHash() });
  if (r.code == 200) {
    localStorage.setItem('gy_card', code);
    localStorage.setItem('gy_expire', r.data.expire_time);
    if (r.data.notice) alert(r.data.notice);
    return true;
  }
  alert('验证失败：' + r.msg);
  return false;
}

机器码由客户端本地计算，服务端只做字符串比对，没有「查机器码」的接口。 要求：同一台机器每次算出来完全一样；不同机器不撞。

// —— PHP ——
function getMachineCode(): string {
    $src = php_uname('n') . '|' . php_uname('m') . '|' . APP_KEY;
    return substr(hash('sha256', $src), 0, 32);
}