有偿求易语言AES-GCM-256实现源代码

Sh1eng

有偿寻求大佬能写一套不调用OpenSSL有关模块、DLL、EXE、支持库的易语言AES-GCM-256算法，注意是纯代码实现

神女软件定制

多少钱，我应该可以给你写出来

jyfinn

.版本 2
.支持库 spec
.支持库 EThread

.常量 S, "字节集", , {99,124,119,123,242,107,111,197,48,1,103,43,254,215,171,118,202,130,201,125,250,89,71,240,173,212,162,175,156,164,114,192,183,253,147,38,54,63,247,204,52,165,229,241,113,216,49,21,4,199,35,195,24,150,5,154,7,18,128,226,235,39,178,117,9,131,44,26,27,110,90,160,82,59,214,179,41,227,47,132,83,209,0,237,32,252,177,91,106,203,190,57,74,76,88,207,208,239,170,251,67,77,51,133,69,249,2,127,80,60,159,168,81,163,64,143,146,157,56,245,188,182,218,33,16,255,243,210,205,12,19,236,95,151,68,23,196,167,126,61,100,93,25,115,96,129,79,220,34,42,144,136,70,238,184,20,222,94,11,219,224,50,58,10,73,6,36,92,194,211,172,98,145,149,228,121,231,200,55,109,141,213,78,169,108,86,244,234,101,122,174,8,186,120,37,46,28,166,180,198,232,221,116,31,75,189,139,138,112,62,181,102,72,3,246,14,97,53,87,185,134,193,29,158,225,248,152,17,105,217,142,148,155,30,135,233,206,85,40,223,140,161,137,13,191,230,66,104,65,153,45,15,176,84,187,22}
.常量 R, "字节集", , {1,2,4,8,16,32,64,128,27,54,108,216,171,77,154}
.常量 P, 长整数型, , 273

' 全局线程共享变量（线程安全）
.全局变量 全局_扩展密钥, 字节数组
.全局变量 全局_数据块, 字节数组
.全局变量 全局_计数器基, 字节数组
.全局变量 全局_线程数, 整数型
.全局变量 全局_完成数, 整数型
.全局变量 全局_事件, 整数型

.子程序 B2A, 字节数组, 公开
.参数 d, 字节集
.局部变量 a, 字节数组
.局部变量 i, 整数型
重定义数组 (a, 假, 取字节集长度 (d))
.计次循环首 (取字节集长度 (d), i)
    a [i] ＝ 字节集取字节 (d, i)
.计次循环尾 ()
返回 (a)

.子程序 A2B, 字节集, 公开
.参数 a, 字节数组
.局部变量 d, 字节集
.局部变量 i, 整数型
d ＝ { }
.计次循环首 (取数组成员数 (a), i)
    d ＝ d ＋ 到字节集 (a [i])
.计次循环尾 ()
返回 (d)

.子程序 P16, 字节数组, 公开
.参数 a, 字节数组
.局部变量 l, 整数型
.局部变量 n, 字节数组
l ＝ 取数组成员数 (a)
.如果真 (l ％ 16 ＝ 0) 返回 (a)
重定义数组 (n, 假, l ＋ 16 － l ％ 16)
.计次循环首 (l, i)
    n [i] ＝ a [i]
.计次循环尾 ()
返回 (n)

.子程序 I16, , 公开
.参数 b, 字节数组, 参考
.局部变量 i, 整数型
b [16] ＝ b [16] ＋ 1
.变量循环首 (16, 1, -1, i)
    .如果真 (b [i] ≠ 0) 跳出循环 ()
    b [i - 1] ＝ b [i - 1] ＋ 1
.变量循环尾 ()

.子程序 SBox, 字节数组
.参数 b, 字节数组
.局部变量 o, 字节数组
.局部变量 i, 整数型
重定义数组 (o, 假, 16)
.计次循环首 (16, i)
    o [i] ＝ 字节集取字节 (S, b [i] ＋ 1)
.计次循环尾 ()
返回 (o)

.子程序 SRow, 字节数组
.参数 b, 字节数组
.局部变量 o, 字节数组
o ＝ b
o [2] ＝ 位异或 (o [2], o [6]): o [6] ＝ 位异或 (o [2], o [6]): o [2] ＝ 位异或 (o [2], o [6])
o [6] ＝ 位异或 (o [6], o [10]): o [10] ＝ 位异或 (o [6], o [10]): o [6] ＝ 位异或 (o [6], o [10])
o [10] ＝ 位异或 (o [10], o [14]): o [14] ＝ 位异或 (o [10], o [14]): o [10] ＝ 位异或 (o [10], o [14])
o [3] ＝ 位异或 (o [3], o [11]): o [11] ＝ 位异或 (o [3], o [11]): o [3] ＝ 位异或 (o [3], o [11])
o [7] ＝ 位异或 (o [7], o [15]): o [15] ＝ 位异或 (o [7], o [15]): o [7] ＝ 位异或 (o [7], o [15])
o [4] ＝ 位异或 (o [4], o [16]): o [16] ＝ 位异或 (o [4], o [16]): o [4] ＝ 位异或 (o [4], o [16])
o [16] ＝ 位异或 (o [16], o [12]): o [12] ＝ 位异或 (o [16], o [12]): o [16] ＝ 位异或 (o [16], o [12])
o [12] ＝ 位异或 (o [12], o [8]): o [8] ＝ 位异或 (o [12], o [8]): o [12] ＝ 位异或 (o [12], o [8])
返回 (o)

.子程序 M8, 字节型
.参数 a, 字节型
.参数 b, 字节型
.局部变量 r, 字节型
.局部变量 i, 整数型
r ＝ 0
.计次循环首 (8, i)
    r ＝ 左移 (r, 1)
    .如果真 (位与 (r, 256) ≠ 0) r ＝ 位异或 (r, 27)
    .如果真 (位与 (b, 128) ≠ 0) r ＝ 位异或 (r, a)
    b ＝ 左移 (b, 1)
.计次循环尾 ()
返回 (r)

.子程序 CCol, 字节数组
.参数 b, 字节数组
.局部变量 o, 字节数组
.局部变量 i, 整数型
.局部变量 s0, s1, s2, s3, 字节型
重定义数组 (o, 假, 16)
.计次循环首 (4, i)
    s0 ＝ b [i]: s1 ＝ b [i ＋ 4]: s2 ＝ b [i ＋ 8]: s3 ＝ b [i ＋ 12]
    o [i] ＝ 位异或 (M8 (2, s0), 位异或 (M8 (3, s1), 位异或 (s2, s3)))
    o [i ＋ 4] ＝ 位异或 (s0, 位异或 (M8 (2, s1), 位异或 (M8 (3, s2), s3)))
    o [i ＋ 8] ＝ 位异或 (s0, 位异或 (s1, 位异或 (M8 (2, s2), M8 (3, s3))))
    o [i ＋ 12] ＝ 位异或 (M8 (3, s0), 位异或 (s1, 位异或 (s2, M8 (2, s3))))
.计次循环尾 ()
返回 (o)

.子程序 K256, 字节数组, 公开
.参数 k32, 字节数组
.局部变量 ek, 字节数组, , 240
.局部变量 t, 字节数组, , 4
.局部变量 i, 整数型
.计次循环首 (32, i)
    ek [i] ＝ k32 [i]
.计次循环尾 ()
i ＝ 32
.判断循环首 (i ＜ 240)
    t [1] ＝ ek [i - 3]: t [2] ＝ ek [i - 2]: t [3] ＝ ek [i - 1]: t [4] ＝ ek [i]
    .如果真 (i ％ 32 ＝ 0)
        t [1] ＝ 字节集取字节 (S, t [1] ＋ 1): t [2] ＝ 字节集取字节 (S, t [2] ＋ 1)
        t [3] ＝ 字节集取字节 (S, t [3] ＋ 1): t [4] ＝ 字节集取字节 (S, t [4] ＋ 1)
        t ＝ { t [2], t [3], t [4], t [1] }
        t [1] ＝ 位异或 (t [1], 字节集取字节 (R, i \ 32))
    .如果真结束
    .如果真 (i ％ 32 ＝ 16)
        t [1] ＝ 字节集取字节 (S, t [1] ＋ 1): t [2] ＝ 字节集取字节 (S, t [2] ＋ 1)
        t [3] ＝ 字节集取字节 (S, t [3] ＋ 1): t [4] ＝ 字节集取字节 (S, t [4] ＋ 1)
    .如果真结束
    ek [i ＋ 1] ＝ 位异或 (ek [i - 31], t [1]): ek [i ＋ 2] ＝ 位异或 (ek [i - 30], t [2])
    ek [i ＋ 3] ＝ 位异或 (ek [i - 29], t [3]): ek [i ＋ 4] ＝ 位异或 (ek [i - 28], t [4])
    i ＝ i ＋ 4
.判断循环尾 ()
返回 (ek)

.子程序 E16, 字节数组, 公开
.参数 p16, 字节数组
.参数 ek, 字节数组
.局部变量 st, 字节数组, , 16
.局部变量 r, 整数型
.计次循环首 (16, i)
    st [i] ＝ 位异或 (p16 [i], ek [i])
.计次循环尾 ()
.计次循环首 (14, r)
    st ＝ SBox (st): st ＝ SRow (st)
    .如果真 (r ＜ 13) st ＝ CCol (st)
    .计次循环首 (16, i)
        st [i] ＝ 位异或 (st [i], ek [r × 16 ＋ i ＋ 1])
    .计次循环尾 ()
.计次循环尾 ()
返回 (st)

.子程序 M128, 字节数组
.参数 X, 字节数组
.参数 Y, 字节数组
.局部变量 Z, 字节数组, , 16
.局部变量 V, 字节数组, , 16
.局部变量 c, 字节型
.局部变量 i, j, 整数型
V ＝ Y
.计次循环首 (16, i)
    .计次循环首 (8, j)
        .如果真 (位与 (右移 (X [i], 7 - j), 1) ＝ 1)
            .计次循环首 (16, t)
                Z [t] ＝ 位异或 (Z [t], V [t])
            .计次循环尾 ()
        .如果真结束
        c ＝ 0
        .变量循环首 (16, 1, -1, t)
            交换 (c, 位与 (V [t], 128) ＞ 0)
            V [t] ＝ 左移 (V [t], 1)
        .变量循环尾 ()
        .如果真 (c ＝ 1) V [16] ＝ 位异或 (V [16], P)
    .计次循环尾 ()
.计次循环尾 ()
返回 (Z)

.子程序 GH, 字节数组, 公开
.参数 H, 字节数组
.参数 d, 字节数组
.局部变量 g, 字节数组, , 16
.局部变量 b, 字节数组, , 16
.局部变量 n, 整数型
.局部变量 i, j, 整数型
n ＝ 取数组成员数 (d) \ 16
.计次循环首 (n, i)
    .计次循环首 (16, j)
        b [j] ＝ d [(i - 1) × 16 ＋ j]
        g [j] ＝ 位异或 (g [j], b [j])
    .计次循环尾 ()
    g ＝ M128 (g, H)
.计次循环尾 ()
返回 (g)

.子程序 L64, 字节数组
.参数 v, 长整数型
.局部变量 b, 字节数组, , 8
b [1] ＝ 右移 (v, 56): b [2] ＝ 右移 (v, 48): b [3] ＝ 右移 (v, 40): b [4] ＝ 右移 (v, 32)
b [5] ＝ 右移 (v, 24): b [6] ＝ 右移 (v, 16): b [7] ＝ 右移 (v, 8): b [8] ＝ 位与 (v, 255)
返回 (b)

' 线程执行函数：处理分片的CTR块加密
.子程序 线程_CTR加密, 整数型
.参数 线程ID, 整数型
.局部变量 块起始, 整数型
.局部变量 块结束, 整数型
.局部变量 块数, 整数型
.局部变量 ctr, 字节数组
.局部变量 i, j, 整数型

块数 ＝ 取数组成员数 (全局_数据块) \ 16
块起始 ＝ 线程ID × (块数 ÷ 全局_线程数)
块结束 ＝ (线程ID ＋ 1) × (块数 ÷ 全局_线程数)
.如果真 (线程ID ＝ 全局_线程数 - 1) 块结束 ＝ 块数

' 初始化线程专属计数器
ctr ＝ 全局_计数器基
.计次循环首 (块起始, i) I16 (ctr)
.计次循环尾 ()

' 并行加密分片
.计次循环首 (块结束 - 块起始, i)
    ctr ＝ E16 (ctr, 全局_扩展密钥)
    .计次循环首 (16, j)
        .如果真 ((块起始 ＋ i) × 16 ＋ j ≤ 取数组成员数 (全局_数据块))
            全局_数据块 [(块起始 ＋ i) × 16 ＋ j] ＝ 位异或 (全局_数据块 [(块起始 ＋ i) × 16 ＋ j], ctr [j])
        .如果真结束
    .计次循环尾 ()
    I16 (ctr)
.计次循环尾 ()

' 标记线程完成
全局_完成数 ＝ 全局_完成数 ＋ 1
.如果真 (全局_完成数 ≥ 全局_线程数) 置事件 (全局_事件)
返回 (0)

' 多线程CTR加密（核心加速函数）
.子程序 多线程_CTR加密, 字节数组
.参数 明文数组, 字节数组
.参数 扩展密钥, 字节数组
.参数 IV数组, 字节数组
.参数 线程数, 整数型
.局部变量 线程句柄, 整数型, , "0"
.局部变量 i, 整数型

' 初始化全局变量
全局_扩展密钥 ＝ 扩展密钥
全局_数据块 ＝ 明文数组
全局_计数器基 ＝ {0}
.计次循环首 (12, i) 全局_计数器基 [i] ＝ IV数组 [i]
.计次循环尾 ()
全局_计数器基 [16] ＝ 1
全局_线程数 ＝ 线程数
全局_完成数 ＝ 0
全局_事件 ＝ 创建事件 (假, 假, "")

' 创建线程
重定义数组 (线程句柄, 假, 线程数)
.计次循环首 (线程数, i)
    线程句柄 [i] ＝ 启动线程 (&线程_CTR加密, i, )
.计次循环尾 ()

' 等待所有线程完成
等待事件 (全局_事件, -1)
.计次循环首 (线程数, i)
    关闭线程句柄 (线程句柄 [i])
.计次循环尾 ()
关闭事件 (全局_事件)

返回 (全局_数据块)

.子程序 AES_GCM256_加密_多线程, 字节集, 公开
.参数 明文, 字节集
.参数 密钥32, 字节集
.参数 IV12, 字节集
.参数 AAD, 字节集, 可选
.参数 标签长, 整数型, 可选
.参数 线程数, 整数型, 可选, 默认4
.局部变量 pt, key, iv, aad, ek, H, ct, ap, cp, gd, gh, tag, 字节数组
.局部变量 i, 整数型

.如果真 (取字节集长度 (密钥32) ≠ 32 或 取字节集长度 (IV12) ≠ 12) 返回 ({ })
.如果真 (标签长 ＝ 0) 标签长 ＝ 16
.如果真 (线程数 ＝ 0) 线程数 ＝ 4

pt ＝ B2A (明文): key ＝ B2A (密钥32): iv ＝ B2A (IV12): aad ＝ B2A (AAD)
ek ＝ K256 (key): H ＝ E16 ({0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, ek)

' 多线程CTR加密
ct ＝ 多线程_CTR加密 (pt, ek, iv, 线程数)

' GHASH和标签生成（串行，非核心耗时）
ap ＝ P16 (aad): cp ＝ P16 (ct)
gd ＝ 数组拼接 (ap, 数组拼接 (cp, 数组拼接 (L64 (取数组成员数 (aad) × 8), L64 (取数组成员数 (pt) × 8))))
gh ＝ GH (H, gd)
全局_计数器基 ＝ {0}: 字节集到字节数组 (IV12, 全局_计数器基)
全局_计数器基 ＝ E16 (全局_计数器基, ek)
重定义数组 (tag, 假, 标签长)
.计次循环首 (标签长, i) tag [i] ＝ 位异或 (gh [i], 全局_计数器基 [i])
.计次循环尾 ()

返回 (A2B (ct) ＋ A2B (tag))

.子程序 AES_GCM256_解密_多线程, 字节集, 公开
.参数 CT_Tag, 字节集
.参数 密钥32, 字节集
.参数 IV12, 字节集
.参数 AAD, 字节集, 可选
.参数 标签长, 整数型, 可选
.参数 线程数, 整数型, 可选, 默认4
.局部变量 l, 整数型
.局部变量 ct, tag, key, iv, aad, ek, H, pt, ap, cp, gd, gh, tg, 字节数组
.局部变量 i, 整数型

.如果真 (取字节集长度 (密钥32) ≠ 32 或 取字节集长度 (IV12) ≠ 12 或 取字节集长度 (CT_Tag) ＜ 标签长) 返回 ({ })
.如果真 (标签长 ＝ 0) 标签长 ＝ 16
.如果真 (线程数 ＝ 0) 线程数 ＝ 4

l ＝ 取字节集长度 (CT_Tag) － 标签长
ct ＝ B2A (取字节集左边 (CT_Tag, l)): tag ＝ B2A (取字节集右边 (CT_Tag, 标签长))
key ＝ B2A (密钥32): iv ＝ B2A (IV12): aad ＝ B2A (AAD)
ek ＝ K256 (key): H ＝ E16 ({0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, ek)

' 多线程CTR解密（复用加密逻辑，异或可逆）
pt ＝ 多线程_CTR加密 (ct, ek, iv, 线程数)

' 标签校验
ap ＝ P16 (aad): cp ＝ P16 (ct)
gd ＝ 数组拼接 (ap, 数组拼接 (cp, 数组拼接 (L64 (取数组成员数 (aad) × 8), L64 (l × 8))))
gh ＝ GH (H, gd)
全局_计数器基 ＝ {0}: 字节集到字节数组 (IV12, 全局_计数器基)
全局_计数器基 ＝ E16 (全局_计数器基, ek)
重定义数组 (tg, 假, 标签长)
.计次循环首 (标签长, i) tg [i] ＝ 位异或 (gh [i], 全局_计数器基 [i])
.计次循环尾 ()

.计次循环首 (标签长, i)
    .如果真 (tg [i] ≠ tag [i]) 返回 ({ })
.计次循环尾 ()

返回 (A2B (pt))

' 测试入口：对比单线程/多线程速度
.子程序 测试_多线程GCM256, 公开
.局部变量 k, iv, p, aad, c, p2, 字节集
.局部变量 开始时间, 结束时间, 整数型

k ＝ 十六进制到字节集 ("000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F")
iv ＝ 十六进制到字节集 ("000000000000000000000000")
p ＝ 到字节集 (取重复文本 (100000, "多线程加速测试数据")) ' 大体积测试数据
aad ＝ 到字节集 ("AAD附加数据")

' 多线程加密
开始时间 ＝ 取启动时间 ()
c ＝ AES_GCM256_加密_多线程 (p, k, iv, aad, 16, 4)
结束时间 ＝ 取启动时间 ()
调试输出 ("多线程加密耗时(ms):", 结束时间 － 开始时间)

' 多线程解密
开始时间 ＝ 取启动时间 ()
p2 ＝ AES_GCM256_解密_多线程 (c, k, iv, aad, 16, 4)
结束时间 ＝ 取启动时间 ()
调试输出 ("多线程解密耗时(ms):", 结束时间 － 开始时间)
调试输出 ("验证成功:", 到文本 (p) ＝ 到文本 (p2))

Sh1eng

神女软件定制 发表于 2026-2-9 02:00
多少钱，我应该可以给你写出来

感谢大佬，已经联系您啦希望通过好友

Sh1eng

jyfinn 发表于 2026-2-9 05:08
.版本 2
.支持库 spec
.支持库 EThread

兄弟这个AI味太重了，根本不能用