接入文档

import java.net.URI;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import java.util.*;

public class QuickStart {
    static final String APPKEY = "nkxxxx", SECRET = "你的AppSecret";   // 控制台创建软件后获得
    static final String API = "https://app.netccheck.tech/api/v1";
    static final HttpClient HTTP = HttpClient.newHttpClient();
    // SignModule.sign / verifyRsign 来自官方签名模块（获取方式见文末「签名模块」）

    static String call(String path, String... kv) throws Exception {
        Map<String, String> body = new TreeMap<>();               // 含 appkey/time/nonce + 业务参数
        body.put("appkey", APPKEY);
        body.put("time", String.valueOf(System.currentTimeMillis() / 1000));
        body.put("nonce", UUID.randomUUID().toString().replace("-", ""));
        for (int i = 0; i < kv.length; i += 2) body.put(kv[i], kv[i + 1]);
        body.put("sign", SignModule.sign(body, SECRET));
        StringBuilder json = new StringBuilder("{");
        for (var e : body.entrySet()) json.append('"').append(e.getKey()).append("\":\"")
                .append(e.getValue().replace("\\", "\\\\").replace("\"", "\\\"")).append("\",");
        json.setCharAt(json.length() - 1, '}');
        HttpRequest req = HttpRequest.newBuilder(URI.create(API + path))
                .header("Content-Type", "application/json")
                .header("User-Agent", "NetcCheck-SDK/1.0")       // 必设：默认 UA 会被 CF 拦截
                .POST(HttpRequest.BodyPublishers.ofString(json.toString())).build();
        String resp = HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body();
        if (!SignModule.verifyRsign(resp, body.get("nonce"), SECRET))  // 200 必须验签：假服务器立即中止
            throw new IllegalStateException("响应验签失败（疑似假服务器）");
        return resp;
    }

    public static void main(String[] args) throws Exception {
        String info = call("/app/info", "ver", "1.0.0");          // 启动：公告 + 强更结论
        if (info.contains("\"need_update\":true"))                // 生产请用 JSON 库
            throw new IllegalStateException("发现新版本，请先更新");
        System.out.println(call("/user/register", "username", "tom",
                "password", "123456"));               // 首次运行先注册（已存在返回 411，忽略即可）
        System.out.println(call("/user/login", "username", "tom",
                "password", "123456", "machine", "PC-01"));
    }
}

import java.net.URI
import java.net.http.*
import java.nio.charset.StandardCharsets
import java.util.*

val APPKEY = "nkxxxx"                            // 控制台创建软件后获得
val SECRET = "你的AppSecret"
val API = "https://app.netccheck.tech/api/v1"
val HTTP = HttpClient.newHttpClient()

// SignModule.sign / verifyRsign 来自官方签名模块（获取方式见文末「签名模块」）

fun call(path: String, vararg kv: Pair<String, String>): String {
    val body = sortedMapOf(
        "appkey" to APPKEY,
        "time" to (System.currentTimeMillis() / 1000).toString(),
        "nonce" to UUID.randomUUID().toString().replace("-", ""),
        *kv
    )
    body["sign"] = SignModule.sign(body, SECRET)
    val json = body.entries.joinToString(",", "{", "}") {
        "\"${it.key}\":\"${it.value.replace("\\", "\\\\").replace("\"", "\\\"")}\""
    }
    val req = HttpRequest.newBuilder(URI.create(API + path))
        .header("Content-Type", "application/json")
        .header("User-Agent", "NetcCheck-SDK/1.0")   // 必设：默认 UA 会被 CF 拦截
        .POST(HttpRequest.BodyPublishers.ofString(json)).build()
    val resp = HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body()
    check(SignModule.verifyRsign(resp, body["nonce"]!!, SECRET)) { "响应验签失败（疑似假服务器）" }  // 200 必须验签
    return resp
}

fun main() {
    val info = call("/app/info", "ver" to "1.0.0")               // 启动：公告 + 强更结论
    if ("\"need_update\":true" in info)                           // 生产请用 JSON 库
        error("发现新版本，请先更新")
    println(call("/user/register", "username" to "tom", "password" to "123456"))  // 首次运行先注册（已存在 411 忽略）
    println(call("/user/login", "username" to "tom", "password" to "123456", "machine" to "PC-01"))
}

// .NET 6+：零第三方依赖（JSON 为极简拼接，生产环境建议 System.Text.Json）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;

class QuickStart {
    const string APPKEY = "nkxxxx", SECRET = "你的AppSecret";   // 控制台创建软件后获得
    const string API = "https://app.netccheck.tech/api/v1";
    static readonly HttpClient HTTP = new HttpClient();

    // 签名：与官方签名模块同规则——除 sign 外全部参数按名升序 k=v 用 & 连接，末尾拼 &key=SECRET，HMAC-SHA256 hex 小写
    static string Sign(SortedDictionary<string, string> p, string secret) {
        string bas = string.Join("&", p.Where(x => x.Key != "sign").Select(x => x.Key + "=" + x.Value)) + "&key=" + secret;
        using var h = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
        return BitConverter.ToString(h.ComputeHash(Encoding.UTF8.GetBytes(bas))).Replace("-", "").ToLower();
    }

    // 最小提取响应 JSON 顶层字段（示例版；生产环境请用 JSON 库）
    static string JGet(string s, string k) {
        int i = s.IndexOf("\"" + k + "\":", StringComparison.Ordinal);
        if (i < 0) return "";
        i += k.Length + 3;
        if (i < s.Length && s[i] == '"') { int e = s.IndexOf('"', i + 1); return e < 0 ? "" : s.Substring(i + 1, e - i - 1); }
        int j = s.IndexOfAny(new[] { ',', '}' }, i);
        return j < 0 ? "" : s.Substring(i, j - i);
    }

    // 响应验签：rsign = HMAC-SHA256(secret, "ncrs|nonce|code|msg")。200 响应必须验签，失败立即中止
    static void VerifyRsign(string resp, string nonce, string secret) {
        using var h = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
        string expect = BitConverter.ToString(h.ComputeHash(Encoding.UTF8.GetBytes(
            "ncrs|" + nonce + "|" + JGet(resp, "code") + "|" + JGet(resp, "msg")))).Replace("-", "").ToLower();
        if (expect != JGet(resp, "rsign").ToLower())
            throw new Exception("响应验签失败（疑似假服务器）");
    }

    static string Esc(string v) => v.Replace("\\", "\\\\").Replace("\"", "\\\"");

    static string Call(string path, params string[] kv) {
        var body = new SortedDictionary<string, string> {   // SortedDictionary 自动按参数名排序
            { "appkey", APPKEY },
            { "time", ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeSeconds().ToString() },
            { "nonce", Guid.NewGuid().ToString("N") }
        };
        for (int i = 0; i < kv.Length; i += 2) body[kv[i]] = kv[i + 1];
        body["sign"] = Sign(body, SECRET);
        string json = "{" + string.Join(",", body.Select(e => "\"" + e.Key + "\":\"" + Esc(e.Value) + "\"")) + "}";
        using var resp = HTTP.PostAsync(API + path, new StringContent(json, Encoding.UTF8, "application/json")).Result;
        string text = resp.Content.ReadAsStringAsync().Result;
        VerifyRsign(text, body["nonce"], SECRET);
        return text;
    }

    public static void Main() {
        Console.WriteLine(Call("/app/info", "ver", "1.0.0"));                        // 启动：公告 + 强更结论
        Console.WriteLine(Call("/user/register", "username", "tom", "password", "123456")); // 首次运行先注册（已存在 411 忽略）
        Console.WriteLine(Call("/user/login", "username", "tom", "password", "123456", "machine", "PC-01"));
    }
}

// Windows（VS2019+ / MinGW-w64）：WinHTTP 请求 + CNG 签名验签
// 编译（MSVC）：cl /EHsc /utf-8 qs.cpp winhttp.lib bcrypt.lib
// 编译（MinGW）：g++ qs.cpp -lwinhttp -lbcrypt -std=c++17
#include 
#include 
#include 
#include 
#include 

// Java 11+：javax.crypto 自带 AES-GCM，无需第三方库
static final byte[] KEY = hexToBytes("控制台64位hex加密密钥");   // 32 字节

static byte[] hexToBytes(String hex) {
    byte[] out = new byte[hex.length() / 2];
    for (int i = 0; i < out.length; i++)
        out[i] = (byte) Integer.parseInt(hex.substring(i * 2, i * 2 + 2), 16);
    return out;
}

/** 返回 {iv, data}；Java 的 GCM doFinal 自动把 16 字节 Tag 拼在密文尾部 */
static String[] encrypt(String json) throws Exception {
    byte[] iv = new byte[12];
    new SecureRandom().nextBytes(iv);
    Cipher c = Cipher.getInstance("AES/GCM/NoPadding");
    c.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(KEY, "AES"), new GCMParameterSpec(128, iv));
    return new String[]{ Base64.getEncoder().encodeToString(iv),
                         Base64.getEncoder().encodeToString(c.doFinal(json.getBytes(StandardCharsets.UTF_8))) };
}

static String decrypt(String ivB64, String dataB64) throws Exception {
    Cipher c = Cipher.getInstance("AES/GCM/NoPadding");
    c.init(Cipher.DECRYPT_MODE, new SecretKeySpec(KEY, "AES"),
           new GCMParameterSpec(128, Base64.getDecoder().decode(ivB64)));
    return new String(c.doFinal(Base64.getDecoder().decode(dataB64)), StandardCharsets.UTF_8);
}

// JVM 自带 AES-GCM，无需第三方库
val KEY = hexToBytes("控制台64位hex加密密钥")   // 32 字节

fun hexToBytes(hex: String): ByteArray {
    val out = ByteArray(hex.length / 2)
    for (i in out.indices) out[i] = hex.substring(i * 2, i * 2 + 2).toInt(16).toByte()
    return out
}

/** 返回 (iv, data)；JVM 的 GCM doFinal 自动把 16 字节 Tag 拼在密文尾部 */
fun encrypt(json: String): Pair<String, String> {
    val iv = ByteArray(12).also { SecureRandom().nextBytes(it) }
    val c = Cipher.getInstance("AES/GCM/NoPadding")
    c.init(Cipher.ENCRYPT_MODE, SecretKeySpec(KEY, "AES"), GCMParameterSpec(128, iv))
    return Base64.getEncoder().encodeToString(iv) to                            // iv
           Base64.getEncoder().encodeToString(c.doFinal(json.toByteArray()))    // data = 密文+Tag
}

fun decrypt(ivB64: String, dataB64: String): String {
    val c = Cipher.getInstance("AES/GCM/NoPadding")
    c.init(Cipher.DECRYPT_MODE, SecretKeySpec(KEY, "AES"),
           GCMParameterSpec(128, Base64.getDecoder().decode(ivB64)))
    return String(c.doFinal(Base64.getDecoder().decode(dataB64)))
}

// .NET 6+：内置 AesGcm，零第三方依赖
using System;
using System.Linq;
using System.Security.Cryptography;
using System.Text;

static class AesUtil {
    const string KEY = "控制台64位hex加密密钥";   // 32 字节

    // 返回 (iv, data)：data = base64(密文+16字节Tag)，与服务端及各语言示例一致
    public static Tuple<string, string> Encrypt(string json) {
        byte[] key = Convert.FromHexString(KEY), iv = new byte[12];
        RandomNumberGenerator.Fill(iv);
        byte[] pt = Encoding.UTF8.GetBytes(json), ct = new byte[pt.Length], tag = new byte[16];
        using var g = new AesGcm(key, 16);
        g.Encrypt(iv, pt, ct, tag);
        return Tuple.Create(Convert.ToBase64String(iv), Convert.ToBase64String(ct.Concat(tag).ToArray()));
    }

    public static string Decrypt(string ivB64, string dataB64) {
        byte[] key = Convert.FromHexString(KEY);
        byte[] all = Convert.FromBase64String(dataB64), iv = Convert.FromBase64String(ivB64);
        byte[] ct = all.Take(all.Length - 16).ToArray(), tag = all.Skip(all.Length - 16).ToArray();
        byte[] pt = new byte[ct.Length];
        using var g = new AesGcm(key, 16);
        g.Decrypt(iv, ct, tag, pt);   // 密文被改/密钥错时抛异常
        return Encoding.UTF8.GetString(pt);
    }
}

// CNG AES-256-GCM：data = base64(密文+16字节Tag)，与服务端及各语言示例一致（Windows 自带，零第三方依赖）
#include <windows.h>
#include <bcrypt.h>
#include <string>
#include <vector>
#pragma comment(lib, "bcrypt.lib")

static const std::string B64T = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

static std::string B64(const unsigned char* d, int n) {
    std::string o;
    for (int i = 0; i < n; i += 3) {
        int left = n - i;
        unsigned v = (unsigned)d[i] << 16 | (left > 1 ? (unsigned)d[i + 1] << 8 : 0) | (left > 2 ? d[i + 2] : 0);
        o.push_back(B64T[(v >> 18) & 63]); o.push_back(B64T[(v >> 12) & 63]);
        o.push_back(left > 1 ? B64T[(v >> 6) & 63] : '='); o.push_back(left > 2 ? B64T[v & 63] : '=');
    }
    return o;
}

static std::vector<unsigned char> UnB64(const std::string& s) {
    auto V = [](char c) -> int {
        if (c >= 'A' && c <= 'Z') return c - 'A';
        if (c >= 'a' && c <= 'z') return c - 'a' + 26;
        if (c >= '0' && c <= '9') return c - '0' + 52;
        if (c == '+') return 62; if (c == '/') return 63; return -1;
    };
    std::vector<unsigned char> o; int acc = 0, bits = 0;
    for (char c : s) { int v = V(c); if (v < 0) continue; acc = (acc << 6) | v; bits += 6;
        if (bits >= 8) { bits -= 8; o.push_back((acc >> bits) & 255); } }
    return o;
}

static std::string HexToRaw(const std::string& hex) {
    auto V = [](char c) -> int { return c <= '9' ? c - '0' : (c | 32) - 'a' + 10; };
    std::string o; for (size_t i = 0; i + 1 < hex.size(); i += 2) o.push_back((char)((V(hex[i]) << 4) | V(hex[i + 1])));
    return o;
}

// GCM 一次加密：返回 false = 参数/环境错误；tag 16 字节拼在密文尾部由调用方 base64
static bool AesGcm(const std::string& key32, const unsigned char iv[12],
                   const std::string& in, std::string& out, unsigned char tag[16], bool decrypt) {
    BCRYPT_ALG_HANDLE alg = nullptr; BCRYPT_KEY_HANDLE k = nullptr;
    bool ok = false;
    if (BCryptOpenAlgorithmProvider(&alg, BCRYPT_AES_ALGORITHM, nullptr, 0) == 0
        && BCryptSetProperty(alg, BCRYPT_CHAINING_MODE, (PUCHAR)BCRYPT_CHAIN_MODE_GCM,
                             sizeof(BCRYPT_CHAIN_MODE_GCM), 0) == 0
        && BCryptGenerateSymmetricKey(alg, &k, nullptr, 0, (PUCHAR)key32.data(), (ULONG)key32.size(), 0) == 0) {
        BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO info;
        BCRYPT_INIT_AUTH_MODE_INFO(info);
        info.pbNonce = (PUCHAR)iv; info.cbNonce = 12; info.pbTag = tag; info.cbTag = 16;
        ULONG done = 0;
        out.resize(in.size());
        ok = decrypt ? BCryptDecrypt(k, (PUCHAR)in.data(), (ULONG)in.size(), &info,
                                     nullptr, 0, (PUCHAR)out.data(), (ULONG)out.size(), &done, 0) == 0
                     : BCryptEncrypt(k, (PUCHAR)in.data(), (ULONG)in.size(), &info,
                                     nullptr, 0, (PUCHAR)out.data(), (ULONG)out.size(), &done, 0) == 0;
        // 解密时 Tag 不匹配（密文被改/密钥错）会返回 AUTH_TAG_FAILURE，ok=false
        out.resize(done);
    }
    if (k) BCryptDestroyKey(k);
    if (alg) BCryptCloseAlgorithmProvider(alg, 0);
    return ok;
}

import java.net.URI;
import java.net.http.*;
import java.util.*;

/** 设备会话 · Java：call 与基础示例同构，唯一差异是签名密钥改为参数（AppSecret / deviceSecret / sessionKey） */
public class DeviceSession {
    static final String APPKEY = "nkxxxx", APPSECRET = "你的AppSecret";   // strict 下 APPSECRET 仅用于注册设备
    static final String API = "https://app.netccheck.tech/api/v1";
    static final HttpClient HTTP = HttpClient.newHttpClient();

    static String call(String path, String key, String... kv) throws Exception {
        Map<String, String> body = new TreeMap<>();
        body.put("appkey", APPKEY);
        body.put("time", String.valueOf(System.currentTimeMillis() / 1000));
        body.put("nonce", UUID.randomUUID().toString().replace("-", ""));
        for (int i = 0; i < kv.length; i += 2) body.put(kv[i], kv[i + 1]);
        body.put("sign", SignModule.sign(body, key));
        StringBuilder json = new StringBuilder("{");
        for (var e : body.entrySet()) json.append('"').append(e.getKey()).append("\":\"")
                .append(e.getValue().replace("\\", "\\\\").replace("\"", "\\\"")).append("\",");
        json.setCharAt(json.length() - 1, '}');
        HttpRequest req = HttpRequest.newBuilder(URI.create(API + path))
                .header("Content-Type", "application/json")
                .header("User-Agent", "NetcCheck-SDK/1.0")
                .POST(HttpRequest.BodyPublishers.ofString(json.toString())).build();
        String resp = HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body();
        if (!SignModule.verifyRsign(resp, body.get("nonce"), key))   // 密钥跟随当前签名密钥
            throw new IllegalStateException("响应验签失败（疑似假服务器）");
        return resp;
    }

    /** 最小提取响应 JSON 顶层字段（生产请用 JSON 库） */
    static String jget(String s, String k) {
        var m = java.util.regex.Pattern.compile("\"" + k + "\":\"?([^,}\"]+)").matcher(s);
        return m.find() ? m.group(1) : "";
    }

    public static void main(String[] args) throws Exception {
        // ① 注册设备（AppSecret 仅此一步；同机重复注册幂等换发新密钥）
        String enr = call("/device/enroll", APPSECRET, "username", "tom", "password", "123456",
                "machine", "PC-01", "device_name", "我的电脑");
        String did = jget(enr, "deviceId"), dsec = jget(enr, "deviceSecret");
        // ② 换取短时会话（两次签发需间隔 10 秒以上，服务端防刷）
        String s = call("/device/session", dsec, "deviceId", did);
        String sid = jget(s, "sessionId"), skey = jget(s, "sessionKey");
        // ③ 会话内业务：签名与验签都用 sessionKey；收到 401 重签一次再试（多线程共用需加锁）
        System.out.println(call("/user/login", skey, "sid", sid,
                "username", "tom", "password", "123456", "machine", "PC-01"));
        // ④ 作者可在控制台「设备」页随时吊销该设备
    }
}

import java.net.URI
import java.net.http.*
import java.util.*

// 设备会话 · Kotlin：call 与基础示例同构，唯一差异是签名密钥改为参数
val APPKEY = "nkxxxx"                            // strict 下 APPSECRET 仅用于注册设备
val APPSECRET = "你的AppSecret"
val API = "https://app.netccheck.tech/api/v1"
val HTTP = HttpClient.newHttpClient()

fun call(path: String, key: String, vararg kv: Pair<String, String>): String {
    val body = sortedMapOf(
        "appkey" to APPKEY,
        "time" to (System.currentTimeMillis() / 1000).toString(),
        "nonce" to UUID.randomUUID().toString().replace("-", ""),
        *kv
    )
    body["sign"] = SignModule.sign(body, key)
    val json = body.entries.joinToString(",", "{", "}") {
        "\"${it.key}\":\"${it.value.replace("\\", "\\\\").replace("\"", "\\\"")}\""
    }
    val req = HttpRequest.newBuilder(URI.create(API + path))
        .header("Content-Type", "application/json")
        .header("User-Agent", "NetcCheck-SDK/1.0")
        .POST(HttpRequest.BodyPublishers.ofString(json)).build()
    val resp = HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body()
    check(SignModule.verifyRsign(resp, body["nonce"]!!, key)) { "响应验签失败（疑似假服务器）" }
    return resp
}

fun jget(s: String, k: String): String =           // 最小提取顶层字段（生产请用 JSON 库）
    Regex("\"$k\":\"?([^,}\"]+)").find(s)?.groupValues?.get(1) ?: ""

fun main() {
    // ① 注册设备（AppSecret 仅此一步；同机重复注册幂等换发新密钥）
    val enr = call("/device/enroll", APPSECRET, "username" to "tom", "password" to "123456",
            "machine" to "PC-01", "device_name" to "我的电脑")
    val did = jget(enr, "deviceId"); val dsec = jget(enr, "deviceSecret")
    // ② 换取短时会话（两次签发需间隔 10 秒以上，服务端防刷）
    val sess = call("/device/session", dsec, "deviceId" to did)
    val sid = jget(sess, "sessionId"); val skey = jget(sess, "sessionKey")
    // ③ 会话内业务：签名与验签都用 sessionKey；收到 401 重签一次再试（多线程共用需加锁）
    println(call("/user/login", skey, "sid" to sid,
            "username" to "tom", "password" to "123456", "machine" to "PC-01"))
    // ④ 作者可在控制台「设备」页随时吊销该设备
}

// 设备会话 · C#：Call 与基础示例同构，唯一差异是签名密钥改为参数（AppSecret / deviceSecret / sessionKey）
// Sign / JGet / VerifyRsign / Esc 复制「最小可运行示例 · C#」；JSON 为极简拼接，生产建议 System.Text.Json
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;

class DeviceSession {
    const string APPKEY = "nkxxxx", APPSECRET = "你的AppSecret";   // strict 下 APPSECRET 仅用于注册设备
    const string API = "https://app.netccheck.tech/api/v1";
    static readonly HttpClient HTTP = new HttpClient();

    static string Call(string path, string key, params string[] kv) {
        var body = new SortedDictionary<string, string> {
            { "appkey", APPKEY },
            { "time", ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeSeconds().ToString() },
            { "nonce", Guid.NewGuid().ToString("N") }
        };
        for (int i = 0; i < kv.Length; i += 2) body[kv[i]] = kv[i + 1];
        body["sign"] = Sign(body, key);
        string json = "{" + string.Join(",", body.Select(e => "\"" + e.Key + "\":\"" + Esc(e.Value) + "\"")) + "}";
        using var resp = HTTP.PostAsync(API + path, new StringContent(json, Encoding.UTF8, "application/json")).Result;
        string text = resp.Content.ReadAsStringAsync().Result;
        VerifyRsign(text, body["nonce"], key);
        return text;
    }

    public static void Main() {
        // ① 注册设备（AppSecret 仅此一步；同机重复注册幂等换发新密钥）
        string enr = Call("/device/enroll", APPSECRET, "username", "tom", "password", "123456",
                "machine", Environment.MachineName, "device_name", "我的电脑");
        string did = JGet(enr, "deviceId"); string dsec = JGet(enr, "deviceSecret");
        // ② 换取短时会话（两次签发需间隔 10 秒以上，服务端防刷）
        string sess = Call("/device/session", dsec, "deviceId", did);
        string sid = JGet(sess, "sessionId"); string skey = JGet(sess, "sessionKey");
        // ③ 会话内业务：签名与验签都用 sessionKey；收到 401 重签一次再试（多线程共用需加锁）
        Console.WriteLine(Call("/user/login", skey, "sid", sid,
                "username", "tom", "password", "123456", "machine", Environment.MachineName));
        // ④ 作者可在控制台「设备」页随时吊销该设备
    }
}

// 设备会话 · C++：Call 与最小示例同构，唯一差异是签名密钥作为参数传入（AppSecret / deviceSecret / sessionKey）
// 公共代码（Hmac/Sign/Post/JGet/Esc）复制「最小可运行示例 · C++」，编译参数相同
int main() {
    // ① 注册设备（AppSecret 仅此一步；同机重复注册幂等换发新密钥）
    std::string enr = Call("/device/enroll", {},
        "\"username\":\"tom\",\"password\":\"123456\",\"machine\":\"PC-01\",\"device_name\":\"我的电脑\"", SECRET);
    std::string did = JGet(enr, "deviceId"), dsec = JGet(enr, "deviceSecret");
    // ② 换取短时会话（两次签发需间隔 10 秒以上，服务端防刷）
    std::string sess = Call("/device/session", {}, "\"deviceId\":\"" + Esc(did) + "\"", dsec);
    std::string sid = JGet(sess, "sessionId"), skey = JGet(sess, "sessionKey");
    // ③ 会话内业务：签名与验签都用 sessionKey；收到 401 重签一次再试（多线程共用需加锁）
    std::cout << Call("/user/login", { {"sid", sid} },
        "\"username\":\"tom\",\"password\":\"123456\",\"machine\":\"PC-01\"", skey) << "\n";
    // ④ 作者可在控制台「设备」页随时吊销该设备
    return 0;
}

// 与「设备会话 · Java」唯一差异：① 用 /card/enroll（card_key+machine，无需账号）；② /card/session 换会话；
// ③ 复查带 sid 免 card_key/machine。call()/jget() 与该节完全一致，此处仅展示流程差异
public static void main(String[] args) throws Exception {
    String CARD_KEY = "NCCK-XXXX-XXXX-XXXX", MACHINE = "CARD-PC-01";
    // ① 注册卡设备（未激活的卡在此步完成激活；同卡同机重跑幂等换发）
    String enr = call("/card/enroll", APPSECRET, "card_key", CARD_KEY,
            "machine", MACHINE, "device_name", "卡测试机");
    String did = jget(enr, "deviceId"), dsec = jget(enr, "deviceSecret");
    // ② 换短时会话；③ 定期复查：sid 即凭证
    String sess = call("/card/session", dsec, "deviceId", did);
    String sid = jget(sess, "sessionId"), skey = jget(sess, "sessionKey");
    String st = call("/card/login", skey, "sid", sid);
    System.out.println("剩余秒数: " + jget(st, "remaining"));   // 412=过期/次数用尽 416=封禁/被吊销 → 立即退出
}

// 与「设备会话 · Kotlin」唯一差异：① /card/enroll（card_key+machine，无需账号）；② /card/session；
// ③ 复查带 sid 免 card_key/machine。call()/jget() 与该节完全一致，此处仅展示流程差异
fun main() {
    val cardKey = "NCCK-XXXX-XXXX-XXXX"; val machine = "CARD-PC-01"
    // ① 注册卡设备（未激活的卡在此步完成激活；同卡同机重跑幂等换发）
    val enr = call("/card/enroll", APPSECRET, "card_key" to cardKey,
            "machine" to machine, "device_name" to "卡测试机")
    val did = jget(enr, "deviceId"); val dsec = jget(enr, "deviceSecret")
    // ② 换短时会话；③ 定期复查：sid 即凭证
    val sess = call("/card/session", dsec, "deviceId" to did)
    val sid = jget(sess, "sessionId"); val skey = jget(sess, "sessionKey")
    val st = call("/card/login", skey, "sid" to sid)
    println("剩余秒数: " + jget(st, "remaining"))   // 412=过期/次数用尽 416=封禁/被吊销 → 立即退出
}

// 与「设备会话 · C#」唯一差异：① /card/enroll（card_key+machine，无需账号）；② /card/session；
// ③ 复查带 sid 免 card_key/machine。Call()/JGet() 与该节完全一致，此处仅展示流程差异
public static void Main() {
    const string CARD_KEY = "NCCK-XXXX-XXXX-XXXX", MACHINE = "CARD-PC-01";
    // ① 注册卡设备（未激活的卡在此步完成激活；同卡同机重跑幂等换发）
    string enr = Call("/card/enroll", APPSECRET, "card_key", CARD_KEY,
            "machine", MACHINE, "device_name", "卡测试机");
    string did = JGet(enr, "deviceId"); string dsec = JGet(enr, "deviceSecret");
    // ② 换短时会话；③ 定期复查：sid 即凭证
    string sess = Call("/card/session", dsec, "deviceId", did);
    string sid = JGet(sess, "sessionId"); string skey = JGet(sess, "sessionKey");
    string st = Call("/card/login", skey, "sid", sid);
    Console.WriteLine("剩余秒数: " + JGet(st, "remaining"));   // 412=过期/次数用尽 416=封禁/被吊销 → 立即退出
}

// 与「设备会话 · C++」唯一差异：① /card/enroll（card_key+machine，无需账号）；② /card/session；
// ③ 复查带 sid 免 card_key/machine。公共代码与该节完全一致，此处仅展示流程差异
int main() {
    const char* CARD_KEY = "NCCK-XXXX-XXXX-XXXX"; const char* MACHINE = "CARD-PC-01";
    std::string bk = std::string("\"card_key\":\"") + CARD_KEY + "\",\"machine\":\"" + MACHINE + "\",\"device_name\":\"卡测试机\"";
    // ① 注册卡设备（未激活的卡在此步完成激活；同卡同机重跑幂等换发）
    std::string enr = Call("/card/enroll", {}, bk, SECRET);
    std::string did = JGet(enr, "deviceId"), dsec = JGet(enr, "deviceSecret");
    // ② 换短时会话；③ 定期复查：sid 即凭证
    std::string sess = Call("/card/session", {}, "\"deviceId\":\"" + Esc(did) + "\"", dsec);
    std::string sid = JGet(sess, "sessionId"), skey = JGet(sess, "sessionKey");
    std::string st = Call("/card/login", { {"sid", sid} }, "", skey);
    std::cout << "剩余秒数: " << JGet(st, "remaining") << "\n";   // 412=过期/次数用尽 416=封禁/被吊销 → 立即退出
    return 0;
}

import java.net.URI;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import java.util.*;

/** NetcCheck 基础接入（零依赖示例；生产环境建议引入 Jackson/Gson 处理 JSON） */
public class NetcCheck {
    static final String APPKEY = "nkxxxx", SECRET = "你的AppSecret";
    static final String API = "https://app.netccheck.tech/api/v1";
    static final HttpClient HTTP = HttpClient.newHttpClient();

    // SignModule.sign / verifyRsign 来自官方签名模块（获取方式见文末「签名模块」）

    /** 发起请求：kv 为业务参数键值对（成对传入），返回原始 JSON 文本 */
    static String call(String path, String... kv) throws Exception {
        Map<String, String> body = new TreeMap<>();
        body.put("appkey", APPKEY);
        body.put("time", String.valueOf(System.currentTimeMillis() / 1000));
        body.put("nonce", UUID.randomUUID().toString().replace("-", ""));
        for (int i = 0; i < kv.length; i += 2) body.put(kv[i], kv[i + 1]);
        body.put("sign", SignModule.sign(body, SECRET));
        StringBuilder json = new StringBuilder("{");
        for (var e : body.entrySet()) json.append('"').append(e.getKey()).append("\":\"")
                .append(e.getValue().replace("\\", "\\\\").replace("\"", "\\\"")).append("\",");
        json.setCharAt(json.length() - 1, '}');
        HttpRequest req = HttpRequest.newBuilder(URI.create(API + path))
                .header("Content-Type", "application/json")
                .header("User-Agent", "NetcCheck-SDK/1.0")       // 必设：默认 UA 会被 CF 拦截
                .POST(HttpRequest.BodyPublishers.ofString(json.toString())).build();
        String resp = HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body();
        if (!SignModule.verifyRsign(resp, body.get("nonce"), SECRET))  // 200 必须验签：假服务器立即中止
            throw new IllegalStateException("响应验签失败（疑似假服务器）");
        return resp;
    }

    public static void main(String[] args) throws Exception {
        System.out.println(call("/app/info", "ver", "1.0.0"));                   // 1. 公告/版本/强更结论
        System.out.println(call("/user/register", "username", "tom", "password", "123456"));
        String login = call("/user/login", "username", "tom",                    // 3. 登录+机器码
                "password", "123456", "machine", "PC-01");
        System.out.println(login);
        String token = login.contains("\"token\"")                               // 生产请用 JSON 库
                ? login.split("\"token\":\"")[1].split("\"")[0] : "";
        System.out.println(call("/user/heartbeat", "token", token));             // 4. 心跳
        System.out.println(call("/var/get", "token", token, "key", "notice"));   // 5. 云变量
        System.out.println(call("/user/recharge", "username", "tom",             // 6. 充值
                "password", "123456", "card_key", "NCCK-XXXX-XXXX-XXXX"));
    }
}

import java.net.URI
import java.net.http.*
import java.nio.charset.StandardCharsets
import java.util.*

// NetcCheck 基础接入（零依赖示例；生产环境建议用 kotlinx.serialization 处理 JSON）
object NetcCheck {
    const val APPKEY = "nkxxxx"
    const val SECRET = "你的AppSecret"
    const val API = "https://app.netccheck.tech/api/v1"
    val HTTP = HttpClient.newHttpClient()

    // SignModule.sign / verifyRsign 来自官方签名模块（获取方式见文末「签名模块」）

    fun call(path: String, vararg kv: Pair<String, String>): String {
        val body = sortedMapOf(
            "appkey" to APPKEY,
            "time" to (System.currentTimeMillis() / 1000).toString(),
            "nonce" to UUID.randomUUID().toString().replace("-", ""),
            *kv
        )
        body["sign"] = SignModule.sign(body, SECRET)
        val json = body.entries.joinToString(",", "{", "}") {
            "\"${it.key}\":\"${it.value.replace("\\", "\\\\").replace("\"", "\\\"")}\""
        }
        val req = HttpRequest.newBuilder(URI.create(API + path))
            .header("Content-Type", "application/json")
            .header("User-Agent", "NetcCheck-SDK/1.0")   // 必设：默认 UA 会被 CF 拦截
            .POST(HttpRequest.BodyPublishers.ofString(json)).build()
        val resp = HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body()
        check(SignModule.verifyRsign(resp, body["nonce"]!!, SECRET)) { "响应验签失败（疑似假服务器）" }  // 200 必须验签
        return resp
    }
}

fun main() {
    println(NetcCheck.call("/app/info", "ver" to "1.0.0"))                        // 1. 公告/版本/强更结论
    println(NetcCheck.call("/user/register", "username" to "tom", "password" to "123456"))
    val login = NetcCheck.call("/user/login", "username" to "tom",                // 3. 登录+机器码
            "password" to "123456", "machine" to "PC-01")
    println(login)
    val token = Regex("\"token\":\"([0-9a-f]{64})\"").find(login)                 // 生产请用 JSON 库
        ?.groupValues?.get(1) ?: ""
    println(NetcCheck.call("/user/heartbeat", "token" to token))                  // 4. 心跳
    println(NetcCheck.call("/var/get", "token" to token, "key" to "notice"))      // 5. 云变量
    println(NetcCheck.call("/user/recharge", "username" to "tom",                 // 6. 充值
            "password" to "123456", "card_key" to "NCCK-XXXX-XXXX-XXXX"))
}

// NetcCheck 基础接入（零第三方依赖；JSON 为极简拼接，生产环境建议 System.Text.Json）
// QuickStart 的 Sign / JGet / VerifyRsign / Call 与「最小可运行示例 · C#」完全一致，此处复用
using System;

class NetcCheck {
    // ……复制 QuickStart 的 APPKEY/SECRET/Sign/JGet/VerifyRsign/Esc/Call 定义……

    public static void Main() {
        Console.WriteLine(Call("/app/info", "ver", "1.0.0"));                                // 1. 公告/版本/强更结论
        Console.WriteLine(Call("/user/register", "username", "tom", "password", "123456"));  // 2. 注册（已存在 411）
        string login = Call("/user/login", "username", "tom",                                // 3. 登录+机器码
                "password", "123456", "machine", "PC-01");
        Console.WriteLine(login);
        string token = JGet(login, "token");                                                 // 生产请用 JSON 库
        Console.WriteLine(Call("/user/heartbeat", "token", token));                          // 4. 心跳
        Console.WriteLine(Call("/var/get", "token", token, "key", "notice"));                // 5. 云变量
        Console.WriteLine(Call("/user/recharge", "username", "tom",                          // 6. 充值
                "password", "123456", "card_key", "NCCK-XXXX-XXXX-XXXX"));
    }
}

// NetcCheck 基础接入：Call/Sign/Hmac/Post/JGet 与「最小可运行示例 · C++」完全一致，此处复用
// 编译：cl /EHsc /utf-8 basic.cpp winhttp.lib bcrypt.lib   或   g++ basic.cpp -lwinhttp -lbcrypt -std=c++17
// ……复制最小示例的全部公共代码……

int main() {
    std::cout << Call("/app/info", {}, "\"ver\":\"1.0.0\"", SECRET) << "\n";                    // 1. 公告/版本/强更结论
    std::cout << Call("/user/register", {}, "\"username\":\"tom\",\"password\":\"123456\"", SECRET) << "\n";  // 2. 注册（已存在 411）
    std::string login = Call("/user/login", {}, "\"username\":\"tom\",\"password\":\"123456\",\"machine\":\"PC-01\"", SECRET);  // 3. 登录+机器码
    std::cout << login << "\n";
    std::string token = JGet(login, "token");
    std::cout << Call("/user/heartbeat", {}, "\"token\":\"" + Esc(token) + "\"", SECRET) << "\n";              // 4. 心跳
    std::cout << Call("/var/get", {}, "\"token\":\"" + Esc(token) + "\",\"key\":\"notice\"", SECRET) << "\n";  // 5. 云变量
    std::cout << Call("/user/recharge", {}, "\"username\":\"tom\",\"password\":\"123456\",\"card_key\":\"NCCK-XXXX-XXXX-XXXX\"", SECRET) << "\n";  // 6. 充值
    return 0;
}

import java.net.URI;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.*;
import java.util.regex.Pattern;
import javax.crypto.Cipher;
import javax.crypto.Mac;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/** NetcCheck 进阶接入：传输加密 + 机器码 + 心跳守护线程 + 错误分派（零依赖示例，JSON 用正则简析） */
public class NetcCheckPro {
    static final String APPKEY = "nkxxxx", SECRET = "你的AppSecret";
    static final String ENC_KEY_HEX = "";               // 控制台 64 位 hex 加密密钥，未开加密留空
    static final byte[] ENC_KEY = hexToBytes(ENC_KEY_HEX);
    static final String API = "https://app.netccheck.tech/api/v1";
    static final HttpClient HTTP = HttpClient.newHttpClient();
    static volatile String token = "";

    static byte[] hexToBytes(String hex) {
        byte[] out = new byte[hex.length() / 2];
        for (int i = 0; i < out.length; i++)
            out[i] = (byte) Integer.parseInt(hex.substring(i * 2, i * 2 + 2), 16);
        return out;
    }

    /** 机器码：主机名 + 用户名 SHA-256（推荐再混入硬件序列号，换机由作者后台重置） */
    static String machineCode() throws Exception {
        String raw = java.net.InetAddress.getLocalHost().getHostName() + "-" + System.getProperty("user.name");
        byte[] h = MessageDigest.getInstance("SHA-256").digest(raw.getBytes(StandardCharsets.UTF_8));
        StringBuilder sb = new StringBuilder();
        for (byte b : Arrays.copyOf(h, 16)) sb.append(String.format("%02x", b));
        return sb.toString();
    }

    // SignModule.sign / verifyRsign 来自官方签名模块（获取方式见文末「签名模块」）
    // 调用处：body.put("sign", SignModule.sign(body, SECRET));

    /** AES-256-GCM：返回 {iv, data}，data = base64(密文+Tag) */
    static String[] encrypt(String json) throws Exception {
        byte[] iv = new byte[12];
        new SecureRandom().nextBytes(iv);
        Cipher c = Cipher.getInstance("AES/GCM/NoPadding");
        c.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(ENC_KEY, "AES"), new GCMParameterSpec(128, iv));
        return new String[]{ Base64.getEncoder().encodeToString(iv),
                             Base64.getEncoder().encodeToString(c.doFinal(json.getBytes(StandardCharsets.UTF_8))) };
    }

    static String call(String path, String... kv) throws Exception {
        TreeMap<String, String> body = new TreeMap<>();
        body.put("appkey", APPKEY);
        body.put("time", String.valueOf(System.currentTimeMillis() / 1000));
        body.put("nonce", UUID.randomUUID().toString().replace("-", ""));
        for (int i = 0; i < kv.length; i += 2) body.put(kv[i], kv[i + 1]);
        if (ENC_KEY.length > 0) {                        // 开启加密：业务参数整体进密文（appkey 除外）
            StringBuilder biz = new StringBuilder("{");
            for (int i = 0; i < kv.length; i += 2)
                biz.append('"').append(kv[i]).append("\":\"")
                   .append(kv[i + 1].replace("\\", "\\\\").replace("\"", "\\\"")).append("\",");
            if (kv.length > 0) biz.setCharAt(biz.length() - 1, '}'); else biz.append('}');
            String[] enc = encrypt(biz.toString());
            body.put("enc", "1"); body.put("iv", enc[0]); body.put("data", enc[1]);
        }
        body.put("sign", SignModule.sign(body, SECRET)); // enc/iv/data 同样参与签名
        StringBuilder json = new StringBuilder("{");
        for (var e : body.entrySet()) json.append('"').append(e.getKey()).append("\":\"")
                .append(e.getValue().replace("\\", "\\\\").replace("\"", "\\\"")).append("\",");
        json.setCharAt(json.length() - 1, '}');
        HttpRequest req = HttpRequest.newBuilder(URI.create(API + path))
                .header("Content-Type", "application/json")
                .header("User-Agent", "NetcCheck-SDK/1.0")
                .POST(HttpRequest.BodyPublishers.ofString(json.toString())).build();
        String resp = HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body();
        if (!SignModule.verifyRsign(resp, body.get("nonce"), SECRET))  // 200 必须验签（rsign 在明文上，先验再解密）
            throw new IllegalStateException("响应验签失败（疑似假服务器）");
        return resp;
    }

    static int codeOf(String resp) {                     // 生产环境请用 JSON 库解析
        var m = Pattern.compile("\"code\"\\s*:\\s*(\\d+)").matcher(resp);
        return m.find() ? Integer.parseInt(m.group(1)) : -1;
    }

    /** 错误分派：业务性失败给出明确文案后退出（网络宽限只用于异常，不用于业务失败） */
    static void exitWith(int code) {
        String msg = switch (code) {
            case 410 -> "账号或密码错误"; case 412 -> "账号已过期，请续费";
            case 414 -> "机器码数量已达上限"; case 415 -> "登录态失效（可能被顶号）";
            case 416 -> "账号已封禁"; case 418 -> "软件授权已到期";
            case 429 -> "请求过于频繁"; case 430 -> "本月验证额度已用尽";
            default -> "验证失败(" + code + ")";
        };
        System.out.println(msg);
        System.exit(1);
    }

    public static void main(String[] args) throws Exception {
        String login = call("/user/login", "username", "tom",
                "password", "123456", "machine", machineCode());
        int code = codeOf(login);
        if (code != 200) { exitWith(code); return; }
        token = login.split("\"token\":\"")[1].split("\"")[0];
        Thread hb = new Thread(() -> {                   // 心跳守护线程：每 10 分钟
            int fails = 0;
            while (true) {
                try {
                    String r = call("/user/heartbeat", "token", token);
                    int c = codeOf(r);
                    if (c != 200) { exitWith(c); return; }
                    fails = 0;
                    Thread.sleep(600_000);
                } catch (InterruptedException e) { return; }
                  catch (Exception e) { if (++fails >= 3) exitWith(-1); }   // 网络彻底不可达：必须终止业务，而非只退出线程
            }
        });
        hb.setDaemon(true);
        hb.start();
        System.out.println("验证通过，业务逻辑运行中…");      // ……你的业务代码
        Thread.sleep(Long.MAX_VALUE);
    }
}

import java.net.URI
import java.net.http.*
import java.nio.charset.StandardCharsets
import java.security.MessageDigest
import java.security.SecureRandom
import java.util.*
import java.util.regex.Pattern
import javax.crypto.Cipher
import javax.crypto.Mac
import javax.crypto.spec.GCMParameterSpec
import javax.crypto.spec.SecretKeySpec
import kotlin.concurrent.thread

// NetcCheck 进阶接入：传输加密 + 机器码 + 心跳守护线程 + 错误分派（零依赖示例，JSON 用正则简析）
object NetcCheckPro {
    const val APPKEY = "nkxxxx"
    const val SECRET = "你的AppSecret"
    const val ENC_KEY_HEX = ""                       // 控制台 64 位 hex 加密密钥，未开加密留空
    val ENC_KEY = hexToBytes(ENC_KEY_HEX)
    const val API = "https://app.netccheck.tech/api/v1"
    val HTTP = HttpClient.newHttpClient()
    @Volatile var token = ""

    fun hexToBytes(hex: String): ByteArray {
        val out = ByteArray(hex.length / 2)
        for (i in out.indices) out[i] = hex.substring(i * 2, i * 2 + 2).toInt(16).toByte()
        return out
    }

    /** 机器码：主机名 + 用户名 SHA-256（推荐再混入硬件序列号） */
    fun machineCode(): String {
        val raw = java.net.InetAddress.getLocalHost().hostName + "-" + System.getProperty("user.name")
        return MessageDigest.getInstance("SHA-256").digest(raw.toByteArray())
            .take(16).joinToString("") { "%02x".format(it) }
    }

    // SignModule.sign / verifyRsign 来自官方签名模块（获取方式见文末「签名模块」）
    // 调用处：body["sign"] = SignModule.sign(body, SECRET)

    /** AES-256-GCM：返回 (iv, data)，data = base64(密文+Tag) */
    fun encrypt(json: String): Pair<String, String> {
        val iv = ByteArray(12).also { SecureRandom().nextBytes(it) }
        val c = Cipher.getInstance("AES/GCM/NoPadding")
        c.init(Cipher.ENCRYPT_MODE, SecretKeySpec(ENC_KEY, "AES"), GCMParameterSpec(128, iv))
        return Base64.getEncoder().encodeToString(iv) to
               Base64.getEncoder().encodeToString(c.doFinal(json.toByteArray(StandardCharsets.UTF_8)))
    }

    fun call(path: String, vararg kv: Pair<String, String>): String {
        val body = sortedMapOf(
            "appkey" to APPKEY,
            "time" to (System.currentTimeMillis() / 1000).toString(),
            "nonce" to UUID.randomUUID().toString().replace("-", ""),
            *kv
        )
        if (ENC_KEY.isNotEmpty()) {                      // 开启加密：业务参数整体进密文（appkey 除外）
            val biz = kv.joinToString(",", "{", "}") {
                "\"${it.first}\":\"${it.second.replace("\\", "\\\\").replace("\"", "\\\"")}\""
            }
            val (iv, data) = encrypt(biz)
            body["enc"] = "1"; body["iv"] = iv; body["data"] = data
        }
        body["sign"] = SignModule.sign(body, SECRET)     // enc/iv/data 同样参与签名
        val json = body.entries.joinToString(",", "{", "}") {
            "\"${it.key}\":\"${it.value.replace("\\", "\\\\").replace("\"", "\\\"")}\""
        }
        val req = HttpRequest.newBuilder(URI.create(API + path))
            .header("Content-Type", "application/json")
            .header("User-Agent", "NetcCheck-SDK/1.0")
            .POST(HttpRequest.BodyPublishers.ofString(json)).build()
        val resp = HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body()
        check(SignModule.verifyRsign(resp, body["nonce"]!!, SECRET)) { "响应验签失败（疑似假服务器）" }  // 200 必须验签（先验再解密）
        return resp
    }

    fun codeOf(resp: String): Int =                      // 生产环境请用 JSON 库解析
        Pattern.compile("\"code\"\\s*:\\s*(\\d+)").matcher(resp).takeIf { it.find() }
            ?.let { it.group(1).toInt() } ?: -1

    fun exitWith(code: Int) {                            // 错误分派：明确文案后退出
        val msg = when (code) {
            410 -> "账号或密码错误"
            412 -> "账号已过期，请续费"
            414 -> "机器码数量已达上限"
            415 -> "登录态失效（可能被顶号）"
            416 -> "账号已封禁"
            418 -> "软件授权已到期"
            429 -> "请求过于频繁"
            430 -> "本月验证额度已用尽"
            else -> "验证失败($code)"
        }
        println(msg)
        kotlin.system.exitProcess(1)
    }
}

fun main() {
    val login = NetcCheckPro.call("/user/login", "username" to "tom",
            "password" to "123456", "machine" to NetcCheckPro.machineCode())
    if (NetcCheckPro.codeOf(login) != 200) NetcCheckPro.exitWith(NetcCheckPro.codeOf(login))
    NetcCheckPro.token = Regex("\"token\":\"([0-9a-f]{64})\"").find(login)!!.groupValues[1]
    thread(isDaemon = true) {                            // 心跳守护线程：每 10 分钟
        var fails = 0
        while (true) {
            try {
                val r = NetcCheckPro.call("/user/heartbeat", "token" to NetcCheckPro.token)
                val c = NetcCheckPro.codeOf(r)
                if (c != 200) NetcCheckPro.exitWith(c)
                fails = 0
                Thread.sleep(600_000)
            } catch (e: InterruptedException) { return@thread }
              catch (e: Exception) { if (++fails >= 3) NetcCheckPro.exitWith(-1) }   // 网络彻底不可达：必须终止业务，而非只退出线程
        }
    }
    println("验证通过，业务逻辑运行中…")                      // ……你的业务代码
    Thread.sleep(Long.MAX_VALUE)
}

// NetcCheck 进阶接入：AES-256-GCM 传输加密 + 心跳后台线程 + 错误分派（.NET 6+，零第三方依赖）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading;

class NetcCheckPro {
    const string APPKEY = "nkxxxx", SECRET = "你的AppSecret";
    const string ENC_KEY = "";                       // 控制台 64 位 hex 加密密钥，未开加密留空
    const string API = "https://app.netccheck.tech/api/v1";
    static readonly HttpClient HTTP = new HttpClient();

    // ……复制 QuickStart 的 Sign / JGet / VerifyRsign / Esc / Call（含 key 版）……

    // AES-256-GCM：data = base64(密文+16字节Tag)
    static Tuple<string, string> Encrypt(string json) {
        byte[] key = Convert.FromHexString(ENC_KEY), iv = new byte[12];
        RandomNumberGenerator.Fill(iv);
        byte[] pt = Encoding.UTF8.GetBytes(json), ct = new byte[pt.Length], tag = new byte[16];
        using var g = new AesGcm(key, 16);
        g.Encrypt(iv, pt, ct, tag);
        return Tuple.Create(Convert.ToBase64String(iv), Convert.ToBase64String(ct.Concat(tag).ToArray()));
    }

    // 把响应中的 "enc":{...} 原位替换为解密后的 "data":{...}
    static string ReplaceEnc(string text, string inner) {
        int s = text.IndexOf("\"enc\":{", StringComparison.Ordinal);
        int depth = 0, e = s;
        for (; e < text.Length; e++) {
            if (text[e] == '{') depth++;
            else if (text[e] == '}') { if (--depth == 0) { e++; break; } }
        }
        return text.Substring(0, s) + "\"data\":" + inner + text.Substring(e);
    }

    static string Call(string path, params string[] kv) {
        var body = new SortedDictionary<string, string> {
            { "appkey", APPKEY },
            { "time", ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeSeconds().ToString() },
            { "nonce", Guid.NewGuid().ToString("N") }
        };
        if (ENC_KEY.Length > 0) {                            // 开启加密：业务参数整体进密文（enc/iv/data 同样参与签名）
            string biz = "{" + string.Join(",", Enumerable.Range(0, kv.Length / 2)
                .Select(i => "\"" + kv[2 * i] + "\":\"" + Esc(kv[2 * i + 1]) + "\"")) + "}";
            var enc = Encrypt(biz);
            body["enc"] = "1"; body["iv"] = enc.Item1; body["data"] = enc.Item2;
        } else {
            for (int i = 0; i < kv.Length; i += 2) body[kv[i]] = kv[i + 1];
        }
        body["sign"] = Sign(body, SECRET);
        string json = "{" + string.Join(",", body.Select(x => "\"" + x.Key + "\":\"" + Esc(x.Value) + "\"")) + "}";
        using var resp = HTTP.PostAsync(API + path, new StringContent(json, Encoding.UTF8, "application/json")).Result;
        string text = resp.Content.ReadAsStringAsync().Result;
        VerifyRsign(text, body["nonce"], SECRET);            // rsign 在 code/msg 明文上：先验签，再解密
        if (ENC_KEY.Length > 0 && text.Contains("\"enc\":")) {
            byte[] all = Convert.FromBase64String(JGet(text, "data"));
            byte[] iv = Convert.FromBase64String(JGet(text, "iv"));
            byte[] ct = all.Take(all.Length - 16).ToArray(), tag = all.Skip(all.Length - 16).ToArray();
            byte[] pt = new byte[ct.Length];
            using var g = new AesGcm(Convert.FromHexString(ENC_KEY), 16);
            g.Decrypt(iv, ct, tag, pt);
            text = ReplaceEnc(text, Encoding.UTF8.GetString(pt));
        }
        return text;
    }

    static void ExitWith(int code) {                         // 错误分派：业务性失败给出明确文案后退出
        string msg = code switch {
            410 => "账号或密码错误", 412 => "账号已过期，请续费", 414 => "机器码数量已达上限",
            415 => "登录态失效（可能被顶号）", 416 => "账号已封禁", 418 => "软件授权已到期",
            429 => "请求过于频繁", 430 => "本月验证额度已用尽", _ => "验证失败(" + code + ")"
        };
        Console.WriteLine(msg);
        Environment.Exit(1);
    }

    static void HeartbeatLoop(string token) {                // 心跳后台线程：每 10 分钟
        int fails = 0;
        while (true) {
            try {
                string r = Call("/user/heartbeat", "token", token);
                int c = int.Parse(JGet(r, "code"));
                if (c != 200) ExitWith(c);
                fails = 0;
                Thread.Sleep(600000);
            } catch (ThreadInterruptedException) { return; }
              catch (Exception) { if (++fails >= 3) ExitWith(-1); }   // 网络彻底不可达：必须终止业务，而非只退出线程
        }
    }

    public static void Main() {
        string login = Call("/user/login", "username", "tom",
                "password", "123456", "machine", Environment.MachineName);
        int code = int.Parse(JGet(login, "code"));
        if (code != 200) ExitWith(code);
        string token = JGet(login, "token");
        // 关键数据放服务端：拿不到就拒绝启动（不要判空继续！）
        string cfg = JGet(Call("/var/get", "token", token, "key", "license_flag"), "value");
        if (cfg.Length == 0) { Console.WriteLine("未获取到授权配置"); Environment.Exit(1); }
        var hb = new Thread(() => HeartbeatLoop(token)) { IsBackground = true };
        hb.Start();
        Console.WriteLine("验证通过，业务逻辑运行中…");       // ……你的业务代码
        Thread.Sleep(Timeout.Infinite);
    }
}

// NetcCheck 进阶接入：AES-256-GCM 传输加密 + 心跳后台线程 + 错误分派（Windows，零第三方依赖）
// 在最小示例公共代码基础上，追加 AesGcm/B64/UnB64/HexToRaw（见「加解密实现 · C++」）与以下内容
#include <thread>
#include <vector>

static const std::string ENC_KEY = "";   // 控制台 64 位 hex 加密密钥，未开加密留空

static std::string B64(const unsigned char* d, int n);      // 见「加解密实现 · C++」
static std::vector<unsigned char> UnB64(const std::string& s);
static std::string HexToRaw(const std::string& hex);
static bool AesGcm(const std::string& key32, const unsigned char iv[12],
                   const std::string& in, std::string& out, unsigned char tag[16], bool decrypt);

static void ExitWith(int code) {                             // 错误分派：业务性失败给出明确文案后退出
    const char* msg = code == 410 ? "账号或密码错误" : code == 412 ? "账号已过期，请续费"
        : code == 414 ? "机器码数量已达上限" : code == 415 ? "登录态失效（可能被顶号）"
        : code == 416 ? "账号已封禁" : code == 418 ? "软件授权已到期"
        : code == 429 ? "请求过于频繁" : code == 430 ? "本月验证额度已用尽" : "验证失败";
    std::cerr << msg << std::endl;
    exit(1);
}

// 加密版 Call：ENC_KEY 非空时业务参数整体进密文（enc/iv/data 同样参与签名）；响应先验签再解密
static std::string CallEnc(const std::string& path, std::map<std::string, std::string> body,
                           const std::string& biz, const std::string& key) {
    body["appkey"] = APPKEY;
    long long ts = (long long)std::time(nullptr);
    body["time"] = std::to_string(ts);
    static unsigned long long counter = 0;
    body["nonce"] = std::to_string(ts) + "-" + std::to_string(counter++);
    std::string payload = biz;
    if (!ENC_KEY.empty()) {
        std::string key32 = HexToRaw(ENC_KEY);
        unsigned char iv[12];
        BCryptGenRandom(nullptr, iv, 12, BCRYPT_USE_SYSTEM_PREFERRED_RNG);
        std::string ct; unsigned char tag[16];
        if (!AesGcm(key32, iv, payload, ct, tag, false)) ExitWith(-2);
        ct.append((char*)tag, 16);                                   // data = base64(密文+Tag)
        body["enc"] = "1";
        body["iv"] = B64(iv, 12);
        body["data"] = B64((const unsigned char*)ct.data(), (int)ct.size());
        payload = "";
    }
    std::string json = "{";
    for (auto& kv : body) { if (json.size() > 1) json += ","; json += "\"" + kv.first + "\":\"" + Esc(kv.second) + "\""; }
    if (!payload.empty()) { if (json.size() > 1) json += ","; json += payload; }
    json += "}";
    std::string resp = Post(path, json);
    if (JGet(resp, "code") == "200") {
        std::string expect = Hmac("ncrs|" + body["nonce"] + "|200|" + JGet(resp, "msg"), key);
        if (expect != JGet(resp, "rsign")) ExitWith(-2);             // rsign 在明文上：先验签，再解密
    }
    if (!ENC_KEY.empty() && !JGet(resp, "iv").empty()) {
        std::vector<unsigned char> iv = UnB64(JGet(resp, "iv")), all = UnB64(JGet(resp, "data"));
        std::string ct((char*)all.data(), all.size() - 16);          // 尾部 16 字节为 Tag
        std::string inner; unsigned char tag[16];
        std::copy(all.end() - 16, all.end(), tag);
        if (!AesGcm(HexToRaw(ENC_KEY), iv.data(), ct, inner, tag, true)) ExitWith(-2);
        resp = "{\"code\":" + JGet(resp, "code") + ",\"msg\":\"" + JGet(resp, "msg") + "\",\"data\":" + inner + "}";
    }
    return resp;
}

static void HeartbeatLoop() {                                // 心跳后台线程：每 10 分钟
    int fails = 0;
    while (true) {
        // token 由 main 存入全局；实际项目建议封装为类成员
        std::string r = CallEnc("/user/heartbeat", {}, "\"token\":\"" + Esc(g_token) + "\"", SECRET);
        int c = 0; try { c = std::stoi(JGet(r, "code")); } catch (...) {}
        if (c != 200) ExitWith(c);
        fails = 0;
        std::this_thread::sleep_for(std::chrono::minutes(10));
    }
}

static std::string g_token;

int main() {
    std::string login = CallEnc("/user/login", {}, "\"username\":\"tom\",\"password\":\"123456\",\"machine\":\"PC-01\"", SECRET);
    int c = 0; try { c = std::stoi(JGet(login, "code")); } catch (...) {}
    if (c != 200) ExitWith(c);
    g_token = JGet(login, "token");
    // 关键数据放服务端：拿不到就拒绝启动（不要判空继续！）
    std::string cfg = JGet(CallEnc("/var/get", {}, "\"token\":\"" + Esc(g_token) + "\",\"key\":\"license_flag\"", SECRET), "value");
    if (cfg.empty()) { std::cerr << "未获取到授权配置" << std::endl; return 1; }
    std::thread(HeartbeatLoop).detach();                     // 网络彻底不可达时 ExitWith 终止整个进程
    std::cout << "验证通过，业务逻辑运行中…" << std::endl;        // ……你的业务代码
    for (;;) std::this_thread::sleep_for(std::chrono::hours(1));
}