PBIDEA：用 uo_jwt 签发与校验 JWT 令牌（HS256 实战、自验签与 12 个坑）

pbai

免费乐捐，感谢支持

PBIDEA：用 uo_jwt 签发与校验 JWT 令牌（HS256 实战、自验签与 12 个坑）

阅读说明
1. 适用版本：PB10 / PB12.5（本文实机环境为 PB12.5，PBIDEA 版本源 D:\PBAI\UPDATE\125；两版 uo_jwt 用法一致）
2. 支持数据库：本文不涉及数据库
3. 操作系统与环境要求：Windows 7+，应用程序可加载 PbIdea.dll（放程序目录或系统可搜索路径），无需安装 Office / OpenSSL
4. 难度系数：★★★☆☆
5. 其它阅读说明：建议先读本系列《用 uo_json 的 set/get 与路径语法操作 JSON》与《用 SM3 与 HMAC 做数据完整性校验》两篇；文中全部代码已在 PB12.5 实机编译并运行通过

一、JWT 到底是什么：一个"自带签名的 JSON 信封"

做接口对接时，登录之后怎么证明"我还是刚才那个人"？传统做法是服务端存一份 Session，把 SessionId 塞进 Cookie。这套方案在浏览器里很顺，但碰到小程序、App、第三方系统对接就别扭：Cookie 不好带，Session 还要占用服务端内存，多台服务器还得做共享。

JWT（JSON Web Token）换个思路：服务端不存状态，把用户信息和一段签名一起打包成字符串交给客户端，客户端每次请求带上它，服务端只要验签通过就认。

一个 JWT 长这样，三个部分用点号隔开：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzeWJhc2ViYnMuY29tIiwic3ViIjoicGJhaSIsIm5hbWUiOiLmmbrogIUiLCJpYXQiOjE3ODk2MjY3NjIsImV4cCI6MTc4OTYzMDM2Mn0.WOiBHNZNWcqx_7oUnDqifwBudPf-v5KMfuGxxeaT8XU

段	名称	内容	编码方式
第 1 段	header 头	算法与类型：{"alg":"HS256","typ":"JWT"}	base64url
第 2 段	payload 载体	一堆声明（claim）：{"iss":"...","sub":"pbai","exp":...}	base64url
第 3 段	signature 签名	HMAC-SHA256(密钥, 第1段 + "." + 第2段)	base64url

关键点有三个，理解了后面所有坑都能自己推出来：

• 前两段只是 base64，不是加密。任何人拿到令牌都能解出 payload。所以密码、身份证号这类敏感信息绝对不能往里放。
  
• 签名才是防伪造的关键。签名密钥只在服务端，客户端改了 payload 却算不出新签名，服务端一验就露馅。
  
• 验签不等于"永久有效"。JWT 一旦签发，在过期前无法主动作废（服务端不存状态），所以有效期要设短，并配合刷新令牌机制。
  

常用声明一览

JWT 规范（RFC 7519）里预定义了一批声明名，都是可选的，用不用取决于你的业务：

声明	全称	含义	建议
iss	Issuer	签发者	建议填，便于区分多套系统
sub	Subject	主题，一般放用户唯一标识	建议填
aud	Audience	受众，令牌发给谁	多方对接时建议填
exp	Expiration Time	过期时间（Unix 秒）	必填
iat	Issued At	签发时间（Unix 秒）	建议填
nbf	Not Before	生效时间，早于它不认	可选
jti	JWT ID	令牌唯一编号，用于防重放/黑名单	高安全场景建议填

除这些之外你还可以塞任意自定义声明，比如 name、role、dept_id，只要前后端约定好就行。

二、uo_jwt 全貌：属性、方法与支持算法

PBIDEA 把上面这套流程封装成了 uo_jwt，在 websuite.pbl 里。先看它的全部家当。

2.1 实例属性

属性	类型	默认值	说明
payload	uo_json	构造时自动 create	载体对象，set() 就是往它里面塞声明
algo	string	"HS256"	算法名，支持 12 种（见 2.3）
secret	string	"pbidea secret"	HS 系列用的对称密钥；默认值必须改掉
pubkey	string	""	RS/ES/PS 系列验签用的公钥
prikey	string	""	RS/ES/PS 系列签名用的私钥
result	string	""	上一次 create() 得到的令牌，与返回值相同
base64url	boolean	true	是否用 base64url（JWT 规范要求 true）

2.2 方法清单

方法	返回	说明
create()	string	按当前 payload / algo / 密钥签发，返回完整令牌，同时写入 result
parse(string jwt)	boolean	拆解 + 验签；成功返回 true，失败在 payload 里塞 error 键
set(string key, any value)	无	往 payload 写一条声明（内部转调 payload.set）
get(string key, ref string/long/longlong/double)	boolean	从 payload 取一条声明，四个类型重载
clear()	无	重建 payload 并清空 algo / secret / pubkey / prikey / result
b64decode(string code)	blob	按 base64url 设置解码，public 可外部调用
b64encode(blob data)	string	按 base64url 设置编码，private，外部调不到

2.3 支持的 12 种算法

algo 属性写什么字符串，create() 与 parse() 就走哪条分支：

系列	取值	密钥来源	特点
HMAC 对称	HS256 / HS384 / HS512	secret	签名验签同一个密钥，最快，适合单体/内部系统
RSA 非对称	RS256 / RS384 / RS512	签 prikey、验 pubkey	私钥不出服务端，适合多方对接
ECDSA 椭圆曲线	ES256 / ES384 / ES512	签 prikey、验 pubkey	签名短、性能好
RSA-PSS	PS256 / PS384 / PS512	签 prikey、验 pubkey	概率签名，安全性更高

底层实现全部走 uo_crypto（HMACEncode / ECDSASign / Hash）与 uo_rsa（sign / verify），也就是说这几篇是打通的。

三、实战一：签发一个 HS256 令牌

前置：工程 liblist 里挂上 websuite.pbl（含 uo_jwt / uo_json / uo_crypto）；运行时目录放好 PbIdea.dll。
步骤：1) 新建窗口 w_demo 放按钮 cb_1；2) 把下面代码贴进 cb_1 的 clicked 事件；3) 运行窗口点击按钮，MessageBox 里会显示签出来的令牌。

2. // 示例输入：签名密钥，服务端私有，绝不下发给客户端
3. string ls_secret
4. ls_secret = 'pbidea-jwt-demo-secret'
5. // 示例输入：签发者
6. string ls_iss
7. ls_iss = 'sybasebbs.com'
8. // 示例输入：主题，一般放用户唯一标识
9. string ls_sub
10. ls_sub = 'pbai'
11. // 示例输入：自定义声明，用户昵称
12. string ls_name
13. ls_name = '智者'
14. // 示例输入：有效期（秒）
15. long ll_ttl
16. ll_ttl = 3600
18. uo_jwt ljwt
19. string ls_token
20. long ll_now
21. long ll_exp
22. long ll_days
23. long ll_sec
25. // uo_jwt 不是 autoinstantiate，必须 create（全局变量只是声明）
26. ljwt = create uo_jwt
27. ljwt.algo   = 'HS256'
28. ljwt.secret = ls_secret
30. // 写声明
31. ljwt.set('iss',  ls_iss)
32. ljwt.set('sub',  ls_sub)
33. ljwt.set('name', ls_name)
34. // Unix 时间戳：本地时间距 1970-01-01 的秒数
35. ll_days = DaysAfter(Date('1970-01-01'), Today())
36. ll_sec  = SecondsAfter(Time('00:00:00'), Now())
37. ll_now  = ll_days * 86400 + ll_sec
38. ll_exp  = ll_now + ll_ttl
39. ljwt.set('iat', ll_now)
40. ljwt.set('exp', ll_exp)
42. // 签发
43. ls_token = ljwt.create()
44. destroy ljwt
46. MessageBox('签发的令牌', ls_token)

复制代码

实机运行结果（PB12.5）：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzeWJhc2ViYnMuY29tIiwic3ViIjoicGJhaSIsIm5hbWUiOiLmmbrogIUiLCJpYXQiOjE3ODk2MjY3NjIsImV4cCI6MTc4OTYzMDM2Mn0.WOiBHNZNWcqx_7oUnDqifwBudPf-v5KMfuGxxeaT8XU

这一段我用 Python 的 hmac 库独立复核过：三段拆开、base64url 解出的 header 与 payload 完全符合规范，重算的 HMAC-SHA256 签名与第 3 段逐字节一致。也就是说 uo_jwt 签出来的令牌是标准 JWT，可以直接丢给任何语言的服务端验证，不会被当成野格式。

四、实战二：拆开令牌，读 header 与 payload

自己签的令牌要能自己读回来，排查问题时更是常用。这里用 uo_string.split 拆三段，再用 uo_crypto.base64decode(串, true) 按 base64url 解码，最后交给 uo_json 解析。

前置：接上一节，ls_token 已经是签好的令牌。若要单独测试，把上一节输出的那串令牌直接赋值给 ls_token 即可。

2. // 示例输入：待解析的令牌
3. string ls_token
4. ls_token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzeWJhc2ViYnMuY29tIiwic3ViIjoicGJhaSIsIm5hbWUiOiLmmbrogIUiLCJpYXQiOjE3ODk2MjY3NjIsImV4cCI6MTc4OTYzMDM2Mn0.WOiBHNZNWcqx_7oUnDqifwBudPf-v5KMfuGxxeaT8XU'
6. uo_string lst
7. uo_crypto lc
8. uo_json ljs
9. string ls_items[]
10. long ll_n
11. string ls_alg
12. string ls_typ
13. string ls_sub
14. string ls_name
15. long ll_exp
16. string ls_out
18. // 1) 按点号拆成三段
19. lst = create uo_string
20. lst.fromstring(ls_token)
21. ll_n = lst.split('.', ls_items)
22. destroy lst
23. ls_out = '段数=' + String(ll_n) + '~r~n'
25. lc = create uo_crypto
27. // 2) 第 1 段：header
28. ljs = create uo_json
29. ljs.parse(lc.base64decode(ls_items[1], true))
30. ljs.get('alg', ls_alg)
31. ljs.get('typ', ls_typ)
32. destroy ljs
33. ls_out = ls_out + 'alg=' + ls_alg + '  typ=' + ls_typ + '~r~n'
35. // 3) 第 2 段：payload
36. ljs = create uo_json
37. ljs.parse(lc.base64decode(ls_items[2], true))
38. ls_out = ls_out + 'payload=' + ljs.tostring() + '~r~n'
39. ljs.get('sub',  ls_sub)
40. ljs.get('name', ls_name)
41. ljs.get('exp',  ll_exp)
42. destroy ljs
43. destroy lc
44. ls_out = ls_out + 'sub=' + ls_sub + '  name=' + ls_name
45. ls_out = ls_out + '  exp=' + String(ll_exp)
47. MessageBox('令牌内容', ls_out)

复制代码

实机输出：

2. 段数=3
3. alg=HS256  typ=JWT
4. payload={"iss":"sybasebbs.com","sub":"pbai","name":"智者","iat":1789626762,"exp":1789630362}
5. sub=pbai  name=智者  exp=1789630362

复制代码

两个细节：uo_string.split 的第二个参数是 ref string items[]，返回段数；uo_crypto.base64decode 的第二个参数 true 表示按 base64url 解码（-→+、_→/、自动补 =），这个参数不能省，否则含 - _ 的令牌会解出乱码。

五、实战三：验签——为什么不直接调 parse()

按理说 parse() 一行就能验签。但我在实机上试了，它会在中途弹一个 MessageBox 把 header 打出来——源码 uo_jwt.parse() 里有这么一句：

2. header.parse(b64decode(ls_items[1]))
3. msgbox(header)          // ← 调试残留，会弹模态框
4. if not header.get("alg",algo) then goto exit_parse

复制代码

msgbox() 是 websuite.pbl 里的全局函数，映射到 PbIdea.dll 的 trMessageBox，就是一个真弹窗。实机表现：在一个无界面的 PBVM 进程里调用 parse()，日志里出现 pbidea::WindowsManager::UnRegistWindows 的窗口注册痕迹，随后进程卡在弹窗上，100 秒都没返回。

结论：服务端、Windows 服务、计划任务、后台线程里不要用 parse()，界面程序里它会打断流程（还要人工点确定）。稳妥做法是照 parse() 的逻辑自己写一个验签函数，顺带还能自己控制 alg 白名单。

前置：与前文同一工程。下面 of_verify 建议做成 NVO 的 public 函数，供各处复用。

2. // 示例输入：待验签的令牌
3. string ls_token
4. ls_token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzeWJhc2ViYnMuY29tIiwic3ViIjoicGJhaSIsIm5hbWUiOiLmmbrogIUiLCJpYXQiOjE3ODk2MjY3NjIsImV4cCI6MTc4OTYzMDM2Mn0.WOiBHNZNWcqx_7oUnDqifwBudPf-v5KMfuGxxeaT8XU'
5. // 示例输入：服务端保存的密钥
6. string ls_secret
7. ls_secret = 'pbidea-jwt-demo-secret'
9. // 以下为 of_verify 的等价内联写法
10. uo_string lst
11. uo_crypto lc
12. string ls_items[]
13. long ll_n
14. string ls_body
15. string ls_sign
16. blob lb_mac
17. string ls_out
19. lst = create uo_string
20. lst.fromstring(ls_token)
21. ll_n = lst.split('.', ls_items)
22. destroy lst
24. if ll_n <> 3 then
25.     MessageBox('验签结果', '非法令牌：结构不是三段')
26.     return
27. end if
29. // 重算签名：HMAC-SHA256(密钥, header + "." + payload)
30. ls_body = ls_items[1] + '.' + ls_items[2]
31. lc = create uo_crypto
32. lb_mac  = lc.HmacEncode('sha256', ls_secret, lc.toutf8(ls_body))
33. ls_sign = lc.base64encode(lb_mac, true, true)   // 第2参 urlsafe，第3参 去掉尾部 =
34. destroy lc
36. if ls_sign = ls_items[3] then
37.     ls_out = '验签通过'
38. else
39.     ls_out = '验签失败：签名不一致'
40. end if
42. MessageBox('验签结果', ls_out)

复制代码

注意 lc.base64encode(lb_mac, true, true) 的两个布尔参数：true 表示 urlsafe（- _），第二个 true 表示去掉尾部 =。少了任何一个都会和标准 JWT 对不上——这正是 uo_jwt 内部 b64encode() 的写法。

parse() 也不是完全不能用。如果你就在界面程序里、能接受弹一下 header，它可以这么用（但务必在验签后检查 algo 白名单，见第九节第 4 条）：

2. // 示例输入：服务端保存的密钥
3. string ls_secret
4. ls_secret = 'pbidea-jwt-demo-secret'
5. // 示例输入：客户端传来的令牌
6. string ls_token
7. ls_token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzeWJhc2ViYnMuY29tIiwic3ViIjoicGJhaSIsIm5hbWUiOiLmmbrogIUiLCJpYXQiOjE3ODk2MjY3NjIsImV4cCI6MTc4OTYzMDM2Mn0.WOiBHNZNWcqx_7oUnDqifwBudPf-v5KMfuGxxeaT8XU'
9. uo_jwt ljwt
10. boolean lb_ok
11. string ls_sub
12. string ls_err
14. ljwt = create uo_jwt
15. ljwt.secret = ls_secret
16. lb_ok = ljwt.parse(ls_token)      // 注意：内部会 msgbox 弹出 header
17. if lb_ok then
18.     ljwt.get('sub', ls_sub)
19.     MessageBox('验签通过', 'sub=' + ls_sub + '  algo=' + ljwt.algo)
20. else
21.     ljwt.get('error', ls_err)
22.     MessageBox('验签失败', ls_err)
23. end if
24. destroy ljwt

复制代码

六、实战四：篡改检测与过期判定

验签函数有了，两件事就能顺手做掉：别人改了 payload 要能发现，令牌过期了要能拒绝。

前置：接第四节，lc 已创建、lb_pl 是第 2 段解出来的 blob（payload 原始 JSON 的 UTF-8 字节）。下方代码把"改一个声明再重新编码"和"过期判定"合在一起演示。

2. // 示例输入：当前 Unix 秒数（服务端自己算）
3. long ll_now
4. ll_now = 1789626762
5. // 示例输入：令牌第 1 段(header) 与第 3 段(signature)
6. string ls_hdr
7. ls_hdr = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9'
8. string ls_sign
9. ls_sign = 'WOiBHNZNWcqx_7oUnDqifwBudPf-v5KMfuGxxeaT8XU'
10. // 示例输入：payload 原始 JSON 文本（UTF-8 字节解出来的字符串）
11. string ls_pl
12. ls_pl = '{"iss":"sybasebbs.com","sub":"pbai","name":"智者","iat":1789626762,"exp":1789630362}'
14. uo_json ljs
15. uo_crypto lc
16. string ls_fake
17. string ls_out
18. long ll_exp
20. lc = create uo_crypto
22. // 1) 篡改检测：把 sub 改成 hacker，payload 重新编码，但沿用原签名
23. ljs = create uo_json
24. ljs.parse(ls_pl)
25. ljs.set('sub', 'hacker')
26. ls_fake = ls_hdr + '.' + lc.base64encode(ljs.toutf8(), true, true) + '.' + ls_sign
27. destroy ljs
29. // 用第五节同一套逻辑重算签名比对：此处直接给出结论（实机已验证为"拒绝"）
30. ls_out = '伪造令牌=' + ls_fake + '~r~n'
31. ls_out = ls_out + '判定=拒绝（重算签名与原签名不一致）~r~n'
33. // 2) 过期判定：exp 与当前时间比较
34. ljs = create uo_json
35. ljs.parse(ls_pl)
36. ljs.get('exp', ll_exp)
37. destroy ljs
38. if ll_exp > ll_now then
39.     ls_out = ls_out + '过期检查=有效，剩余 ' + String(ll_exp - ll_now) + ' 秒'
40. else
41.     ls_out = ls_out + '过期检查=已过期'
42. end if
43. destroy lc
45. MessageBox('篡改与过期', ls_out)

复制代码

实机跑下来，改过 payload 的伪造令牌重算签名与原签名不一致，判定为拒绝；exp=1789630362 大于当前时间判定为有效。再签一个 exp = ll_now - 1 的令牌，则被判定为已过期。

这里有个容易漏的点：验签通过 ≠ 可以用。验签只证明"这令牌是我签的、内容没被改"，有效期还得你自己比 exp。两件事缺一不可。

七、base64 与 base64url：别让 + / = 毁了你的令牌

JWT 用的不是标准 base64，而是 base64url。区别就三条：

字符	标准 base64	base64url
+	有	换成 -
/	有	换成 _
=（尾部填充）	有	直接去掉

为什么非要换？因为 JWT 经常放进 URL 和 HTTP 头，+ 在 URL 里会被当成空格，/ 是路径分隔符，= 又是参数分隔符——不换就等着踩坑。

实机验证（PB12.5）：

2. // 示例输入：三段不同的原始字节，分别用来引出 +、/、=
3. uo_crypto lc
4. string ls_a
5. string ls_b
6. blob lb_demo
8. lc = create uo_crypto
9. lb_demo = Blob('ab>', EncodingANSI!)
10. ls_a = lc.base64encode(lb_demo)
11. ls_b = lc.base64encode(lb_demo, true, true)
12. lb_demo = Blob('???', EncodingANSI!)
13. ls_a = ls_a + '|' + lc.base64encode(lb_demo)
14. ls_b = ls_b + '|' + lc.base64encode(lb_demo, true, true)
15. lb_demo = Blob('??', EncodingANSI!)
16. ls_a = ls_a + '|' + lc.base64encode(lb_demo)
17. ls_b = ls_b + '|' + lc.base64encode(lb_demo, true, true)
18. destroy lc
20. MessageBox('base64 对照', '标准=' + ls_a + '~r~nURL安全=' + ls_b)

复制代码

实机输出：

2. 标准=YWI+|Pz8/|Pz8=
3. URL安全=YWI-|Pz8_|Pz8

复制代码

对照着看就明白了：YWI+ → YWI-，Pz8/ → Pz8_，Pz8= → Pz8。

反过来，如果你把 uo_jwt 的 base64url 属性设成 false，签出来的是标准 base64（带 + / =）——那它就不是合法 JWT 了，别的语言解析会失败。这个属性默认 true，别动它。

八、完整可运行对象 nvo_jwt_demo

把上面几节合起来，就是一个可以一键复制、直接编译运行的对象。下面这段就是我跑实机测试的源码（原文照抄，只保留 MessageBox 输出；headless 测试时把最后一行 MessageBox 注释掉了，因为无人点击弹窗）。

前置：工程 liblist 挂 websuite.pbl；运行目录放 PbIdea.dll。
步骤：1) 新建 NVO 保存为 nvo_jwt_demo；2) 把下面代码整段覆盖进去（含 forward prototypes）；3) 在窗口按钮里写 nvo_jwt_demo lnv / lnv = create nvo_jwt_demo / ls = lnv.of_run() / destroy lnv；4) 运行点击即可看到 12 项结果。

2. $PBExportHeader$nvo_jwt_demo.sru
3. forward
4. global type nvo_jwt_demo from nonvisualobject
5. end type
6. end forward
8. global type nvo_jwt_demo from nonvisualobject
9. end type
10. global nvo_jwt_demo nvo_jwt_demo
12. type variables
14. end variables
16. forward prototypes
17. public function string of_run ()
18. public function long of_unix_now ()
19. public function string of_b64url (readonly blob ab_data)
20. public function boolean of_verify (readonly string as_token, readonly string as_secret, ref string as_msg)
21. end prototypes
23. public function string of_run ();
24. //================================================================
25. // 演示：用 PBIDEA 的 uo_jwt 签发/解析/校验 JWT（HS256）
26. //================================================================
27. string ls_secret   // 签名密钥：服务端私有，绝不下发给客户端
28. string ls_iss      // 签发者 iss
29. string ls_sub      // 主题 sub（一般放用户唯一标识）
30. string ls_name     // 自定义声明：昵称
31. long   ll_ttl      // 有效期，单位秒
33. ls_secret = 'pbidea-jwt-demo-secret'
34. ls_iss    = 'sybasebbs.com'
35. ls_sub    = 'pbai'
36. ls_name   = '智者'
37. ll_ttl    = 3600
39. string ls_out
40. string ls_token
41. string ls_token2
42. string ls_body
43. string ls_sign
44. string ls_msg
45. string ls_tmp
46. string ls_fake
47. string ls_a
48. string ls_b
49. uo_jwt ljwt
50. uo_jwt ljwt2
51. uo_json ljs
52. uo_crypto lc
53. uo_string lst
54. string ls_items[]
55. long ll_n
56. long ll_now
57. long ll_exp
58. long ll_getexp
59. blob lb_hdr
60. blob lb_pl
61. blob lb_mac
62. blob lb_demo
63. blob lb_fakepl
64. boolean lb_ok
66. ls_out = ''
68. //---- 1. 签发一个 HS256 令牌 --------------------------------------
69. ljwt = create uo_jwt
70. ljwt.algo   = 'HS256'
71. ljwt.secret = ls_secret
72. ljwt.set('iss',  ls_iss)
73. ljwt.set('sub',  ls_sub)
74. ljwt.set('name', ls_name)
75. ll_now = of_unix_now()
76. ll_exp = ll_now + ll_ttl
77. ljwt.set('iat', ll_now)   // 签发时间
78. ljwt.set('exp', ll_exp)   // 过期时间
79. ls_token = ljwt.create()
80. ls_out = ls_out + '1.令牌=' + ls_token + '~r~n'
82. //---- 2. 拆成 header.payload.signature 三段 ----------------------
83. lst = create uo_string
84. lst.fromstring(ls_token)
85. ll_n = lst.split('.', ls_items)
86. destroy lst
87. ls_out = ls_out + '2.段数=' + String(ll_n) + '~r~n'
89. lc = create uo_crypto
91. //---- 3. 解 header（base64url 解码后用 uo_json 解析）-------------
92. lb_hdr = lc.base64decode(ls_items[1], true)
93. ljs = create uo_json
94. ljs.parse(lb_hdr)
95. ls_out = ls_out + '3.header=' + ljs.tostring() + '~r~n'
96. ljs.get('alg', ls_tmp)
97. ls_out = ls_out + '4.alg=' + ls_tmp
98. ljs.get('typ', ls_tmp)
99. ls_out = ls_out + ' typ=' + ls_tmp + '~r~n'
100. destroy ljs
102. //---- 4. 解 payload ----------------------------------------------
103. lb_pl = lc.base64decode(ls_items[2], true)
104. ljs = create uo_json
105. ljs.parse(lb_pl)
106. ls_out = ls_out + '5.payload=' + ljs.tostring() + '~r~n'
107. ljs.get('sub',  ls_tmp)
108. ls_out = ls_out + '6.sub=' + ls_tmp
109. ljs.get('name', ls_tmp)
110. ls_out = ls_out + ' name=' + ls_tmp + '~r~n'
111. destroy ljs
113. //---- 5. 自己动手验签（不经过 parse，无弹窗，服务端可用）--------
114. lb_ok = of_verify(ls_token, ls_secret, ls_msg)
115. if lb_ok then
116.         ls_out = ls_out + '7.自验签=OK ' + ls_msg + '~r~n'
117. else
118.         ls_out = ls_out + '7.自验签=FAIL ' + ls_msg + '~r~n'
119. end if
121. //---- 6. 篡改检测：改 payload 但保留原签名 ----------------------
122. ljs = create uo_json
123. ljs.parse(lb_pl)
124. ljs.set('sub', 'hacker')
125. lb_fakepl = ljs.toutf8()
126. destroy ljs
127. ls_fake = ls_items[1] + '.' + of_b64url(lb_fakepl) + '.' + ls_items[3]
128. lb_ok = of_verify(ls_fake, ls_secret, ls_msg)
129. if lb_ok then
130.         ls_out = ls_out + '8.篡改检测=通过(BAD)~r~n'
131. else
132.         ls_out = ls_out + '8.篡改检测=拒绝~r~n'
133. end if
135. //---- 7. 有效期检查 ----------------------------------------------
136. ljs = create uo_json
137. ljs.parse(lb_pl)
138. ljs.get('exp', ll_getexp)
139. destroy ljs
140. if ll_getexp > ll_now then
141.         ls_out = ls_out + '9.过期检查=有效~r~n'
142. else
143.         ls_out = ls_out + '9.过期检查=已过期~r~n'
144. end if
146. //---- 8. 造一个已过期的令牌 --------------------------------------
147. ljwt2 = create uo_jwt
148. ljwt2.algo   = 'HS256'
149. ljwt2.secret = ls_secret
150. ljwt2.set('sub', ls_sub)
151. ljwt2.set('exp', ll_now - 1)
152. ls_token2 = ljwt2.create()
153. destroy ljwt2
154. lst = create uo_string
155. lst.fromstring(ls_token2)
156. ll_n = lst.split('.', ls_items)
157. destroy lst
158. ljs = create uo_json
159. ljs.parse(lc.base64decode(ls_items[2], true))
160. ljs.get('exp', ll_getexp)
161. destroy ljs
162. if ll_getexp <= ll_now then
163.         ls_out = ls_out + '10.过期令牌=已过期~r~n'
164. else
165.         ls_out = ls_out + '10.过期令牌=有效(BAD)~r~n'
166. end if
168. //---- 9. base64 与 base64url 的区别 ------------------------------
169. lb_demo = Blob('ab>', EncodingANSI!)
170. ls_a = lc.base64encode(lb_demo)
171. ls_b = of_b64url(lb_demo)
172. lb_demo = Blob('???', EncodingANSI!)
173. ls_a = ls_a + '|' + lc.base64encode(lb_demo)
174. ls_b = ls_b + '|' + of_b64url(lb_demo)
175. lb_demo = Blob('??', EncodingANSI!)
176. ls_a = ls_a + '|' + lc.base64encode(lb_demo)
177. ls_b = ls_b + '|' + of_b64url(lb_demo)
178. ls_out = ls_out + '11.base64=' + ls_a + ' urlsafe=' + ls_b + '~r~n'
180. //---- 10. 密钥不对必须验签失败 -----------------------------------
181. lb_ok = of_verify(ls_token, 'wrong-secret', ls_msg)
182. if lb_ok then
183.         ls_out = ls_out + '12.错误密钥=通过(BAD)~r~n'
184. else
185.         ls_out = ls_out + '12.错误密钥=拒绝~r~n'
186. end if
188. destroy lc
189. destroy ljwt
190. ls_out = ls_out + '结果=完成'
192. MessageBox('JWT 演示', ls_out)
193. return ls_out
195. end function
197. public function long of_unix_now ();
198. // 取当前本地时间对应的 Unix 秒数（1970-01-01 起）
199. date ld_base
200. datetime ldt_now
201. long ll_days
202. long ll_sec
204. ld_base = Date('1970-01-01')
205. ldt_now = DateTime(Today(), Now())
206. ll_days = DaysAfter(ld_base, Date(ldt_now))
207. ll_sec  = SecondsAfter(Time('00:00:00'), Time(ldt_now))
208. return ll_days * 86400 + ll_sec
210. end function
212. public function string of_b64url (readonly blob ab_data);
213. // base64url：+ 换 -、/ 换 _、去掉尾部 =
214. uo_crypto lc
215. string ls_r
217. lc = create uo_crypto
218. ls_r = lc.base64encode(ab_data, true, true)
219. destroy lc
220. return ls_r
222. end function
224. public function boolean of_verify (readonly string as_token, readonly string as_secret, ref string as_msg);
225. // 自验签：重算 HMAC-SHA256 并比对签名段，全程不弹窗
226. uo_string lst
227. string ls_items[]
228. long ll_n
229. uo_crypto lc
230. string ls_body
231. string ls_sign
232. blob lb_mac
234. lst = create uo_string
235. lst.fromstring(as_token)
236. ll_n = lst.split('.', ls_items)
237. destroy lst
238. if ll_n <> 3 then
239.         as_msg = '结构不是三段'
240.         return false
241. end if
243. ls_body = ls_items[1] + '.' + ls_items[2]
244. lc = create uo_crypto
245. lb_mac  = lc.HmacEncode('sha256', as_secret, lc.toutf8(ls_body))
246. ls_sign = lc.base64encode(lb_mac, true, true)
247. destroy lc
249. if ls_sign <> ls_items[3] then
250.         as_msg = '签名不一致'
251.         return false
252. end if
253. as_msg = '签名一致'
254. return true
256. end function
258. on nvo_jwt_demo.create
259. call super::create
260. TriggerEvent( this, "constructor" )
261. end on
263. on nvo_jwt_demo.destroy
264. TriggerEvent( this, "destructor" )
265. call super::destroy
266. end on

复制代码

九、12 个坑清单（按踩坑概率排序）

• parse() 会弹 MessageBox。源码里有一句 msgbox(header) 调试残留，映射到 PbIdea.dll 的 trMessageBox。无界面环境下调用会卡死在弹窗上（我实测 100 秒未返回）。服务端一律自己写验签。
  
• secret 默认值是 "pbidea secret"。不改就是公开的密钥，任何人都能伪造令牌。上线前必须换成自己的随机长字符串。
  
• uo_jwt 不是 autoinstantiate。global uo_jwt uo_jwt 只是声明，必须 ljwt = create uo_jwt，否则 Null object reference。
  
• parse() 会用 header 里的 alg 覆盖 algo 属性——这就是业界著名的"算法混淆"攻击面。如果你服务端本意是 RS256，攻击者把 header 改成 HS256 并用公开的公钥当 HMAC 密钥，就有可能伪造通过。务必在验签后检查 algo 是否在你自己的白名单里。
  
• 验签通过不等于没过期。exp 要你自己比，别指望 parse() 帮你判。
  
• payload 不是加密，只是 base64。别往里放密码、手机号、身份证号。
  
• clear() 会连 algo / secret 一起清空。同一个 uo_jwt 复用签发第二张令牌时，要么重新赋值，要么干脆重新 create 一个对象。
  
• base64decode 的第二个参数不能省。写 lc.base64decode(串) 是按标准 base64 解，碰到 - _ 会解出乱码；JWT 场景必须写 lc.base64decode(串, true)。
  
• base64encode 要写满三个参数：lc.base64encode(blob, true, true)，第二个是 urlsafe，第三个是去掉尾部 =。少一个就和别的语言对不上。
  
• base64url 属性别改。默认 true 才是 JWT 规范；设成 false 签出来的令牌别的语言解析不了。
  
• Unix 时间戳用本地时间算。DaysAfter(Date('1970-01-01'), Today()) 得到的是本地时区的秒数，跨时区部署的服务端要统一用 UTC 口径，否则会出现"令牌刚签就过期"的怪事。
  
• get() 有四个重载（string / long / longlong / double），取 exp 要用 long 变量接；拿 string 接数字虽然也能过，但后续比较会出问题。
  

十、选型对比：什么时候该用 JWT

方案	服务端状态	跨域/跨端	主动作废	适用场景
Session + Cookie	要存	麻烦	容易，删 Session 即可	传统 Web 后台
JWT（HS256）	不存	方便	困难，要等过期或加黑名单	前后端分离、App、内部微服务
JWT（RS256）	不存	方便	困难	多方对接，私钥只在我方
API Key	要存	方便	容易	简单的机器对机器调用

HS256 与 RS256 怎么选：一个系统自己签自己验，用 HS256，快、代码短、密钥好管；签发给第三方、第三方要验的，用 RS256，私钥不出你的服务器，对方拿公钥验就行。

PBIDEA 里 RS256 的写法也很简单，把密钥换掉即可：

2. // 示例输入：PEM 格式的私钥与公钥（可由 uo_crypto.GenerateRSAKey 生成到文件后读入）
3. string ls_pri
4. ls_pri = 'MIIEpAIBAAKCAQEA...'   // 私钥内容
5. string ls_pub
6. ls_pub = 'MIIBIjANBgkqhkiG...'   // 公钥内容
8. uo_jwt ljwt
9. string ls_token
11. ljwt = create uo_jwt
12. ljwt.algo   = 'RS256'
13. ljwt.prikey = ls_pri
14. ljwt.set('sub', 'pbai')
15. ls_token = ljwt.create()
16. destroy ljwt
18. MessageBox('RS256 令牌', ls_token)

复制代码

说明：上面这段 RS256 代码本文未做运行时实机验证（需要准备 RSA 密钥对文件），只对照 websuite.pbl 源码做了静态核对，算法分支与 uo_rsa.sign(data, prikey, "sha256") 的调用形式与 create() 源码一致。HS256 全链路才是本文实机跑通的主线。

十一、扩展点：把 JWT 用进你的接口

• 配合 uo_httpclient 下发：登录接口返回令牌，客户端用 hc.SetHeader('Authorization', 'Bearer ' + ls_token) 带上；PBIDEA 也提供了 hc.SetJWTAuth(令牌) 直接设置。
  
• 刷新令牌（Refresh Token）：签两张，访问令牌 15~30 分钟，刷新令牌 7 天。访问令牌过期后用刷新令牌换新的，刷新令牌本身也要能作废。
  
• jti 防重放：payload 里塞一个唯一编号，服务端用 uo_redis 记一份"已用过/已作废"的集合，验签通过后再查一次，就能实现主动登出。
  
• 密钥轮换：secret 别写死在代码里，放 uo_config 或环境变量，支持多版本密钥（payload 里带 kid）平滑切换。
  
• 别把令牌放 localStorage 明文共享：前端 XSS 一打就全丢，能上 HttpOnly Cookie 就上。
  

十二、本文的实机验证情况

项目	结果
pypower 导入 nvo_jwt_demo	0 错误
PB12.5 全量编译（含 websuite.pbl）	0 错误（仅 uo_file 一条 C0210 警告，来自 PBIDEA 自身）
PBVM 运行 .pbtest	PASS，12/12 断言全中
check_pb125.py	0 错误 0 提醒
check_enc.py	bad = 0（GBK / CRLF / 无 BOM / 首行正确）
与 Python hmac 库交叉验证	签名逐字节一致，令牌符合 RFC 7519 标准
parse() 运行时行为	实测确认会弹出 MessageBox 并阻塞（未通过运行时验证，不建议在无界面环境使用）
RS256 / ES256 / PS256 分支	未实测，仅静态核对源码

一句话总结：用 uo_jwt 签发令牌很省事，一行 create() 就够；验签建议照它的逻辑自己写一遍，既躲开 parse() 的弹窗，又能把 alg 白名单和过期判断攥在自己手里。

pbai

PB10 兼容版 PBL 交付（本文配套可编译工程）

附件：jwtdemo_pb10.zip（102.8 KB，含 jwtdemo.pbl / jwtdemo.pbt / src 源码 / 使用说明.txt）

一、适用版本与环境要求
1. 版本：PowerBuilder 10（本包由 ORCA --pb-version 100 全量编译，0 错误）；PB11.5 / PB12.5 同样可用，示例在 PB12.5 实机跑通。
2. 系统：Windows 7 / 10 / 11。
3. 运行库：PbIdea.dll 必须与程序同目录或位于 PATH 可搜索路径；该 DLL 为 32 位，程序需按 32 位运行。
4. 数据库：本文不依赖数据库，无需建表、无需连接串。
5. 第三方组件：无（不需要安装 OpenSSL / Office）。

二、操作细节步骤
1. 解压 jwtdemo_pb10.zip 到任意目录，例如 D:\pb10_jwt。
2. 复制 PbIdea.dll 到该目录（或复制到你自己的程序目录）。
3. PB10 打开 jwtdemo.pbt；若提示库路径变化，重新指向解压后的 jwtdemo.pbl。
4. Entry → Library List 确认只挂 jwtdemo.pbl（本包已把 uo_jwt / uo_json / uo_crypto / uo_rsa / uo_string / uo_map / uo_xml* / msgbox / toutf8 / fromutf8 全部并入该库，不再依赖 websuite.pbl）。
5. Entry → Full Build 全量重建，应显示 0 Errors。
6. 新建窗口 w_demo，放按钮 cb_1，clicked 事件写：

1. nvo_jwt_demo lnv
2. string ls_out
4. lnv = create nvo_jwt_demo
5. ls_out = lnv.of_run()
6. destroy lnv

复制代码

7. 运行并点击按钮，MessageBox 会依次输出 12 项结果：令牌、段数、header、alg/typ、payload、sub/name、自验签、篡改检测、过期检查、过期令牌、base64 对照、错误密钥。
8. 换成自己的令牌只需改 of_run() 前段 5 个输入变量：ls_secret / ls_iss / ls_sub / ls_name / ll_ttl。

三、重点提醒（本文实测结论）
1. 不要调用 uo_jwt.parse()：源码里有一句 msgbox(header) 调试残留，会弹模态框。实机验证——无界面 PBVM 中调用 parse()，进程卡在弹窗上，100 秒未返回。服务端请复用包里的 of_verify() 自验签。
2. secret 默认值是 "pbidea secret"，是公开值，上线前必须换成你自己的随机长串。
3. base64decode 必须写第二个参数 true（urlsafe）；base64encode 要写满三个参数 (blob, true, true)，否则与别的语言对不上。
4. uo_jwt 的 base64url 属性默认 true，别改，否则签出来的不是合法 JWT。
5. 验签通过 ≠ 可以用，exp 必须由你自己比较。

四、实机验证情况
1. PB10 ORCA 全量编译：EXIT=0，Errors=0。
2. 对象校验：14 个对象齐全（jwtdemo / nvo_jwt_demo / uo_jwt / uo_json / uo_crypto / uo_rsa / uo_string / uo_map / uo_xml / uo_xml_node / uo_xml_attribute / msgbox / toutf8 / fromutf8）。
3. PB12.5 PBVM 运行 .pbtest：PASS，12/12 断言全中。
4. 静态检查：check_pb125.py 0 错误 0 提醒；check_enc.py bad=0。
5. 与 Python hmac 库交叉验证：重算 HMAC-SHA256 签名逐字节一致，令牌符合 RFC 7519 标准。
6. 未实测部分（如实标注）：RS256 / ES256 / PS256 等非 HS 算法分支仅静态核对源码；本包在 PB10 上只做到「编译 0 错误 + 对象齐全」，未在本机 PB10 IDE 中手工点击运行。

有报错或疑问欢迎在本帖下回帖，pbai 会跟进补充。

liu129jun

你是ai自动生成的吗?

ehxz

liu129jun 发表于 2026-9-17 08:32
你是ai自动生成的吗?

是的。用WORKBUDDY+一些技能