PCSC脚本介绍

本脚本采用的语言为javascript,并参考Snooper提供了一系列常用函数(能力有限，没法做到Snooper那么全面)
基本接口数据转换条码二维码卡片交互 TLV解析 DES AES SM4 SHA1 SHA224 SHA256 SHA384 SHA512 MD5 SM3 HMAC 计算文件哈希 RSA SM2 MAC 串口 SOCKET 提示信息文件操作 HTTP

示例脚本-读取电子现金余额

//读取电子现金余额
clear();
if (!reset()) {
    exit("上电失败，请选择读卡器并放置卡片");   
}
var item = getchoose("请选择入口", ["PSE", "PPSE"], 0, 60);
var aid, list;
if (item == 0) {
    list = BuildCandByPSE();
} else {
    list = BuildCandByPPSE();
}
while (true) {
    if (list.length == 0) {
        exit("没有候选应用列表");
    }
    if (item == 0) {
        var aidIndex = 0;
        if (list.length > 1) {
            var msg = [];
            for (var i = 0; i < list.length; i++) {
                if (list[i].$50) {
                    msg.push(HexArrayToGB2312(list[i].$50));
                }
                else {
                    msg.push(list[i].$4F);
                }
            }
            aidIndex = getchoose("请选择AID", msg, 0, 60);
        }
        aid = list[aidIndex].$4F;
    } else {
        aid = list[0].$4F;
    }
    var tlvObj = sendSelectAID(aid, 0);
    if (!tlvObj) {
        exit("选择AID失败");
    }
    if (tlvObj.sw != "9000" && tlvObj.sw != "6283") {
        printf("选择下一个AID");
        list.splice(0, 1);
        continue;
    }
    break;
}
var str = "\n", tag9F51, tag9F79, tagDF71, tagDF79;
//获取第一货币
var tlvObj = sendGetData(0x9F51);
str += "第一货币代码: "
if (tlvObj && tlvObj.sw == "9000" && (tag9F51 = FindTlv(tlvObj.tlv, 0x9F51))) {
    str += GetCurrencyName(tag9F51.value) + "\n";

tlvObj = sendGetData(0x9F79);
    str += "第一货币余额: "
    if (tlvObj && tlvObj.sw == "9000" && (tag9F79 = FindTlv(tlvObj.tlv, 0x9F79))) {
        str += parseInt(tag9F79.value,10) / 100 + "\n";
    } else {
        str += "获取失败\n";
    }
} else {
    str += "获取失败\n";
}
//获取第二货币
tlvObj = sendGetData(0xDF71);
str += "第二货币代码: "
if (tlvObj && tlvObj.sw == "9000" && (tagDF71 = FindTlv(tlvObj.tlv, 0xDF71))) {
    str += GetCurrencyName(tagDF71.value) + "\n";

tlvObj = sendGetData(0xDF79);
    str += "第二货币余额: "
    if (tlvObj && tlvObj.sw == "9000" && (tagDF79 = FindTlv(tlvObj.tlv, 0xDF79))) {
        str += parseInt(tagDF79.value) / 100 + "\n";
    } else {
        str += "获取失败\n";
    }
} else {
    str += "获取失败\n";
}
printf(str, "blue");

//选择PSE来建立应用候选列表
function BuildCandByPSE() {
    var tlvObj = sendSelectPSE();
    if (!tlvObj || tlvObj.sw!="9000") {
        exit("选择PSE失败");
    }
    if (tlvObj.tlv.length != 1 || tlvObj.tlv[0].tag!=0x6F) {
        exit("PSE返回数据失败，应为6F模板");
    }
    if (!FindTlv(tlvObj.tlv, 0x84)) {
        exit("PSE返回数据失败，84不存在");
    }
    if (!FindTlv(tlvObj.tlv, 0xA5)) {
        exit("PSE返回数据失败，A5不存在");
    }
    var tag88 = FindTlv(tlvObj.tlv, 0x88);
    if (!tag88 || tag88.len != 1 || tag88.valueHex[0] < 1 || tag88.valueHex[0] > 10) {
        exit("PSE返回数据失败，88的SFI值必须在1-10之间");
    }

//选择PSE来建立应用候选列表
function BuildCandByPPSE() {
    var tlvObj = sendSelectPPSE();
    if (!tlvObj || tlvObj.sw != "9000") {
        exit("选择PPSE失败");
    }
    if (tlvObj.tlv.length != 1 || tlvObj.tlv[0].tag != 0x6F) {
        exit("PPSE返回数据失败，应为6F模板");
    }
    if (!FindTlv(tlvObj.tlv, 0x84)) {
        exit("PPSE返回数据失败，84不存在");
    }
    if (!FindTlv(tlvObj.tlv, 0xA5)) {
        exit("PPSE返回数据失败，A5不存在");
    }
    var tagBF0C = FindTlv(tlvObj.tlv, 0xBF0C);
    if (!tagBF0C) {
        exit("PPSE返回数据失败，BF0C不存在");
    }
    var count = 1;
    var CandList = [];
    while (true) {
        var tag61 = FindTlv(tagBF0C, 0x61, count++);
        if (!tag61) {
            break;
        }
        var cand = {};
        var tag4F = FindTlv(tag61, 0x4F);
        if (!tag4F) {
            exit("PPSE返回数据失败，61应用模板下4F不存在");
        }
        cand.$4F = tag4F.value;
        var tag50 = FindTlv(tag61, 0x50);
        if (tag50) {
            cand.$50 = tag50.value;
        }
        var tag87 = FindTlv(tag61, 0x87);
        if (tag87 && tag87.len == 1) {
            cand.$87 = tag87.valueHex[0] & 0x0F;
        }
        CandList.push(cand);
    }
    SortCandList(CandList);
    return CandList;
}

//对候选应用列表进行排序
function SortCandList(list) {
    for (i = 0; i < list.length; i++) {
        for (j = list.length - 1; j > i; j--) {
            if (!list[j].$87 && !list[j - 1].$87) {
                continue;
            }
            var needswap = false;
            if (!list[j - 1].$87) {
                needswap = true;
            }
            else if (list[j].$87 && list[j].$87 < list[j - 1].$87) {
                needswap = true;
            }
            if (needswap) {
                var tmp = list[j];
                list[j] = list[j - 1];
                list[j - 1] = tmp;
            }
        }
    }
}

//根据货币代码返回货币名称
function GetCurrencyName(code) {
    switch (code) {
        case "0156": return "人民币";
        case "0344": return "港币";
        case "0446": return "澳元";
        case "0840": return "美元";
        default: return "未知";
    }
}

clear()

清空LOG框的内容。无入参，无返回值。
调用示例：clear();

printf(str,color)

输出信息到LOG框。无返回值。
str：字符串类型
color:可选填，字符串类型。当前这条LOG信息的颜色，可使用red、green等英文或#112233这样的16进制RGB
调用示例：printf("这是一条日志");printf("这是一条有颜色的日志","blue");

setColor(color)

设置全局的LOG信息颜色。无返回值。
color:字符串类型。可使用red、green等英文或#112233这样的16进制RGB
调用示例：setColor("green");printf("这是一条日志");setColor("#00008B");printf("这是一条日志");

sleep(time)

睡眠。无返回值。
time：毫秒数
调用示例：sleep(500);

getTick()

获取系统启动后经过的毫秒数。无入参。
调用示例：printf(getTick());

datetime()

获取当前时间。无入参。
返回值：数值型，精确到秒，格式为yyyyMMddHHmmss
调用示例：printf(datetime());

beep(frequency, duration)

播放扬声器。无返回值。
frequency：提示音的频率，介于 37 到 32767 赫兹之间
duration：提示音的持续时间，以毫秒为单位
调用示例：beep(2000,500);

messageBeep(type)

播放波形声音。无返回值。
type：可取值为0-4，分别表示Ok/Error/Question/Warning/Information
调用示例：messageBeep(0);

exit(info)

强制退出脚本。无返回值。
info：附加信息，可选填
调用示例：

clear();
if(!reset()){
    exit("reset失败！");    
}

load_script(path)

加载子脚本并返回脚本内容，一般用于加载公共函数。后续需用户自行调用eval来执行子脚本内容(eval后只能在当前函数中使用子脚本的函数)
path：子脚本绝对路径或子脚本文件名(从AssistantTool.exe所在目录\script目录中查找)
调用示例：

eval(load_script("1.txt"));
Test("全局调用")
function XX(){
    Test("XX中调用")
}
XX();

子脚本1.txt内容
//测试函数
function Test(str){
    printf(str);
}

setIsShowError(flag)

设置脚本执行时是否自动显示错误信息,默认为false。无返回值。
flag：true OR false

setIsShowAPDU(flag)

设置脚本执行时是否自动显示APDU数据,默认为true。无返回值。
flag：true OR false
数据转换

AscToBcd(asc)

将字符串压缩成BCD
asc：0-F字符串，字节之间可以有空格等其它非0-F的字符
返回值：bcd格式数据的数组
调用示例：

var bcd=AscToBcd("1122 33  CD EF");
printf(bcd.length+" "+bcd[0].toString(16)+" "+bcd[4].toString(16));
var bcd=AscToBcd("0x12 0x34 0x56 0x78 0xFF ZZZZ 0xAA");
printf(bcd.length+" "+bcd[0].toString(16)+" "+bcd[5].toString(16));

输出
5 11 ef
6 12 aa

BcdToAsc(bcd)

将bcd格式数据的数组转成字符串
bcd：bcd格式数据的数组
返回值：字符串
调用示例：

var bcd=[];
bcd.push(0x11);bcd.push(0x22);bcd.push(0xAB);bcd.push(0xCD);
printf(BcdToAsc(bcd));

输出1122ABCD

AsciiToHexArray(str)

将字符串按ASCII格式编码为字节序列
str：字符串
返回值：字节序列数组
调用示例：

var hex=AsciiToHexArray("ABCD123");
printf(BcdToAsc(hex));

输出41424344313233

HexArrayToAscii(hex)

将字节序列按ASCII格式解码为字符串
hex：字节序列数组或字节序列字符串
返回值：字符串
调用示例：

var hex=[];
hex.push(0x31);hex.push(0x32);hex.push(0x61);hex.push(0x62);
printf(HexArrayToAscii(hex));
hex=AscToBcd("31326162");
printf(HexArrayToAscii(hex));
printf(HexArrayToAscii("31326162"));

输出
12ab
12ab
12ab

GB2312ToHexArray(str)

将字符串按GB2312格式编码为字节序列
str：字符串
返回值：字节序列数组
调用示例：

var hex=GB2312ToHexArray("金三爷");
printf(BcdToAsc(hex));

输出BDF0C8FDD2AF

HexArrayToGB2312(hex)

将字节序列按GB2312格式解码为字符串
hex：字节序列数组或字节序列字符串
返回值：字符串
调用示例：

var hex=[];
hex.push(0xBD);hex.push(0xF0);hex.push(0xC8);hex.push(0xFD);
printf(HexArrayToGB2312(hex));
hex=AscToBcd("BDF0C8FDD2AF");
printf(HexArrayToGB2312(hex));
printf(HexArrayToGB2312("BDF0C8FDD2AF"));

输出
金三
金三爷
金三爷

UTF8ToHexArray(str)

将字符串按UTF8格式编码为字节序列
str：字符串
返回值：字节序列数组
调用示例：

var hex=UTF8ToHexArray("金三爷");
printf(BcdToAsc(hex));

输出E98791E4B889E788B7

HexArrayToUTF8(hex)

将字节序列按UTF8格式解码为字符串
hex：字节序列数组或字节序列字符串
返回值：字符串
调用示例：

var hex=[];
hex.push(0xE9);hex.push(0x87);hex.push(0x91);
printf(HexArrayToUTF8(hex));
hex=AscToBcd("E98791E4B889E788B7");
printf(HexArrayToUTF8(hex));
printf(HexArrayToUTF8("E98791E4B889E788B7"));

输出
金
金三爷
金三爷

fixed_8_00(data)

数据长度不足8的倍数则填充0x00
data：字节序列数组或字节序列字符串
返回值：填充后的字节序列字符串
调用示例：
printf(fixed_8_00("11 22 AABBCC"));
输出11 22 AABBCC000000

fixed_8_80(data)

先填充1字节0x80,填充后数据长度不足8的倍数则填充0x00
data：字节序列数组或字节序列字符串
返回值：填充后的字节序列字符串
调用示例：
printf(fixed_8_80("11 22 AABBCC"));
输出11 22 AABBCC800000

fixed_16_00(data)

数据长度不足16的倍数则填充0x00
data：字节序列数组或字节序列字符串
返回值：填充后的字节序列字符串
调用示例：
printf(fixed_16_00("11 22 AABBCC"));
输出11 22 AABBCC0000000000000000000000

fixed_16_80(data)

先填充1字节0x80,填充后数据长度不足16的倍数则填充0x00
data：字节序列数组或字节序列字符串
返回值：填充后的字节序列字符串
调用示例：
printf(fixed_16_80("11 22 AABBCC"));
输出11 22 AABBCC8000000000000000000000

dup(data, count)

将数据重复count次并返回。
data：字节序列数组或字节序列字符串
count：重复次数，数值型
返回值：字节序列字符串
调用示例：

var data=AscToBcd("1234AABB");
printf(dup(data,3));
printf(dup("F299",2));

输出
1234AABB1234AABB1234AABB
F299F299

random(len)

获取指定长度字节的随机数
len：长度，数值型
返回值：字节序列字符串
调用示例：

printf(random(2));
printf(random(10));

输出
F451
4F878C21A04BEC85F8F1

reverse_block_byte(data)

翻转所有字节
data：字节序列数组或字节序列字符串
返回值：字节序列字符串
调用示例：printf(reverse_block_byte("1122AA"));
输出AA2211

data_xor(data1, data2)

异或
data1：字节序列数组或字节序列字符串
data2：字节序列数组或字节序列字符串
返回值：字节序列字符串，长度为data2的数据长度
调用示例：printf(data_xor("1122AA","88990022"));
输出99BBAA22

data_and(data1, data2)

与
data1：字节序列数组或字节序列字符串
data2：字节序列数组或字节序列字符串
返回值：字节序列字符串，长度为data2的数据长度
调用示例：printf(data_and("1122AA","88990022"));
输出00000022

data_or(data1, data2)

或
data1：字节序列数组或字节序列字符串
data2：字节序列数组或字节序列字符串
返回值：字节序列字符串，长度为data2的数据长度
调用示例：printf(data_or("123456","ABCDEF88"));
输出BBFDFF88

hex2int(hexData)

将16进制数据转成10进制数值
hexData：字节序列数组或字节序列字符串
返回值：数值
调用示例：printf(hex2int("1122AABB"));
输出287484603

int2hex(intData)

将10进制数值转成16进制数据
intData：数值
返回值：字节序列字符串
调用示例：printf(int2hex(287484603));
输出1122AABB

base64_encode(data)

BASE64编码
data：字节序列数组或字节序列字符串
返回值：BASE64字符串
调用示例：printf(base64_encode("1122"));
输出ESI=

base64_encode(data)

BASE64编码
data：字节序列数组或字节序列字符串
返回值：BASE64字符串
调用示例：printf(base64_decode("ESI="));
输出1122
条码二维码

drawqrcode(str)

绘制QR二维码，无返回值
str：字符串
调用示例：drawqrcode("寂井浮廊");

drawbarcode39(numStr)

绘制Code39条形码，无返回值
numStr：只包含0-9数字的字符串
调用示例：drawbarcode39("12345");

drawbarcode128(numStr)

绘制Code128条形码，无返回值
numStr：只包含0-9数字的字符串
调用示例：drawbarcode128("12345");

drawcodeDataMatrix(str)

绘制Data Matrix二维码，无返回值
str：ISO-8859-1编码的字符串
调用示例：drawcodeDataMatrix("abc123SX-=./s");

drawbarEAN8(numStr)

绘制EAN8条形码，无返回值
numStr：只包含0-9数字的字符串，且长度必须为7-8
调用示例：drawbarEAN8("1234567");

drawbarEAN13(numStr)

绘制EAN13条形码，无返回值
numStr：只包含0-9数字的字符串，且长度必须为12-13
调用示例：drawbarEAN13("123456789012");

drawcodePDF417(str)

绘制PDF 417条形码，无返回值
str：ISO-8859-1编码的字符串
调用示例：drawcodePDF417("abc123SX-=./s");
卡片交互

reset()

复位卡片，需在页面上提前选择读卡器。无入参。系统会自动将ATR显示在LOG框
返回值：复位ATR信息，字符串
调用示例：

var str=reset();
if(!str)
    printf("reset失败");
else
    printf(str);

waitCard(time)

等待用户使用卡片。
time：等待的毫秒数
返回值：复位ATR信息，字符串
调用示例：

var str=waitCard(10*1000);
if(!str)
    printf("10秒内没有检测到卡片");
else
    printf("监测到卡片，ATR："+str);

sendAPDU(apdu)

发送C-APDU指令
apdu：C-APDU指令,字节序列数组或字节序列字符串
返回值：R-APDU数据，json格式(包含data字节序列字符串，dataHex数值型数组，sw字节序列字符串，swHex数值型数组)
调用示例：

clear();
reset();
var rapdu=sendAPDU("00 84 00 00 04");
printf(JSON.stringify(rapdu));
var rapdu=sendAPDU("00A404000E315041592E5359532E4444463031000");
printf(JSON.stringify(rapdu));

输出
{"data":"","dataHex":[],"sw":"6D00","swHex":[109,0]}
{"data":"6F26840E315041592E5359532E4444463031A5148801015F2D027A689F110101BF0C059F4D020B0A","dataHex":[111,38,132,14,49,80,65,89,46,83,89,83,46,68,68,70,48,49,165,20,136,1,1,95,45,2,122,104,159,17,1,1,191,12,5,159,77,2,11,10],"sw":"9000","swHex":[144,0]}

sendSelectPSE()

发送选择PSE的C-APDU指令
返回值：R-APDU数据，json格式(包含data字节序列字符串，dataHex数值型数组，sw字节序列字符串，swHex数值型数组，tlv数据)
调用示例：

clear();
reset();
var rapdu=sendPSE();
printf(JSON.stringify(rapdu));

输出
{"data":"6F1E840E315041592E5359532E4444463031A50C8801015F2D027A689F110101","dataHex":[111,30,132,14,49,80,65,89,46,83,89,83,46,68,68,70,48,49,165,12,136,1,1,95,45,2,122,104,159,17,1,1],"sw":"9000","swHex":[144,0],"tlv":[{"tag":111,"len":30,"value":"840E315041592E5359532E4444463031A50C8801015F2D027A689F110101","valueHex":[132,14,49,80,65,89,46,83,89,83,46,68,68,70,48,49,165,12,136,1,1,95,45,2,122,104,159,17,1,1],"items":[{"tag":132,"len":14,"value":"315041592E5359532E4444463031","valueHex":[49,80,65,89,46,83,89,83,46,68,68,70,48,49],"items":[]},{"tag":165,"len":12,"value":"8801015F2D027A689F110101","valueHex":[136,1,1,95,45,2,122,104,159,17,1,1],"items":[{"tag":136,"len":1,"value":"01","valueHex":[1],"items":[]},{"tag":24365,"len":2,"value":"7A68","valueHex":[122,104],"items":[]},{"tag":40721,"len":1,"value":"01","valueHex":[1],"items":[]}]}]}]}

sendSelectPPSE()

发送选择PPSE的C-APDU指令
返回值：R-APDU数据，json格式(包含data字节序列字符串，dataHex数值型数组，sw字节序列字符串，swHex数值型数组，tlv数据)

sendSelectAID(aid, option)

发送选择指定AID的C-APDU指令
aid：AID，字节序列数组或字节序列字符串
option：0表示选择当前AID，2表示选择下一个AID
返回值：R-APDU数据，json格式(包含data字节序列字符串，dataHex数值型数组，sw字节序列字符串，swHex数值型数组，tlv数据)
调用示例：sendSelectAID("A0 00 00 03 33 01 01",0)

sendReadRecord(SFI, RecordNumber)

发送读记录的C-APDU指令
SFI：记录的SFI，数值型
RecordNumber：记录号，数值型
返回值：R-APDU数据，json格式(包含data字节序列字符串，dataHex数值型数组，sw字节序列字符串，swHex数值型数组，tlv数据)
调用示例：sendReadRecord(2,1)

sendGetData(tag)

发送Get Data的C-APDU指令
tag：待读取的TAG，数值型
返回值：R-APDU数据，json格式(包含data字节序列字符串，dataHex数值型数组，sw字节序列字符串，swHex数值型数组，tlv数据)
调用示例：sendGetData(0x9F79)
TLV解析

UnPackTLV(tlv, IsIgnoreFF)

解析TLV数据
tlv：字节序列数组或字节序列字符串
IsIgnoreFF：是否忽略多余的FF，布尔型，可不填默认为true
返回值：解析后结果，json格式(包含tag数值型，len数值型，value字节序列字符串，valueHex数值型数组，items子节点数组)
调用示例：

var tlv=UnPackTLV("6F07FFFFFF9F110101",true);
printf(JSON.stringify(tlv));
tlv=UnPackTLV("6F24840E315041592E5359532E4444463031A5128801015F2D086573656E667264659F110101");
ShowTlvObject(tlv);

输出

[{"tag":111,"len":7,"value":"FFFFFF9F110101","valueHex":[255,255,255,159,17,1,1],"items":[{"tag":40721,"len":1,"value":"01","valueHex":[1],"items":[]}]}]
tag:6F
len:24
value:840E315041592E5359532E4444463031A5128801015F2D086573656E667264659F110101
items:
___tag:84
___len:0E
___value:315041592E5359532E4444463031
___tag:A5
___len:12
___value:8801015F2D086573656E667264659F110101
___items:
______tag:88
______len:01
______value:01
______tag:5F2D
______len:08
______value:6573656E66726465
______tag:9F11
______len:01
______value:01

查找TLV

FindTlv(tlvObj,tag,index)

查找TLV数据
tlvObj：经过UnPackTLV解析后的json对象
tag：TAG，数值型
index：表示查找第几个出现的该TAG，从1开始。数值型
返回值：查找结果，json格式(包含tag数值型，len数值型，value字节序列字符串，items子节点数组)
调用示例：

var tlvObj=UnPackTLV("6F 4C 84 0E 32 50 41 59 2E 53 59 53 2E 44 44 46 30 31 A5 3A BF 0C 37 61 1A 4F 08 A0 00 00 03 33 01 01 02 50 0B 50 42 4F 43 20 43 52 45 44 49 54 87 01 01 61 19 4F 08 A0 00 00 03 33 01 01 01 50 0A 50 42 4F 43 20 44 45 42 49 54 87 01 02",true)
var result=FindTlv(tlvObj,0x61,1);
printf(JSON.stringify(result));
result=FindTlv(tlvObj,0x61,2);
printf(JSON.stringify(result));

输出

{"tag":97,"len":26,"value":"4F08A000000333010102500B50424F4320435245444954870101","valueHex":[79,8,160,0,0,3,51,1,1,2,80,11,80,66,79,67,32,67,82,69,68,73,84,135,1,1],"items":[{"tag":79,"len":8,"value":"A000000333010102","valueHex":[160,0,0,3,51,1,1,2],"items":[]},{"tag":80,"len":11,"value":"50424F4320435245444954","valueHex":[80,66,79,67,32,67,82,69,68,73,84],"items":[]},{"tag":135,"len":1,"value":"01","valueHex":[1],"items":[]}]}
{"tag":97,"len":25,"value":"4F08A000000333010101500A50424F43204445424954870102","valueHex":[79,8,160,0,0,3,51,1,1,1,80,10,80,66,79,67,32,68,69,66,73,84,135,1,2],"items":[{"tag":79,"len":8,"value":"A000000333010101","valueHex":[160,0,0,3,51,1,1,1],"items":[]},{"tag":80,"len":10,"value":"50424F43204445424954","valueHex":[80,66,79,67,32,68,69,66,73,84],"items":[]},{"tag":135,"len":1,"value":"02","valueHex":[2],"items":[]}]}

ShowTlvObject(tlvObj)

简单地以层级结构显示tlv对象。无返回值
tlvObj：经过UnPackTLV解析后的json对象
调用示例：参看UnPackTLV

UnPackDOL(dolData)

解析DOL数据
dolData：字节序列数组或字节序列字符串
返回值：解析后结果，json格式(包含tag数值型，len数值型)
调用示例：

var dol=UnPackDOL("9F02069F66049C01");
printf(JSON.stringify(dol));
for(var i=0;i<dol.length;i++){
	printf(int2hex(dol[i].tag)+"  "+int2hex(dol[i].len));
}

输出

[{"tag":0x9F02,"len":6},{"tag":0x9F66,"len":4},{"tag":0x9C,"len":1}]
9F02 06
9F66 04
9C 01

calc_dol_len(dolData)

计算DOL数据的长度
dolData：字节序列数组或字节序列字符串
返回值：DOL数据长度，数值型
调用示例：printf(calc_dol_len("9F02069F66049C01"));

输出11
加解密算法

des_encode_ecb(data,key)

单倍长DES加密,ECB模式
data：待加密数据,字节序列数组或字节序列字符串。如不满8字节的倍数则自动填充0x00
key：DES密钥,只使用前8字节
返回值：密文,字节序列字符串
调用示例：
printf(des_encode_ecb("112233","1122334455667788"));
输出FE9F7065059A5F21

des_decode_ecb(data,key)

单倍长DES解密,ECB模式
data：待解密数据,字节序列数组或字节序列字符串。长度必须8字节的倍数
key：DES密钥,只使用前8字节
返回值：明文,字节序列字符串
调用示例：
printf(des_decode_ecb("CD09BC4876AC0F2BCD09BC4876AC0F2B","1122334455667788"));
输出11223344556677881122334455667788

tdes_encode_ecb(data,key)

双倍长DES加密,ECB模式
data：待加密数据,字节序列数组或字节序列字符串。如不满8字节的倍数则自动填充0x00
key：DES密钥,只使用前16字节
返回值：密文,字节序列字符串
调用示例：
printf(tdes_encode_ecb("112233","112233445566778811223344556677FF"));
输出06D5FF0F3E9B913B

tdes_decode_ecb(data,key)

双倍长DES解密,ECB模式
data：待解密数据,字节序列数组或字节序列字符串。长度必须8字节的倍数
key：DES密钥,只使用前16字节
返回值：明文,字节序列字符串
调用示例：
printf(tdes_decode_ecb("06D5FF0F3E9B913B06D5FF0F3E9B913B","112233445566778811223344556677FF"));
输出11223300000000001122330000000000

tdes_24k_encode_ecb(data,key)

三倍长DES加密,ECB模式
data：待加密数据,字节序列数组或字节序列字符串。如不满8字节的倍数则自动填充0x00
key：DES密钥,只使用前24字节
返回值：密文,字节序列字符串
调用示例：
printf(tdes_24k_encode_ecb("112233","112233445566778811223344556677FFAA223344556677FF"));
输出923B1167E9FA21D1

tdes_24k_decode_ecb(data,key)

三倍长DES解密,ECB模式
data：待解密数据,字节序列数组或字节序列字符串。长度必须8字节的倍数
key：DES密钥,只使用前24字节
返回值：明文,字节序列字符串
调用示例：
printf(tdes_24k_decode_ecb("923B1167E9FA21D1","112233445566778811223344556677FFAA223344556677FF"));
输出1122330000000000

des_encode_cbc(data,key,iv)

单倍长DES加密,CBC模式
data：待加密数据,字节序列数组或字节序列字符串。如不满8字节的倍数则自动填充0x00
key：DES密钥,只使用前8字节
iv：初始向量,只使用前8字节
返回值：密文,字节序列字符串
调用示例：
printf(des_encode_cbc("112233","1122334455667788","0000000011111111"));
输出B83BF900F9BDBAAA

des_decode_cbc(data,key,iv)

单倍长DES解密,CBC模式
data：待解密数据,字节序列数组或字节序列字符串。长度必须8字节的倍数
key：DES密钥,只使用前8字节
iv：初始向量,只使用前8字节
返回值：明文,字节序列字符串
调用示例：
printf(des_decode_cbc("B83BF900F9BDBAAA","1122334455667788","0000000011111111"));
输出1122330000000000

tdes_encode_cbc(data,key,iv)

双倍长DES加密,CBC模式
data：待加密数据,字节序列数组或字节序列字符串。如不满8字节的倍数则自动填充0x00
key：DES密钥,只使用前16字节
iv：初始向量,只使用前8字节
返回值：密文,字节序列字符串
调用示例：
printf(tdes_encode_cbc("112233112233112233","112233445566778811223344556677FF","0000000011111111"));
输出5AAC471DB8A8D709939AAF2072ABE4C7

tdes_decode_cbc(data,key,iv)

双倍长DES解密,CBC模式
data：待解密数据,字节序列数组或字节序列字符串。长度必须8字节的倍数
key：DES密钥,只使用前16字节
iv：初始向量,只使用前8字节
返回值：明文,字节序列字符串
调用示例：
printf(tdes_decode_cbc("5AAC471DB8A8D709939AAF2072ABE4C7","112233445566778811223344556677FF","0000000011111111"));
输出11223311223311223300000000000000

tdes_24k_encode_cbc(data,key,iv)

三倍长DES加密,CBC模式
data：待加密数据,字节序列数组或字节序列字符串。如不满8字节的倍数则自动填充0x00
key：DES密钥,只使用前24字节
iv：初始向量,只使用前8字节
返回值：密文,字节序列字符串
调用示例：
printf(tdes_24k_encode_cbc("112233","112233445566778811223344556677FFAA223344556677FF","0000000011111111"));
输出D99AD7536B0F3EF8

tdes_24k_decode_cbc(data,key,iv)

三倍长DES解密,CBC模式
data：待解密数据,字节序列数组或字节序列字符串。长度必须8字节的倍数
key：DES密钥,只使用前24字节
iv：初始向量,只使用前8字节
返回值：明文,字节序列字符串
调用示例：
printf(tdes_24k_decode_cbc("D99AD7536B0F3EF8","112233445566778811223344556677FFAA223344556677FF","0000000011111111"));
输出1122330000000000

aes128_encode_ecb(data,key)

AES128加密,ECB模式
data：待加密数据,字节序列数组或字节序列字符串。如不满16字节的倍数则自动填充0x00
key：AES密钥,只使用前16字节
返回值：密文,字节序列字符串
调用示例：
printf(aes128_encode_ecb("112233","11223344556677881122334455667788"));
输出774ACE896B3CE46D9610311C52B4067F

aes128_decode_ecb(data,key)

AES128解密,ECB模式
data：待解密数据,字节序列数组或字节序列字符串。长度必须16字节的倍数
key：AES密钥,只使用前16字节
返回值：明文,字节序列字符串
调用示例：
printf(aes128_decode_ecb("774ACE896B3CE46D9610311C52B4067F","11223344556677881122334455667788"));
输出11223300000000000000000000000000

aes192_encode_ecb(data,key)

AES192加密,ECB模式
data：待加密数据,字节序列数组或字节序列字符串。如不满16字节的倍数则自动填充0x00
key：AES密钥,只使用前24字节
返回值：密文,字节序列字符串
调用示例：
printf(aes192_encode_ecb("112233","112233445566778811223344556677881122334455667788"));
输出DD434A92B0481AE13989A259BFD13C6E

aes192_decode_ecb(data,key)

AES192解密,ECB模式
data：待解密数据,字节序列数组或字节序列字符串。长度必须16字节的倍数
key：AES密钥,只使用前24字节
返回值：明文,字节序列字符串
调用示例：
printf(aes192_decode_ecb("DD434A92B0481AE13989A259BFD13C6E","112233445566778811223344556677881122334455667788"));
输出11223300000000000000000000000000

aes256_encode_ecb(data,key)

AES256加密,ECB模式
data：待加密数据,字节序列数组或字节序列字符串。如不满16字节的倍数则自动填充0x00
key：AES密钥,只使用前32字节
返回值：密文,字节序列字符串
调用示例：
printf(aes256_encode_ecb("112233","1122334455667788112233445566778811223344556677881122334455667788"));
输出EEA91DC51675F15CE065CF8E02D42466

aes256_decode_ecb(data,key)

AES256解密,ECB模式
data：待解密数据,字节序列数组或字节序列字符串。长度必须16字节的倍数
key：AES密钥,只使用前32字节
返回值：明文,字节序列字符串
调用示例：
printf(aes256_decode_ecb("EEA91DC51675F15CE065CF8E02D42466","1122334455667788112233445566778811223344556677881122334455667788"));
输出11223300000000000000000000000000

aes128_encode_cbc(data,key,iv)

AES128加密,CBC模式
data：待加密数据,字节序列数组或字节序列字符串。如不满16字节的倍数则自动填充0x00
key：AES密钥,只使用前16字节
iv：初始向量,只使用前16字节
返回值：密文,字节序列字符串
调用示例：
printf(aes128_encode_cbc("112233112233112233","112233445566778811223344556677FF","00000000111111110000000011111111"));
输出4E853E2EF07C16E9756C70DA0B6249A9

aes128_decode_cbc(data,key,iv)

AES128解密,CBC模式
data：待解密数据,字节序列数组或字节序列字符串。长度必须16字节的倍数
key：AES密钥,只使用前16字节
iv：初始向量,只使用前16字节
返回值：明文,字节序列字符串
调用示例：
printf(aes128_decode_cbc("4E853E2EF07C16E9756C70DA0B6249A9","112233445566778811223344556677FF","00000000111111110000000011111111"));
输出11223311223311223300000000000000

aes192_encode_cbc(data, key, iv)

AES192加密,CBC模式
data：待加密数据,字节序列数组或字节序列字符串。如不满16字节的倍数则自动填充0x00
key：AES密钥,只使用前24字节
iv：初始向量,只使用前16字节
返回值：密文,字节序列字符串
调用示例：
printf(aes192_encode_cbc("112233112233112233","112233445566778811223344556677FF11223344556677FF","00000000111111110000000011111111"));
输出001080DDABF1112804537409AE2CEE4D

aes192_decode_cbc(data, key, iv)

AES192解密,CBC模式
data：待解密数据,字节序列数组或字节序列字符串。长度必须16字节的倍数
key：AES密钥,只使用前24字节
iv：初始向量,只使用前16字节
返回值：明文,字节序列字符串
调用示例：
printf(aes192_decode_cbc("001080DDABF1112804537409AE2CEE4D","112233445566778811223344556677FF11223344556677FF","00000000111111110000000011111111"));
输出11223311223311223300000000000000

aes256_encode_cbc(data, key, iv)

AES256加密,CBC模式
data：待加密数据,字节序列数组或字节序列字符串。如不满16字节的倍数则自动填充0x00
key：AES密钥,只使用前32字节
iv：初始向量,只使用前16字节
返回值：密文,字节序列字符串
调用示例：
printf(aes256_encode_cbc("112233112233112233","112233445566778811223344556677FF11223344556677FF1122334455667788","00000000111111110000000011111111"));
输出53A6D0CF50E59652F086714F3AC31C00

aes256_decode_cbc(data, key, iv)

AES256解密,CBC模式
data：待解密数据,字节序列数组或字节序列字符串。长度必须16字节的倍数
key：AES密钥,只使用前32字节
iv：初始向量,只使用前16字节
返回值：明文,字节序列字符串
调用示例：
printf(aes256_decode_cbc("53A6D0CF50E59652F086714F3AC31C00","112233445566778811223344556677FF11223344556677FF1122334455667788","00000000111111110000000011111111"));
输出11223311223311223300000000000000

sm4_encode_ecb(data,key)

SM4加密,ECB模式
data：待加密数据,字节序列数组或字节序列字符串。如不满16字节的倍数则自动填充0x00
key：SM4密钥,只使用前16字节
返回值：密文,字节序列字符串
调用示例：
printf(sm4_encode_ecb("112233","11223344556677881122334455667788"));
输出A1DC843BBB58E672EA52782C44CC50A9

sm4_decode_ecb(data,key)

SM4解密,ECB模式
data：待解密数据,字节序列数组或字节序列字符串。长度必须16字节的倍数
key：SM4密钥,只使用前16字节
返回值：明文,字节序列字符串
调用示例：
printf(sm4_decode_ecb("A1DC843BBB58E672EA52782C44CC50A9","11223344556677881122334455667788"));
输出11223300000000000000000000000000

sm4_encode_cbc(data, key, iv)

SM4加密,CBC模式
data：待加密数据,字节序列数组或字节序列字符串。如不满16字节的倍数则自动填充0x00
key：SM4密钥,只使用前16字节
iv：初始向量,只使用前16字节
返回值：密文,字节序列字符串
调用示例：
printf(sm4_encode_cbc("112233112233112233","11223344556677881122334455667788","00000000111111110000000011111111"));
输出713A9781ADDEFDB920DFE9E24A96F0A3

sm4_decode_cbc(data, key, iv)

SM4解密,CBC模式
data：待解密数据,字节序列数组或字节序列字符串。长度必须16字节的倍数
key：DES密钥,只使用前16字节
iv：初始向量,只使用前16字节
返回值：明文,字节序列字符串
调用示例：
printf(sm4_decode_cbc("713A9781ADDEFDB920DFE9E24A96F0A3","11223344556677881122334455667788","00000000111111110000000011111111"));
输出11223311223311223300000000000000

sha1_hash(data)

SHA-1计算，适用于少量数据
data：字节序列数组或字节序列字符串
返回值：哈希值，字节序列字符串
调用示例：
printf(sha1_hash("1122AABB"));
printf(sha1_hash(""));
输出
BEBF7A992BBF381A8B6E184B8AF5FDE4B499B846
DA39A3EE5E6B4B0D3255BFEF95601890AFD80709

sha1_hash_init()

SHA-1计算初始化，每次计算只需调用1次，必须与sha1_hash_dofinal成对出现
返回值：句柄，请勿修改
调用示例：

var ptr=sha1_hash_init();
sha1_hash_update(ptr,"112233");
sha1_hash_update(ptr,"AABB");
printf(sha1_hash_dofinal(ptr));

输出4CA18EC6C8C159D7CB68581442E0098AF2B91571

sha1_hash_update(ptr, data)

SHA-1计算更新数据，每次计算可调用多次
ptr：sha1_hash_init返回的句柄
data：字节序列数组或字节序列字符串
返回值：true/false
调用示例：参看sha1_hash_init

sha1_hash_dofinal(ptr)

SHA-1计算最终结果，每次计算只需调用1次，必须与sha1_hash_init成对出现
ptr：sha1_hash_init返回的句柄
返回值：哈希值，字节序列字符串
调用示例：参看sha1_hash_init

sha224_hash(data)

SHA-224计算，适用于少量数据
data：字节序列数组或字节序列字符串
返回值：哈希值，字节序列字符串
调用示例：
printf(sha224_hash("1122AABB"));
printf(sha224_hash(""));
输出
5BE898803C142C9A8FFFE4CA164C8F98D636F87EA323E30FEB217651
D14A028C2A3A2BC9476102BB288234C415A2B01F828EA62AC5B3E42F

sha224_hash_init()

SHA-224计算初始化，每次计算只需调用1次，必须与sha224_hash_dofinal成对出现
返回值：句柄，请勿修改
调用示例：

var ptr=sha224_hash_init();
sha224_hash_update(ptr,"112233");
sha224_hash_update(ptr,"AABB");
printf(sha224_hash_dofinal(ptr));

输出6D94E4B45F7EB7BB87EBB4B65134658C64C3550E147FAB4C5F08CD29

sha224_hash_update(ptr, data)

SHA-224计算更新数据，每次计算可调用多次
ptr：sha224_hash_init返回的句柄
data：字节序列数组或字节序列字符串
返回值：true/false
调用示例：参看sha224_hash_init

sha224_hash_dofinal(ptr)

SHA-224计算最终结果，每次计算只需调用1次，必须与sha224_hash_init成对出现
ptr：sha224_hash_init返回的句柄
返回值：哈希值，字节序列字符串
调用示例：参看sha224_hash_init

sha256_hash(data)

SHA-256计算，适用于少量数据
data：字节序列数组或字节序列字符串
返回值：哈希值，字节序列字符串
调用示例：
printf(sha256_hash("1122AABB"));
printf(sha256_hash(""));
输出
B6A5DA1E3F802CDF50E68D4506D8A3462A1E1892AAB81225F7A9274CF6F1DD7C
E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855

sha256_hash_init()

SHA-256计算初始化，每次计算只需调用1次，必须与sha256_hash_dofinal成对出现
返回值：句柄，请勿修改
调用示例：

var ptr=sha256_hash_init();
sha256_hash_update(ptr,"112233");
sha256_hash_update(ptr,"AABB");
printf(sha256_hash_dofinal(ptr));

输出26FA586269FA7CA80E070A7AFA487DD817B05189194B759B72DC8A0D62901C8F

sha256_hash_update(ptr, data)

SHA-256计算更新数据，每次计算可调用多次
ptr：sha256_hash_init返回的句柄
data：字节序列数组或字节序列字符串
返回值：true/false
调用示例：参看sha256_hash_init

sha256_hash_dofinal(ptr)

SHA-256计算最终结果，每次计算只需调用1次，必须与sha256_hash_init成对出现
ptr：sha256_hash_init返回的句柄
返回值：哈希值，字节序列字符串
调用示例：参看sha256_hash_init

sha384_hash(data)

SHA-384计算，适用于少量数据
data：字节序列数组或字节序列字符串
返回值：哈希值，字节序列字符串
调用示例：
printf(sha384_hash("1122AABB"));
printf(sha384_hash(""));
输出
30DCE517D0D608C82685B63DE162C3F64FC8616D60979E5EFBEED2D139B4B409F71B0602643519B1A36A95C913AE5C42
38B060A751AC96384CD9327EB1B1E36A21FDB71114BE07434C0CC7BF63F6E1DA274EDEBFE76F65FBD51AD2F14898B95B

sha384_hash_init()

SHA-384计算初始化，每次计算只需调用1次，必须与sha384_hash_dofinal成对出现
返回值：句柄，请勿修改
调用示例：

var ptr=sha384_hash_init();
sha384_hash_update(ptr,"112233");
sha384_hash_update(ptr,"AABB");
printf(sha384_hash_dofinal(ptr));

输出F4F68ACDE8D01D30FFD7474E14BF6B45B0EB7B7EA7A7CC032DA5462EEF39B96D719485C5B22218B586C511AD4E7413C7

sha384_hash_update(ptr, data)

SHA-384计算更新数据，每次计算可调用多次
ptr：sha384_hash_init返回的句柄
data：字节序列数组或字节序列字符串
返回值：true/false
调用示例：参看sha384_hash_init

sha384_hash_dofinal(ptr)

SHA-384计算最终结果，每次计算只需调用1次，必须与sha384_hash_init成对出现
ptr：sha384_hash_init返回的句柄
返回值：哈希值，字节序列字符串
调用示例：参看sha384_hash_init

sha512_hash(data)

SHA-512计算，适用于少量数据
data：字节序列数组或字节序列字符串
返回值：哈希值，字节序列字符串
调用示例：
printf(sha512_hash("1122AABB"));
printf(sha512_hash(""));
输出
E3ED1B3130F131D25DCED07ADD76B0394E395B43464BD6CDAAC674394EFFE6D75D4E3D91F242D0A685DCFDB3ABCFED12550816F37239D0911F2EB057F1AAB5D1
CF83E1357EEFB8BDF1542850D66D8007D620E4050B5715DC83F4A921D36CE9CE47D0D13C5D85F2B0FF8318D2877EEC2F63B931BD47417A81A538327AF927DA3E

sha512_hash_init()

SHA-512计算初始化，每次计算只需调用1次，必须与sha512_hash_dofinal成对出现
返回值：句柄，请勿修改
调用示例：

var ptr=sha512_hash_init();
sha512_hash_update(ptr,"112233");
sha512_hash_update(ptr,"AABB");
printf(sha512_hash_dofinal(ptr));

输出3A6D73657981D2D60D4ED0B9BE28F47A6983AB4B5BBE95B57A25E798FA667620A403E8C2C46E8A1158792AC78A655D82F1F2DDB99D91F570EC20753D95FF1E6D

sha512_hash_update(ptr, data)

SHA-512计算更新数据，每次计算可调用多次
ptr：sha512_hash_init返回的句柄
data：字节序列数组或字节序列字符串
返回值：true/false
调用示例：参看sha512_hash_init

sha512_hash_dofinal(ptr)

SHA-512计算最终结果，每次计算只需调用1次，必须与sha512_hash_init成对出现
ptr：sha512_hash_init返回的句柄
返回值：哈希值，字节序列字符串
调用示例：参看sha512_hash_init

md5_hash(data)

MD5计算，适用于少量数据
data：字节序列数组或字节序列字符串
返回值：哈希值，字节序列字符串
调用示例：
printf(md5_hash("1122AABB"));
printf(md5_hash(""));
输出
13A5EE856BB72AFD0C9F323614B7455B
D41D8CD98F00B204E9800998ECF8427E

md5_hash_init()

MD5计算初始化，每次计算只需调用1次，必须与md5_hash_dofinal成对出现
返回值：句柄，请勿修改
调用示例：

var ptr=md5_hash_init();
md5_hash_update(ptr,"112233");
md5_hash_update(ptr,"AABB");
printf(md5_hash_dofinal(ptr));

输出CE2AC6DE982120AC6E4865F4AFE64FA8

md5_hash_update(ptr, data)

MD5计算更新数据，每次计算可调用多次
ptr：md5_hash_init返回的句柄
data：字节序列数组或字节序列字符串
返回值：true/false
调用示例：参看md5_hash_init

md5_hash_dofinal(ptr)

MD5计算最终结果，每次计算只需调用1次，必须与md5_hash_init成对出现
ptr：md5_hash_init返回的句柄
返回值：哈希值，字节序列字符串
调用示例：参看md5_hash_init

sm3_hash(data)

SM3计算，适用于少量数据
data：字节序列数组或字节序列字符串
返回值：哈希值，字节序列字符串
调用示例：
printf(sm3_hash("1122AABB"));
printf(sm3_hash(""));
输出
C61CD2B635A1437139ADED32F93BCAB5C0BCD780445BFB7CFFBC132D48343C19
1AB21D8355CFA17F8E61194831E81A8F22BEC8C728FEFB747ED035EB5082AA2B

sm3_hash_init()

SM3计算初始化，每次计算只需调用1次，必须与sm3_hash_dofinal成对出现
返回值：句柄，请勿修改
调用示例：

var ptr=sm3_hash_init();
sm3_hash_update(ptr,"112233");
sm3_hash_update(ptr,"AABB");
printf(sm3_hash_dofinal(ptr));

输出864B20A8F483601CE0D58844C84305F9E949DBA05E5F5A58B54D0AFC76A7463D

sm3_hash_update(ptr, data)

SM3计算更新数据，每次计算可调用多次
ptr：sm3_hash_init返回的句柄
data：字节序列数组或字节序列字符串
返回值：true/false
调用示例：参看sm3_hash_init

sm3_hash_dofinal(ptr)

SM3计算最终结果，每次计算只需调用1次，必须与sm3_hash_init成对出现
ptr：sm3_hash_init返回的句柄
返回值：哈希值，字节序列字符串
调用示例：参看sm3_hash_init

hmac_sha1(data,key)

基于SHA1的HAMC计算
data：字节序列数组或字节序列字符串
key：密钥，字节序列数组或字节序列字符串
返回值：HMAC值，字节序列字符串
调用示例：
printf(hmac_sha1("1122AABB","1122"));
printf(hmac_sha1("","1122"));
输出
C7DEE084538BFFE35CC418DC3F7C4E9A302DF3D1
DDE9AD9FCE3E842C2CC81597B7380364208FE59D

hmac_sha224(data,key)

基于SHA224的HAMC计算
data：字节序列数组或字节序列字符串
key：密钥，字节序列数组或字节序列字符串
返回值：HMAC值，字节序列字符串
调用示例：
printf(hmac_sha224("1122AABB","1122"));
printf(hmac_sha224("","1122"));
输出
B4E047772BE3D500D196D85D8C7AD4EE10886CB3A9AA431F89390DB1
0D1B5D229D9B975245F3FE837393B72E36F1414A63A2961847F3CC11

hmac_sha256(data,key)

基于SHA256的HAMC计算
data：字节序列数组或字节序列字符串
key：密钥，字节序列数组或字节序列字符串
返回值：HMAC值，字节序列字符串
调用示例：
printf(hmac_sha256("1122AABB","1122"));
printf(hmac_sha256("","1122"));
输出
4942F5DED244961222897AC8DF417AD71481F0C34039A534A870837A8FC7A920
5DBB652AA9C50C5FA2F14D562B974E8F551FDEBF2F67B410EC6FA84665BD4D39

hmac_sha384(data,key)

基于SHA384的HAMC计算
data：字节序列数组或字节序列字符串
key：密钥，字节序列数组或字节序列字符串
返回值：HMAC值，字节序列字符串
调用示例：
printf(hmac_sha384("1122AABB","1122"));
printf(hmac_sha384("","1122"));
输出
E08A1B8EC296810F7EC6C92C7F11EB538B7F64B5DC7E34671366CC16BB027B96FCD74F7C930050E7D6545BED894210EB
32D1455ED00552B32DA41F148E73502FD0739297EC63BBABBBDDE390DC4B433EA55DD9F4446C07E8A124F92B635E2255

hmac_sha512(data,key)

基于SHA512的HAMC计算
data：字节序列数组或字节序列字符串
key：密钥，字节序列数组或字节序列字符串
返回值：HMAC值，字节序列字符串
调用示例：
printf(hmac_sha512("1122AABB","1122"));
printf(hmac_sha512("","1122"));
输出
52771F3DBF72DF45109A2EA1FA1E47066E6640DBFAB5F5A27B09B4A3A3C883FE5C69BA9C19D5957A680DBDB40367F60859CCE0DF1DD8A0520DEA79A4994A0BCD
C7F3127497379AEF1C884AD7F6CE735A36520872DC989F3E91E0868F0E605C17CF9AD09AAFE211CD462DDAF491925C00B5C3C3E1B5DD9A885D608DA7810E2129

hmac_md5(data,key)

基于MD5的HAMC计算
data：字节序列数组或字节序列字符串
key：密钥，字节序列数组或字节序列字符串
返回值：HMAC值，字节序列字符串
调用示例：
printf(hmac_md5("1122AABB","1122"));
printf(hmac_md5("","1122"));
输出
2323CDD493580057F5F7139C91176F90
2C31F4676F81B64C42CFBC8E278C84AE

hmac_sm3(data,key)

基于SM3的HAMC计算
data：字节序列数组或字节序列字符串
key：密钥，字节序列数组或字节序列字符串
返回值：HMAC值，字节序列字符串
调用示例：
printf(hmac_sm3("1122AABB","1122"));
printf(hmac_sm3("","1122"));
输出
BDCC1F3E653C317A37C11C399B307D48C77355514CBADBA483D596F689C9E101
908C9B19BD622E391D2598EB29154C1170C2BC83451E2192545A4873F015C4EE

file_md5(path)

计算文件的MD5值
path：文件绝对路径或文件名(从AssistantTool.exe所在目录\script目录中查找)
返回值：哈希值，字节序列字符串

file_sha1(path)

计算文件的SHA1值
返回值：哈希值，字节序列字符串

file_sha256(path)

计算文件的SHA256值
返回值：哈希值，字节序列字符串

file_sha384(path)

计算文件的SHA384值
返回值：哈希值，字节序列字符串

file_sha512(path)

计算文件的SHA512值
返回值：哈希值，字节序列字符串

file_sm3(path)

计算文件的SM3值
返回值：哈希值，字节序列字符串

generate_rsa_keypair(bit,e)

产生RSA密钥对
bit：密钥长度,范围为384-4096
e：公钥指数，0表示公钥指数取010001，1表示取03(密钥长度大的时候速度较慢)，2表示随机取两者之一
返回值：密钥对的json数据,包含N E D P Q DP DQ InverseQ
调用示例：

var key=generate_rsa_keypair(512,0);
printf(JSON.stringify(key));

输出{"N":"E30B7B5196E958FA4C7D73F0F9547E33002BE3077D988BBE6DAAD6642733979247CBF282A555FE742490E82386CD218DF86B627385D4398A0293EF6179FB5581","E":"010001","D":"9018045EE6B117E85ACD2FDD1AD035FBB63B242DE7D6FDB190B660B45570D7DB2B7D088EDAD18B144B6B874081386B66EDD18B80D041382D977326CCA0081835","P":"E8463CB9CFF4F97E9D29781D99827E6AC544DA346911FA0640ECA2A5C5A5585B","Q":"FA3C7F5B89F91B6CE7EB7AF43A8DE34812854423FBAD142C542297C1A6AE1053","DP":"16D969F9E17238E4F2B2F4A4FCC7F085B2583E9AEF471C70670CA0476C750287","DQ":"1D658C04A1F1CCC1FF80CF61EF9B098F46F5B6EA8F3F66F64A300229F2BDD217","InverseQ":"D332B0CCDBF334ED03760FDAA991AAE58578241E72AD30A43E2A4E2D75C4EDD8"}

rsa_public_encode(data, key)

RSA公钥计算
data：字节序列数组或字节序列字符串，长度必须等于模长或不大于模长-11
key：包含N与E的json数据
返回值：计算结果，字节序列字符串
调用示例：

var key={N:"BACABD7A4BE4C7353E55F719EA112CBD8631AAF4834C45C713E43E7590DAB0D1BDEF248E52A478B2D7EC73889B47A2DEEDCC9C9A6F17C7371635757144E70F11",E:"010001"}
printf(rsa_public_encode("112233",key));
printf(rsa_public_encode("112233445566778899001122334455667788990011223344556677889900112233445566778899001122334455667788990011223344556677889900FFFFFFFF",key));

输出
7040CCEE4B637BD9C28EC4C9FAD3241C60192BBBC68DAF80511043AAFC0A241FBE9DADC2004DB1504987F21D06A26313B095C72F34A6A10BCD9B581F7599326E
4E423D424377402CC3421BA61258F9ED129137A77DF51FEB0D80DBBE6414B49D590B4B1CC6C7BC0ADE645BE2294497D49CE05AF35651F4361778CE4168861EDE

rsa_private_encode(data, key, flag)

RSA私钥计算
data：字节序列数组或字节序列字符串，长度必须等于模长
key：包含N E D P Q DP DQ InverseQ的json数据
flag：选填。为true时表示不处理填充字符，可用于查看公钥加密时填充后的数据
返回值：计算结果，字节序列字符串
调用示例：

var key={N:"BACABD7A4BE4C7353E55F719EA112CBD8631AAF4834C45C713E43E7590DAB0D1BDEF248E52A478B2D7EC73889B47A2DEEDCC9C9A6F17C7371635757144E70F11",
        E:"010001",
        D:"6745F4608B595FB256569D19DCC9C61CBAF6F6F7DD27EC6456E1188F539935ACAF2DEBEC7CF9773B91C2F0EDBC7027669E97CA89B6BF87A16B818D5576AC6CE9",
        P:"DD4C0223C97247C849CF32D66B086F5D5A8B5344A80F58DB73C90AE7BEDA1D57",
        Q:"D81586B24FD7586E7BC15BA6EAB9E917131A8FADF85E0EF8A10827BC59BD0DD7",
        DP:"A285C6F0876AC1A32BE9DAD934443E9D9DF8C2CFA2699B05989466C8EA168003",
        DQ:"A7D2F02E853C277E87B7814B7E7AADC232202AFF5F2B0E4DA42405589009F939",
        InverseQ:"8064A5DCB7B2C141EA9A570422592B6FBF8DD23BFD972812144EA4FE35898058"};
printf(rsa_private_encode("7040CCEE4B637BD9C28EC4C9FAD3241C60192BBBC68DAF80511043AAFC0A241FBE9DADC2004DB1504987F21D06A26313B095C72F34A6A10BCD9B581F7599326E",key));
printf(rsa_private_encode("7040CCEE4B637BD9C28EC4C9FAD3241C60192BBBC68DAF80511043AAFC0A241FBE9DADC2004DB1504987F21D06A26313B095C72F34A6A10BCD9B581F7599326E",key,true));
printf(rsa_private_encode("4E423D424377402CC3421BA61258F9ED129137A77DF51FEB0D80DBBE6414B49D590B4B1CC6C7BC0ADE645BE2294497D49CE05AF35651F4361778CE4168861EDE",key));

输出
112233
00021E8510A175A88C9CA7FECCEAA0E128720B1E14856C0DE20666724D966655EE7168787A4ED1C652B3438B962CE72F0B5CF43C01271A9866CE926D00112233
112233445566778899001122334455667788990011223344556677889900112233445566778899001122334455667788990011223344556677889900FFFFFFFF

rsa_md5_sign(data, key)

基于MD5的RSA签名
data：待签名数据，字节序列数组或字节序列字符串
key：包含N E D P Q DP DQ InverseQ的json数据
返回值：签名结果，字节序列字符串
调用示例：

var key={N:"BACABD7A4BE4C7353E55F719EA112CBD8631AAF4834C45C713E43E7590DAB0D1BDEF248E52A478B2D7EC73889B47A2DEEDCC9C9A6F17C7371635757144E70F11",
        E:"010001",
        D:"6745F4608B595FB256569D19DCC9C61CBAF6F6F7DD27EC6456E1188F539935ACAF2DEBEC7CF9773B91C2F0EDBC7027669E97CA89B6BF87A16B818D5576AC6CE9",
        P:"DD4C0223C97247C849CF32D66B086F5D5A8B5344A80F58DB73C90AE7BEDA1D57",
        Q:"D81586B24FD7586E7BC15BA6EAB9E917131A8FADF85E0EF8A10827BC59BD0DD7",
        DP:"A285C6F0876AC1A32BE9DAD934443E9D9DF8C2CFA2699B05989466C8EA168003",
        DQ:"A7D2F02E853C277E87B7814B7E7AADC232202AFF5F2B0E4DA42405589009F939",
        InverseQ:"8064A5DCB7B2C141EA9A570422592B6FBF8DD23BFD972812144EA4FE35898058"};
printf(rsa_md5_sign("1122334455667788",key));

输出
263D662F070BFD48D264D35758AA4A79BC4ADF41E025248F78394FCE09C71AF2C939F160294C80EE93B20C0026E684417B7F0A753FFBBF6E544BC08E08FF53AD

rsa_md5_verify(data, signData, key)

基于MD5的RSA验签
data：待签名数据，字节序列数组或字节序列字符串
signData：签名结果，字节序列数组或字节序列字符串
key：包含N与E的json数据
返回值：true/false
调用示例：

var key={N:"BACABD7A4BE4C7353E55F719EA112CBD8631AAF4834C45C713E43E7590DAB0D1BDEF248E52A478B2D7EC73889B47A2DEEDCC9C9A6F17C7371635757144E70F11",E:"010001"}
printf(rsa_md5_verify("1122334455667788","263D662F070BFD48D264D35758AA4A79BC4ADF41E025248F78394FCE09C71AF2C939F160294C80EE93B20C0026E684417B7F0A753FFBBF6E544BC08E08FF53AD",key));
printf(rsa_md5_verify("1122334455667788","FF3D662F070BFD48D264D35758AA4A79BC4ADF41E025248F78394FCE09C71AF2C939F160294C80EE93B20C0026E684417B7F0A753FFBBF6E544BC08E08FF53AD",key));

输出true false

rsa_sha1_sign(data, key)

基于SHA1的RSA签名
data：待签名数据，字节序列数组或字节序列字符串
key：包含N E D P Q DP DQ InverseQ的json数据
返回值：签名结果，字节序列字符串
调用示例：

var key={N:"BACABD7A4BE4C7353E55F719EA112CBD8631AAF4834C45C713E43E7590DAB0D1BDEF248E52A478B2D7EC73889B47A2DEEDCC9C9A6F17C7371635757144E70F11",
        E:"010001",
        D:"6745F4608B595FB256569D19DCC9C61CBAF6F6F7DD27EC6456E1188F539935ACAF2DEBEC7CF9773B91C2F0EDBC7027669E97CA89B6BF87A16B818D5576AC6CE9",
        P:"DD4C0223C97247C849CF32D66B086F5D5A8B5344A80F58DB73C90AE7BEDA1D57",
        Q:"D81586B24FD7586E7BC15BA6EAB9E917131A8FADF85E0EF8A10827BC59BD0DD7",
        DP:"A285C6F0876AC1A32BE9DAD934443E9D9DF8C2CFA2699B05989466C8EA168003",
        DQ:"A7D2F02E853C277E87B7814B7E7AADC232202AFF5F2B0E4DA42405589009F939",
        InverseQ:"8064A5DCB7B2C141EA9A570422592B6FBF8DD23BFD972812144EA4FE35898058"};
printf(rsa_sha1_sign("1122334455667788",key));

输出
55350C6D1822166DBB0874C7372F2E5B2794D76ECAEEBF72600BD6834F75BECA641C5FC19B1759841E15D6FF97B2985B5857D79565B721BA36B63F0B4096D17C

rsa_sha1_verify(data, signData, key)

基于SHA1的RSA验签
data：待签名数据，字节序列数组或字节序列字符串
signData：签名结果，字节序列数组或字节序列字符串
key：包含N与E的json数据
返回值：true/false
调用示例：

var key={N:"BACABD7A4BE4C7353E55F719EA112CBD8631AAF4834C45C713E43E7590DAB0D1BDEF248E52A478B2D7EC73889B47A2DEEDCC9C9A6F17C7371635757144E70F11",E:"010001"}
printf(rsa_sha1_verify("1122334455667788","55350C6D1822166DBB0874C7372F2E5B2794D76ECAEEBF72600BD6834F75BECA641C5FC19B1759841E15D6FF97B2985B5857D79565B721BA36B63F0B4096D17C",key));
printf(rsa_sha1_verify("1122334455667788","55110C6D1822166DBB0874C7372F2E5B2794D76ECAEEBF72600BD6834F75BECA641C5FC19B1759841E15D6FF97B2985B5857D79565B721BA36B63F0B4096D17C",key));

输出true false

rsa_sha256_sign(data, key)

基于SHA256的RSA签名
data：待签名数据，字节序列数组或字节序列字符串
key：包含N E D P Q DP DQ InverseQ的json数据
返回值：签名结果，字节序列字符串
调用示例：

var key={N:"BACABD7A4BE4C7353E55F719EA112CBD8631AAF4834C45C713E43E7590DAB0D1BDEF248E52A478B2D7EC73889B47A2DEEDCC9C9A6F17C7371635757144E70F11",
        E:"010001",
        D:"6745F4608B595FB256569D19DCC9C61CBAF6F6F7DD27EC6456E1188F539935ACAF2DEBEC7CF9773B91C2F0EDBC7027669E97CA89B6BF87A16B818D5576AC6CE9",
        P:"DD4C0223C97247C849CF32D66B086F5D5A8B5344A80F58DB73C90AE7BEDA1D57",
        Q:"D81586B24FD7586E7BC15BA6EAB9E917131A8FADF85E0EF8A10827BC59BD0DD7",
        DP:"A285C6F0876AC1A32BE9DAD934443E9D9DF8C2CFA2699B05989466C8EA168003",
        DQ:"A7D2F02E853C277E87B7814B7E7AADC232202AFF5F2B0E4DA42405589009F939",
        InverseQ:"8064A5DCB7B2C141EA9A570422592B6FBF8DD23BFD972812144EA4FE35898058"};
printf(rsa_sha256_sign("1122334455667788",key));

输出
A539C7CA9E97FC99507A6DAE05DF3A0A2C3A52F1622A3AC969FB08D84D143BC63665F27C7FA067D201461FCA5BF70516A4A24AEAB64E0A504EE62505772FBCC7

rsa_sha256_verify(data, signData, key)

基于SHA256的RSA验签
data：待签名数据，字节序列数组或字节序列字符串
signData：签名结果，字节序列数组或字节序列字符串
key：包含N与E的json数据
返回值：true/false
调用示例：

var key={N:"BACABD7A4BE4C7353E55F719EA112CBD8631AAF4834C45C713E43E7590DAB0D1BDEF248E52A478B2D7EC73889B47A2DEEDCC9C9A6F17C7371635757144E70F11",E:"010001"}
printf(rsa_sha256_verify("1122334455667788","A539C7CA9E97FC99507A6DAE05DF3A0A2C3A52F1622A3AC969FB08D84D143BC63665F27C7FA067D201461FCA5BF70516A4A24AEAB64E0A504EE62505772FBCC7",key));
printf(rsa_sha256_verify("1122334455667788","A511C7CA9E97FC99507A6DAE05DF3A0A2C3A52F1622A3AC969FB08D84D143BC63665F27C7FA067D201461FCA5BF70516A4A24AEAB64E0A504EE62505772FBCC7",key));

输出true false

rsa_sha384_sign(data, key)

基于SHA384的RSA签名
data：待签名数据，字节序列数组或字节序列字符串
key：包含N E D P Q DP DQ InverseQ的json数据
返回值：签名结果，字节序列字符串
调用示例：

var key={N:"B559909EDF3B4EF252FF913709BC55381B290F6D28A8DCC85959D7E4BD7C4C22D808FCB4B64863D05A03C77280DF776BA1FDC9CF179D545C4EDF5ED08DD52C21D98C9D2ACA9CC3A6F8736BCADDD5D2EEABCC6A8D24C5FEC0B8BC70ED7FD4CCE8681B7500DFC7B65A56FD7EAAE72B80BC7F108AFB6E73F652F79BE9BAC64868DD",
        E:"010001",
        D:"6C75F0C4D40608A56D766447628F3CF89D65E55007ED567E8CD1EB09673A9BDE8B0E74F52FC003D26CC3ADD991B2151E4E7816E6C0DCDBC3897896A06CF37DBC8E882C3AC64EE0DB8DC55744E021448447200F286BE89A51884C674882169D1F87BE0EF2B825211227010318952243AC3864615B7857B50256E774B0A4A08A91",
        P:"E83031282B71CDE659E514E5572556BB08099E97E17286606618C3F1AADEB5771DA162BF3C03D7A31AE261EAB1A03720E923B89CEABCE605F86F1850E60E61C3",
        Q:"C7F2ACF0227CEB7ED86423FD89FE48126FDFCE8A92F98F24B6DE685F8AE04EF1C4C214A7A3591D6504C09337C1950D95071F0C86516DFB9F57FD1DC021E5C0DF",
        DP:"0A41AEBA3689156E5A843B1312716CCE60418486F3078B16110C810358E7F39E2A69E9A1C6F5E87DA4FF6111EBFCC6D2A659D49AE1E7AC45913EDF151BC480DF",
        DQ:"5FD2BD6E9818A603B450C9AEC86344C711368115883A718F76D43FD10A0D55C828339B127C0649401076FA16CE7F50730B66A5E9F93C6C4A81309D01673D64A1",
        InverseQ:"B34FABAA8FE395EF356F35FFC89F2619A6263260B32DDE7CE545C437052A8A0B48B2993E86694859585DD71D82F26F2597F1CDECF561F4E88F5AA7F0C474F4A0"};
printf(rsa_sha384_sign("1122334455667788",key));

输出
919F06753CB4E9D0B1F9FDCEA4573C1F290CAE36A530810650CC260756EB3CD7FA4639C018DF64305D5C67005663AE753E7C7EFB7ADDB76DAE203023E188A8D2E51570BBEFBEF9E822F6370D53D01BE6EA43A79ECD7F0CC0E589EFCFD4E0D6336FFC2427D20630FAC1644D93DFD35811BA052AE4A76CBB27C16BF6E6DB2EEA9A

rsa_sha384_verify(data, signData, key)

基于SHA384的RSA验签
data：待签名数据，字节序列数组或字节序列字符串
signData：签名结果，字节序列数组或字节序列字符串
key：包含N与E的json数据
返回值：true/false
调用示例：

var key={N:"B559909EDF3B4EF252FF913709BC55381B290F6D28A8DCC85959D7E4BD7C4C22D808FCB4B64863D05A03C77280DF776BA1FDC9CF179D545C4EDF5ED08DD52C21D98C9D2ACA9CC3A6F8736BCADDD5D2EEABCC6A8D24C5FEC0B8BC70ED7FD4CCE8681B7500DFC7B65A56FD7EAAE72B80BC7F108AFB6E73F652F79BE9BAC64868DD",E:"010001"}
printf(rsa_sha384_verify("1122334455667788","919F06753CB4E9D0B1F9FDCEA4573C1F290CAE36A530810650CC260756EB3CD7FA4639C018DF64305D5C67005663AE753E7C7EFB7ADDB76DAE203023E188A8D2E51570BBEFBEF9E822F6370D53D01BE6EA43A79ECD7F0CC0E589EFCFD4E0D6336FFC2427D20630FAC1644D93DFD35811BA052AE4A76CBB27C16BF6E6DB2EEA9A",key));
printf(rsa_sha384_verify("1122334455667788","919F11753CB4E9D0B1F9FDCEA4573C1F290CAE36A530810650CC260756EB3CD7FA4639C018DF64305D5C67005663AE753E7C7EFB7ADDB76DAE203023E188A8D2E51570BBEFBEF9E822F6370D53D01BE6EA43A79ECD7F0CC0E589EFCFD4E0D6336FFC2427D20630FAC1644D93DFD35811BA052AE4A76CBB27C16BF6E6DB2EEA9A",key));

输出true false

rsa_sha512_sign(data, key)

基于SHA512的RSA签名
data：待签名数据，字节序列数组或字节序列字符串
key：包含N E D P Q DP DQ InverseQ的json数据
返回值：签名结果，字节序列字符串
调用示例：

var key={N:"B559909EDF3B4EF252FF913709BC55381B290F6D28A8DCC85959D7E4BD7C4C22D808FCB4B64863D05A03C77280DF776BA1FDC9CF179D545C4EDF5ED08DD52C21D98C9D2ACA9CC3A6F8736BCADDD5D2EEABCC6A8D24C5FEC0B8BC70ED7FD4CCE8681B7500DFC7B65A56FD7EAAE72B80BC7F108AFB6E73F652F79BE9BAC64868DD",
        E:"010001",
        D:"6C75F0C4D40608A56D766447628F3CF89D65E55007ED567E8CD1EB09673A9BDE8B0E74F52FC003D26CC3ADD991B2151E4E7816E6C0DCDBC3897896A06CF37DBC8E882C3AC64EE0DB8DC55744E021448447200F286BE89A51884C674882169D1F87BE0EF2B825211227010318952243AC3864615B7857B50256E774B0A4A08A91",
        P:"E83031282B71CDE659E514E5572556BB08099E97E17286606618C3F1AADEB5771DA162BF3C03D7A31AE261EAB1A03720E923B89CEABCE605F86F1850E60E61C3",
        Q:"C7F2ACF0227CEB7ED86423FD89FE48126FDFCE8A92F98F24B6DE685F8AE04EF1C4C214A7A3591D6504C09337C1950D95071F0C86516DFB9F57FD1DC021E5C0DF",
        DP:"0A41AEBA3689156E5A843B1312716CCE60418486F3078B16110C810358E7F39E2A69E9A1C6F5E87DA4FF6111EBFCC6D2A659D49AE1E7AC45913EDF151BC480DF",
        DQ:"5FD2BD6E9818A603B450C9AEC86344C711368115883A718F76D43FD10A0D55C828339B127C0649401076FA16CE7F50730B66A5E9F93C6C4A81309D01673D64A1",
        InverseQ:"B34FABAA8FE395EF356F35FFC89F2619A6263260B32DDE7CE545C437052A8A0B48B2993E86694859585DD71D82F26F2597F1CDECF561F4E88F5AA7F0C474F4A0"};
printf(rsa_sha512_sign("1122334455667788",key));

输出
10EBDE5E599B572BCF0CBACB4F2F00DA94091A86CF1D5DB438AEDD52D04DCDA8D42D2F1F7EDC3845FA9C8EDB05D888B845B03235E58DDCDCD363C3C286630EAD7652A0D5C5E85CA13441A45765A5C84C7BD2D8DEC6392C3EEE7F880CF13A97056F3E58BC8764F2C2053695578C0029C54E811C446ED510E3DFA998B937CCFA77

rsa_sha512_verify(data, signData, key)

基于SHA512的RSA验签
data：待签名数据，字节序列数组或字节序列字符串
signData：签名结果，字节序列数组或字节序列字符串
key：包含N与E的json数据
返回值：true/false
调用示例：

var key={N:"B559909EDF3B4EF252FF913709BC55381B290F6D28A8DCC85959D7E4BD7C4C22D808FCB4B64863D05A03C77280DF776BA1FDC9CF179D545C4EDF5ED08DD52C21D98C9D2ACA9CC3A6F8736BCADDD5D2EEABCC6A8D24C5FEC0B8BC70ED7FD4CCE8681B7500DFC7B65A56FD7EAAE72B80BC7F108AFB6E73F652F79BE9BAC64868DD",E:"010001"}
printf(rsa_sha512_verify("1122334455667788","10EBDE5E599B572BCF0CBACB4F2F00DA94091A86CF1D5DB438AEDD52D04DCDA8D42D2F1F7EDC3845FA9C8EDB05D888B845B03235E58DDCDCD363C3C286630EAD7652A0D5C5E85CA13441A45765A5C84C7BD2D8DEC6392C3EEE7F880CF13A97056F3E58BC8764F2C2053695578C0029C54E811C446ED510E3DFA998B937CCFA77",key));
printf(rsa_sha512_verify("1122334455667788","1011DE5E599B572BCF0CBACB4F2F00DA94091A86CF1D5DB438AEDD52D04DCDA8D42D2F1F7EDC3845FA9C8EDB05D888B845B03235E58DDCDCD363C3C286630EAD7652A0D5C5E85CA13441A45765A5C84C7BD2D8DEC6392C3EEE7F880CF13A97056F3E58BC8764F2C2053695578C0029C54E811C446ED510E3DFA998B937CCFA77",key));

输出true false

generate_sm2_keypair()

产生SM2密钥对
返回值：密钥对的json数据,包含公钥X Y 私钥PKey
调用示例：

var key=generate_sm2_keypair();
printf(JSON.stringify(key));

输出{"X":"39EBFDF2B4B419B11DECEC6B47A118FEF6CDE4579BB983731C88856E893BBF56","Y":"1932D9DF7F1E56174FA57448B2DB679E8ECC42912BD05F3C0EC4A944AB621C64","PKey":"09E55AE456DEC96CFC96F92DF82DF5152A7255A90CD72E49084AB1D533EEA41E"}

sm2_generate_pub_by_pri(priKey)

根据SM2私钥计算公钥
priKey：SM2私钥，字节序列数组或字节序列字符串
返回值：密钥对的json数据,包含公钥X Y
调用示例：

var key=sm2_generate_pub_by_pri("AD1E36DD2A1C7A53EB37CBED910CB4E910BF1E184B0C1E472DB655C39199E450");
printf(JSON.stringify(key));

输出{"X":"7E027B5348BEF262EA8672FDDA240A685ED89F49E1CC10E0138A7A9E936DBE02","Y":"A6B8BC1A4FE9D1895F40E4A50E9BC76B2860A05EAB96563049BCAE73FDDCEBE3"}

sm2_pub_encode(X,Y,data,format)

SM2公钥加密
X：32字节SM2公钥X，字节序列数组或字节序列字符串
Y：32字节SM2公钥Y，字节序列数组或字节序列字符串
data：待加密数据，字节序列数组或字节序列字符串
format：数据格式，0表示C1C2C3，1表示C1C3C2。数值型
返回值：密文，字节序列字符串
调用示例：

var X="7E027B5348BEF262EA8672FDDA240A685ED89F49E1CC10E0138A7A9E936DBE02";
var Y="A6B8BC1A4FE9D1895F40E4A50E9BC76B2860A05EAB96563049BCAE73FDDCEBE3";
printf(sm2_pub_encode(X,Y,"1122",0));
printf(sm2_pub_encode(X,Y,"1122",1));

sm2_pri_decode(key,data)

SM2私钥解密
key：32字节SM2私钥，字节序列数组或字节序列字符串
data：密文数据，字节序列数组或字节序列字符串
返回值：明文，字节序列字符串
调用示例：

var key="AD1E36DD2A1C7A53EB37CBED910CB4E910BF1E184B0C1E472DB655C39199E450";
printf(sm2_pri_decode(key,"225B9149F2CAE304D0BCFFC057260D08823DAF21210427101B314DF98282416BB2A894C28BD1CB6366CA60B5917DE4587F9EC00C917DD19F12D9D1AF715D0519F36726AE67D7D01CCD4AC53134961B0D576D13D8C8576FF9242FC4598F4C6809646D"));
printf(sm2_pri_decode(key,"7EE4AD46B86EA99DC2082E906AA2F9ECB4E6D85CD1C059EC3ECCC88F485D4E0B33B517B60B5A61C0ED2F1BDA70042E7AF4221494AD4CB7133E6520EFD1A76917FB11C077D5C7484ABF467B87594307CC69E48F2A59925CF25E63F8A7DEDB6C05B248"));

输出1122 1122

sm2_calc_hash(X,Y,data,ID)

依据PBOC3.0第17部分8.2的描述计算SM2签名所需的哈希值
X：32字节SM2公钥X，字节序列数组或字节序列字符串
Y：32字节SM2公钥Y，字节序列数组或字节序列字符串
data：待签名数据，字节序列数组或字节序列字符串
ID：用户ID，字节序列数组或字节序列字符串，可为空
返回值：32字节哈希值，字节序列字符串
调用示例：

var X="7E027B5348BEF262EA8672FDDA240A685ED89F49E1CC10E0138A7A9E936DBE02";
var Y="A6B8BC1A4FE9D1895F40E4A50E9BC76B2860A05EAB96563049BCAE73FDDCEBE3";
printf(sm2_calc_hash(X,Y,"112233","31323334353637383132333435363738"));
printf(sm2_calc_hash(X,Y,"112233",""));
printf(sm2_calc_hash(X,Y,"112233","123456"));

输出
559FB6029C7296793224C915E7D87F1C213F11C2EA61F9DC79475CF370F7DDA6
69EBBD43851F4570702157FA47A7067E688BEBD4F6D2EC75AA73F5533A9D0CD1
924F4B588B60FE8D5D56DEE62F6E1B35C0D3C529A099CDC4D908A2D0E516EBA8

sm2_sign_hash(key,hash)

对哈希值进行SM2签名，需与sm2_calc_hash配合使用
key：32字节SM2私钥，字节序列数组或字节序列字符串
hash：哈希值，字节序列数组或字节序列字符串
返回值：包含签名数据R与S的json数据
调用示例：

var key="AD1E36DD2A1C7A53EB37CBED910CB4E910BF1E184B0C1E472DB655C39199E450";
var publicKey=sm2_generate_pub_by_pri(key);
var hash=sm2_calc_hash(publicKey.X,publicKey.Y,"112233","31323334353637383132333435363738");
var signData=sm2_sign_hash(key,hash);
printf("正确的哈希："+hash);
printf("正确的签名数据："+JSON.stringify(signData));
printf("验签结果："+sm2_verify_hash(publicKey.X,publicKey.Y,hash,signData.R,signData.S));
var errorHash="00"+hash.substr(2);
printf("错误的哈希："+errorHash);
printf("正确的签名数据："+JSON.stringify(signData));
printf("验签结果："+sm2_verify_hash(publicKey.X,publicKey.Y,errorHash,signData.R,signData.S));
signData.R="00"+signData.R.substr(2);
printf("正确的哈希："+hash);
printf("错误的签名数据："+JSON.stringify(signData));
printf("验签结果："+sm2_verify_hash(publicKey.X,publicKey.Y,hash,signData.R,signData.S));

输出

正确的哈希：559FB6029C7296793224C915E7D87F1C213F11C2EA61F9DC79475CF370F7DDA6
正确的签名数据：{"R":"7FE78B670F9FE872ED82645005AEDB2502EA50B1C6A0274D6870A8B70F08D0CB","S":"3749E41C2F2F3EA5398CBDBD1368CF3425BD1D5C37D6C7F4C88DE4448C24E136"}
验签结果：true
错误的哈希：009FB6029C7296793224C915E7D87F1C213F11C2EA61F9DC79475CF370F7DDA6
正确的签名数据：{"R":"7FE78B670F9FE872ED82645005AEDB2502EA50B1C6A0274D6870A8B70F08D0CB","S":"3749E41C2F2F3EA5398CBDBD1368CF3425BD1D5C37D6C7F4C88DE4448C24E136"}
验签结果：false
正确的哈希：559FB6029C7296793224C915E7D87F1C213F11C2EA61F9DC79475CF370F7DDA6
错误的签名数据：{"R":"00E78B670F9FE872ED82645005AEDB2502EA50B1C6A0274D6870A8B70F08D0CB","S":"3749E41C2F2F3EA5398CBDBD1368CF3425BD1D5C37D6C7F4C88DE4448C24E136"}
验签结果：false

sm2_verify_hash(X,Y,hash,R,S)

对哈希值进行SM2验签，需与sm2_calc_hash配合使用
X：32字节SM2公钥X，字节序列数组或字节序列字符串
Y：32字节SM2公钥Y，字节序列数组或字节序列字符串
hash：哈希值，字节序列数组或字节序列字符串
R：签名数据R，字节序列数组或字节序列字符串
S：签名数据S，字节序列数组或字节序列字符串
返回值：true/false
调用示例：参见sm2_sign_hash

sm2_sign(key, data)

依据PBOC3.0第17部分8.2的描述,对数据进行SM2签名
key：32字节SM2私钥，字节序列数组或字节序列字符串
data：待签名数据，字节序列数组或字节序列字符串
返回值：包含签名数据R与S的json数据
调用示例：

var key="AD1E36DD2A1C7A53EB37CBED910CB4E910BF1E184B0C1E472DB655C39199E450";
printf(JSON.stringify(sm2_sign(key,"112233")));

输出{"R":"3DDEB0A8297169F42F0810D4EB5681FCD7508547356979AC168CE20B93FDC3CB","S":"4CF60CC768520F7D2D74EB9DEFB6FB633A200644D5BF77520F1F99A6C5672926"}

sm2_verify(X, Y, data, R, S)

依据PBOC3.0第17部分8.2的描述,对数据进行SM2验签
X：32字节SM2公钥X，字节序列数组或字节序列字符串
Y：32字节SM2公钥Y，字节序列数组或字节序列字符串
data：待签名数据，字节序列数组或字节序列字符串
R：签名数据R，字节序列数组或字节序列字符串
S：签名数据S，字节序列数组或字节序列字符串
返回值：true/false
调用示例：

var X="7E027B5348BEF262EA8672FDDA240A685ED89F49E1CC10E0138A7A9E936DBE02";
var Y="A6B8BC1A4FE9D1895F40E4A50E9BC76B2860A05EAB96563049BCAE73FDDCEBE3";
var R="3DDEB0A8297169F42F0810D4EB5681FCD7508547356979AC168CE20B93FDC3CB";
var S="4CF60CC768520F7D2D74EB9DEFB6FB633A200644D5BF77520F1F99A6C5672926";
printf(sm2_verify(X,Y,"112233",R,S));
var R="00DEB0A8297169F42F0810D4EB5681FCD7508547356979AC168CE20B93FDC3CB";
printf(sm2_verify(X,Y,"112233",R,S));

输出true false
MAC

des_x99_mac(data,key,iv)

基于单倍长DES的ANSI X99 MAC计算
data：待计算MAC的数据，字节序列数组或字节序列字符串
key：8字节DES密钥，字节序列数组或字节序列字符串
iv：8字节初始向量，为空表示全0x00。字节序列数组或字节序列字符串
返回值：MAC结果
调用示例：

printf(des_x99_mac("11223344556677889900","1234567812345678"));
printf(des_x99_mac("11223344556677889900","1234567812345678","1234567812345678"));

输出
3C1A5EACEAED5B35
D3A7AF167BC3D7A5

tdes_x919_mac(data, key, iv)

基于双倍长DES的ANSI X9.19 MAC计算
data：待计算MAC的数据，字节序列数组或字节序列字符串
key：16字节DES密钥，字节序列数组或字节序列字符串
iv：8字节初始向量，为空表示全0x00。字节序列数组或字节序列字符串
返回值：MAC结果
调用示例：

printf(tdes_x919_mac("11223344556677889900","123456781234567812345678123456FF"));
printf(tdes_x919_mac("11223344556677889900","12345678123456781234567812345600","1234567812345678"));

输出
73C9CF24B3E47162
0057DF8E8EA890E4

tdes_24k_x919_mac(data, key, iv)

基于三倍长DES的ANSI X9.19 MAC计算
data：待计算MAC的数据，字节序列数组或字节序列字符串
key：24字节DES密钥，字节序列数组或字节序列字符串
iv：8字节初始向量，为空表示全0x00。字节序列数组或字节序列字符串
返回值：MAC结果
调用示例：

printf(tdes_24k_x919_mac("11223344556677889900","123456781234567812345678123456FF12345678123456AA"));
printf(tdes_24k_x919_mac("11223344556677889900","1234567812345678123456781234560012345678123456BB","1234567812345678"));

输出
FF04CE557A5E6B42
C6613EAA04854340

des_pboc_mac(data,key,iv)

基于单倍长DES的PBOC MAC计算(依据PBOC3.0第7部分11.1.2)
data：待计算MAC的数据，字节序列数组或字节序列字符串
key：8字节DES密钥，字节序列数组或字节序列字符串
iv：8字节初始向量，为空表示全0x00。字节序列数组或字节序列字符串
返回值：MAC结果
调用示例：

printf(des_pboc_mac("11223344556677889900","1234567812345678"));
printf(des_pboc_mac("11223344556677889900","1234567812345678","1234567812345678"));

输出
E68B90A27716ACD3
443B2C5CE663A543

tdes_pboc_mac(data, key, iv)

基于双倍长DES的PBOC MAC计算(依据PBOC3.0第7部分11.1.2)
data：待计算MAC的数据，字节序列数组或字节序列字符串
key：16字节DES密钥，字节序列数组或字节序列字符串
iv：8字节初始向量，为空表示全0x00。字节序列数组或字节序列字符串
返回值：MAC结果
调用示例：

printf(tdes_pboc_mac("11223344556677889900","123456781234567812345678123456FF"));
printf(tdes_pboc_mac("11223344556677889900","12345678123456781234567812345600","1234567812345678"));

输出
763DC20EAC9115FE
E3880A6F352482BF

tdes_24k_pboc_mac(data, key, iv)

基于三倍长DES的PBOC MAC计算(依据PBOC3.0第7部分11.1.2)
data：待计算MAC的数据，字节序列数组或字节序列字符串
key：24字节DES密钥，字节序列数组或字节序列字符串
iv：8字节初始向量，为空表示全0x00。字节序列数组或字节序列字符串
返回值：MAC结果
调用示例：

printf(tdes_24k_pboc_mac("11223344556677889900","123456781234567812345678123456FF12345678123456AA"));
printf(tdes_24k_pboc_mac("11223344556677889900","1234567812345678123456781234560012345678123456BB","1234567812345678"));

输出
DD9B1F0DDAE6E42D
D49CF7136BE67B6B

des_ecb_mac(data,key,iv)

基于单倍长DES的银联ECB MAC计算(依据销售点终端应用规范附录“POS终端MAC的算法”章节)
data：待计算MAC的数据，字节序列数组或字节序列字符串
key：8字节DES密钥，字节序列数组或字节序列字符串
iv：8字节初始向量，为空表示全0x00。字节序列数组或字节序列字符串
返回值：MAC结果
调用示例：

printf(des_ecb_mac("11223344556677889900","1234567812345678"));
printf(des_ecb_mac("11223344556677889900","1234567812345678","1234567812345678"));

输出
4636463838353744
4334324530364430

tdes_ecb_mac(data, key, iv)

基于双倍长DES的银联ECB MAC计算(依据销售点终端应用规范附录“POS终端MAC的算法”章节)
data：待计算MAC的数据，字节序列数组或字节序列字符串
key：16字节DES密钥，字节序列数组或字节序列字符串
iv：8字节初始向量，为空表示全0x00。字节序列数组或字节序列字符串
返回值：MAC结果
调用示例：

printf(tdes_ecb_mac("11223344556677889900","123456781234567812345678123456FF"));
printf(tdes_ecb_mac("11223344556677889900","12345678123456781234567812345600","1234567812345678"));

输出
3933444236434236
3638443933384543

tdes_24k_ecb_mac(data, key, iv)

基于三倍长DES的银联ECB MAC计算(依据销售点终端应用规范附录“POS终端MAC的算法”章节)
data：待计算MAC的数据，字节序列数组或字节序列字符串
key：24字节DES密钥，字节序列数组或字节序列字符串
iv：8字节初始向量，为空表示全0x00。字节序列数组或字节序列字符串
返回值：MAC结果
调用示例：

printf(tdes_24k_ecb_mac("11223344556677889900","123456781234567812345678123456FF12345678123456AA"));
printf(tdes_24k_ecb_mac("11223344556677889900","1234567812345678123456781234560012345678123456BB","1234567812345678"));

输出
3431363739373330
4141323243423631

sm4_x919_mac(data, key, iv)

基于SM4的ANSI X9.19 MAC计算
data：待计算MAC的数据，字节序列数组或字节序列字符串
key：16字节SM4密钥，字节序列数组或字节序列字符串
iv：16字节初始向量，为空表示全0x00。字节序列数组或字节序列字符串
返回值：MAC结果
调用示例：

printf(sm4_x919_mac("11223344556677889900","123456781234567812345678123456FF"));
printf(sm4_x919_mac("11223344556677889900","12345678123456781234567812345600","12345678123456781234567812345678"));

输出
20AA6371FB5D955F69903C621271449C
C58EABC5DBDF2CB8E42EEB3C5FE80688

sm4_pboc_mac(data, key, iv)

基于SM4的PBOC MAC计算(依据PBOC3.0第17部分8.1.2)
data：待计算MAC的数据，字节序列数组或字节序列字符串
key：16字节SM4密钥，字节序列数组或字节序列字符串
iv：16字节初始向量，为空表示全0x00。字节序列数组或字节序列字符串
返回值：MAC结果
调用示例：

printf(sm4_pboc_mac("11223344556677889900","123456781234567812345678123456FF"));
printf(sm4_pboc_mac("11223344556677889900","12345678123456781234567812345600","12345678123456781234567812345678"));

输出
65869FA198E8A0F34BCB24E1B58A52BB
F6C3F3AC4A407399E8C1AD59BE571AF0

sm4_ecb_mac(data, key, iv)

基于SM4的银联ECB MAC计算(依据销售点终端应用规范附录“POS终端MAC的算法”章节)
data：待计算MAC的数据，字节序列数组或字节序列字符串
key：16字节SM4密钥，字节序列数组或字节序列字符串
iv：16字节初始向量，为空表示全0x00。字节序列数组或字节序列字符串
返回值：MAC结果
调用示例：

printf(sm4_ecb_mac("11223344556677889900","123456781234567812345678123456FF"));
printf(sm4_ecb_mac("11223344556677889900","12345678123456781234567812345600","12345678123456781234567812345678"));

输出
35443330463537453343433031313845
42304237443744313532464537364145
串口通讯

com_get_list()

获取当前可用的串口列表
返回值：字符串数组

com_open(port,boud)

打开串口
port：串口号，数值型
boud：波特率，数值型
返回值：成功返回串口句柄，失败返回null
调用示例：

    com_close_port(2);
    var handle=com_open(2,115200);
    if(!handle){
        exit("COM2打开失败");
    }
    printf(com_clear_buf(handle));
    printf(com_send(handle,"1122334455667788"));
    printf(com_recv(handle,10*1000));
    printf(com_close(handle));

com_close(handle)

关闭串口
handle：串口句柄
返回值：true/false

com_close_port(port)

根据串口号关闭串口，只能关闭由本系统打开的串口
port：串口号
返回值：true/false

com_clear_buf(handle)

清空串口接收缓冲区
handle：串口句柄
返回值：true/false

com_send(handle,data)

串口发送数据
handle：串口句柄
data：字节序列数组或字节序列字符串
返回值：true/false

com_recv(handle, maxLen, timeout)

串口接收数据
handle：串口句柄
maxLen：最大长度，数值型
timeout：超时时间，单位毫秒，数值型。如果为0表示立即返回
返回值：字节序列字符串
SOCKET

socket_connect(ServerIP, ServerPort)

SOCKET连接服务端
ServerIP：服务端IP，字符串
ServerPort：服务端端口，数值型
返回值：成功返回串口句柄，失败返回null
调用示例：

    var handle=socket_connect("127.0.0.1",8888);
    if(!handle){
        exit("socket连接失败");
    }
    printf(socket_send(handle,"1122334455667788"));
    printf(socket_recv(handle,1024,10*1000));
    socket_close(handle);

socket_close(handle)

关闭SOCKET连接，无返回值
handle：SOCKET句柄

socket_send(handle,data)

SOCKET发送数据
handle：SOCKET句柄
data：字节序列数组或字节序列字符串
返回值：true/false

socket_recv(handle, maxLen, timeout)

SOCKET接收数据
handle：SOCKET句柄
maxLen：最大长度，数值型
timeout：超时时间，单位毫秒，数值型。如果为0表示立即返回
返回值：字节序列字符串
提示信息

yes_no(msg, flag, timeout)

显示对话框，让用户选择YES或NO
msg：提示信息，字符串
flag：true/false，表示超时或点击关闭按钮时默认选择YES还是NO
timeout：超时时间，单位秒。等于0时表示永久等待。数值型
返回值：true/false
调用示例：printf(yes_no("提示信息",true,10));

messagebox(msg, timeout)

显示消息框，无返回值
msg：提示信息，字符串
timeout：超时时间，单位秒。等于0时表示永久等待。数值型
调用示例：messagebox("提示信息",10);

getinput(msg,defaultStr,timeout)

显示对话框，让用户输入字符串
msg：提示信息，字符串
defaultStr：默认值，字符串
timeout：超时时间，单位秒。等于0时表示永久等待。数值型
返回值：字符串
调用示例：printf(getinput("提示信息","这是默认值abc",60));

getchoose(msg, items, defaultItem, timeout)

显示选择框，让用户从多个选项中选一个
msg：提示信息，字符串
items：选项内容，至少两个选项。字符串数组
defaultItem：默认选项索引，从0开始。数值型
timeout：超时时间，单位秒。等于0时表示永久等待。数值型
返回值：选项索引，从0开始
调用示例：printf(getchoose("请选择界面",["PSE","PPSE"],0,60));
文件操作

copyfile(sourceFile,destFile,overwrite)

复制文件
sourceFile：源文件绝对路径或源文件名(从AssistantTool.exe所在目录\script目录中查找)
destFile：目标文件绝对路径或目标文件名(从AssistantTool.exe所在目录\script目录中查找)
overwrite：目标文件如果已存在，是否允许覆盖。布尔型
返回值：true/false
调用示例：printf(copyfile("d:\\1.txt","d:\\2.txt",false));

deletefile(filename)

删除文件
filename：文件绝对路径或文件名(从AssistantTool.exe所在目录\script目录中查找)
返回值：true/false
调用示例：printf(deletefile("d:\\1.txt"));

file_read(filename, len, seek)

以二进制格式读取文件内容
filename：文件绝对路径或文件名(从AssistantTool.exe所在目录\script目录中查找)
len：长度，数值型
seek：偏移量，数值型
返回值：字节序列字符串
调用示例：printf(file_read("d:\\1.txt",10,0));

file_write(filename, data, seek)

以二进制格式写入文件内容
filename：文件绝对路径或文件名(从AssistantTool.exe所在目录\script目录中查找)
data：字节序列数组或字节序列字符串
seek：偏移量，数值型
返回值：true/false
调用示例：printf(file_write("d:\\1.txt","313233343536",0));

file_readall(filename)

以二进制格式读取所有文件内容
filename：文件绝对路径或文件名(从AssistantTool.exe所在目录\script目录中查找)
返回值：字节序列字符串
调用示例：printf(file_readall("d:\\1.txt"));

file_length(filename)

获取文件长度
filename：文件绝对路径或文件名(从AssistantTool.exe所在目录\script目录中查找)
返回值：数值型，如果文件不存在则返回0
调用示例：printf(file_length("d:\\1.txt"));

file_append(filename, data)

向文件末尾追加数据(文件可以不存在)
filename：文件绝对路径或文件名(从AssistantTool.exe所在目录\script目录中查找)
data：字节序列数组或字节序列字符串
返回值：true/false
调用示例：printf(file_append("d:\\1.txt","31323334"));
HTTP

http_init(url)

HTTP初始化
url：目标地址，字符串
返回值：http对象
调用示例：

clear();
var cardno="6222031212135622563";
var httpObj=http_init("http://paynews.net/plugin.php?id=kabin:search");
http_set_method(httpObj,"POST");
http_set_header(httpObj,"Content-Type","application/x-www-form-urlencoded; charset=UTF-8");
http_set_header(httpObj,"Referer","http://paynews.net/plugin.php?id=kabin");
http_set_header(httpObj,"User-Agent","Mozilla/5.0 AppleWebKit Chrome");
http_set_cookie(httpObj,"XXX","YYY");
//http_set_proxy(httpObj,"116.62.104.133",39);
http_set_content_data(httpObj,UTF8ToHexArray("kahao="+cardno));
var result=http_get_response(httpObj);
if(!result){
     exit();
}
result=eval("("+HexArrayToUTF8(result)+")");
if(!result || !result.data){
     exit("卡号不对");
}
printf("发卡行名称及机构代码:"+result.data[0].backname);
printf("卡名:"+result.data[0].cardname);
printf("卡种:"+result.data[0].type);
http_delete(httpObj);

http_set_method(httpObj, Method)

设置HTTP请求方法
httpObj：http_init返回的对象
Method：请求方法，如GET/POST，字符串
返回值：true/false

http_set_header(httpObj, name,value)

设置HTTP头部信息
httpObj：http_init返回的对象
name：头部信息名称，如Accept/Referer/User-Agent/Content-Type，字符串
name：头部信息值，字符串
返回值：true/false

http_set_cookie(httpObj, name, value)

设置HTTP Cookie信息
httpObj：http_init返回的对象
name：Cookie名称，字符串
name：Cookie值，字符串
返回值：true/false

http_set_content_data(httpObj, data)

设置HTTP Content Data，一般用于POST
httpObj：http_init返回的对象
data：Cookie名称，字节序列字符串
返回值：true/false

http_set_proxy(httpObj, ip, port)

设置HTTP代理信息
httpObj：http_init返回的对象
ip：代理服务器IP地址，字符串
port：代理服务器端口，数值型
返回值：true/false

http_get_response(httpObj)

获取HTTP请求的返回内容
httpObj：http_init返回的对象
返回值：字节序列字符串

http_delete(httpObj)

删除HTTP对象
httpObj：http_init返回的对象
返回值：无