易语言生成COS签名

.局部变量 时间值, 日期时间型
.局部变量 初始时间, 日期时间型
.局部变量 签名有效期, 整数型, , , 签名有效期
.局部变量 StartTimestamp, 整数型, , , 签名开始时间
.局部变量 EndTimestamp, 整数型, , , 签名截止时间
.局部变量 KeyTime, 文本型, , , 生成固定格式
.局部变量 SecretId, 文本型, , , 密钥ID
.局部变量 SecretKey, 文本型, , , 密钥Key
.局部变量 SignKey, 文本型, , , 计算消息摘要
.局部变量 HttpMethod, 文本型, , , 请求方法（传入小写）
.局部变量 UriPathname, 文本型, , , 请求路径（对象键）
.局部变量 HttpString, 文本型
.局部变量 HttpParameters, 文本型
.局部变量 HttpHeaders, 文本型
.局部变量 SHA1HttpString, 字节集
.局部变量 StringToSign, 文本型
.局部变量 Signature, 文本型, , , 签名头部
.局部变量 Authorization, 文本型, , , 生成最终签名


SecretId ＝ 到文本 ('SecretId ')
SecretKey ＝ 到文本 ('SecretKey')
签名有效期 ＝ 到整数 ('time(s)')
初始时间 ＝ 到时间 (“1970-01-01 08:00:00”)
时间值 ＝ 取现行时间 ()
StartTimestamp ＝ 取时间间隔 (时间值, 初始时间, #秒)
EndTimestamp ＝ StartTimestamp ＋ 签名有效期
KeyTime ＝ 到文本 (StartTimestamp) ＋ “;” ＋ 到文本 (EndTimestamp)
输出调试文本 (KeyTime)
SignKey ＝ 到小写 (字节集_字节集到十六进制 (EC_加密_rstr_hmac_sha1 (到字节集 (SecretKey), 到字节集 (KeyTime))))  ' 密钥，数据
输出调试文本 (SignKey)
HttpParameters ＝ “”
HttpHeaders ＝ “”
HttpMethod ＝ 到文本 ('Method(需要传入小写)')
UriPathname ＝ 到文本 ('Key(对象键)')
HttpString ＝ HttpMethod ＋ 字符 (10) ＋ UriPathname ＋ 字符 (10) ＋ 字符 (10) ＋ 字符 (10)
SHA1HttpString ＝ EC_加密_rstr_sha1 (到字节集 (HttpString))
StringToSign ＝ “sha1” ＋ 字符 (10) ＋ KeyTime ＋ 字符 (10) ＋ 到小写 (字节集_字节集到十六进制 (SHA1HttpString)) ＋ 字符 (10)
输出调试文本 (StringToSign)
Signature ＝ 到小写 (字节集_字节集到十六进制 (EC_加密_rstr_hmac_sha1 (到字节集 (SignKey), 到字节集 (StringToSign))))
输出调试文本 (Signature)
Authorization ＝ “q-sign-algorithm=sha1&q-ak=” ＋ SecretId ＋ “&q-sign-time=” ＋ KeyTime ＋ “&q-key-time=” ＋ KeyTime ＋ “&q-header-list=&q-url-param-list=&q-signature=” ＋ Signature
输出调试文本 (Authorization)


#以下为加密算法子程序（'依赖精易模块'）


.子程序 EC_加密_safe_add, 整数型, 公开
.参数 x, 整数型
.参数 y, 整数型
.局部变量 lsw, 整数型
.局部变量 msw, 整数型
.局部变量 return, 整数型

lsw ＝ 位与 (x, 65535) ＋ 位与 (y, 65535)
msw ＝ 右移 (x, 16) ＋ 右移 (y, 16) ＋ 右移 (lsw, 16)
return ＝ 位或 (左移 (msw, 16), 位与 (lsw, 65535))
返回 (return)


.子程序 EC_加密_binb_sha1, , 公开
.参数 x, 整数型, 数组
.参数 len, 整数型
.参数 return, 整数型, 参考 数组
.局部变量 w, 整数型, , "80"
.局部变量 a, 整数型
.局部变量 b, 整数型
.局部变量 c, 整数型
.局部变量 d, 整数型
.局部变量 e, 整数型
.局部变量 i, 整数型
.局部变量 xlength, 整数型
.局部变量 olda, 整数型
.局部变量 oldb, 整数型
.局部变量 oldc, 整数型
.局部变量 oldd, 整数型
.局部变量 olde, 整数型
.局部变量 j, 整数型
.局部变量 t, 整数型
.局部变量 ret, 文本型
.局部变量 tmp, 整数型

xlength ＝ 取数组成员数 (x)
tmp ＝ 左移 (右移 (len ＋ 64, 9), 4) ＋ 16

.如果真 (xlength ＜ tmp)
    重定义数组 (x, 真, tmp)
.如果真结束

x [右移 (len, 5) ＋ 1] ＝ 位或 (x [右移 (len, 5) ＋ 1], 左移 (128, 24 － len ％ 32))
x [左移 (右移 (len ＋ 64, 9), 4) ＋ 16] ＝ len
xlength ＝ 取数组成员数 (x)
a ＝ 1732584193
b ＝ -271733879
c ＝ -1732584194
d ＝ 271733878
e ＝ -1009589776

.变量循环首 (0, xlength, 16, i)
    .如果真 (i ≥ xlength)
        跳出循环 ()
    .如果真结束
    olda ＝ a
    oldb ＝ b
    oldc ＝ c
    oldd ＝ d
    olde ＝ e
    .变量循环首 (0, 80, 1, j)
        .如果真 (j ≥ 80)
            跳出循环 ()
        .如果真结束
        .如果 (j ＜ 16)
            w [j ＋ 1] ＝ x [i ＋ j ＋ 1]
            ' 调试输出 (w [j ＋ 1], j ＋ 1)
        .否则
            w [j ＋ 1] ＝ EC_加密_bit_rol (位异或 (w [j － 3 ＋ 1], w [j － 8 ＋ 1], w [j － 14 ＋ 1], w [j － 16 ＋ 1]), 1)
            ' 调试输出 (w [j ＋ 1], j ＋ 1)
        .如果结束
        ' w [j ＋ 1] ＝ 0
        t ＝ EC_加密_safe_add (EC_加密_safe_add (EC_加密_bit_rol (a, 5), EC_加密_sha1_ft (j, b, c, d)), EC_加密_safe_add (EC_加密_safe_add (e, w [j ＋ 1]), EC_加密_sha1_kt (j)))
        e ＝ d
        d ＝ c
        c ＝ EC_加密_bit_rol (b, 30)
        b ＝ a
        a ＝ t

    .变量循环尾 ()


    a ＝ EC_加密_safe_add (a, olda)
    b ＝ EC_加密_safe_add (b, oldb)
    c ＝ EC_加密_safe_add (c, oldc)
    d ＝ EC_加密_safe_add (d, oldd)
    e ＝ EC_加密_safe_add (e, olde)

.变量循环尾 ()
重定义数组 (return, 假, 5)
return [1] ＝ a
return [2] ＝ b
return [3] ＝ c
return [4] ＝ d
return [5] ＝ e





.子程序 EC_加密_binb2rstr, 字节集, 公开
.参数 input, 整数型, 数组
.局部变量 output, 字节集
.局部变量 length, 整数型
.局部变量 i, 整数型


length ＝ 取数组成员数 (input) × 32
.变量循环首 (0, length, 8, i)
    .如果真 (i ≥ length)
        跳出循环 ()
    .如果真结束

    output ＝ output ＋ 到字节集 (到字节 (位与 (EC_加密_逻辑右移 (input [右移 (i, 5) ＋ 1], 24 － i ％ 32), 255)))
.变量循环尾 ()
返回 (output)


.子程序 EC_加密_rstr_sha1, 字节集, 公开
.参数 s, 字节集
.局部变量 容器1, 整数型, , "0"
.局部变量 容器2, 整数型, , "0"

EC_加密_rstr2binb (s, 容器1)
EC_加密_binb_sha1 (容器1, 取字节集长度 (s) × 8, 容器2)
返回 (EC_加密_binb2rstr (容器2))



.子程序 EC_加密_rstr_hmac_sha1, 字节集, 公开
.参数 key, 字节集
.参数 data, 字节集
.局部变量 bkey, 整数型, , "0"
.局部变量 length, 整数型
.局部变量 ipad, 整数型, , "16"
.局部变量 opad, 整数型, , "16"
.局部变量 i, 整数型
.局部变量 数组容器, 整数型, , "0"
.局部变量 hash, 整数型, , "0"

EC_加密_rstr2binb (key, bkey)

length ＝ 取数组成员数 (bkey)
.如果真 (length ＞ 16)
    EC_加密_binb_sha1 (bkey, 取字节集长度 (key) × 8, bkey)
.如果真结束

.如果真 (取数组成员数 (bkey) ＜ 16)
    重定义数组 (bkey, 真, 16)
.如果真结束

.变量循环首 (1, 16, 1, i)
    ipad [i] ＝ 位异或 (bkey [i], 909522486)
    opad [i] ＝ 位异或 (bkey [i], 1549556828)

.变量循环尾 ()
EC_加密_rstr2binb (data, 数组容器)
加入成员 (ipad, 数组容器)

EC_加密_binb_sha1 (ipad, 512 ＋ 取字节集长度 (data) × 8, hash)
清除数组 (数组容器)
加入成员 (opad, hash)

EC_加密_binb_sha1 (opad, 512 ＋ 160, 数组容器)
返回 (EC_加密_binb2rstr (数组容器))




.子程序 EC_加密_rstr2binb, , 公开
.参数 input, 字节集
.参数 output, 整数型, 数组
.局部变量 inputlength, 整数型
.局部变量 outputlength, 整数型
.局部变量 i, 整数型
.局部变量 jp, 整数型

inputlength ＝ 取字节集长度 (input)
重定义数组 (output, 假, 右移 (inputlength, 2))
outputlength ＝ 取数组成员数 (output)
.如果真 (outputlength ＜ 右移 (inputlength × 8, 5) ＋ 1)
    重定义数组 (output, 真, 右移 (inputlength × 8, 5) ＋ 1)
.如果真结束

.变量循环首 (0, outputlength, 1, i)
    .如果真 (i ≥ outputlength)
        跳出循环 ()
    .如果真结束
    output [i ＋ 1] ＝ 0
.变量循环尾 ()
i ＝ 0
.变量循环首 (0, inputlength × 8, 8, i)
    .如果真 (i ≥ inputlength × 8)
        跳出循环 ()
    .如果真结束

    output [右移 (i, 5) ＋ 1] ＝ 位或 (output [右移 (i, 5) ＋ 1], 左移 (位与 (input [i ÷ 8 ＋ 1], 255), 24 － i ％ 32))
.变量循环尾 ()


.子程序 EC_加密_bit_rol, 整数型, 公开
.参数 num, 整数型
.参数 cnt, 整数型
.局部变量 return, 整数型

return ＝ 位或 (左移 (num, cnt), EC_加密_逻辑右移 (num, 32 － cnt))
返回 (return)



.子程序 EC_加密_sha1_kt, 整数型, 公开
.参数 t, 整数型

.判断开始 (t ＜ 20)
    返回 (1518500249)
.判断 (t ＜ 40)
    返回 (1859775393)
.判断 (t ＜ 60)
    返回 (-1894007588)
.默认
    返回 (-899497514)
.判断结束




.子程序 EC_加密_sha1_ft, 整数型, 公开
.参数 t, 整数型
.参数 b, 整数型
.参数 c, 整数型
.参数 d, 整数型

.如果真 (t ＜ 20)
    返回 (位或 (位与 (b, c), 位与 (位取反 (b), d)))
.如果真结束

.如果真 (t ＜ 40)
    返回 (位异或 (b, c, d))
.如果真结束

.如果真 (t ＜ 60)
    返回 (位或 (位与 (b, c), 位与 (b, d), 位与 (c, d)))
.如果真结束

返回 (位异或 (b, c, d))

.子程序 EC_加密_逻辑右移, 整数型, 公开, （逻辑右移） （算术右移） 寄存器，1
.参数 欲移动的整数, 整数型
.参数 欲被移动的位数, 字节型

置入代码 ({ 81, 139, 69, 8, 138, 77, 12, 211, 232, 89, 139, 229, 93, 194, 8, 0 })
返回 (-1)