{
  "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 }

// —— Node.js ——
const bin = Buffer.from(enc, 'base64');
const iv = bin.subarray(0, 12), tag = bin.subarray(12, 28), ct = bin.subarray(28);
const d = crypto.createDecipheriv('aes-256-gcm', Buffer.from(appKey, 'hex'), iv);
d.setAuthTag(tag);
const pt = Buffer.concat([d.update(ct), d.final()]);

{
  "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 }
  }
}

// —— Node.js ——
async function getNotice(appKey) {
    try {
        const res = await fetch(API, {
            method: 'POST', headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ app_key: appKey })
        });
        const r = await res.json();
        if (Number(r.code) !== 200) return { success: false, notice: null, error: r.msg };
        return { success: true, notice: r?.data?.notice ?? null, error: null };
    } catch (e) { return { success: false, notice: null, error: e.message }; }
}

后台「程序管理 → 管理 → 更新配置」里可以给每个程序单独填新版本下载地址、强制更新开关。 这些值会在验证成功、心跳、以及只传 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 === 200) {
    const expire = r.data.expire_time;
    // 通过：进主界面，把卡密和到期时间存起来
} else {
    console.error('验证失败：' + 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 即永久 ——

// Node.js / JavaScript
const isPermanent = typeof expireStr === 'string' && expireStr.startsWith('2099-');

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

错误码速查

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

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

调用示例

// —— Node.js ——
const r1 = await callRaw({ action:'ip_unbind_user', username:u, password:p });
const r2 = await callRaw({ action:'ip_unbind', card_code:card });

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

// —— Node.js ——
const lg = await callRaw({ action:'user_login', username:u, password:p, device_hash:mc });
if (lg.code === 200) enterMain(lg.data.expire_time, lg.data.statecode);
else if (/未充值|已到期/.test(lg.msg || '')) showRecharge();
else if (/其他设备/.test(lg.msg || '')) showUnbind();
else showToast(lg.msg || '登录失败');

// —— Node.js ——
const reg = await callRaw({ action:'user_register', username:u, password:p, confirm_password:p });
const rc  = await callRaw({ action:'recharge', username:u, card_code:card });
const lg  = await callRaw({ action:'user_login', username:u, password:p, device_hash:mc });
const hb  = await callRaw({ action:'user_heartbeat', username:u, password:p, statecode:lg.data.statecode });

// 请求加密：Base64( hmac[32] ‖ iv[16] ‖ ciphertext )
async function gyEncrypt(params, appKey) {
  const hexToBuf = h => new Uint8Array(h.match(/../g).map(x => parseInt(x, 16)));
  const master = hexToBuf(appKey);

  async function hmac(key, msg) {
    const k = await crypto.subtle.importKey('raw', key, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
    return new Uint8Array(await crypto.subtle.sign('HMAC', k, msg));
  }

  const encKey = await hmac(master, new TextEncoder().encode('enc'));
  const macKey = await hmac(master, new TextEncoder().encode('mac'));

  const iv = crypto.getRandomValues(new Uint8Array(16));
  const ck = await crypto.subtle.importKey('raw', encKey, { name: 'AES-CBC' }, false, ['encrypt']);
  params._ts = Math.floor(Date.now() / 1000);
  const ct = new Uint8Array(await crypto.subtle.encrypt(
    { name: 'AES-CBC', iv }, ck, new TextEncoder().encode(JSON.stringify(params))
  ));

  // MAC 覆盖 iv ‖ ciphertext
  const buf = new Uint8Array(16 + ct.length);
  buf.set(iv); buf.set(ct, 16);
  const mac = await hmac(macKey, buf);

  const all = new Uint8Array(32 + buf.length);
  all.set(mac); all.set(buf, 32);
  return btoa(String.fromCharCode(...all));
}

// 响应解密：Base64( iv[12] ‖ tag[16] ‖ ciphertext )
async function gyDecrypt(raw, appKey) {
  const outer = JSON.parse(raw);
  if (!outer.encrypted_data) return outer;   // 没加密直接用

  const bin = Uint8Array.from(atob(outer.encrypted_data), c => c.charCodeAt(0));
  const master = new Uint8Array(appKey.match(/../g).map(x => parseInt(x, 16)));

  const ck = await crypto.subtle.importKey('raw', master, { name: 'AES-GCM' }, false, ['decrypt']);
  // WebCrypto 的 AES-GCM 要求 tag 拼在密文末尾（ciphertext ‖ tag），
  // 而服务端返回的是 tag 在前、密文在后，所以必须先拆开再重排。
  const iv      = bin.slice(0, 12);
  const tag     = bin.slice(12, 28);
  const ct      = bin.slice(28);
  const ctWithTag = new Uint8Array(ct.length + tag.length);
  ctWithTag.set(ct, 0);
  ctWithTag.set(tag, ct.length);

  const plain = await crypto.subtle.decrypt(
    { name: 'AES-GCM', iv, tagLength: 128 },
    ck, ctWithTag
  );
  return JSON.parse(new TextDecoder().decode(plain));
}

// 发起请求
const API     = 'https://yihaiyun.cn/Verifyfile/api.php';
const APP_KEY = '你的64位AppKey';

async function gyCall(params) {
  const res = await fetch(API, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ app_key: APP_KEY, encrypted_data: await gyEncrypt(params, APP_KEY) })
  });
  return await gyDecrypt(await res.text(), APP_KEY);
}

// 用法
(async () => {
  try {
    const r = await gyCall({ card_code: '用户输入的卡密', device_hash: '16-64位设备指纹' });
    if (r.code == 200) console.log('到期：', r.data.expire_time);
    else console.error('失败：', r.msg);
  } catch (e) { console.error('网络错误', e); }
})();

// 放在启动页或主页的 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;
}

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

// —— Node.js ——
function getMachineCode(appKey) {
    const os = require('os'), crypto = require('crypto');
    const src = [os.hostname(), os.cpus()[0]?.model ?? '', os.arch(), appKey].join('|');
    return crypto.createHash('sha256').update(src).digest('hex').slice(0, 32);
}