kauth-go SDK 对接指南

Go 语言版本的卡密网络验证客户端 SDK。提供完整的身份认证、远程控制、配置管理等功能，支持多种登录方式和签名算法。

支持平台：懒人精灵、AutoGo 等 Go 语言运行环境
官网：https://kauth.cn

快速开始

安装依赖

bash

go get github.com/kauth-coder/kauth-go

初始化客户端

package main

import (
    "fmt"
    "github.com/kauth-coder/kauth-go/kauth"
)

var client *kauth.KauthApi

func init() {
    config := kauth.Config{
        ApiDomain:         "https://api.kauth.cn",
        ProgramId:         1959821336266936321,        // 程序ID
        ProgramSecret:     "F77VzI7UWAElpWrz",         // 程序秘钥
        MerchantPublicKey: "MIGfMA0GCSqGSIb3...",      // 商户公钥
    }
    // RSA 签名方式
    client = kauth.NewKauthApi(config, kauth.SignTypeRSA)
}

func main() {
    // 从这里开始调用 API
}

代码运行

bash

go run main.go

用户认证模块

用户认证模块支持多种登录方式：试用登录、卡密登录、账号登录；以及用户信息查询、密码修改、充值、设备绑定等操作。

获取图形验证码

用于获取验证码图片，通常在需要验证用户身份时使用。

func testGetCaptcha() {
    captchaReq := kauth.CaptchaRequest{
        UUID: kauth.GenerateUUID(),  // 生成唯一标识
    }
    
    resp, _, err := client.GetCaptcha(captchaReq)
    if err != nil {
        fmt.Printf("获取验证码失败: %v\n", err)
        return
    }
    fmt.Printf("UUID: %s\n验证码Base64: %s\n", resp.UUID, resp.CaptchaBase64)
}

请求参数：

UUID (string)：客户端生成的唯一标识

响应数据：

UUID (string)：验证码唯一标识
CaptchaBase64 (string)：验证码图片的 Base64 编码

试用登录

无需卡密或账号，允许用户试用程序功能。适合新用户体验。

func testTrialLogin() {
    trialReq := kauth.TrialLoginReq{
        DeviceId: "device_uuid_here",  // 设备唯一标识
    }
    
    loginResp, resp, err := client.TrialLogin(trialReq)
    if err != nil {
        fmt.Printf("试用登录失败: %v (Code: %d, Msg: %s)\n", err, resp.Code, resp.Msg)
        return
    }
    
    fmt.Printf("试用登录成功!\n")
    fmt.Printf("用户: %s (%s)\n", loginResp.NickName, loginResp.UserID)
    fmt.Printf("Token: %s\n", loginResp.Token)
    fmt.Printf("心跳间隔: %s ms\n", loginResp.PongInterval)
}

请求参数：

DeviceId (string)：设备的唯一标识（UUID 格式）

响应数据：

UserID (string)：用户唯一标识
NickName (string)：用户昵称
Token (string)：登录令牌（后续请求需使用）
PongInterval (string)：心跳间隔时间（毫秒）

卡密登录

使用卡密进行登录。卡密由管理员颁发，用于快速身份验证。

func testKaLogin() {
    loginReq := kauth.LoginRequest{
        KaPwd:        "your_card_password",   // 卡密
        DeviceId:     "device_uuid_here",     // 设备ID
        PlatformType: "golang",               // 平台类型（可选）
    }
    
    loginResp, resp, err := client.KaLogin(loginReq)
    if err != nil {
        fmt.Printf("卡密登录失败: %v (Code: %d, Msg: %s)\n", err, resp.Code, resp.Msg)
        return
    }
    
    // 登录成功，Token 已自动保存到客户端
    fmt.Printf("卡密登录成功!\n")
    fmt.Printf("用户: %s (%s)\n", loginResp.NickName, loginResp.UserID)
    fmt.Printf("Token: %s\n", loginResp.Token)
}

请求参数：

KaPwd (string)：卡密
DeviceId (string)：设备 ID
PlatformType (string)：平台类型，如 golang、pc 等（可选，默认 golang）

响应数据：

UserID (string)：用户 ID
NickName (string)：用户昵称
Token (string)：登录令牌
PongInterval (string)：心跳间隔

账号密码登录

使用用户名和密码登录。支持可选的图形验证码二次验证。

func testPwdLogin() {
    loginReq := kauth.PwdLoginRequest{
        LoginName:   "username",               // 登录账号
        Password:    "password",               // 登录密码
        CaptchaCode: "1234",                   // 验证码（可选）
        CaptchaUuid: "uuid-here",              // 验证码UUID（可选）
        DeviceId:    "device_uuid_here",       // 设备 ID
    }
    
    loginResp, resp, err := client.PwdLogin(loginReq)
    if err != nil {
        fmt.Printf("账号登录失败: %v (Code: %d, Msg: %s)\n", err, resp.Code, resp.Msg)
        return
    }
    
    fmt.Printf("账号登录成功!\n")
    fmt.Printf("用户: %s (%s)\n", loginResp.NickName, loginResp.UserID)
}

请求参数：

LoginName (string)：登录账号，4-20 位字母、数字或下划线
Password (string)：登录密码，6-20 位字母、数字或特殊字符
CaptchaCode (string)：图形验证码（可选）
CaptchaUuid (string)：验证码 UUID（可选）
DeviceId (string)：设备 ID

响应数据：

同卡密登录响应

获取用户信息

查询当前登录用户的详细信息，包括订阅到期时间、剩余次数、计费类型等。

func testGetUserInfo() {
    userInfo, resp, err := client.GetUserInfo()
    if err != nil {
        fmt.Printf("获取用户信息失败: %v\n", err)
        return
    }
    
    fmt.Printf("=== 用户信息 ===\n")
    fmt.Printf("用户 ID: %s\n", userInfo.UserId)
    fmt.Printf("到期时间: %s\n", userInfo.ServerExpireTime)
    fmt.Printf("剩余次数: %d\n", userInfo.ServerRemainNum)
    fmt.Printf("计费类型: %s\n", userInfo.ServerType)     // time/ci
    fmt.Printf("是否试用: %v\n", userInfo.Trial)
}

响应数据：

UserId (string)：用户 ID
ServerExpireTime (string)：服务端过期时间（YYYY-MM-DD 格式）
ServerRemainNum (int64)：剩余次数或天数
ServerType (string)：计费类型（time 按时间计费，ci 按次数计费）
Trial (bool)：是否为试用账户

修改密码

修改当前登录账号的登录密码。

func testChangePassword() {
    resetReq := kauth.ResetPwdRequest{
        LoginName:       "username",           // 登录账号
        OldPassword:     "old_password",       // 旧密码
        NewPassword:     "new_password_456",   // 新密码
        ConfirmPassword: "new_password_456",   // 确认密码（必须匹配）
        CaptchaCode:     "1234",               // 验证码（可选）
        CaptchaUuid:     "uuid-here",          // 验证码UUID（可选）
    }
    
    resp, err := client.ResetPassword(resetReq)
    if err != nil {
        fmt.Printf("修改密码失败: %v\n", err)
        return
    }
    fmt.Printf("修改密码成功! Code: %d\n", resp.Code)
}

请求参数：

LoginName (string)：登录账号
OldPassword (string)：旧密码
NewPassword (string)：新密码，6-20 位
ConfirmPassword (string)：确认密码（必须与新密码相同）
CaptchaCode (string)：图形验证码（可选）
CaptchaUuid (string)：验证码 UUID（可选）

卡密充卡

使用充值卡密为另一张卡进行充值。

func testRechargeKa() {
    rechargeReq := kauth.KaRechargeKaReq{
        CardPwd:         "card_to_recharge",      // 被充值的卡密
        RechargeCardPwd: "recharge_card",         // 充值卡密
    }
    
    resp, err := client.RechargeKa(rechargeReq)
    if err != nil {
        fmt.Printf("卡密充卡失败: %v\n", err)
        return
    }
    fmt.Printf("卡密充卡成功! Code: %d\n", resp.Code)
}

请求参数：

CardPwd (string)：被充值的卡密
RechargeCardPwd (string)：充值卡密

账号充值

使用充值卡密为账号充值。

func testRecharge() {
    rechargeReq := kauth.RechargeRequest{
        LoginName:   "username",           // 账户名
        KaPassword:  "recharge_card",      // 充值卡密
        DeviceId:    "device_uuid_here",   // 设备 ID
        CaptchaCode: "1234",               // 验证码（可选）
        CaptchaUuid: "uuid-here",          // 验证码UUID（可选）
    }
    
    resp, err := client.Recharge(rechargeReq)
    if err != nil {
        fmt.Printf("账号充值失败: %v\n", err)
        return
    }
    fmt.Printf("账号充值成功! Code: %d\n", resp.Code)
}

请求参数：

LoginName (string)：登录账号
KaPassword (string)：充值卡密
DeviceId (string)：设备 ID
CaptchaCode (string)：验证码（可选）
CaptchaUuid (string)：验证码 UUID（可选）

账号解绑设备

解除账号与指定设备的绑定关系，允许该设备重新绑定其他账号。

func testUnbindDevice() {
    unbindReq := kauth.UnbindDeviceRequest{
        LoginName:   "username",           // 账户名
        Password:    "password",           // 密码
        DeviceId:    "device_uuid_here",   // 要解绑的设备ID
        CaptchaCode: "1234",               // 验证码（可选）
        CaptchaUuid: "uuid-here",          // 验证码UUID（可选）
    }
    
    resp, err := client.UnbindDevice(unbindReq)
    if err != nil {
        fmt.Printf("账号解绑设备失败: %v\n", err)
        return
    }
    fmt.Printf("账号解绑设备成功! Code: %d\n", resp.Code)
}

请求参数：

LoginName (string)：登录账号
Password (string)：登录密码
DeviceId (string)：要解绑的设备 ID
CaptchaCode (string)：验证码（可选）
CaptchaUuid (string)：验证码 UUID（可选）

卡密解绑设备

解除卡密与指定设备的绑定关系。

func testUnbindDeviceKaPwd() {
    unbindReq := kauth.UnbindDeviceKaPwdRequest{
        KaPwd:    "card_password",         // 卡密
        DeviceId: "device_uuid_here",      // 要解绑的设备ID
    }
    
    resp, err := client.UnbindDeviceKaPwd(unbindReq)
    if err != nil {
        fmt.Printf("卡密解绑设备失败: %v\n", err)
        return
    }
    fmt.Printf("卡密解绑设备成功! Code: %d\n", resp.Code)
}

请求参数：

KaPwd (string)：卡密
DeviceId (string)：要解绑的设备 ID

退出登录

主动注销当前登录会话，服务端将清除该用户的 Token。

func testLoginOut() {
    resp, err := client.LoginOut()
    if err != nil {
        fmt.Printf("退出登录失败: %v\n", err)
        return
    }
    fmt.Printf("退出登录成功! Code: %d, Msg: %s\n", resp.Code, resp.Msg)
}

Code (int)：状态码（200 表示成功）
Msg (string)：状态消息

配置管理模块

支持保存和获取自定义配置，可用于存储用户偏好设置、个性化配置等。

更新用户配置

func testUpdateUserConfig() {
    configReq := kauth.UpdateCustomConfigReq{
        Config: `{"theme":"dark","language":"zh-CN"}`,
    }
    
    resp, err := client.UpdateUserConfig(configReq)
    if err != nil {
        fmt.Printf("更新用户配置失败: %v\n", err)
        return
    }
    fmt.Printf("更新用户配置成功! Code: %d\n", resp.Code)
}

请求参数：

Config (string)：自定义配置内容（JSON 字符串或任意格式）

获取用户配置

func testGetUserConfig() {
    configResp, resp, err := client.GetUserConfig()
    if err != nil {
        fmt.Printf("获取用户配置失败: %v\n", err)
        return
    }
    fmt.Printf("用户配置: %s\n", configResp.Config)
}

响应数据：

Config (string)：已保存的自定义配置内容

更新卡密配置

为卡密更新配置信息。

func testUpdateKaConfig() {
    configReq := kauth.UpdateCustomConfigReq{
        Config: `{"kaLevel":2,"features":"all"}`,
    }
    
    resp, err := client.UpdateKaConfig(configReq)
    if err != nil {
        fmt.Printf("更新卡密配置失败: %v\n", err)
        return
    }
    fmt.Printf("更新卡密配置成功! Code: %d\n", resp.Code)
}

程序管理模块

获取程序的元数据信息、版本信息、公告、服务器时间等。常用于客户端启动时进行版本检查、时间同步等。

获取程序详情

func testGetProgramDetail() {
    detail, _, err := client.GetProgramDetail()
    if err != nil {
        fmt.Printf("获取程序详情失败: %v\n", err)
        return
    }
    
    fmt.Printf("=== 程序信息 ===\n")
    fmt.Printf("程序 ID: %s\n", detail.ProgramId)
    fmt.Printf("名称: %s\n", detail.Name)
    fmt.Printf("状态: %s\n", detail.Status)
    fmt.Printf("强制更新: %v\n", detail.ForceUpdateDict)
    fmt.Printf("允许用户注册: %v\n", detail.EnableRegisterDict)
    fmt.Printf("公告: %s\n", detail.Notice)
    
    if detail.CurrentVersion != nil {
        fmt.Printf("\n--- 当前版本 ---\n")
        fmt.Printf("版本号: %d\n", detail.CurrentVersion.VersionNo)
        fmt.Printf("版本名称: %s\n", detail.CurrentVersion.VersionName)
        fmt.Printf("版本描述: %s\n", detail.CurrentVersion.VersionDesc)
        fmt.Printf("下载链接: %s\n", detail.CurrentVersion.VersionDownUrl)
    }
}

响应数据：

ProgramId (string)：程序唯一标识
Name (string)：程序名称
Status (string)：程序状态
ForceUpdateDict (bool)：是否开启强制更新
EnableRegisterDict (bool)：是否开启用户注册
Notice (string)：程序公告内容
CurrentVersion (*ProgrameVersionInfo)：当前版本详细信息

获取服务器时间

获取服务器的精确时间戳。用于客户端与服务端的时间同步。

func testGetServerTime() {
    timeResp, _, err := client.GetServerTime()
    if err != nil {
        fmt.Printf("获取服务器时间失败: %v\n", err)
        return
    }
    
    fmt.Printf("=== 服务器时间 ===\n")
    fmt.Printf("格式化时间: %s\n", timeResp.ServerTimeStr)      // yyyy-MM-dd HH:mm:ss
    fmt.Printf("时间戳(毫秒): %s\n", timeResp.ServerTimeMill)
    fmt.Printf("时间戳(秒): %s\n", timeResp.ServerTimeSec)
}

响应数据：

ServerTimeStr (string)：格式化时间字符串 yyyy-MM-dd HH:mm:ss
ServerTimeMill (string)：服务器时间戳（毫秒）
ServerTimeSec (string)：服务器时间戳（秒）

远程控制模块

支持动态获取远程变量、远程数据 CRUD、调用远程函数、获取远程脚本等功能。广泛应用于实时下发配置、动态脚本执行等场景。

获取远程变量

获取由服务端管理的单个远程变量的值。

func testGetRemoteVar() {
    varReq := kauth.GetRemoteVarReq{
        Key: "server_status",  // 变量名
    }
    
    varResp, _, err := client.GetRemoteVar(varReq)
    if err != nil {
        fmt.Printf("获取远程变量失败: %v\n", err)
        return
    }
    fmt.Printf("变量值: %s\n", varResp.Value)
}

请求参数：

Key (string)：变量名

响应数据：

Value (string)：变量值

获取远程数据

获取存储在服务端的远程数据。

func testGetRemoteData() {
    dataReq := kauth.GetRemoteVarReq{
        Key: "remote_config",  // 数据键
    }
    
    dataResp, _, err := client.GetRemoteData(dataReq)
    if err != nil {
        fmt.Printf("获取远程数据失败: %v\n", err)
        return
    }
    fmt.Printf("远程数据: %s\n", dataResp.Value)
}

请求参数：

Key (string)：数据键

响应数据：

Value (string)：数据值

添加远程数据

向服务端添加新的远程数据（键值对）。

func testAddRemoteData() {
    addReq := kauth.RemoteDataAddReq{
        Key:   "new_key",      // 数据键，最大 32 字符
        Value: "new_value",    // 数据值，最大 255 字符
    }
    
    resp, err := client.AddRemoteData(addReq)
    if err != nil {
        fmt.Printf("添加远程数据失败: %v\n", err)
        return
    }
    fmt.Printf("添加远程数据成功! Code: %d\n", resp.Code)
}

请求参数：

Key (string)：数据键，最大 32 字符
Value (string)：数据值，最大 255 字符

更新远程数据

更新已存在的远程数据。

func testUpdateRemoteData() {
    updateReq := kauth.RemoteDataUpdateReq{
        Key:   "existing_key",   // 数据键
        Value: "updated_value",  // 新的数据值
    }
    
    resp, err := client.UpdateRemoteData(updateReq)
    if err != nil {
        fmt.Printf("更新远程数据失败: %v\n", err)
        return
    }
    fmt.Printf("更新远程数据成功! Code: %d\n", resp.Code)
}

请求参数：

Key (string)：数据键
Value (string)：新的数据值

删除远程数据

删除服务端存储的远程数据。

func testDeleteRemoteData() {
    deleteReq := kauth.RemoteDataDeleteReq{
        Key: "key_to_delete",  // 数据键
    }
    
    resp, err := client.DeleteRemoteData(deleteReq)
    if err != nil {
        fmt.Printf("删除远程数据失败: %v\n", err)
        return
    }
    fmt.Printf("删除远程数据成功! Code: %d\n", resp.Code)
}

请求参数：

Key (string)：数据键

调用远程函数

支持调用服务端的函数，函数可用 JavaScript 或 Lua 编写。

JavaScript 函数示例：

javascript

function calculate(a, b) {
    return a + b;
}
calculate(param1, param2);

Lua 函数示例：

lua

--lua
local result = param1 * param2
return result

Go 调用代码：

func testCallFunction() {
    funcReq := kauth.CallFunctionReq{
        FunctionName: "calculate",  // 函数名称
        FunctionParams: []kauth.CallFunctionParamsReq{
            {ParamName: "param1", ParamValue: "10"},
            {ParamName: "param2", ParamValue: "20"},
        },
    }
    
    funcResp, _, err := client.CallFunction(funcReq)
    if err != nil {
        fmt.Printf("调用函数失败: %v\n", err)
        return
    }
    fmt.Printf("函数执行结果: %s\n", funcResp.Result)
}

请求参数：

FunctionName (string)：函数名称
FunctionParams ([]CallFunctionParamsReq)：参数列表
- ParamName (string)：参数名
- ParamValue (string)：参数值

响应数据：

Result (string)：函数执行结果

获取最新脚本

从服务端获取最新的脚本信息及下载地址。可用于获取 Lua 脚本、文本文件、二进制文件等。

func testGetNewestScript() {
    scriptReq := kauth.GetNewestScriptReq{
        ScriptName: "my_lua_script",  // 脚本名称
    }
    
    scriptResp, _, err := client.GetNewestScript(scriptReq)
    if err != nil {
        fmt.Printf("获取脚本信息失败: %v\n", err)
        return
    }
    
    fmt.Printf("=== 脚本信息 ===\n")
    fmt.Printf("脚本名称: %s\n", scriptResp.ScriptName)
    fmt.Printf("版本号: %s\n", scriptResp.VersionNumber)
    fmt.Printf("版本说明: %s\n", scriptResp.VersionDescription)
    fmt.Printf("脚本类型: %s\n", scriptResp.ScriptType)  // TEXT/BINARY
    fmt.Printf("发布时间: %s\n", scriptResp.ScriptReleaseTime)
    
    // 获取下载地址
    downloadReq := kauth.ScriptDownloadReq{
        ScriptName:    scriptResp.ScriptName,
        VersionNumber: scriptResp.VersionNumber,
    }
    
    downloadResp, _, err := client.ScriptDownloadV2(downloadReq)
    if err != nil {
        fmt.Printf("获取下载地址失败: %v\n", err)
        return
    }
    fmt.Printf("下载地址: %s\n", downloadResp.DownloadUrl)
}

请求参数：

ScriptName (string)：脚本名称

响应数据：

ScriptName (string)：脚本名称
VersionNumber (string)：版本号
VersionDescription (string)：版本说明
ScriptType (string)：脚本类型（TEXT 文本，BINARY 二进制）
ScriptReleaseTime (string)：发布时间

脚本错误模块

用于上报脚本执行过程中出现的错误信息到服务端，帮助开发者追踪问题。

报告脚本错误

func testReportScriptError() {
    errorReq := kauth.ConsumerProgramScriptErrorReportReq{
        ScriptName:   "my_script.lua",          // 脚本名称
        ErrorMessage: "NilValue exception",     // 错误信息
        StackTrace:   "at line 42 in main",    // 堆栈跟踪
        Line:         42,                       // 出错行号
        OS:           "Windows",                // 操作系统
        OSVersion:    "10",                     // 系统版本
        DeviceId:     "device_uuid_here",       // 设备ID
    }
    
    resp, err := client.ReportScriptError(errorReq)
    if err != nil {
        fmt.Printf("上报脚本错误失败: %v\n", err)
        return
    }
    fmt.Printf("脚本错误上报成功! Code: %d\n", resp.Code)
}

请求参数：

ScriptName (string)：脚本文件名称
ErrorMessage (string)：错误描述信息
StackTrace (string)：堆栈跟踪信息
Line (int)：出错行号
OS (string)：操作系统名称
OSVersion (string)：系统版本
DeviceId (string)：设备 ID

设备管理模块

管理设备与账户/卡密的绑定关系。支持卡密解绑设备等操作。

卡密解绑设备

解除卡密与当前设备的绑定关系。

func testCardUnBindDevice() {
    resp, err := client.CardUnBindDevice()
    if err != nil {
        fmt.Printf("卡密解绑设备失败: %v\n", err)
        return
    }
    fmt.Printf("卡密解绑设备成功! Code: %d, Msg: %s\n", resp.Code, resp.Msg)
}

Code (int)：状态码（200 表示成功）
Msg (string)：状态消息

错误处理

所有 API 调用返回 (response, rawResponse, error) 三个值。需要根据 error 和 rawResponse.Code 进行综合判断。

response, rawResponse, err := client.SomeApi(request)

// 1. 网络或解析错误
if err != nil {
    fmt.Printf("请求失败: %v\n", err)
    return
}

// 2. API 返回错误码
if rawResponse.Code != 200 {
    fmt.Printf("API 错误: Code=%d, Msg=%s\n", rawResponse.Code, rawResponse.Msg)
    return
}

// 3. 正常处理响应
fmt.Printf("操作成功: %v\n", response)

签名方式

SDK 支持多种签名算法，通过第二个参数指定：

// RSA 签名（推荐）
client = kauth.NewKauthApi(config, kauth.SignTypeRSA)

// MD5 签名
client = kauth.NewKauthApi(config, kauth.SignTypeMD5)

// HMAC-SHA256 签名
client = kauth.NewKauthApi(config, kauth.SignTypeHMACSHA256)

完整示例

卡密登录并获取用户信息

package main

import (
    "fmt"
    "github.com/kauth-coder/kauth-go/kauth"
)

var client *kauth.KauthApi

func init() {
    config := kauth.Config{
        ApiDomain:         "https://api.kauth.cn",
        ProgramId:         1959821336266936321,
        ProgramSecret:     "F77VzI7UWAElpWrz",
        MerchantPublicKey: "MIGfMA0GCSq...",
    }
    client = kauth.NewKauthApi(config, kauth.SignTypeRSA)
}

func main() {
    // 1. 卡密登录
    loginReq := kauth.LoginRequest{
        KaPwd:    "your_card_password",
        DeviceId: "device_uuid_12345",
    }
    
    loginResp, resp, err := client.KaLogin(loginReq)
    if err != nil {
        fmt.Printf("登录失败: %v\n", err)
        return
    }
    
    if resp.Code != 200 {
        fmt.Printf("登录失败: %s\n", resp.Msg)
        return
    }
    
    fmt.Printf("✓ 登录成功: %s\n", loginResp.NickName)
    
    // 2. 获取用户信息
    userInfo, _, _ := client.GetUserInfo()
    fmt.Printf("✓ 用户 ID: %s\n", userInfo.UserId)
    fmt.Printf("✓ 到期时间: %s\n", userInfo.ServerExpireTime)
    fmt.Printf("✓ 剩余次数: %d\n", userInfo.ServerRemainNum)
    
    // 3. 获取程序详情
    programDetail, _, _ := client.GetProgramDetail()
    fmt.Printf("✓ 程序名称: %s\n", programDetail.Name)
    
    // 4. 获取服务器时间
    serverTime, _, _ := client.GetServerTime()
    fmt.Printf("✓ 服务器时间: %s\n", serverTime.ServerTimeStr)
}

运行测试

bash

go run main.go

在 main.go 中可以找到所有功能的测试函数，取消注释即可测试相对应的功能。

常见问题

Q: 如何获取设备 ID？

A: 不同平台获取设备 ID 的方法不同。在懒人精灵中可使用平台提供的 API，在 PC 端可生成 UUID 或使用硬件标识。建议自行获取并存储。

Q: Token 有效期多久？

A: Token 由 PongInterval 心跳指示刷新，通常需要定期发送心跳以保持会话活跃。

Q: 支持 HTTPS 吗？

A: 支持，默认 API 域名为 https://api.kauth.cn。

Q: 如何处理并发请求？

A: SDK 的 KauthApi 是线程安全的（使用了互斥锁 sync.RWMutex），可直接在并发环境中使用。

更新日志

详见项目 GitHub 仓库的 Release 页面。

联系支持

官网：https://kauth.cn
遇到问题请通过官网提交问题反馈

kauth-go SDK 对接指南 ​

快速开始 ​

安装依赖 ​

初始化客户端 ​

代码运行 ​

用户认证模块 ​

获取图形验证码 ​

试用登录 ​

卡密登录 ​

账号密码登录 ​

获取用户信息 ​

修改密码 ​

卡密充卡 ​

账号充值 ​

账号解绑设备 ​

卡密解绑设备 ​

退出登录 ​

配置管理模块 ​

更新用户配置 ​

获取用户配置 ​

更新卡密配置 ​

程序管理模块 ​

获取程序详情 ​

获取服务器时间 ​

远程控制模块 ​

获取远程变量 ​

获取远程数据 ​

添加远程数据 ​

更新远程数据 ​

删除远程数据 ​

调用远程函数 ​

获取最新脚本 ​

脚本错误模块 ​

报告脚本错误 ​

设备管理模块 ​

卡密解绑设备 ​

错误处理 ​

签名方式 ​

完整示例 ​

卡密登录并获取用户信息 ​

运行测试 ​

常见问题 ​

Q: 如何获取设备 ID？ ​

Q: Token 有效期多久？ ​

Q: 支持 HTTPS 吗？ ​

Q: 如何处理并发请求？ ​

更新日志 ​

联系支持 ​

kauth-go SDK 对接指南

快速开始

安装依赖

初始化客户端

代码运行

用户认证模块

获取图形验证码

试用登录

卡密登录

账号密码登录

获取用户信息

修改密码

卡密充卡

账号充值

账号解绑设备

卡密解绑设备

退出登录

配置管理模块

更新用户配置

获取用户配置

更新卡密配置

程序管理模块

获取程序详情

获取服务器时间

远程控制模块

获取远程变量

获取远程数据

添加远程数据

更新远程数据

删除远程数据

调用远程函数

获取最新脚本

脚本错误模块

报告脚本错误

设备管理模块

卡密解绑设备

错误处理

签名方式

完整示例

卡密登录并获取用户信息

运行测试

常见问题

Q: 如何获取设备 ID？

Q: Token 有效期多久？

Q: 支持 HTTPS 吗？

Q: 如何处理并发请求？

更新日志

联系支持