脱离存储的卡密验证系统

原理#

传统当中客户端-服务器-数据库的卡密验证架构，对于服务器，数据库存在一定需求，很容易成为攻击目标，为了弥补搭建网络卡密验证方面的缺点，写了本文章
全文分为两个公钥私钥，算法为ES256，是JWT当中常见的数字签名算法，结合与哈希与椭圆曲线，更短的密钥可以有更好的安全性
我们脱离了数据存储，自然是需要将密文解密的，本地的解密是绝对不安全的，因此需要Cloudflare进行解密，为了保证中间人不会篡改，同样用了椭圆曲线进行了前后公私密钥的签名校验这个系统有三个关键角色：
管理员:
- 资产：拥有管理员私钥
- 职责：使用私钥签发包含授权信息（设备ID、过期时间）的令牌
Cloudflare Worker:
- 资产：拥有管理员公钥（用于验证令牌真伪）和自己的 Worker 私钥（用于证明自身身份）。
- 职责：作为一个无状态的验证端点，它接收 App 的请求，验证真实性和有效性，然后用自己的私key签名，给 App 一个可信的回执。
安卓应用（消费者）:
- 资产：拥有 Worker 公钥。
- 职责：向用户索要卡密，提交给 Worker 验证，并用自己的公钥验证 Worker 的回执是否真实。

下面开始教学

TIP
我们需要一个简单的 Node.js 环境

首先，初始化项目并安装 jose 库： npm init -y npm install jose

Jose库需要在本地安装，因此本项目的ts并不能直接复制到CFworkers，因此全程构建需要电脑环境，低成本必须要求的牺牲，没办法，如果有大佬可以构建出脱离电脑的运行脚本，还请多多帮助

附录Jose是实现JWT的核心，有不会的可以去百度搜索，不做赘述了

我们需要两对 ECDSA P-256 密钥：一对用于管理员，一对用于 Worker。修改 package.json，添加 "type": "module",。

卡密的生成与签发#

TIP
package.json没有就创建一个

下面是js代码 generate-keys.js

1
import { generateKeyPair, exportSPKI, exportPKCS8 } from 'jose';
2
import { promises as fs } from 'fs';
3

4
async function generateKeys(prefix) {
5
    const { publicKey, privateKey } = await generateKeyPair('ES256', { extractable: true });
6
    const spkiPem = await exportSPKI(publicKey);
7
    const pkcs8Pem = await exportPKCS8(privateKey);
8

9
    await fs.writeFile(`${prefix}_public_key.pem`, spkiPem);
10
    await fs.writeFile(`${prefix}_private_key.pem`, pkcs8Pem);
11

12
    console.log(`--- ${prefix}_public_key.pem ---`);
13
    console.log(spkiPem);
14
}
15

16
console.log('正在生成管理员密钥对...');
17
await generateKeys('admin');
18
console.log('\n正在生成 Worker 密钥对...');
19
await generateKeys('worker');
20
console.log('\n密钥对已全部生成！');

在终端运行 node generate-keys.js，你将得到四个文件。请妥善保管它们：

admin_private_key.pem: 保护好了哦，用来生成卡密的
admin_public_key.pem: 将部署到 Worker。
worker_private_key.pem: 将部署到 Worker。
worker_public_key.pem: 将硬编码到安卓 App 中

issue-token.js

1
import { SignJWT, importPKCS8 } from 'jose';
2
import { promises as fs } from 'fs';
3

4
async function issueGoldenToken(deviceId, validityInDays) {
5
    const privateKeyPem = await fs.readFile('admin_private_key.pem', 'utf-8');
6
    const privateKey = await importPKCS8(privateKeyPem, 'ES256');
7
    const expiresAt = Math.floor(Date.now() / 1000) + (validityInDays * 24 * 60 * 60);
8

9
    const goldenToken = await new SignJWT({ deviceId, expiresAt })
10
        .setProtectedHeader({ alg: 'ES256' })
11
        .sign(privateKey);
12

13
    console.log('卡密已生成 ---');
14
    console.log(`设备ID: ${deviceId}`);
15
    console.log(`有效期至: ${new Date(expiresAt * 1000).toLocaleString()}`);
16
    console.log('请将下面的字符串发给用户:');
17
    console.log(goldenToken);
18
}
19

20
const userDeviceId = process.argv[2];
21
const days = parseInt(process.argv[3], 10);
22
if (!userDeviceId || !days) {
23
    console.log('用法: node issue-token.js <设备ID> <有效天数>');
24
} else {
25
    issueGoldenToken(userDeviceId, days);
26
}

使用: node issue-token.js <用户的设备ID> <有效天数> (例如 30 天)。生成的长字符串就是发给用户的卡密。

网络端#

我们将使用 Wrangler CLI 工具来创建和部署 Worker。

创建项目: npx wrangler init my-license-worker (选择 Worker only 模板)。
安装依赖: cd my-license-worker 然后 npm install jose
上传密钥: 使用 wrangler secret put 命令，将 admin_public_key.pem 和 worker_private_key.pem 的内容分别上传到名为 ADMIN_PUBLIC_KEY 和 WORKER_PRIVATE_KEY 的环境变量中（这里可能会卡，记得挂梯子）

src/index.ts

1
import { importSPKI, jwtVerify, SignJWT, importPKCS8 } from 'jose';
2

3
export interface Env {
4
    ADMIN_PUBLIC_KEY: string;
5
    WORKER_PRIVATE_KEY: string;
6
}
7

8
export default {
9
    async fetch(request: Request, env: Env): Promise<Response> {
10
        if (request.method !== 'POST') {
11
            return jsonResponse({ error: 'Expected POST' }, 405);
12
        }
13

14
        try {
15
            const { deviceId, token }: { deviceId?: string; token?: string } = await request.json();
16

17
            if (!deviceId || !token) {
18
                return jsonResponse({ isValid: false, reason: 'Missing parameters' }, 400);
19
            }
20

21
            // 1. 用管理员公钥验证黄金令牌
22
            const adminPublicKey = await importSPKI(env.ADMIN_PUBLIC_KEY, 'ES256');
23
            const { payload: tokenPayload } = await jwtVerify(token, adminPublicKey);
24

25
            // 2. 验证业务逻辑
26
            if (tokenPayload.deviceId !== deviceId) {
27
                return jsonResponse({ isValid: false, reason: 'Device ID mismatch' });
28
            }
29
            if (Math.floor(Date.now() / 1000) > (tokenPayload.expiresAt as number)) {
30
                return jsonResponse({ isValid: false, reason: 'Token expired' });
31
            }
32

33
            // 3. 所有验证通过，准备成功回执
34
            const responseData = {
35
                isValid: true,
36
                deviceId: tokenPayload.deviceId,
37
                expiresAt: tokenPayload.expiresAt,
38
                validatedAt: Math.floor(Date.now() / 1000),
39
            };
40

41
            // 4. 用 Worker 私钥签名回执，生成一个响应JWT
42
            const workerPrivateKey = await importPKCS8(env.WORKER_PRIVATE_KEY, 'ES256');
43
            const signedJwtResponse = await new SignJWT(responseData)
44
                .setProtectedHeader({ alg: 'ES256' })
45
                .sign(workerPrivateKey);
46

47
            // 5. 将签好名的 JWT 作为最终结果返回
48
            return jsonResponse({ responseToken: signedJwtResponse });
49

50
        } catch (error: any) {
51
            // 如果 jwtVerify 失败 (签名无效)，也会在这里捕获
52
            const reason = error.code || error.message || 'Internal Server Error';
53
            console.error(`Validation failed: ${reason}`);
54
            return jsonResponse({ isValid: false, reason });
55
        }
56
    },
57
};
58

59
function jsonResponse(data: object, status: number = 200): Response {
60
    return new Response(JSON.stringify(data), { status: status, headers: { 'Content-Type': 'application/json' }});
61
}

最后，运行 npx wrangler deploy 将其部署到全球。

接下来是安卓层面对接了#

成品写在MoonLightAPP了，目前还没有提交

类名：SecurityManager

相关代码

1
package bbs.yuchen.icu;
2

3
import android.util.Base64;
4
import android.util.Log;
5

6
import com.nimbusds.jose.JWSVerifier;
7
import com.nimbusds.jose.crypto.ECDSAVerifier;
8
import com.nimbusds.jwt.SignedJWT;
9

10
import org.json.JSONObject;
11

12
import java.io.BufferedReader;
13
import java.io.InputStream;
14
import java.io.InputStreamReader;
15
import java.io.OutputStream;
16
import java.net.HttpURLConnection;
17
import java.net.URL;
18
import java.nio.charset.StandardCharsets;
19
import java.security.KeyFactory;
20
import java.security.PublicKey;
21
import java.security.interfaces.ECPublicKey;
22
import java.security.spec.X509EncodedKeySpec;
23

24
public class SecurityManager {
25
    private static final String TAG = "SecurityManagerDebug";
26

27

28
    private static final String WORKER_PUBLIC_KEY_STRING = "-----BEGIN PUBLIC KEY-----\-----END PUBLIC KEY-----";  //填写自己的密钥
29

30
    /**
31
     *验证来自 Cloudflare Worker 的 JWT 响应。
32
     * @param responseToken 从 Worker 收到的 JWS 字符串。
33
     * @return 如果签名有效则返回 true，否则返回 false。
34
     */
35
    private static boolean verifyResponse(String responseToken) {
36
        try {
37
            Log.d(TAG, "Verifying response token: " + responseToken);
38

39
            // 1. 使用 Nimbus 库解析收到的 JWS 字符串
40
            SignedJWT signedJWT = SignedJWT.parse(responseToken);
41

42
            // 2. 加载我们硬编码在 App 中的 Worker 公钥
43
            PublicKey publicKey = loadPublicKey(WORKER_PUBLIC_KEY_STRING);
44
            if (!(publicKey instanceof ECPublicKey)) {
45
                Log.e(TAG, "Public key is not an EC public key, cannot verify.");
46
                return false;
47
            }
48

49
            // 3. 创建一个适用于 ECDSA 签名的 Nimbus 验签器
50
            JWSVerifier verifier = new ECDSAVerifier((ECPublicKey) publicKey);
51

52
            // 4. 执行验签！如果令牌的签名与公钥匹配，这里会返回 true            boolean isSignatureValid = signedJWT.verify(verifier);
53
            Log.d(TAG, "Is worker signature on JWT valid? -> " + isSignatureValid);
54

55
            return isSignatureValid;
56

57
        } catch (Exception e) {
58
            Log.e(TAG, "Exception during JWT verification", e);
59
            return false;
60
        }
61
    }
62

63
    /**
64
     * 向 Cloudflare Worker 发起验证请求。
65
     * @param deviceId 当前设备的ID。
66
     * @param goldenToken 用户输入的授权令牌（卡密）。
67
     * @return 如果授权有效则返回 true，否则返回 false。
68
     */
69
    public static boolean validateLicense(String deviceId, String goldenToken) {
70

71
        // 请将这里替换为您真实的 Worker URL。
72
        String workerUrl = "https://card.342191.xyz";  //欢迎打
73

74
        Log.d(TAG, "\n--- Starting License Validation ---");
75
        Log.d(TAG, "Worker URL: " + workerUrl);
76
        Log.d(TAG, "Device ID: " + deviceId);
77
        Log.d(TAG, "Golden Token: " + goldenToken);
78

79
        HttpURLConnection conn = null;
80
        try {
81
            URL url = new URL(workerUrl);
82
            conn = (HttpURLConnection) url.openConnection();
83
            conn.setRequestMethod("POST");
84
            conn.setRequestProperty("Content-Type", "application/json; utf-8");
85
            conn.setConnectTimeout(15000);
86
            conn.setReadTimeout(15000);
87
            conn.setDoOutput(true);
88

89
            // 1. 创建请求体
90
            JSONObject requestPayload = new JSONObject();
91
            requestPayload.put("deviceId", deviceId);
92
            requestPayload.put("token", goldenToken);
93
            String jsonInputString = requestPayload.toString();
94
            Log.d(TAG, "Sending request payload: " + jsonInputString);
95

96
            // 2. 发送请求
97
            try (OutputStream os = conn.getOutputStream()) {
98
                os.write(jsonInputString.getBytes(StandardCharsets.UTF_8));
99
            }
100

101
            // 3. 获取响应
102
            int responseCode = conn.getResponseCode();
103
            String responseMessage = conn.getResponseMessage();
104
            Log.d(TAG, "Received HTTP Response: " + responseCode + " " + responseMessage);
105

106
            InputStream inputStream = (responseCode >= 200 && responseCode <= 299) ? conn.getInputStream() : conn.getErrorStream();
107
            if (inputStream == null) {
108
                Log.e(TAG, "Response input stream is null.");
109
                return false;
110
            }
111

112
            // 4. 读取响应体
113
            try (BufferedReader br = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
114
                StringBuilder response = new StringBuilder();
115
                String responseLine;
116
                while ((responseLine = br.readLine()) != null) {
117
                    response.append(responseLine.trim());
118
                }
119
                String rawResponse = response.toString();
120
                Log.d(TAG, "Raw response body: " + rawResponse);
121

122
                if (responseCode != 200) {
123
                    Log.e(TAG, "Validation failed due to non-200 response code.");
124
                    return false;
125
                }
126

127
                JSONObject jsonResponse = new JSONObject(rawResponse);
128

129
                // 检查 Worker 是否返回了业务逻辑错误
130
                if (jsonResponse.has("isValid") && !jsonResponse.getBoolean("isValid")) {
131
                    Log.e(TAG, "Worker returned a validation failure: " + jsonResponse.optString("reason"));
132
                    return false;
133
                }
134

135
                // 5. [已修正] 提取并验证 Worker 返回的 JWT 令牌
136
                if (!jsonResponse.has("responseToken")) {
137
                    Log.e(TAG, "Response does not contain 'responseToken'");
138
                    return false;
139
                }
140
                String responseToken = jsonResponse.getString("responseToken");
141

142
                // 6. 验证这个 JWT 令牌的签名
143
                if (!verifyResponse(responseToken)) {
144
                    // 如果签名无效，直接失败
145
                    return false;
146
                }
147

148
                // 7. 因为签名已经验证通过，所以我们可以【完全信任】令牌内的内容
149
                SignedJWT signedJWT = SignedJWT.parse(responseToken);
150
                JSONObject payload = new JSONObject(signedJWT.getPayload().toString());
151

152
                boolean isLicenseValid = payload.getBoolean("isValid");
153
                Log.d(TAG, "Is license valid according to TRUSTED payload? -> " + isLicenseValid);
154

155
                return isLicenseValid;
156
            }
157

158
        } catch (Exception e) {
159
            Log.e(TAG, "An exception occurred during validation", e);
160
            return false;
161
        } finally {
162
            if (conn != null) {
163
                conn.disconnect();
164
            }
165
            Log.d(TAG, "--- License Validation Finished ---");
166
        }
167
    }
168

169
    /**
170
     * 辅助方法，从 PEM 格式的字符串加载公钥。
171
     * @param key 公钥的 PEM 字符串。
172
     * @return PublicKey 对象。
173
     * @throws Exception
174
     */    private static PublicKey loadPublicKey(String key) throws Exception {
175
        String publicKeyPEM = key
176
                .replace("-----BEGIN PUBLIC KEY-----", "")
177
                .replaceAll("\n", "")
178
                .replace("-----END PUBLIC KEY-----", "");
179
        byte[] encoded = Base64.decode(publicKeyPEM, Base64.DEFAULT);
180
        KeyFactory keyFactory = KeyFactory.getInstance("EC");
181
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(encoded);
182
        return keyFactory.generatePublic(keySpec);
183
    }
184
}

原理#

卡密的生成与签发#

网络端#

接下来是安卓层面对接了#

由于原本就封装好了，UI层面代码发出来没用，自己写吧#