File size: 4,826 Bytes
f70c501
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
/**
 * entitlement token 本地验签单测(144 号 P1.1,2026-11-05)。
 *
 * 运行:node --test tests/unit/
 * 测试内用 node:crypto 现生成 Ed25519 密钥对 + jose SignJWT 签发与
 * llm-tools/lib/auth/token.ts 同构的 token(EdDSA, plan claim),验证
 * createTierVerifier 的全部分类路径与 fail-open 语义。
 */
import { test, describe } from 'node:test';
import assert from 'node:assert/strict';
import { createRequire } from 'node:module';
import { generateKeyPairSync } from 'node:crypto';
import { SignJWT, exportJWK } from 'jose';

const require = createRequire(import.meta.url);
const { createTierVerifier, loadPublicKey } = require('../../lib/entitlement-verify.js');

async function makeKeyPair() {
  const { publicKey, privateKey } = generateKeyPairSync('ed25519');
  const jwk = await exportJWK(publicKey); // { kty:'OKP', crv:'Ed25519', x }
  return { publicKeyB64Url: jwk.x, privateKey };
}

async function sign(privateKey, claims, { expires = '24h' } = {}) {
  return new SignJWT(claims)
    .setProtectedHeader({ alg: 'EdDSA', typ: 'JWT' })
    .setIssuedAt()
    .setExpirationTime(expires)
    .sign(privateKey);
}

describe('loadPublicKey', () => {
  test('接受 base64url raw 32B(网站 AUTH_SIGNING_PUBLIC_KEY 形态)', async () => {
    const { publicKeyB64Url } = await makeKeyPair();
    assert.ok(loadPublicKey(publicKeyB64Url), '合法公钥应构造成功');
    assert.equal(loadPublicKey('not-base64!!'), null);
    assert.equal(loadPublicKey('AAAA'), null, '长度非 32B 拒绝');
    assert.equal(loadPublicKey(''), null);
    assert.equal(loadPublicKey(undefined), null);
  });
});

describe('verifyTier 分类', () => {
  test('plan=pro → pro;plan=free → free;无 token → free', async () => {
    const { publicKeyB64Url, privateKey } = await makeKeyPair();
    const v = createTierVerifier({ publicKeyB64Url, log: () => {} });
    assert.equal(v.enabled, true);
    const proToken = await sign(privateKey, { sub: 'u1', plan: 'pro', products: ['backup', 'exporter'] });
    const freeToken = await sign(privateKey, { sub: 'u2', plan: 'free', products: [] });
    assert.equal(await v.verifyTier(`Bearer ${proToken}`), 'pro');
    assert.equal(await v.verifyTier(`Bearer ${freeToken}`), 'free');
    assert.equal(await v.verifyTier(null), 'free');
    assert.equal(await v.verifyTier(undefined), 'free');
    assert.equal(await v.verifyTier('Basic abc'), 'free', '非 Bearer 形态 → free');
    assert.equal(await v.verifyTier('Bearer not-a-jwt'), 'free', '垃圾 token → free 不抛错');
  });

  test('exporter-only 付费用户(plan=free + products 含 exporter)→ pro(与插件 isPro 同口径)', async () => {
    // 2026-11-07 本地实测发现:token 的 plan 是 Backup 域语义,exporter-only
    // 付费用户 plan 恒 'free'——只认 plan 会漏掉这部分付费 PRO
    const { publicKeyB64Url, privateKey } = await makeKeyPair();
    const v = createTierVerifier({ publicKeyB64Url, log: () => {} });
    const exporterOnly = await sign(privateKey, { sub: 'u3', plan: 'free', products: ['exporter'] });
    assert.equal(await v.verifyTier(`Bearer ${exporterOnly}`), 'pro');
    const backupOnly = await sign(privateKey, { sub: 'u4', plan: 'free', products: ['backup'] });
    assert.equal(await v.verifyTier(`Bearer ${backupOnly}`), 'free', '只有 Backup 无 exporter → 不享插件导出优先级');
  });

  test('过期 token(含 60s 容差内)→ free,绝不拦截', async () => {
    const { publicKeyB64Url, privateKey } = await makeKeyPair();
    const v = createTierVerifier({ publicKeyB64Url, log: () => {} });
    const expired = await sign(privateKey, { sub: 'u1', plan: 'pro' }, { expires: '-1h' });
    assert.equal(await v.verifyTier(`Bearer ${expired}`), 'free');
  });

  test('错误公钥签发的 token → free(签名不匹配)', async () => {
    const { publicKeyB64Url } = await makeKeyPair();
    const other = await makeKeyPair();
    const v = createTierVerifier({ publicKeyB64Url, log: () => {} });
    const forged = await sign(other.privateKey, { sub: 'u1', plan: 'pro' });
    assert.equal(await v.verifyTier(`Bearer ${forged}`), 'free');
  });

  test('公钥未配置 ⇒ 功能关闭:恒 free 且 enabled=false(灰度安全)', async () => {
    const { privateKey } = await makeKeyPair();
    const v = createTierVerifier({ publicKeyB64Url: '', log: () => {} });
    assert.equal(v.enabled, false);
    const proToken = await sign(privateKey, { sub: 'u1', plan: 'pro' });
    assert.equal(await v.verifyTier(`Bearer ${proToken}`), 'free');
  });

  test('非法公钥值 ⇒ enabled=false(与未配置同语义)', () => {
    const v = createTierVerifier({ publicKeyB64Url: '!!!bad!!!', log: () => {} });
    assert.equal(v.enabled, false);
  });
});