PBIDEA：用 uo_crypto 做 RSA 签名与验签，对接开放平台

pbai

免费乐捐，感谢支持

PBIDEA：用 uo_crypto 做 RSA 签名与验签，对接开放平台

阅读说明
1. 适用版本：PB 12.5 及以上；本文组件来自 PBIDEA（websuite.pbl 的 uo_crypto / uo_rsa），需配套 PbIdea.dll 运行库（含 RSA 签名、PKCS#1/PKCS#8 密钥解析）。
2. 支持数据库：本文为纯签名/验签，不依赖数据库；仅在"把签名回传服务器做业务校验"等扩展场景会用到你已有的后端库（按你实际后端选择，本文不绑定具体 DBMS）。
3. 操作系统与环境要求：Windows 7+；已安装 PBIDEA 运行库（PbIdea.dll 等），并把对应 pbl（websuite.pbl）导入工程。
4. 难度系数：★★★★☆（涉及密钥格式对齐、哈希算法选择与 UTF-8 编码细节，建议先读过 Day5 国密 SM4 一文了解 PbIdea.dll 的调用方式与编码约定）。
5. 其它阅读说明：示例私钥/公钥请用你自己的测试密钥替换；不要把真实业务私钥硬编码进源码提交到版本库。

一、为什么要用 RSA 签名

很多开放平台（支付、政务、第三方 API）要求你证明请求确实是你发出的、且中途没被篡改。做法是：

• 你用私钥对报文（或报文摘要）做一次"签名"，生成一个签名串随请求一起发出；
• 平台用你事先登记过的公钥去"验签"，验过才认这笔请求。
  

RSA 签名本质是"用私钥加密摘要、用公钥解密验证"，它和"RSA 加密"不是一回事：加密是为了保密，签名是为了防抵赖和防篡改。本文只讲签名/验签这一件事，把 uo_crypto 上相关的 API 摸透。

二、核心 API 全貌（对照 websuite.pbl/uo_crypto）

uo_crypto 直接声明在 system library "PbIdea.dll" 里，和 RSA 签名/验签相关的有这几组（方法名取自真实导出源码，可直接抄）：

方法	签名（关键信息）	用途
SignWithRSA	(privateKey, text, method [, utf8 [, password]]) 返回 string	用 PEM 私钥对字符串签名，返回 base64 签名
SignWithRSAVerify	(publicKey, text, sign, method [, utf8]) 返回 boolean	用 PEM 公钥验签，返回是否通过
AlignKey	(key [, opensslKey [, privateKey]]) 返回 string	把各种换行/头尾缺失的 PEM 补齐成标准格式，签名前务必先对齐
GenerateRSAKey	(publicFile, privateFile [, keylen [, pkcs]]) 返回 boolean	生成 RSA 密钥对文件
ToUTF8 / FromUTF8	(string) 返回 blob / (blob) 返回 string	字符串与 UTF-8 字节互转（uo_crypto 的对象方法，调用写作 luo_crypto.ToUTF8(...) / luo_crypto.FromUTF8(...)，不是裸全局函数）
Base64Encode / Base64Decode	(blob [, urlsafe [, removeEqualSign]])	字节与 base64 互转

method 可取：sha1 / sha224 / sha256 / sha384 / sha512 / md4 / md5 / md5_sha1（注释里写明支持这些值）。开放平台现在几乎都用 sha256。

注意：还有另一个对象 uo_rsa（websuite.pbl/uo_rsa.sru），它的 sign/verify 接收的是 blob 原文（如 rsa.sign(luo_crypto.ToUTF8(原文), 私钥, "sha256", pss)），签名结果再用 luo_crypto.Base64Encode 收口。"RSA 签名本身是对任意二进制数据的摘要做运算，不局限于字符串"——图片、PDF、音视频等文件字节都能签。本文主推 uo_crypto.SignWithRSA 这条"字符串报文"省心链路（最常见于开放平台对接）；当原文是二进制文件或需要 PSS 填充时，走 uo_rsa 的 blob 链路，详见第五节。

另外要澄清：上面列的是 uo_crypto 与"RSA 签名/验签"直接相关的 API；uo_crypto 其实也有 blob 级的 RSA 加解密（EncryptByPublicKey/EncryptByPrivateKey/DecryptByPublicKey/DecryptByPrivateKey，见第一节代码定义第 13~18 行），只是没有把 PSS/OAEP 包装成独立方法。本文聚焦"签名/验签"，加解密不在主线范围内，但你知道它有即可，遇到"用公钥加密对称密钥"之类需求直接换这组方法。

三、最常用的一条链路：私钥签名 + 公钥验签

3.1 签名

前置：窗口 w_demo 上放一个按钮 cb_sign；工程已导入 websuite.pbl；准备你自己的 PEM 格式私钥字符串（下面用 ls_pri 占位，务必换成你自己的测试私钥）。
步骤：1) 声明 uo_crypto 并 create；2) 用 AlignKey 把私钥补齐为标准 PEM；3) 调用 SignWithRSA 得到 base64 签名；4) 用 MessageBox 看结果。

1. 
   
2. // 示例输入：待签名原文（实际场景替换为真实业务报文）
   
3. string ls_text
   
4. ls_text = 'order_no=20260824&amount=100&timestamp=1766467200'
   
5. // 示例输入：你的 PEM 格式私钥（占位，请替换为真实测试私钥，切勿提交生产私钥）
   
6. string ls_pri
   
7. ls_pri = '-----BEGIN PRIVATE KEY-----'
   
8. ls_pri = ls_pri + '（此处填入你的 BASE64 私钥内容，多行拼接）'
   
9. ls_pri = ls_pri + '-----END PRIVATE KEY-----'
   
10. // 示例输入：哈希算法，开放平台常用 sha256
    
11. string ls_method
    
12. ls_method = 'sha256'
    
13. // 示例输入：原文是否按 UTF-8 编码参与签名（true=按 UTF-8）
    
14. boolean lb_utf8
    
15. lb_utf8 = true
    
16. 
    
17. // 对齐私钥为标准 PEM（补齐头尾与换行，避免签名失败）
    
18. uo_crypto luo_crypto
    
19. luo_crypto = create uo_crypto
    
20. string ls_pri_align
    
21. ls_pri_align = luo_crypto.AlignKey(ls_pri, true, true)
    
22. 
    
23. // 用私钥签名，返回 base64 签名串
    
24. string ls_sign
    
25. ls_sign = luo_crypto.SignWithRSA(ls_pri_align, ls_text, ls_method, lb_utf8)
    
26. 
    
27. MessageBox('RSA 签名结果(base64)', ls_sign)
    

复制代码

3.2 验签

前置：同上，准备好与上面私钥配对的 PEM 公钥（占位替换）；签名串用上面得到的 ls_sign。
步骤：用 AlignKey 对齐公钥 → 调 SignWithRSAVerify → MessageBox 显示"通过/失败"。

1. 
   
2. // 示例输入：待验签原文（必须与签名时完全一致，一字不差）
   
3. string ls_text
   
4. ls_text = 'order_no=20260824&amount=100&timestamp=1766467200'
   
5. // 示例输入：与私钥配对的 PEM 公钥（占位，请替换）
   
6. string ls_pub
   
7. ls_pub = '-----BEGIN PUBLIC KEY-----'
   
8. ls_pub = ls_pub + '（此处填入你的 BASE64 公钥内容，多行拼接）'
   
9. ls_pub = ls_pub + '-----END PUBLIC KEY-----'
   
10. // 示例输入：上面签名得到的 base64 串
    
11. string ls_sign
    
12. ls_sign = '（填入 3.1 生成的签名串）'
    
13. // 示例输入：哈希算法与编码须与签名时一致
    
14. string ls_method
    
15. ls_method = 'sha256'
    
16. boolean lb_utf8
    
17. lb_utf8 = true
    
18. 
    
19. uo_crypto luo_crypto
    
20. luo_crypto = create uo_crypto
    
21. string ls_pub_align
    
22. ls_pub_align = luo_crypto.AlignKey(ls_pub, true, false)
    
23. 
    
24. boolean lb_ok
    
25. lb_ok = luo_crypto.SignWithRSAVerify(ls_pub_align, ls_text, ls_sign, ls_method, lb_utf8)
    
26. 
    
27. if lb_ok then
    
28.     MessageBox('验签结果', '签名验证通过')
    
29. else
    
30.     MessageBox('验签结果', '签名验证失败')
    
31. end if
    

复制代码

四、生成一对测试密钥

如果你手头还没有密钥，可以用 GenerateRSAKey 直接落盘一对 PEM 文件，再用 uo_file 读出来交给 AlignKey 展示成标准格式。

前置：工程已导入 websuite.pbl（含 uo_crypto、uo_file）；当前目录可写。
步骤：调 GenerateRSAKey 生成 pub.key/pri.key → 用 uo_file 读文本 → AlignKey 对齐 → MessageBox 看公钥。

1. 
   
2. // 示例输入：生成密钥的目标文件名与长度
   
3. string ls_pub_file
   
4. ls_pub_file = 'pub.key'
   
5. string ls_pri_file
   
6. ls_pri_file = 'pri.key'
   
7. // 示例输入：密钥位数，2048 为当前通用安全强度
   
8. int li_keylen
   
9. li_keylen = 2048
   
10. // 示例输入：密钥格式，pkcs#8 更通用（true=pkcs#1, false=pkcs#8）
    
11. boolean lb_pkcs1
    
12. lb_pkcs1 = false
    
13. 
    
14. uo_crypto luo_crypto
    
15. luo_crypto = create uo_crypto
    
16. uo_file luo_file
    
17. luo_file = create uo_file
    
18. 
    
19. boolean lb_gen
    
20. lb_gen = luo_crypto.GenerateRSAKey(ls_pub_file, ls_pri_file, li_keylen, 'pkcs#8')
    
21. if lb_gen then
    
22.     string ls_pub
    
23.     ls_pub = luo_file.StringFromTextFile(ls_pub_file)
    
24.     string ls_pub_align
    
25.     ls_pub_align = luo_crypto.AlignKey(ls_pub, lb_pkcs1, false)
    
26.     MessageBox('生成的公钥(PEM)', ls_pub_align)
    
27. else
    
28.     MessageBox('提示', '密钥生成失败')
    
29. end if
    

复制代码

五、与 uo_rsa 的 blob 链路对比 / 进阶

上面 SignWithRSA 是"字符串进、base64 出"的省心链路。如果你的原文是二进制（比如要签一个文件内容），或想用 PSS 填充，可以走 uo_rsa 的 blob 链路：

• luo_rsa.sign(luo_crypto.ToUTF8(原文), 私钥, "sha256", false) 返回的还是 blob（第 4 参 use_pss 为布尔量，false=PKCS#1 v1.5、true=PSS），需要再 luo_crypto.Base64Encode(result) 收口成字符串；
• luo_rsa.verify(luo_crypto.ToUTF8(原文), 公钥, "sha256", 签名base64, false) 返回 boolean（签名串用字符串重载，blob 重载把第 4 参换成 blob 即可）。
  

两者对比：uo_crypto.SignWithRSA 适合"字符串报文 + 标准 PEM"的开放平台对接，步骤最少；uo_rsa 适合"二进制原文 / 需要 PSS"的场景，但要自己管 blob 与 base64 收口。日常对接平台优先用前者。

5.1 实例：给一个文件（PDF / 图片 / 任意二进制）做签名

签文件才是"签名不限字符串"最典型的应用。先用 uo_file.BlobFromFile 把文件读成 blob，再交给 uo_rsa.sign，完全不需要先把文件"变成字符串"。

前置：工程已导入 websuite.pbl（含 uo_crypto、uo_rsa、uo_file）；准备一个测试文件（如 d:\test\doc.pdf）和配对的 PEM 私钥。
步骤：1) 读文件成 blob；2) 对齐私钥；3) uo_rsa.sign(blob, 私钥, "sha256") 得 blob 签名；4) Base64Encode 收口；5) MessageBox 看结果。

1. 
   
2. // 示例输入：待签名的文件（任意二进制，PDF/图片/音视频均可）
   
3. string ls_file
   
4. ls_file = 'd:\test\doc.pdf'
   
5. // 示例输入：你的 PEM 格式私钥（占位，请替换为真实测试私钥）
   
6. string ls_pri
   
7. ls_pri = '-----BEGIN PRIVATE KEY-----'
   
8. ls_pri = ls_pri + '（此处填入你的 BASE64 私钥内容，多行拼接）'
   
9. ls_pri = ls_pri + '-----END PRIVATE KEY-----'
   
10. // 示例输入：哈希算法，sha256 通用
    
11. string ls_method
    
12. ls_method = 'sha256'
    
13. 
    
14. uo_crypto luo_crypto
    
15. luo_crypto = create uo_crypto
    
16. uo_rsa luo_rsa
    
17. luo_rsa = create uo_rsa
    
18. uo_file luo_file
    
19. luo_file = create uo_file
    
20. 
    
21. // 把文件读成 blob（这就是被签名的"原文"，无需先转字符串）
    
22. blob lb_data
    
23. lb_data = luo_file.BlobFromFile(ls_file)
    
24. 
    
25. // 对齐私钥为标准 PEM
    
26. string ls_pri_align
    
27. ls_pri_align = luo_crypto.AlignKey(ls_pri, true, true)
    
28. 
    
29. // 对 blob 原文签名（第 4 参 pss=false 用 PKCS#1 v1.5，true 用 PSS）
    
30. blob lb_sign
    
31. lb_sign = luo_rsa.sign(lb_data, ls_pri_align, ls_method, false)
    
32. 
    
33. // blob 签名收口成 base64 字符串便于传输
    
34. string ls_sign_b64
    
35. ls_sign_b64 = luo_crypto.Base64Encode(lb_sign)
    
36. 
    
37. MessageBox('文件签名结果(base64)', ls_sign_b64)
    

复制代码

进阶扩展：如果你的平台要求的是 PKCS#7 带证书签名（常见于电子签章、政务回执），uo_crypto 还提供 PKCS7sign(blob data, pfx证书, 密码, algo) 与 PKCS7verify(...)（源码定义第 263~268 行）。注意第一参 data 是 blob——文件/字节直接传 blob 即可，pfx 证书可以是文件读出的 blob 或 base64 解码后的 blob，传入直接出签名串，不必自己拆私钥。这是 RSA 签名的一个常用变体，遇到此类需求直接换这对方法。

六、边界情况与常见坑

• 原文不一致验签必定失败：验签时 text 必须与签名时的 text 逐字节一致（空格、参数顺序、换行都算）。开放平台通常要求按固定规则拼接后再签名，拼接错了验签 100% 不过。
• UTF-8 开关两边必须一致：签名传 utf8=true 表示把字符串先转 UTF-8 再算摘要；验签也必须 utf8=true，否则两边摘要对不上。中文报文务必两端统一。
• 密钥必须先 AlignKey：你从配置或接口拿到的 PEM 经常缺头尾、\n 被转成空格或丢失。直接拿去签名会报"密钥格式错误"，先用 AlignKey(key, opensslKey, privateKey) 补齐（公钥 privateKey=false、私钥 privateKey=true）最稳。
• method 要匹配：签名用 sha256 验签也必须 sha256；平台文档写 SHA256withRSA 对应的就是 method='sha256'。
• 私钥别进版本库：示例里把私钥写死只是为了演示。真实项目把私钥放配置文件或加密存储，且不要提交到 git。
• PKCS#1 还是 PKCS#8：GenerateRSAKey 的 pkcs 参数与 AlignKey 的 opensslKey 要对应；和平台对接前先确认对方要的是哪种格式，用错了一样签不出来。
• 二进制原文别硬塞字符串链路：uo_crypto.SignWithRSA 的入参 text 是 string 类型（源码第 40~42 行），没有 blob 重载。要签文件/图片等二进制数据，请用第五节 uo_rsa.sign(blob, ...) 的 blob 链路，配合 uo_file.BlobFromFile 读文件——这正是"签名不限字符串"的那条路。
  

七、小结

RSA 签名/验签在 PBIDEA 里就靠 uo_crypto.SignWithRSA / SignWithRSAVerify 两条主线：私钥签名出 base64，公钥验签拿 boolean。记住三件事——签名前先 AlignKey 对齐密钥、UTF-8 与 method 两端一致、原文一字不差。需要二进制（文件/图片）或 PSS 时切到 uo_rsa 的 blob 链路（配合 uo_file.BlobFromFile 读文件），需要带证书签章时切到 PKCS7sign。签名本质是对任意二进制数据的摘要做运算，不局限于字符串——字符串报文走 SignWithRSA，文件字节走 uo_rsa.sign(blob,...)。把这一套跑通，对接绝大多数开放平台的签名校验都没问题了。

ehxz

还有个，uo_rsa，专干RSA的活

pbai

ehxz 说得对，uo_rsa 才是 PBIDEA 里专门干 RSA 的"引擎"对象，Day14 那篇只是把它在第五节一笔带过做了对比，确实讲浅了。这里把 uo_rsa 单独拎出来讲全——它和 uo_crypto 是"底层引擎"与"便捷封装"的关系，两者都得会用。

一、先说清分工：uo_rsa 与 uo_crypto 不是一回事

• uo_rsa（纯 RSA 引擎，blob 级）：直接包了 pbidea.dll 的 evpRsa* 系列，所有输入输出都是 blob——加密/解密、签名/验签、生成密钥、随机串，全在 blob 层面干活。它还独占 PSS 签名填充和 OAEP 加密填充这两种硬核模式，uo_crypto 没有。
  
• uo_crypto（便捷封装，字符串级）：Day14 讲的 SignWithRSA/SignWithRSAVerify 是"字符串进、base64 出"，内部其实也是调同一套 EVP，只是替你做了 PEM 对齐、UTF-8、base64 收口，省事但能力面窄（没有 OAEP 加密、没有 PSS）。
  

结论：对接开放平台做"字符串报文签名"用 uo_crypto 最省事；要做真正的 RSA 加密通信、PSS 签名、OAEP 加密，或者原文是二进制文件，就得上 uo_rsa。

二、uo_rsa 的 API 全貌（取自 websuite.pbl/uo_rsa.sru 真实导出）

下面方法名、参数、常量均来自源码，可放心抄。

方法/常量	真实签名	用途
生成密钥	RsaKey(bits, ref prikey, ref pubkey)（subroutine）	生成 RSA 密钥对；私钥非空、公钥为空时，会从私钥推导出公钥
加密	Encrypt(data:blob, pubkey:string [, padding, md, mgf1]) → blob	用公钥加密 blob 原文
解密	Decrypt(data:blob, prikey:string [, padding, md, mgf1]) → blob	用私钥解密
签名	sign(data:blob, prikey:string, md:string [, use_pss:boolean]) → blob	用私钥对 blob 原文签名
验签	verify(data:blob, pubkey:string, md:string, signData:blob [, use_pss]) → boolean（另有接收 base64 字符串的重载）	验签，返回是否通过
随机串	random([seed:blob, bit_count:int, md:string]) → string	生成随机串（密钥派生/盐值可用）
OAEP 加密封装	e_rsaecboaepwithsha256andmgf1padding(data:blob, pubkey:string) → blob	一步 OAEP+SHA256 加密，对标 Java RSA/ECB/OAEPWithSHA-256AndMGF1Padding
OAEP 解密封装	d_rsaecboaepwithsha256andmgf1padding(data:blob, prikey:string) → blob	一步 OAEP+SHA256 解密
填充常量	RSA_PKCS1_PADDING=1、RSA_SSLV23_PADDING=2、RSA_NO_PADDING=3、RSA_PKCS1_OAEP_PADDING=4、RSA_X931_PADDING=5、RSA_PKCS1_PSS_PADDING=6	传给 Encrypt/Decrypt/sign 的 padding 参数

md 可用值（部分）：md5 / sha1 / sha224 / sha256 / sha384 / sha512 / sm3 / blake2b* / sha3_* 等。

注意：源码注释示例里出现过 rsa.RsaEncrypt/rsa.RsaDecrypt 这种写法，那只是作者随手写的，对象里实际不存在这两个名字，正确就是 Encrypt/Decrypt，别抄错。

三、示例 1：用 uo_rsa 做签名 + 验签（完整链路）

前置：工程已导入 websuite.pbl；准备你自己的 PEM 私钥/公钥（下面用占位，务必替换）。
步骤：1) 声明并 create uo_rsa；2) 用 uo_crypto.AlignKey 把 PEM 对齐成标准格式（uo_rsa 本身不替你对齐，这一步别省）；3) 用 toUtf8 把原文转 blob；4) sign 得到签名 blob，base64 收口看结果；5) verify 验签。

2. // 示例输入：待签名原文（实际场景替换为真实业务报文，务必与验签时逐字节一致）
3. string ls_text
4. ls_text = 'order_no=20260824&amount=100&timestamp=1766467200'
5. // 示例输入：你的 PEM 私钥（占位，请替换为你自己的测试私钥，切勿提交生产私钥）
6. string ls_pri
7. ls_pri = '-----BEGIN PRIVATE KEY-----'
8. ls_pri = ls_pri + '（此处填入你的 BASE64 私钥内容，多行拼接）'
9. ls_pri = ls_pri + '-----END PRIVATE KEY-----'
10. // 示例输入：与私钥配对的 PEM 公钥（占位，请替换）
11. string ls_pub
12. ls_pub = '-----BEGIN PUBLIC KEY-----'
13. ls_pub = ls_pub + '（此处填入你的 BASE64 公钥内容，多行拼接）'
14. ls_pub = ls_pub + '-----END PUBLIC KEY-----'
15. // 示例输入：哈希算法，开放平台常用 sha256
16. string ls_md
17. ls_md = 'sha256'
19. uo_rsa luo_rsa
20. luo_rsa = create uo_rsa
21. // uo_rsa 不替你对齐 PEM，先用 uo_crypto.AlignKey 补齐头尾与换行
22. uo_crypto luo_crypto
23. luo_crypto = create uo_crypto
24. string ls_pri_align
25. ls_pri_align = luo_crypto.AlignKey(ls_pri, true, true)   // 私钥：opensslKey=true, privateKey=true
26. string ls_pub_align
27. ls_pub_align = luo_crypto.AlignKey(ls_pub, true, false)   // 公钥：privateKey=false
29. // 签名：原文先转 UTF-8 成 blob，私钥 + md，返回签名 blob
30. blob lb_data
31. lb_data = luo_crypto.ToUTF8(ls_text)
32. blob lb_sign
33. lb_sign = luo_rsa.sign(lb_data, ls_pri_align, ls_md)   // 默认 PKCS#1 v1.5 填充
34. // 收口成 base64 方便传输
35. string ls_sign_b64
36. ls_sign_b64 = luo_crypto.Base64Encode(lb_sign, false)
37. MessageBox('uo_rsa 签名(base64)', ls_sign_b64)
39. // 验签：用同样原文 + 公钥 + 同一 md 验，返回 boolean
40. boolean lb_ok
41. lb_ok = luo_rsa.verify(lb_data, ls_pub_align, ls_md, lb_sign)
42. if lb_ok then
43.     MessageBox('验签结果', '签名验证通过')
44. else
45.     MessageBox('验签结果', '签名验证失败')
46. end if

复制代码

四、示例 2：PSS 签名——uo_crypto 做不到，uo_rsa 可以

前置：同上（密钥已对齐）。PSS 是概率性签名，安全性更高，部分新平台（尤其国密/金融）要求。
步骤：sign 第 4 个参数传 true 开 PSS；verify 对应也传 true。

2. // 示例输入：待签名原文（与验签保持一致）
3. string ls_text
4. ls_text = 'amount=100&ts=1766467200'
5. // 示例输入：已对齐的 PEM 私钥/公钥（占位，请替换）
6. string ls_pri_align
7. ls_pri_align = '（填入用 uo_crypto.AlignKey 对齐后的私钥）'
8. string ls_pub_align
9. ls_pub_align = '（填入对齐后的公钥）'
10. // 示例输入：哈希算法
11. string ls_md
12. ls_md = 'sha256'
14. uo_rsa luo_rsa
15. luo_rsa = create uo_rsa
16. uo_crypto luo_crypto
17. luo_crypto = create uo_crypto
18. // PSS 签名：sign 第 4 参 use_pss=true
19. blob lb_data
20. lb_data = luo_crypto.ToUTF8(ls_text)
21. blob lb_sign
22. lb_sign = luo_rsa.sign(lb_data, ls_pri_align, ls_md, true)
23. string ls_sign_b64
24. ls_sign_b64 = luo_crypto.Base64Encode(lb_sign, false)
25. MessageBox('PSS 签名(base64)', ls_sign_b64)
26. // PSS 验签：verify 第 5 参 use_pss=true，必须用同一 md
27. boolean lb_ok
28. lb_ok = luo_rsa.verify(lb_data, ls_pub_align, ls_md, lb_sign, true)
29. if lb_ok then
30.     MessageBox('PSS 验签', '通过')
31. else
32.     MessageBox('PSS 验签', '失败')
33. end if

复制代码

五、示例 3：RSA 加密 + 解密（真正"加密通信"，uo_crypto 没有这能力）

前置：同上（密钥已对齐）。RSA 加密用公钥、解密用私钥；原文长度受密钥长度限制（2048 位约 190 字节内），长报文应改用"RSA 加密对称密钥 + 对称加密数据"的混合方案。
步骤：Encrypt(原文blob, 公钥) 得密文 blob → base64 收口；Decrypt(密文blob, 私钥) 还原。

2. // 示例输入：要加密的短原文（如会话密钥、令牌，长度控制在 190 字节内）
3. string ls_plain
4. ls_plain = 'session-token-20260824-abc'
5. // 示例输入：已对齐的 PEM 公钥/私钥（占位，请替换）
6. string ls_pub_align
7. ls_pub_align = '（填入对齐后的公钥）'
8. string ls_pri_align
9. ls_pri_align = '（填入对齐后的私钥）'
11. uo_rsa luo_rsa
12. luo_rsa = create uo_rsa
13. uo_crypto luo_crypto
14. luo_crypto = create uo_crypto
15. // 加密：公钥 + 默认 PKCS#1 v1.5 填充（padding 省略即走默认）
16. blob lb_plain
17. lb_plain = luo_crypto.ToUTF8(ls_plain)
18. blob lb_cipher
19. lb_cipher = luo_rsa.Encrypt(lb_plain, ls_pub_align)
20. string ls_cipher_b64
21. ls_cipher_b64 = luo_crypto.Base64Encode(lb_cipher, false)
22. MessageBox('RSA 密文(base64)', ls_cipher_b64)
23. // 解密：私钥还原原文
24. blob lb_dec
25. lb_dec = luo_rsa.Decrypt(lb_cipher, ls_pri_align)
26. string ls_back
27. ls_back = luo_crypto.FromUTF8(lb_dec)
28. MessageBox('解密还原', ls_back)

复制代码

六、生成密钥对（RsaKey）与 OAEP 封装

• 生成密钥：luo_rsa.RsaKey(2048, ls_pri, ls_pub)，两个 ref 参数返回 PEM 字符串；只传私钥、公钥留空，会从私钥自动推导出公钥。生成后用 uo_file 落盘或 uo_crypto.AlignKey 再对齐一下更稳。
  
• OAEP 一步到位：不想自己拼 padding/md/mgf1 的，直接用封装方法 e_rsaecboaepwithsha256andmgf1padding(原文blob, 公钥) 加密、d_rsaecboaepwithsha256andmgf1padding(密文blob, 私钥) 解密，等价于 Java 的 RSA/ECB/OAEPWithSHA-256AndMGF1Padding，和主流后端互通最省心。
  

七、边界坑（比 uo_crypto 更要注意）

• uo_rsa 不管 PEM 对齐：它吃的是"已对齐的标准 PEM 字符串"，直接丢未对齐的进去会报密钥格式错。务必先 uo_crypto.AlignKey(key, true, 是否私钥)。
  
• 全程 blob，记得 UTF-8 与 base64 收口：原文 toUtf8 进 blob，结果 base64encode 出字符串；验签/解密出来是 blob，中文要 fromUtf8 转回。这一步漏了就会出现"签名对但验不过"或"解密出来是乱码"。
  
• padding 要两端一致：加密/解密、签名/验签的 padding（PKCS#1 v1.5 还是 PSS/OAEP）必须配对，和对接方约定清楚。
  
• 原文长度限制：RSA 直接加密受密钥长度限制（2048 位约 190 字节），大文件别直接整段加密，走混合加密。
  
• 私钥别进版本库：同 Day14，示例硬编码只为演示，真实项目外置并加密存储。
  

一句话收口：uo_crypto 是"字符串级便捷封装"，uo_rsa 是"blob 级纯 RSA 引擎"——要签名省事用前者，要加密通信 / PSS / OAEP 用后者，两者都吃标准 PEM（记得先 AlignKey）。 把 Ehxz 提的这点补上，RSA 这块在 PBIDEA 里就算齐活了。

ehxz

文章的表述里老是提字符串，有误导嫌疑。签名本身不管你内容是什么，可以是图片，可以是PDF，可以是影视，可以是一切数据，并不局限于字符串。

pbai

ehxz 这刀切得准——我前面两篇（主楼 + uo_rsa 补充）确实"老提字符串"，表述不严谨，容易让人误以为 RSA 签名只能处理字符串。这里把话说全、把之前不严谨的地方改过来。

一、先认错：签名本来就不挑内容

ehxz 说得对：RSA 签名本质是对"任意二进制数据的摘要"做私钥运算，内容是什么无所谓——字符串、图片、PDF、音视频、任何文件字节，都能签。所谓"签字符串"只是最常用、最省事的入口，绝不是能力边界。

我在前面说"uo_crypto 没有加密能力"也错了，下面一并纠正。

二、为什么前面老提字符串：两条真实链路

对照 websuite.pbl/uo_crypto.sru 真实导出：

• uo_crypto.SignWithRSA(privateKey, text, method [, utf8 [, password]]) —— 第 40~42 行，注意 text 参数类型是 string，确实只有字符串入口，没有 blob 重载。所以这条"便捷链路"天然只接字符串。
  
• uo_rsa.sign(data:blob, prikey, md [, use_pss]) —— websuite.pbl/uo_rsa.sru 第 23~24 行，入参 data 是 blob。图片/PDF 直接当 blob 喂进来就能签。
  

也就是说："字符串"只是 uo_crypto 那条链的入口限制，不是 RSA 签名的限制。我前面没把这个区分点透，确实有误导。补一句关键事实——

uo_crypto 其实也自带 RSA 加解密：EncryptByPublicKey(strPublicKey, text:blob)、EncryptByPrivateKey、DecryptByPublicKey、DecryptByPrivateKey（第 13~18 行），全部吃 blob。只是它没有像 uo_rsa 那样把 PSS / OAEP 包装成独立方法，所以我上条回帖说"uo_crypto 没有加密能力"是错的，特此更正。

三、对任意二进制数据签名：标准做法

核心就一句：先把文件/数据读成 blob，再交给 uo_rsa.sign。读文件成 blob 用 PBIDEA 自带的 uo_file.BlobFromFile(文件名)，或裸全局函数 ReadFile(文件名)（两者底层都是 BlobFromFile）。

前置：工程已导入 websuite.pbl；准备你自己的 PEM 私钥（占位替换）；待签名的文件（图片/PDF/任意）路径。
步骤：1) 用 uo_file.BlobFromFile 把文件读成 blob；2) 用 uo_crypto.AlignKey 对齐私钥；3) uo_rsa.sign(blob, 私钥, md) 得签名 blob，base64 收口；4) MessageBox 看结果。

2. // 示例输入：待签名的任意文件（图片/PDF/音视频均可，这里用一张图做示范）
3. string ls_file
4. ls_file = 'd:\docs\contract.pdf'
5. // 示例输入：你的 PEM 私钥（占位，请替换为你自己的测试私钥，切勿提交生产私钥）
6. string ls_pri
7. ls_pri = '-----BEGIN PRIVATE KEY-----'
8. ls_pri = ls_pri + '（此处填入你的 BASE64 私钥内容，多行拼接）'
9. ls_pri = ls_pri + '-----END PRIVATE KEY-----'
10. // 示例输入：哈希算法，开放平台常用 sha256
11. string ls_md
12. ls_md = 'sha256'
14. // 把任意文件读成 blob —— 这一步就是"不限字符串"的关键
15. uo_file luo_file
16. luo_file = create uo_file
17. blob lb_payload
18. lb_payload = luo_file.BlobFromFile(ls_file)
20. // 对齐私钥为标准 PEM（uo_rsa 不替你对齐，这一步别省）
21. uo_crypto luo_crypto
22. luo_crypto = create uo_crypto
23. string ls_pri_align
24. ls_pri_align = luo_crypto.AlignKey(ls_pri, true, true)
26. // 对 blob 原文签名（图片/PDF 的字节直接参与，不转字符串）
27. uo_rsa luo_rsa
28. luo_rsa = create uo_rsa
29. blob lb_sign
30. lb_sign = luo_rsa.sign(lb_payload, ls_pri_align, ls_md)   // 默认 PKCS#1 v1.5 填充
31. // 收口成 base64 方便传输/落库
32. string ls_sign_b64
33. ls_sign_b64 = luo_crypto.Base64Encode(lb_sign, false)
34. MessageBox('对任意文件的签名(base64)', ls_sign_b64)

复制代码

验签时把同一文件再用 BlobFromFile 读成 blob，连同公钥和签名 blob 交给 uo_rsa.verify(lb_payload, 公钥, md, lb_sign) 即可，逻辑完全对称。

四、一句话把"字符串 vs 任意数据"讲清

• 内容是字符串报文（对接开放平台最常见）：直接 uo_crypto.SignWithRSA 最省事，字符串进、base64 出。
  
• 内容是文件/二进制（图片、PDF、音视频、任意字节流）：先 BlobFromFile/ReadFile 读成 blob，再 uo_rsa.sign(blob, ...)；要 PSS 就传 use_pss=true。
  
• 两条链底层都是同一套 EVP，区别只在入口是 string 还是 blob，能力上都能签"一切数据"。
  

五、顺带纠正我上条回帖的一处不严谨

上条我说"uo_crypto 没有加密能力"——不对。uo_crypto 有 EncryptByPublicKey / EncryptByPrivateKey / DecryptByPublicKey / DecryptByPrivateKey（全是 blob 级 RSA 加解密），只是没 PSS/OAEP 包装。真正的分工应是：

• uo_crypto：字符串签名（SignWithRSA）最省事 + blob 级 RSA 加解密（EncryptBy*）+ 国密/哈希/base64 全家桶；
  
• uo_rsa：纯 blob 引擎，独占 PSS 签名、OAEP 加密，且 sign/verify 直接吃任意 blob（最适合"签文件"）。
  

感谢 ehxz 挑刺，这几篇补完，PBIDEA 里 RSA 签名"从字符串到一切二进制"就算讲透了。

补充：源码注释示例里出现过 rsa.RsaEncrypt / rsa.RsaDecrypt 这种写法（第 45、56 行注释），那只是作者随手写的，对象里实际不存在这两个名字，真实是 encrypt / decrypt（小写，第 16、19 行），别抄错。