添加中移指令接口

This commit is contained in:
zhoubin
2021-08-12 10:47:32 +08:00
parent 45f81f4685
commit a1c66f685c
26 changed files with 4590 additions and 17 deletions
+1 -1
View File
@@ -7,7 +7,7 @@
</command> </command>
<data extend="data"> <data extend="data">
<num len="4" cn="授权响应码"> <num len="4" cn="授权响应码" required="false">
授权响应码 授权响应码
</num> </num>
+204
View File
@@ -0,0 +1,204 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>S0</hex>
</command>
<data extend="data">
<storageType len="1" cn="存储类型">
<options>
<option cn="使用内部密钥">
<hex>0</hex>
</option>
<option cn="使用外部密钥">
<hex>1</hex>
</option>
</options>
</storageType>
<keyLength len="4" :value="keyLen()" :if="1 == $packet.data.storageType$option" cn="外部密钥长度">
仅当存储类型为1时有效
密钥长度
</keyLength>
<key :if="1 == $packet.data.storageType$option" cn="外部密钥">
仅当存储类型为1时有效
密钥密文
</key>
<keyIndex len="27" :if="0 == $packet.data.storageType$option" cn="密钥索引">
仅当存储类型为0时有效
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0。
注意:后八位密钥索引不允许输入全0
</keyIndex>
<algorithmKey len="2" cn="算法类型">
支持算法:3DES、AES、SM1、SM4
取值参考数据字典
</algorithmKey>
<iv :len="ivLen()" :if="useCbc()" cn="IV 数据域">
仅当算法为非ECB模式下有此域
当算法标识为3DES-CBC、DES-CBC 时,该域为8B。
当算法标识为AES-CBC、SM1-CBC、SM4-CBC 时,该域为16B。
取值参考数据字典
</iv>
<keyScatterLevel len="1" cn="密钥分散级数">
密钥分散级数,0~3
</keyScatterLevel>
<scatterFactor1 len="16" :if="hasScatterFactor1()" cn="分散因子1">
仅当分散级数不为0时存在
</scatterFactor1>
<scatterFactor2 len="16" :if="hasScatterFactor2()" cn="分散因子2">
仅当分散级数不为0时存在
</scatterFactor2>
<scatterFactor3 len="16" :if="hasScatterFactor3()" cn="分散因子3">
仅当分散级数不为0时存在
</scatterFactor3>
<scatterAlgorithmKey1 len="2" :if="hasScatterFactor1()" cn="分散算法标识1">
仅当分散级数不为0时存在
分散算法标识,定义每一次分散的分散算法,数量与密钥分散级数一致
如果算法类型为3DES、AES,则支持算法:3DES、AES;
如果算法类型为SM1、SM4,则支持算法:SM1、SM4;
取值参考数据字典
</scatterAlgorithmKey1>
<scatterAlgorithmKey2 len="2" :if="hasScatterFactor2()" cn="分散算法标识2">
仅当分散级数不为0时存在,同上
</scatterAlgorithmKey2>
<scatterAlgorithmKey3 len="2" :if="hasScatterFactor3()" cn="分散算法标识3">
仅当分散级数不为0时存在,同上 向量
</scatterAlgorithmKey3>
<scatterAlgorithmVector1 :len="vectorLen()" :if="hasScatterFactor1()" cn="分散算法的初始向量1">
仅当分散级数不为0时存在
分散算法的初始向量,定义每一次分散的分散算法的初始向量,数量与分散级数一致
即使对应分散算法模式为ECB,也需要填充0x00,
填充数量和CBC模式保持一致,
3DES-ECB、3DES-CBC、DES-ECB、DES-CBC 为8B
SM1-ECB、SM1-CBC、SM4-ECB、SM4-CBC、
AES-ECB、AES-CBC 为16B
</scatterAlgorithmVector1>
<scatterAlgorithmVector2 :len="vectorLen()" :if="hasScatterFactor2()" cn="分散算法的初始向量2">
仅当分散级数不为0时存在,同上
</scatterAlgorithmVector2>
<scatterAlgorithmVector3 :len="vectorLen()" :if="hasScatterFactor3()" cn="分散算法的初始向量3">
仅当分散级数不为0时存在,同上
</scatterAlgorithmVector3>
<inputDataLen len="4" :value="inputDataLen()" cn="数据长度">
输入数据长度
</inputDataLen>
<inputData cn="输入数据">
输入数据
</inputData>
</data>
</req>
<res>
<command>
<hex>S1</hex>
</command>
<data>
<error len="2" cn="错误码" format="X" :catch="catchError('%s')">
<options>
<option cn="无错误">
<hex>00</hex>
</option>
</options>
</error>
<infoLen len="4" cn="输出数据长度">
数据长度
</infoLen>
<info :len="getInfoLen()" cn="数据">
数据
</info>
</data>
</res>
<script>
function keyLen() {
return $packet.data.key.length;
}
function ivLen() {
var algorithmKey = $packet.data.algorithmKey
if( 6== algorithmKey || 8== algorithmKey ){
return 8;
}
if( 10== algorithmKey || 2== algorithmKey || 6== algorithmKey ){
return 16;
}
}
function useCbc(){
var algorithmKey = $packet.data.algorithmKey
if( 6== algorithmKey || 8== algorithmKey || 10== algorithmKey || 2== algorithmKey || 4== algorithmKey ){
return true;
}else{
return false;
}
}
function inputDataLen(){
var data = $packet.data;
return data.inputData.length;
}
function hasScatterFactor1(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 1 &lt;= keyScatterLevel ){
return true;
}else{
return false;
}
}
function hasScatterFactor2(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 2 &lt;= keyScatterLevel ){
return true;
}else{
return false;
}
}
function hasScatterFactor3(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 3 == keyScatterLevel){
return true;
}else{
return false;
}
}
function vectorLen(){
var algorithmKey = $packet.data.algorithmKey
if(5==algorithmKey || 6== algorithmKey || 7== algorithmKey || 8== algorithmKey ){
return 8;
}
if( 1== algorithmKey || 2== algorithmKey || 3== algorithmKey || 4== algorithmKey || 5 == algorithmKey || 10 == algorithmKey){
return 16;
}
}
function getInfoLen(){
return Util.a2i( $final.getSection('data').getSection('infoLen') )
}
</script>
</packet>
+204
View File
@@ -0,0 +1,204 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>S1</hex>
</command>
<data extend="data">
<storageType len="1" cn="存储类型">
<options>
<option cn="使用内部密钥">
<hex>0</hex>
</option>
<option cn="使用外部密钥">
<hex>1</hex>
</option>
</options>
</storageType>
<keyLength len="4" :value="keyLen()" :if="1 == $packet.data.storageType$option" cn="外部密钥长度">
仅当存储类型为1时有效
密钥长度
</keyLength>
<key :if="1 == $packet.data.storageType$option" cn="外部密钥">
仅当存储类型为1时有效
密钥密文
</key>
<keyIndex len="27" :if="0 == $packet.data.storageType$option" cn="密钥索引">
仅当存储类型为0时有效
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0。
注意:后八位密钥索引不允许输入全0
</keyIndex>
<algorithmKey len="2" cn="算法类型">
支持算法:3DES、AES、SM1、SM4
取值参考数据字典
</algorithmKey>
<iv :len="ivLen()" :if="useCbc()" cn="IV 数据域">
仅当算法为非ECB模式下有此域
当算法标识为3DES-CBC、DES-CBC 时,该域为8B。
当算法标识为AES-CBC、SM1-CBC、SM4-CBC 时,该域为16B。
取值参考数据字典
</iv>
<keyScatterLevel len="1" cn="密钥分散级数">
密钥分散级数,0~3
</keyScatterLevel>
<scatterFactor1 len="16" :if="hasScatterFactor1()" cn="分散因子1">
仅当分散级数不为0时存在
</scatterFactor1>
<scatterFactor2 len="16" :if="hasScatterFactor2()" cn="分散因子2">
仅当分散级数不为0时存在
</scatterFactor2>
<scatterFactor3 len="16" :if="hasScatterFactor3()" cn="分散因子3">
仅当分散级数不为0时存在
</scatterFactor3>
<scatterAlgorithmKey1 len="2" :if="hasScatterFactor1()" cn="分散算法标识1">
仅当分散级数不为0时存在
分散算法标识,定义每一次分散的分散算法,数量与密钥分散级数一致
如果算法类型为3DES、AES,则支持算法:3DES、AES;
如果算法类型为SM1、SM4,则支持算法:SM1、SM4;
取值参考数据字典
</scatterAlgorithmKey1>
<scatterAlgorithmKey2 len="2" :if="hasScatterFactor2()" cn="分散算法标识2">
仅当分散级数不为0时存在,同上
</scatterAlgorithmKey2>
<scatterAlgorithmKey3 len="2" :if="hasScatterFactor3()" cn="分散算法标识3">
仅当分散级数不为0时存在,同上 向量
</scatterAlgorithmKey3>
<scatterAlgorithmVector1 :len="vectorLen()" :if="hasScatterFactor1()" cn="分散算法的初始向量1">
仅当分散级数不为0时存在
分散算法的初始向量,定义每一次分散的分散算法的初始向量,数量与分散级数一致
即使对应分散算法模式为ECB,也需要填充0x00,
填充数量和CBC模式保持一致,
3DES-ECB、3DES-CBC、DES-ECB、DES-CBC 为8B
SM1-ECB、SM1-CBC、SM4-ECB、SM4-CBC、
AES-ECB、AES-CBC 为16B
</scatterAlgorithmVector1>
<scatterAlgorithmVector2 :len="vectorLen()" :if="hasScatterFactor2()" cn="分散算法的初始向量2">
仅当分散级数不为0时存在,同上
</scatterAlgorithmVector2>
<scatterAlgorithmVector3 :len="vectorLen()" :if="hasScatterFactor3()" cn="分散算法的初始向量3">
仅当分散级数不为0时存在,同上
</scatterAlgorithmVector3>
<inputDataLen len="4" :value="inputDataLen()" cn="数据长度">
输入数据长度
</inputDataLen>
<inputData cn="输入数据">
输入数据
</inputData>
</data>
</req>
<res>
<command>
<hex>S2</hex>
</command>
<data>
<error len="2" cn="错误码" format="X" :catch="catchError('%s')">
<options>
<option cn="无错误">
<hex>00</hex>
</option>
</options>
</error>
<infoLen len="4" cn="输出数据长度">
数据长度
</infoLen>
<info :len="getInfoLen()" cn="数据">
数据
</info>
</data>
</res>
<script>
function keyLen() {
return $packet.data.key.length;
}
function ivLen() {
var algorithmKey = $packet.data.algorithmKey
if( 6==algorithmKey || 8 ==algorithmKey ){
return 8;
}
if( 10==algorithmKey || 2==algorithmKey || 4==algorithmKey ){
return 16;
}
}
function useCbc(){
var algorithmKey = $packet.data.algorithmKey
if( 6==algorithmKey || 8 ==algorithmKey || 10==algorithmKey || 2==algorithmKey || 4==algorithmKey ){
return true;
}else{
return false;
}
}
function inputDataLen(){
var data = $packet.data;
return data.inputData.length;
}
function hasScatterFactor1(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 1 &lt;= keyScatterLevel ){
return true;
}else{
return false;
}
}
function hasScatterFactor2(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 2 &lt;= keyScatterLevel ){
return true;
}else{
return false;
}
}
function hasScatterFactor3(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 3 == keyScatterLevel){
return true;
}else{
return false;
}
}
function vectorLen(){
var algorithmKey = $packet.data.algorithmKey
if( 5==algorithmKey || 6==algorithmKey || 7==algorithmKey || 8==algorithmKey ){
return 8;
}
if( 1==algorithmKey || 2==algorithmKey || 3==algorithmKey || 4==algorithmKey || 9==algorithmKey || 10==algorithmKey){
return 16;
}
}
function getInfoLen(){
return Util.a2i( $final.getSection('data').getSection('infoLen') )
}
</script>
</packet>
+190
View File
@@ -0,0 +1,190 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>S2</hex>
</command>
<data extend="data">
<storageType len="1" cn="存储类型">
<options>
<option cn="使用内部密钥">
<hex>0</hex>
</option>
<option cn="使用外部密钥">
<hex>1</hex>
</option>
</options>
</storageType>
<keyLength len="4" :value="keyLen()" :if="1 == $packet.data.storageType$option" cn="外部密钥长度">
仅当存储类型为1时有效
密钥长度
</keyLength>
<key :if="1 == $packet.data.storageType$option" cn="外部密钥">
仅当存储类型为1时有效
密钥密文
</key>
<keyIndex len="27" :if="0 == $packet.data.storageType$option" cn="密钥索引">
仅当存储类型为0时有效
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0。
注意:后八位密钥索引不允许输入全0
</keyIndex>
<algorithmKey len="2" cn="算法类型">
当存储类型为0时:仅支持3DES-ECB(07)、3DES-CBC(08)
当存储类型为1时:仅支持3DES-ECB、3DES-CBC、HMAC-SHA256(14)
取值参考数据字典
</algorithmKey>
<iv len="8" :if="useCbc()" cn="IV 数据域">
仅当算法为3DES-CBC模式下有此域
</iv>
<keyScatterLevel len="1" cn="密钥分散级数">
密钥分散级数,0~3
</keyScatterLevel>
<scatterFactor1 len="16" :if="hasScatterFactor1()" cn="分散因子1">
仅当分散级数不为0时存在
</scatterFactor1>
<scatterFactor2 len="16" :if="hasScatterFactor2()" cn="分散因子2">
仅当分散级数不为0时存在
</scatterFactor2>
<scatterFactor3 len="16" :if="hasScatterFactor3()" cn="分散因子3">
仅当分散级数不为0时存在
</scatterFactor3>
<scatterAlgorithmKey1 len="2" :if="hasScatterFactor1()" cn="分散算法标识1">
仅当分散级数不为0时存在
分散算法标识,定义每一次分散的分散算法,数量与密钥分散级数一致
如果算法类型为3DES、AES,则支持算法:3DES、AES;
如果算法类型为SM1、SM4,则支持算法:SM1、SM4;
取值参考数据字典
</scatterAlgorithmKey1>
<scatterAlgorithmKey2 len="2" :if="hasScatterFactor2()" cn="分散算法标识2">
仅当分散级数不为0时存在,同上
</scatterAlgorithmKey2>
<scatterAlgorithmKey3 len="2" :if="hasScatterFactor3()" cn="分散算法标识3">
仅当分散级数不为0时存在,同上 向量
</scatterAlgorithmKey3>
<scatterAlgorithmVector1 :len="vectorLen()" :if="hasScatterFactor1()" cn="分散算法的初始向量1">
仅当分散级数不为0时存在
分散算法的初始向量,定义每一次分散的分散算法的初始向量,数量与分散级数一致
即使对应分散算法模式为ECB,也需要填充0x00,
填充数量和CBC模式保持一致,
3DES-ECB、3DES-CBC、DES-ECB、DES-CBC 为8B
SM1-ECB、SM1-CBC、SM4-ECB、SM4-CBC、
AES-ECB、AES-CBC 为16B
</scatterAlgorithmVector1>
<scatterAlgorithmVector2 :len="vectorLen()" :if="hasScatterFactor2()" cn="分散算法的初始向量2">
仅当分散级数不为0时存在,同上
</scatterAlgorithmVector2>
<scatterAlgorithmVector3 :len="vectorLen()" :if="hasScatterFactor3()" cn="分散算法的初始向量3">
仅当分散级数不为0时存在,同上
</scatterAlgorithmVector3>
<inputDataLen len="4" :value="inputDataLen()" cn="数据长度">
输入数据长度
</inputDataLen>
<inputData cn="输入数据">
输入数据
</inputData>
<macLen len="2" cn="需要的MAC长度">
需要的MAC数据长度
</macLen>
</data>
</req>
<res>
<command>
<hex>S3</hex>
</command>
<data>
<error len="2" cn="错误码" format="X" :catch="catchError('%s')">
<options>
<option cn="无错误">
<hex>00</hex>
</option>
</options>
</error>
<mac :len="getMacLen()" cn="MAC数据">
输出的MAC数据
</mac>
</data>
</res>
<script>
function keyLen() {
return $packet.data.key.length;
}
function useCbc(){
var algorithmKey = $packet.data.algorithmKey
if( 8==algorithmKey){
return true;
}else{
return false;
}
}
function inputDataLen(){
var data = $packet.data;
return data.inputData.length;
}
function hasScatterFactor1(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 1 &lt;= keyScatterLevel ){
return true;
}else{
return false;
}
}
function hasScatterFactor2(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 2 &lt;= keyScatterLevel ){
return true;
}else{
return false;
}
}
function hasScatterFactor3(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 3 == keyScatterLevel){
return true;
}else{
return false;
}
}
function vectorLen(){
var algorithmKey = $packet.data.algorithmKey
if( 5==algorithmKey || 6==algorithmKey || 7==algorithmKey || 8==algorithmKey ){
return 8;
}
if( 1==algorithmKey || 2==algorithmKey || 3==algorithmKey || 4==algorithmKey || 9==algorithmKey || 10==algorithmKey ){
return 16;
}
}
function getMacLen(){
return $packet.data.macLen
}
</script>
</packet>
+157
View File
@@ -0,0 +1,157 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>S3</hex>
</command>
<data extend="data">
<keyIndex len="27" cn="密钥索引">
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0
注意:后八位密钥索引不允许输入全0
</keyIndex>
<algorithmKey len="2" cn="算法类型">
仅支持3DES-CBC
</algorithmKey>
<iv len="8" :if="useCbc()" cn="IV 数据域">
仅当算法为3DES-CBC模式下有此域
</iv>
<keyScatterLevel len="1" cn="密钥分散级数">
密钥分散级数,0~3
</keyScatterLevel>
<scatterFactor1 len="16" :if="hasScatterFactor1()" cn="分散因子1">
仅当分散级数不为0时存在
</scatterFactor1>
<scatterFactor2 len="16" :if="hasScatterFactor2()" cn="分散因子2">
仅当分散级数不为0时存在
</scatterFactor2>
<scatterFactor3 len="16" :if="hasScatterFactor3()" cn="分散因子3">
仅当分散级数不为0时存在
</scatterFactor3>
<scatterAlgorithmKey1 len="2" :if="hasScatterFactor1()" cn="分散算法标识1">
仅当分散级数不为0时存在
分散算法标识,定义每一次分散的分散算法,数量与密钥分散级数一致
如果算法类型为3DES、AES,则支持算法:3DES、AES;
如果算法类型为SM1、SM4,则支持算法:SM1、SM4;
取值参考数据字典
</scatterAlgorithmKey1>
<scatterAlgorithmKey2 len="2" :if="hasScatterFactor2()" cn="分散算法标识2">
仅当分散级数不为0时存在,同上
</scatterAlgorithmKey2>
<scatterAlgorithmKey3 len="2" :if="hasScatterFactor3()" cn="分散算法标识3">
仅当分散级数不为0时存在,同上 向量
</scatterAlgorithmKey3>
<scatterAlgorithmVector1 :len="vectorLen()" :if="hasScatterFactor1()" cn="分散算法的初始向量1">
仅当分散级数不为0时存在
分散算法的初始向量,定义每一次分散的分散算法的初始向量,数量与分散级数一致
即使对应分散算法模式为ECB,也需要填充0x00,
填充数量和CBC模式保持一致,
3DES-ECB、3DES-CBC、DES-ECB、DES-CBC 为8B
SM1-ECB、SM1-CBC、SM4-ECB、SM4-CBC、
AES-ECB、AES-CBC 为16B
</scatterAlgorithmVector1>
<scatterAlgorithmVector2 :len="vectorLen()" :if="hasScatterFactor2()" cn="分散算法的初始向量2">
仅当分散级数不为0时存在,同上
</scatterAlgorithmVector2>
<scatterAlgorithmVector3 :len="vectorLen()" :if="hasScatterFactor3()" cn="分散算法的初始向量3">
仅当分散级数不为0时存在,同上
</scatterAlgorithmVector3>
<inputDataLen len="4" :value="inputDataLen()" cn="数据长度">
输入数据长度
</inputDataLen>
<inputData cn="输入数据">
输入数据
</inputData>
</data>
</req>
<res>
<command>
<hex>S4</hex>
</command>
<data>
<error len="2" cn="错误码" format="X" :catch="catchError('%s')">
<options>
<option cn="无错误">
<hex>00</hex>
</option>
</options>
</error>
<macAndNextIv len="16" cn="MacAndNextIv数据">
输出的MacAndNextIv数据
16字节
前8字节为MAC
后8字节为下一次IV
</macAndNextIv>
</data>
</res>
<script>
function useCbc(){
var algorithmKey = $packet.data.algorithmKey
if(8==algorithmKey){
return true;
}else{
return false;
}
}
function inputDataLen(){
var data = $packet.data;
return data.inputData.length;
}
function hasScatterFactor1(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 1 &lt;= keyScatterLevel ){
return true;
}else{
return false;
}
}
function hasScatterFactor2(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 2 &lt;= keyScatterLevel ){
return true;
}else{
return false;
}
}
function hasScatterFactor3(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 3 == keyScatterLevel){
return true;
}else{
return false;
}
}
function vectorLen(){
var algorithmKey = $packet.data.algorithmKey
if( 5==algorithmKey || 6==algorithmKey || 7==algorithmKey || 8==algorithmKey ){
return 8;
}
if( 1==algorithmKey || 2==algorithmKey || 3==algorithmKey || 4==algorithmKey || 9==algorithmKey || 10==algorithmKey){
return 16;
}
}
</script>
</packet>
+78
View File
@@ -0,0 +1,78 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>S4</hex>
</command>
<data extend="data">
<storageType len="1" cn="存储类型">
<options>
<option cn="存储在内部">
<hex>0</hex>
</option>
<option cn="存储在外部">
<hex>1</hex>
</option>
</options>
</storageType>
<algorithmKey len="2" cn="算法类型">
仅支持RSA、SM2
</algorithmKey>
<keyLen len="4" cn="密钥长度">
RSA密钥长度:1024、2048
SM2密钥长度:256
</keyLen>
<keyIndex len="27" :if="0 == $packet.data.storageType$option" cn="密钥索引">
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0.
</keyIndex>
</data>
</req>
<res>
<command>
<hex>S5</hex>
</command>
<data>
<error len="2" cn="错误码" format="X" :catch="catchError('%s')">
<options>
<option cn="无错误">
<hex>00</hex>
</option>
</options>
</error>
<publicKeyLength len="4" cn="公钥长度">
公钥长度
</publicKeyLength>
<publicKey :len="getPubKeyLen()" cn="公钥">
公钥
</publicKey>
<privateKeyLength len="4" cn="私钥长度">
私钥长度
</privateKeyLength>
<privateKey :len="getPriKeyLen()" cn="私钥">
私钥
</privateKey>
</data>
</res>
<script>
function getPubKeyLen() {
return Util.a2i( $final.getSection('data').getSection('publicKeyLength') )
}
function getPriKeyLen() {
return Util.a2i( $final.getSection('data').getSection('privateKeyLength') )
}
</script>
</packet>
+87
View File
@@ -0,0 +1,87 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>S5</hex>
</command>
<data extend="data">
<storageType len="1" cn="存储类型">
<options>
<option cn="使用内部密钥">
<hex>0</hex>
</option>
<option cn="使用外部密钥">
<hex>1</hex>
</option>
</options>
</storageType>
<algorithmKey len="2" cn="算法类型">
仅支持RSA、SM2
</algorithmKey>
<privateKeyLen len="4" :value="getPrivateKeyLen()" :if="1 == $packet.data.storageType$option" cn="签名私钥长度">
仅当存储类型为1时有效
签名私钥长度
</privateKeyLen>
<privateKey :if="1 == $packet.data.storageType$option" cn="签名私钥">
仅当存储类型为1时有效
签名私钥
</privateKey>
<keyIndex len="27" :if="0 == $packet.data.storageType$option" cn="密钥索引">
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0
注意:后八位密钥索引不允许输入全0
</keyIndex>
<inputDataLen len="4" :value="inputDataLen()" cn="数据长度">
输入数据长度
</inputDataLen>
<inputData cn="输入数据">
输入数据
</inputData>
</data>
</req>
<res>
<command>
<hex>S6</hex>
</command>
<data>
<error len="2" cn="错误码" format="X" :catch="catchError('%s')">
<options>
<option cn="无错误">
<hex>00</hex>
</option>
</options>
</error>
<signDataLen len="4" cn="签名数据长度">
签名数据长度
</signDataLen>
<signData :len="getSignDataLen()" cn="签名数据">
签名数据
</signData>
</data>
</res>
<script>
function getPrivateKeyLen() {
return $packet.data.privateKey.length;
}
function inputDataLen(){
var data = $packet.data;
return data.inputData.length;
}
function getSignDataLen() {
return Util.a2i( $final.getSection('data').getSection('signDataLen') )
}
</script>
</packet>
+87
View File
@@ -0,0 +1,87 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>S6</hex>
</command>
<data extend="data">
<storageType len="1" cn="存储类型">
<options>
<option cn="使用内部密钥">
<hex>0</hex>
</option>
<option cn="使用外部密钥">
<hex>1</hex>
</option>
</options>
</storageType>
<algorithmKey len="2" cn="算法类型">
仅支持RSA、SM2
</algorithmKey>
<publicKeyLen len="4" :value="getPublicKeyLen()" :if="1 == $packet.data.storageType$option" cn="验签公钥长度">
仅当存储类型为1时有效
验签公钥长度
</publicKeyLen>
<publicKey :if="1 == $packet.data.storageType$option" cn="验签公钥">
仅当存储类型为1时有效
验签公钥
</publicKey>
<keyIndex len="27" :if="0 == $packet.data.storageType$option" cn="密钥索引">
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0
注意:后八位密钥索引不允许输入全0
</keyIndex>
<orgDataLen len="4" :value="getOrgDataLen()" cn="原数据长度">
原数据长度
</orgDataLen>
<orgData cn="原数据">
原数据
</orgData>
<inputDataLen len="4" :value="inputDataLen()" cn="签名数据长度">
签名数据长度
</inputDataLen>
<inputData cn="签名数据">
签名数据
</inputData>
</data>
</req>
<res>
<command>
<hex>S7</hex>
</command>
<data>
<error len="2" cn="错误码" format="X" :catch="catchError('%s')">
<options>
<option cn="无错误">
<hex>00</hex>
</option>
</options>
</error>
</data>
</res>
<script>
function getPublicKeyLen() {
return $packet.data.publicKey.length;
}
function getOrgDataLen(){
return $packet.data.orgData.length;
}
function inputDataLen(){
var data = $packet.data;
return data.inputData.length;
}
</script>
</packet>
+88
View File
@@ -0,0 +1,88 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>S7</hex>
</command>
<data extend="data">
<storageType len="1" cn="存储类型">
<options>
<option cn="使用内部密钥">
<hex>0</hex>
</option>
<option cn="使用外部密钥">
<hex>1</hex>
</option>
</options>
</storageType>
<algorithmKey len="2" cn="算法类型">
仅支持RSA、SM2
</algorithmKey>
<publicKeyLen len="4" :value="getPublicKeyLen()" :if="1 == $packet.data.storageType$option" cn="公钥长度">
仅当存储类型为1时有效
公钥长度
</publicKeyLen>
<publicKey :if="1 == $packet.data.storageType$option" cn="公钥">
仅当存储类型为1时有效
公钥
</publicKey>
<keyIndex len="27" :if="0 == $packet.data.storageType$option" cn="密钥索引">
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0
注意:后八位密钥索引不允许输入全0
</keyIndex>
<inputDataLen len="4" :value="inputDataLen()" cn="数据长度">
数据长度
</inputDataLen>
<inputData cn="数据">
数据
</inputData>
</data>
</req>
<res>
<command>
<hex>S8</hex>
</command>
<data>
<error len="2" cn="错误码" format="X" :catch="catchError('%s')">
<options>
<option cn="无错误">
<hex>00</hex>
</option>
</options>
</error>
<cipherLen len="4" cn="密文长度">
密文长度
</cipherLen>
<cipher :len="getCipherLen()" cn="密文">
密文
</cipher>
</data>
</res>
<script>
function getPublicKeyLen() {
return $packet.data.publicKey.length;
}
function inputDataLen(){
var data = $packet.data;
return data.inputData.length;
}
function getCipherLen(){
return Util.a2i( $final.getSection('data').getSection('cipherLen') )
}
</script>
</packet>
+88
View File
@@ -0,0 +1,88 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>S8</hex>
</command>
<data extend="data">
<storageType len="1" cn="存储类型">
<options>
<option cn="使用内部密钥">
<hex>0</hex>
</option>
<option cn="使用外部密钥">
<hex>1</hex>
</option>
</options>
</storageType>
<algorithmKey len="2" cn="算法类型">
仅支持RSA、SM2
</algorithmKey>
<privateKeyLen len="4" :value="getPrivateKeyLen()" :if="1 == $packet.data.storageType$option" cn="私钥长度">
仅当存储类型为1时有效
私钥长度
</privateKeyLen>
<privateKey :if="1 == $packet.data.storageType$option" cn="私钥">
仅当存储类型为1时有效
私钥
</privateKey>
<keyIndex len="27" :if="0 == $packet.data.storageType$option" cn="密钥索引">
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0
注意:后八位密钥索引不允许输入全0
</keyIndex>
<inputDataLen len="4" :value="inputDataLen()" cn="密文长度">
密文长度
</inputDataLen>
<inputData cn="密文">
密文
</inputData>
</data>
</req>
<res>
<command>
<hex>S9</hex>
</command>
<data>
<error len="2" cn="错误码" format="X" :catch="catchError('%s')">
<options>
<option cn="无错误">
<hex>00</hex>
</option>
</options>
</error>
<infoLen len="4" cn="数据长度">
数据长度
</infoLen>
<info :len="getInfoLen()" cn="数据">
数据
</info>
</data>
</res>
<script>
function getPrivateKeyLen() {
return $packet.data.privateKey.length;
}
function inputDataLen(){
var data = $packet.data;
return data.inputData.length;
}
function getInfoLen(){
return Util.a2i( $final.getSection('data').getSection('infoLen') )
}
</script>
</packet>
+178
View File
@@ -0,0 +1,178 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>S9</hex>
</command>
<data extend="data">
<protectedKeyIndex len="27" cn="保护密钥的索引">
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0
</protectedKeyIndex>
<algorithmKey len="2" cn="保护密钥算法">
支持算法:3DES、AES、SM1、SM4
</algorithmKey>
<iv len="8" :if="useCbc()" :len="ivLen()" cn="IV 数据域">
仅当算法为非ECB模式下有此域
当算法标识为3DES-CBC、DES-CBC 时,该域为8B。
当算法标识为AES-CBC、SM1-CBC、SM4-CBC 时,该域为16B。
</iv>
<keyScatterLevel len="1" cn="保护密钥分散级数">
密钥分散级数,0~3
</keyScatterLevel>
<scatterFactor1 len="16" :if="hasScatterFactor1()" cn="保护分散因子1">
仅当保护密钥分散级数不为0时存在
</scatterFactor1>
<scatterFactor2 len="16" :if="hasScatterFactor2()" cn="保护分散因子2">
仅当保护密钥分散级数不为0时存在
</scatterFactor2>
<scatterFactor3 len="16" :if="hasScatterFactor3()" cn="保护分散因子3">
仅当保护密钥分散级数不为0时存在
</scatterFactor3>
<scatterAlgorithmKey1 len="2" :if="hasScatterFactor1()" cn="保护分散算法标识1">
仅当保护密钥分散级数不为0时存在
分散算法标识,定义每一次分散的分散算法,数量与密钥分散级数一致
如果保护密钥算法类型为3DES、AES,则支持算法:3DES、AES;
如果保护密钥算法类型为SM1、SM4,则支持算法:SM1、SM4;
取值参考数据字典
</scatterAlgorithmKey1>
<scatterAlgorithmKey2 len="2" :if="hasScatterFactor2()" cn="保护分散算法标识2">
仅当分散级数不为0时存在,同上
</scatterAlgorithmKey2>
<scatterAlgorithmKey3 len="2" :if="hasScatterFactor3()" cn="保护分散算法标识3">
仅当分散级数不为0时存在,同上
</scatterAlgorithmKey3>
<scatterAlgorithmVector1 :len="vectorLen()" :if="hasScatterFactor1()" cn="保护密钥分散算法的初始向量1">
仅当分散级数不为0时存在
分散算法的初始向量,定义每一次分散的分散算法的初始向量,数量与分散级数一致
即使对应分散算法模式为ECB,也需要填充0x00,
填充数量和CBC模式保持一致,
3DES-ECB、3DES-CBC、DES-ECB、DES-CBC 为8B
SM1-ECB、SM1-CBC、SM4-ECB、SM4-CBC、
AES-ECB、AES-CBC 为16B
</scatterAlgorithmVector1>
<scatterAlgorithmVector2 :len="vectorLen()" :if="hasScatterFactor2()" cn="保护密钥分散算法的初始向量2">
仅当分散级数不为0时存在,同上
</scatterAlgorithmVector2>
<scatterAlgorithmVector3 :len="vectorLen()" :if="hasScatterFactor3()" cn="保护密钥分散算法的初始向量3">
仅当分散级数不为0时存在,同上
</scatterAlgorithmVector3>
<exportKeyNum len="2" cn="导出的密钥索引个数">
被导出的密钥索引个数,最大不超过50
</exportKeyNum>
<exportKey cn="导出的密钥结构体">
分散密钥结构体STC_KEYDIV
结构体格式参考数据字典
</exportKey>
</data>
</req>
<res>
<command>
<hex>SA</hex>
</command>
<data>
<error len="2" cn="错误代码" format="X" :catch="catchError('%s')">
<options>
<option cn="成功">
<hex>00</hex>
</option>
</options>
</error>
<linkKeyOut :len="linkKeyOutLen()" cn="依次连接所有密钥密文输出">
依次连接所有密钥密文输出
</linkKeyOut>
<linkKeyCheckOut :len="linkKeyCheckOutLen()" cn="依次连接所有密钥校验值输出">
依次连接所有密钥校验值输出
</linkKeyCheckOut>
</data>
</res>
<script>
function useCbc(){
var algorithmKey = $packet.data.algorithmKey
if( 6==algorithmKey || 8==algorithmKey || 2==algorithmKey || 4==algorithmKey || 10==algorithmKey ){
return true;
}else{
return false;
}
}
function ivLen() {
var algorithmKey = $packet.data.algorithmKey
if(6==algorithmKey || 8==algorithmKey){
return 8;
}
if( 2==algorithmKey || 4==algorithmKey || 10==algorithmKey ){
return 16;
}
}
function vectorLen(){
var algorithmKey = $packet.data.algorithmKey
if(5==algorithmKey || 6==algorithmKey || 7==algorithmKey || 8==algorithmKey ){
return 8;
}
if(1==algorithmKey || 2==algorithmKey || 3==algorithmKey || 4==algorithmKey || 9==algorithmKey || 10==algorithmKey){
return 16;
}
}
function hasScatterFactor1(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 1 &lt;= keyScatterLevel ){
return true;
}else{
return false;
}
}
function hasScatterFactor2(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 2 &lt;= keyScatterLevel ){
return true;
}else{
return false;
}
}
function hasScatterFactor3(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 3 == keyScatterLevel){
return true;
}else{
return false;
}
}
function linkKeyOutLen(){
var exportKeyNum = $packet.data.exportKeyNum
return exportKeyNum * 16
}
function linkKeyCheckOutLen(){
var exportKeyNum = $packet.data.exportKeyNum
return exportKeyNum * 8
}
</script>
</packet>
+184
View File
@@ -0,0 +1,184 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>SA</hex>
</command>
<data extend="data">
<keyIndex len="27" cn="密钥索引">
仅当存储类型为0时有效
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0。
注意:后八位密钥索引不允许输入全0
</keyIndex>
<keyScatterLevel len="1" cn="密钥分散级数">
密钥分散级数,0~3
</keyScatterLevel>
<scatterFactor1 len="16" :if="hasScatterFactor1()" cn="分散因子1">
仅当保护密钥分散级数不为0时存在
</scatterFactor1>
<scatterFactor2 len="16" :if="hasScatterFactor2()" cn="分散因子2">
仅当保护密钥分散级数不为0时存在
</scatterFactor2>
<scatterFactor3 len="16" :if="hasScatterFactor3()" cn="分散因子3">
仅当保护密钥分散级数不为0时存在
</scatterFactor3>
<scatterAlgorithmKey1 len="2" :if="hasScatterFactor1()" cn="分散算法标识1">
仅当保护密钥分散级数不为0时存在
分散算法标识,定义每一次分散的分散算法,数量与密钥分散级数一致
如果保护密钥算法类型为3DES、AES,则支持算法:3DES、AES;
如果保护密钥算法类型为SM1、SM4,则支持算法:SM1、SM4;
取值参考数据字典
</scatterAlgorithmKey1>
<scatterAlgorithmKey2 len="2" :if="hasScatterFactor2()" cn="分散算法标识2">
仅当分散级数不为0时存在,同上
</scatterAlgorithmKey2>
<scatterAlgorithmKey3 len="2" :if="hasScatterFactor3()" cn="分散算法标识3">
仅当分散级数不为0时存在,同上
</scatterAlgorithmKey3>
<scatterAlgorithmVector1 :len="vectorLen()" :if="hasScatterFactor1()" cn="分散算法的初始向量1">
仅当分散级数不为0时存在
分散算法的初始向量,定义每一次分散的分散算法的初始向量,数量与分散级数一致
即使对应分散算法模式为ECB,也需要填充0x00,
填充数量和CBC模式保持一致,
3DES-ECB、3DES-CBC、DES-ECB、DES-CBC 为16H
SM1-ECB、SM1-CBC、SM4-ECB、SM4-CBC、
AES-ECB、AES-CBC 为32H
</scatterAlgorithmVector1>
<scatterAlgorithmVector2 :len="vectorLen()" :if="hasScatterFactor2()" cn="分散算法的初始向量2">
仅当分散级数不为0时存在,同上
</scatterAlgorithmVector2>
<scatterAlgorithmVector3 :len="vectorLen()" :if="hasScatterFactor3()" cn="分散算法的初始向量3">
仅当分散级数不为0时存在,同上
</scatterAlgorithmVector3>
<masterKeyLabelLength :value="getMasterKeyLabel()" len="4" cn="主密钥标签长度">
主密钥标签长度,最大不超过256字节
</masterKeyLabelLength>
<masterKeyLabel cn="主密钥标签">
主密钥标签
</masterKeyLabel>
<workKeyLabelLength :value="getWorkKeyLabel()" len="4" cn="工作密钥标签长度">
工作密钥标签长度,最大不超过256字节
</workKeyLabelLength>
<workKeyLabel cn="工作密钥标签">
工作密钥标签
</workKeyLabel>
<clientRandomNumLength len="4" :value="getClientRandomNum()" cn="客户端随机数长度">
客户端随机数长度,最大不超过2048
</clientRandomNumLength>
<clientRandomNum cn="客户端随机数">
客户端随机数
</clientRandomNum>
<serverRandomNumLength len="4" :value="getServerRandomNum()" cn="服务端随机数长度">
服务端随机数长度,最大不超过2048
</serverRandomNumLength>
<serverRandomNum cn="服务端随机数">
服务端随机数
</serverRandomNum>
</data>
</req>
<res>
<command>
<hex>B2</hex>
</command>
<data>
<error len="2" cn="错误代码" format="X" :catch="catchError('%s')">
<options>
<option cn="成功">
<hex>00</hex>
</option>
</options>
</error>
<sessionKey len="176" cn="会话密钥">
输出会话密钥密文
数序如下:
masterKey(48字节)
clientWriteMacKey(32字节)
serverWriteMacKey(32字节)
clientWriteKey(16字节)
serverWriteKey(16字节)
clientWriteIv(16字节)
serverWriteIv(16字节)
</sessionKey>
</data>
</res>
<script>
function hasScatterFactor1(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 1 &lt;= keyScatterLevel ){
return true;
}else{
return false;
}
}
function hasScatterFactor2(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 2 &lt;= keyScatterLevel ){
return true;
}else{
return false;
}
}
function hasScatterFactor3(){
var keyScatterLevel = $packet.data.keyScatterLevel
if( 3 == keyScatterLevel){
return true;
}else{
return false;
}
}
function vectorLen(){
var algorithmKey = $packet.data.algorithmKey
if(5==algorithmKey || 6==algorithmKey || 7==algorithmKey || 8==algorithmKey ){
return 8;
}
if(1==algorithmKey || 2==algorithmKey || 3==algorithmKey || 4==algorithmKey || 9==algorithmKey || 10==algorithmKey){
return 16;
}
}
function getMasterKeyLabel(){
return $packet.data.masterKeyLabel.length;
}
function getWorkKeyLabel(){
return $packet.data.workKeyLabel.length;
}
function getClientRandomNum(){
return $packet.data.clientRandomNum.length;
}
function getServerRandomNum(){
return $packet.data.serverRandomNum.length;
}
</script>
</packet>
+70
View File
@@ -0,0 +1,70 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>SB</hex>
</command>
<data extend="data">
<keyLength len="4" :value="keyLen()" cn="外部密钥长度">
外部密钥密文长度
</keyLength>
<key cn="外部密钥">
外部密钥密文
</key>
<seedLen len="4" :value="getSeedLen()" cn="种子长度">
种子长度
</seedLen>
<seed cn="种子">
种子
</seed>
<outLen len="4" cn="输出数据长度">
输出数据长度
</outLen>
</data>
</req>
<res>
<command>
<hex>SC</hex>
</command>
<data>
<error len="2" cn="错误码" format="X" :catch="catchError('%s')">
<options>
<option cn="无错误">
<hex>00</hex>
</option>
</options>
</error>
<pHashLen len="4" cn="输出数据长度">
输出数据长度
</pHashLen>
<pHash :len="getPHashLen()" cn="pHash">
输出的指定长度的数据
若指定长度小于块长的整数倍,则取满足返回长度最小整数倍的前指定长度个字节
</pHash>
</data>
</res>
<script>
function keyLen() {
return $packet.data.key.length;
}
function getSeedLen(){
return $packet.data.seed.length;
}
function getPHashLen(){
return Util.a2i( $final.getSection('data').getSection('pHashLen') )
}
</script>
</packet>
+290
View File
@@ -0,0 +1,290 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>SC</hex>
</command>
<data extend="data">
<deKeyIndex len="27" cn="解密密钥索引">
仅当存储类型为0时有效
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0。
注意:后八位密钥索引不允许输入全0
</deKeyIndex>
<algorithmKey len="2" cn="解密算法类型">
解密的算法
支持算法:3DES、AES、SM1、SM4
</algorithmKey>
<scatterAlgorithmVector :len="vectorLength()" :if="hasVector()" cn="解密初始向量">
仅当算法为非ECB模式下有此域
当算法标识为3DES-CBC、DES-CBC 时,该域为8B。
当算法标识为AES-CBC、SM1-CBC、SM4-CBC 时,该域为16B。
取值参考数据字典
</scatterAlgorithmVector>
<deKeyScatterLevel len="1" cn="解密密钥分散级数">
密钥分散级数,0~3
</deKeyScatterLevel>
<deScatterFactor1 len="16" :if="hasDeScatterFactor1()" cn="解密分散因子1">
仅当保护密钥分散级数不为0时存在
</deScatterFactor1>
<deScatterFactor2 len="16" :if="hasDeScatterFactor2()" cn="解密分散因子2">
仅当保护密钥分散级数不为0时存在
</deScatterFactor2>
<deScatterFactor3 len="16" :if="hasDeScatterFactor3()" cn="解密分散因子3">
仅当保护密钥分散级数不为0时存在
</deScatterFactor3>
<deScatterAlgorithmKey1 len="2" :if="hasDeScatterFactor1()" cn="解密分散算法标识1">
仅当保护密钥分散级数不为0时存在
分散算法标识,定义每一次分散的分散算法,数量与密钥分散级数一致
如果保护密钥算法类型为3DES、AES,则支持算法:3DES、AES;
如果保护密钥算法类型为SM1、SM4,则支持算法:SM1、SM4;
取值参考数据字典
</deScatterAlgorithmKey1>
<deScatterAlgorithmKey2 len="2" :if="hasDeScatterFactor2()" cn="解密分散算法标识2">
仅当分散级数不为0时存在,同上
</deScatterAlgorithmKey2>
<deScatterAlgorithmKey3 len="2" :if="hasDeScatterFactor3()" cn="解密分散算法标识3">
仅当分散级数不为0时存在,同上
</deScatterAlgorithmKey3>
<deScatterAlgorithmVector1 :len="vectorLen()" :if="hasDeScatterFactor1()" cn="解密分散算法的初始向量1">
仅当分散级数不为0时存在
分散算法的初始向量,定义每一次分散的分散算法的初始向量,数量与分散级数一致
即使对应分散算法模式为ECB,也需要填充0x00,
填充数量和CBC模式保持一致,
3DES-ECB、3DES-CBC、DES-ECB、DES-CBC 为16H
SM1-ECB、SM1-CBC、SM4-ECB、SM4-CBC、
AES-ECB、AES-CBC 为32H
</deScatterAlgorithmVector1>
<deScatterAlgorithmVector2 :len="vectorLen()" :if="hasDeScatterFactor2()" cn="解密分散算法的初始向量2">
仅当分散级数不为0时存在,同上
</deScatterAlgorithmVector2>
<deScatterAlgorithmVector3 :len="vectorLen()" :if="hasDeScatterFactor3()" cn="解密分散算法的初始向量3">
仅当分散级数不为0时存在,同上
</deScatterAlgorithmVector3>
<enKeyIndex len="27" cn="加密密钥索引">
仅当存储类型为0时有效
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0。
注意:后八位密钥索引不允许输入全0
</enKeyIndex>
<encryptAlgFlag len="2" cn="加密密钥算法">
加密密钥算法,支持3DES、AES、SM1、SM4
取值参考数据字典
</encryptAlgFlag>
<encryptIv :len="enVectorLength()" :if="hasEnVector()" cn="加密密钥IV">
仅当加密密钥算法为CBC模式时存在
加密密钥的初始向量
</encryptIv>
<enKeyScatterLevel len="1" cn="加密密钥分散级数">
密钥分散级数,0~3
</enKeyScatterLevel>
<enScatterFactor1 len="16" :if="hasEnScatterFactor1()" cn="加密分散因子1">
仅当保护密钥分散级数不为0时存在
</enScatterFactor1>
<enScatterFactor2 len="16" :if="hasEnScatterFactor2()" cn="加密分散因子2">
仅当保护密钥分散级数不为0时存在
</enScatterFactor2>
<enScatterFactor3 len="16" :if="hasEnScatterFactor3()" cn="加密分散因子3">
仅当保护密钥分散级数不为0时存在
</enScatterFactor3>
<enScatterAlgorithmKey1 len="2" :if="hasEnScatterFactor1()" cn="加密分散算法标识1">
仅当保护密钥分散级数不为0时存在
分散算法标识,定义每一次分散的分散算法,数量与密钥分散级数一致
如果保护密钥算法类型为3DES、AES,则支持算法:3DES、AES;
如果保护密钥算法类型为SM1、SM4,则支持算法:SM1、SM4;
取值参考数据字典
</enScatterAlgorithmKey1>
<enScatterAlgorithmKey2 len="2" :if="hasEnScatterFactor2()" cn="加密分散算法标识2">
仅当分散级数不为0时存在,同上
</enScatterAlgorithmKey2>
<enScatterAlgorithmKey3 len="2" :if="hasEnScatterFactor3()" cn="加密分散算法标识3">
仅当分散级数不为0时存在,同上
</enScatterAlgorithmKey3>
<enScatterAlgorithmVector1 :len="vectorLen()" :if="hasEnScatterFactor1()" cn="加密分散算法的初始向量1">
仅当分散级数不为0时存在
分散算法的初始向量,定义每一次分散的分散算法的初始向量,数量与分散级数一致
即使对应分散算法模式为ECB,也需要填充0x00,
填充数量和CBC模式保持一致,
3DES-ECB、3DES-CBC、DES-ECB、DES-CBC 为16H
SM1-ECB、SM1-CBC、SM4-ECB、SM4-CBC、
AES-ECB、AES-CBC 为32H
</enScatterAlgorithmVector1>
<enScatterAlgorithmVector2 :len="vectorLen()" :if="hasEnScatterFactor2()" cn="加密分散算法的初始向量2">
仅当分散级数不为0时存在,同上
</enScatterAlgorithmVector2>
<enScatterAlgorithmVector3 :len="vectorLen()" :if="hasEnScatterFactor3()" cn="加密分散算法的初始向量3">
仅当分散级数不为0时存在,同上
</enScatterAlgorithmVector3>
<inputDataLen len="4" :value="inputDataLen()" cn="输入数据长度">
待解密的数据长度
</inputDataLen>
<inputData cn="输入数据">
待解密的数据
</inputData>
</data>
</req>
<res>
<command>
<hex>SD</hex>
</command>
<data>
<error len="2" cn="错误代码" format="X" :catch="catchError('%s')">
<options>
<option cn="成功">
<hex>00</hex>
</option>
</options>
</error>
<infoLen len="4" cn="数据长度">
加密后的数据长度
</infoLen>
<info :len="getInfoLen()" cn="数据">
加密后的数据
</info>
</data>
</res>
<script>
function vectorLength(){
var algorithmKey = $packet.data.algorithmKey
if(6==algorithmKey || 8==algorithmKey ){
return 8;
}
if( 2==algorithmKey || 4==algorithmKey || 10==algorithmKey ){
return 16;
}
}
function hasVector(){
var algorithmKey = $packet.data.algorithmKey
if(2==algorithmKey || 4==algorithmKey || 10==algorithmKey || 6==algorithmKey || 8==algorithmKey){
return true;
}else{
return false;
}
}
function enVectorLength(){
var encryptAlgFlag = $packet.data.encryptAlgFlag
if(6==encryptAlgFlag || 8==encryptAlgFlag ){
return 8;
}
if( 2==encryptAlgFlag || 4==encryptAlgFlag || 10==encryptAlgFlag ){
return 16;
}
}
function hasEnVector(){
var encryptAlgFlag =$packet.data.encryptAlgFlag
if( 2==encryptAlgFlag || 4==encryptAlgFlag || 10==encryptAlgFlag || 6==encryptAlgFlag || 8==encryptAlgFlag){
return true;
}else{
return false;
}
}
function hasDeScatterFactor1(){
var deKeyScatterLevel = $packet.data.deKeyScatterLevel
if( 1 &lt;= deKeyScatterLevel ){
return true;
}else{
return false;
}
}
function hasDeScatterFactor2(){
var deKeyScatterLevel = $packet.data.deKeyScatterLevel
if( 2 &lt;= deKeyScatterLevel ){
return true;
}else{
return false;
}
}
function hasDeScatterFactor3(){
var deKeyScatterLevel = $packet.data.deKeyScatterLevel
if( 3 == deKeyScatterLevel){
return true;
}else{
return false;
}
}
function hasEnScatterFactor1(){
var enKeyScatterLevel = $packet.data.enKeyScatterLevel
if( 1 &lt;= enKeyScatterLevel ){
return true;
}else{
return false;
}
}
function hasEnScatterFactor2(){
var enKeyScatterLevel = $packet.data.enKeyScatterLevel
if( 2 &lt;= enKeyScatterLevel ){
return true;
}else{
return false;
}
}
function hasEnScatterFactor3(){
var enKeyScatterLevel = $packet.data.enKeyScatterLevel
if( 3 == enKeyScatterLevel){
return true;
}else{
return false;
}
}
function vectorLen(){
var algorithmKey = $packet.data.algorithmKey
if(5==algorithmKey || 6==algorithmKey || 7==algorithmKey || 8==algorithmKey ){
return 8;
}
if( 1==algorithmKey || 2==algorithmKey || 3==algorithmKey || 4==algorithmKey || 9==algorithmKey || 10==algorithmKey){
return 16;
}
}
function inputDataLen(){
var data = $packet.data;
return data.inputData.length;
}
function getInfoLen(){
return Util.a2i( $final.getSection('data').getSection('infoLen') )
}
</script>
</packet>
+87
View File
@@ -0,0 +1,87 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>SD</hex>
</command>
<data extend="data">
<storageType len="1" cn="存储类型">
<options>
<option cn="使用内部密钥">
<hex>0</hex>
</option>
<option cn="使用外部密钥">
<hex>1</hex>
</option>
</options>
</storageType>
<keyIndex len="27" :if="0 == $packet.data.storageType$option" cn="解密密钥索引">
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0
</keyIndex>
<algorithmKey len="2" cn="解密算法类型">
解密算法
支持算法:RSA、SM2
取值参考数据字典
</algorithmKey>
<privateKeyLen len="4" :value="getPrivateKeyLen()" :if="1 == $packet.data.storageType$option" cn="解密私钥长度">
仅当密钥索引全0时,存在此域
解密密钥长度
</privateKeyLen>
<privateKey :if="1 == $packet.data.storageType$option" cn="解密私钥">
仅当密钥索引全0时,存在此域
解密的非对称密钥私钥密文
</privateKey>
<inputDataLen len="4" :value="getInputDataLen()" cn="数据长度">
待转加密的数据长度
</inputDataLen>
<inputData cn="数据">
待转加密的数据
</inputData>
</data>
</req>
<res>
<command>
<hex>SE</hex>
</command>
<data>
<error len="2" cn="错误码" format="X" :catch="catchError('%s')">
<options>
<option cn="无错误">
<hex>00</hex>
</option>
</options>
</error>
<keyCiphertextLen len="4" cn="密钥密文长度">
使用加密机主密钥加密的对称密钥长度
</keyCiphertextLen>
<keyCiphertext :len="getKeyCiphertextLen()" cn="密钥密文">
使用加密机主密钥加密的对称密钥
</keyCiphertext>
</data>
</res>
<script>
function getPrivateKeyLen(){
return $packet.data.privateKey.length;
}
function getInputDataLen(){
return $packet.data.inputData.length;
}
function getKeyCiphertextLen(){
return Util.a2i( $final.getSection('data').getSection('keyCiphertextLen') )
}
</script>
</packet>
+99
View File
@@ -0,0 +1,99 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>SE</hex>
</command>
<data extend="data">
<keyLength len="4" :value="keyLen()" cn="解密密钥长度">
仅当存储类型为1时有效
解密密钥密文长度
</keyLength>
<key cn="解密密钥">
仅当存储类型为1时有效
解密密钥密文
</key>
<algorithmKey len="2" cn="解密算法类型">
解密算法
支持算法:SM4、3DES和AES
取值参考数据字典
</algorithmKey>
<iv :len="ivLen()" :if="useCbc()" cn="IV 数据域">
仅当算法为非ECB模式下有此域
当算法标识为3DES-CBC 时,该域为8B。
当算法标识为AES-CBC、 SM4-CBC 时,该域为16B。
取值参考数据字典
</iv>
<inputDataLen len="4" :value="getInputDataLen()" cn="数据长度">
待转加密的数据长度
</inputDataLen>
<inputData cn="数据">
待转加密的数据
</inputData>
</data>
</req>
<res>
<command>
<hex>SF</hex>
</command>
<data>
<error len="2" cn="错误码" format="X" :catch="catchError('%s')">
<options>
<option cn="无错误">
<hex>00</hex>
</option>
</options>
</error>
<keyCiphertextLen len="4" cn="密钥密文长度">
使用加密机主密钥加密的对称密钥长度
</keyCiphertextLen>
<keyCiphertext :len="getKeyCiphertextLen()" cn="密钥密文">
使用加密机主密钥加密的对称密钥
</keyCiphertext>
</data>
</res>
<script>
function keyLen() {
return $packet.data.key.length;
}
function useCbc(){
var algorithmKey = $packet.data.algorithmKey
if( 6==algorithmKey || 8==algorithmKey || 2==algorithmKey || 4==algorithmKey || 10==algorithmKey ){
return true;
}else{
return false;
}
}
function ivLen() {
var algorithmKey = $packet.data.algorithmKey
if(8==algorithmKey ){
return 8;
}
if( 4==algorithmKey || 10==algorithmKey ){
return 16;
}
}
function getInputDataLen(){
return $packet.data.inputData.length;
}
function getKeyCiphertextLen(){
return Util.a2i( $final.getSection('data').getSection('keyCiphertextLen') )
}
</script>
</packet>
+178
View File
@@ -0,0 +1,178 @@
<?xml version="1.0" encoding="UTF-8" ?>
<packet extend="base">
<req>
<command>
<hex>SF</hex>
</command>
<data extend="data">
<enKeyIndex len="27" cn="加密密钥索引">
仅当存储类型为0时有效
内部密钥索引, 接口层对外限制8位,通讯层限制27位,16位机构号+3位密钥类型+8位密钥索引号。前19位补0。
注意:后八位密钥索引不允许输入全0
</enKeyIndex>
<algorithmKey len="2" cn="加密算法类型">
加密算法类型
支持算法:3DES、AES、SM1、SM4
</algorithmKey>
<iv :len="ivLen()" :if="useCbc()" cn="加密算法IV">
仅当算法为非ECB模式下有此域
当算法标识为3DES-CBC 时,该域为8B。
当算法标识为AES-CBC、SM1-CBC、SM4-CBC 时,该域为16B。
取值参考数据字典
</iv>
<enKeyScatterLevel len="1" cn="加密密钥分散级数">
密钥分散级数,0~3
</enKeyScatterLevel>
<enScatterFactor1 len="16" :if="hasEnScatterFactor1()" cn="加密分散因子1">
仅当保护密钥分散级数不为0时存在
</enScatterFactor1>
<enScatterFactor2 len="16" :if="hasEnScatterFactor2()" cn="加密分散因子2">
仅当保护密钥分散级数不为0时存在
</enScatterFactor2>
<enScatterFactor3 len="16" :if="hasEnScatterFactor3()" cn="加密分散因子3">
仅当保护密钥分散级数不为0时存在
</enScatterFactor3>
<enScatterAlgorithmKey1 len="2" :if="hasEnScatterFactor1()" cn="加密分散算法标识1">
仅当保护密钥分散级数不为0时存在
分散算法标识,定义每一次分散的分散算法,数量与密钥分散级数一致
如果保护密钥算法类型为3DES、AES,则支持算法:3DES、AES;
如果保护密钥算法类型为SM1、SM4,则支持算法:SM1、SM4;
取值参考数据字典
</enScatterAlgorithmKey1>
<enScatterAlgorithmKey2 len="2" :if="hasEnScatterFactor2()" cn="加密分散算法标识2">
仅当分散级数不为0时存在,同上
</enScatterAlgorithmKey2>
<enScatterAlgorithmKey3 len="2" :if="hasEnScatterFactor3()" cn="加密分散算法标识3">
仅当分散级数不为0时存在,同上
</enScatterAlgorithmKey3>
<enScatterAlgorithmVector1 :len="vectorLen()" :if="hasEnScatterFactor1()" cn="加密分散算法的初始向量1">
仅当分散级数不为0时存在
分散算法的初始向量,定义每一次分散的分散算法的初始向量,数量与分散级数一致
即使对应分散算法模式为ECB,也需要填充0x00,
填充数量和CBC模式保持一致,
3DES-ECB、3DES-CBC、DES-ECB、DES-CBC 为16H
SM1-ECB、SM1-CBC、SM4-ECB、SM4-CBC、
AES-ECB、AES-CBC 为32H
</enScatterAlgorithmVector1>
<enScatterAlgorithmVector2 :len="vectorLen()" :if="hasEnScatterFactor2()" cn="加密分散算法的初始向量2">
仅当分散级数不为0时存在,同上
</enScatterAlgorithmVector2>
<enScatterAlgorithmVector3 :len="vectorLen()" :if="hasEnScatterFactor3()" cn="加密分散算法的初始向量3">
仅当分散级数不为0时存在,同上
</enScatterAlgorithmVector3>
<inputDataLen len="4" :value="inputDataLen()" cn="输入数据长度">
待加密机主密钥解密的数据长度
</inputDataLen>
<inputData cn="输入数据">
待加密机主密钥解密的数据
</inputData>
</data>
</req>
<res>
<command>
<hex>SH</hex>
</command>
<data>
<error len="2" cn="错误代码" format="X" :catch="catchError('%s')">
<options>
<option cn="成功">
<hex>00</hex>
</option>
</options>
</error>
<infoLen len="4" cn="密钥密文长度">
离散密钥加密的数据密文长度
</infoLen>
<info :len="getInfoLen()" cn="密钥密文">
离散密钥加密的数据密文
</info>
</data>
</res>
<script>
function useCbc(){
var algorithmKey = $packet.data.algorithmKey
if( 6==algorithmKey || 8==algorithmKey || 2==algorithmKey || 4==algorithmKey || 10==algorithmKey ){
return true;
}else{
return false;
}
}
function ivLen() {
var algorithmKey = $packet.data.algorithmKey
if(8==algorithmKey ){
return 8;
}
if( 2==algorithmKey || 4==algorithmKey || 10==algorithmKey){
return 16;
}
}
function hasEnScatterFactor1(){
var enKeyScatterLevel = $packet.data.enKeyScatterLevel
if( 1 &lt;= enKeyScatterLevel ){
return true;
}else{
return false;
}
}
function hasEnScatterFactor2(){
var enKeyScatterLevel = $packet.data.enKeyScatterLevel
if( 2 &lt;= enKeyScatterLevel ){
return true;
}else{
return false;
}
}
function hasEnScatterFactor3(){
var enKeyScatterLevel = $packet.data.enKeyScatterLevel
if( 3 == enKeyScatterLevel){
return true;
}else{
return false;
}
}
function vectorLen(){
var algorithmKey = $packet.data.algorithmKey
if(5==algorithmKey || 6==algorithmKey || 7==algorithmKey || 8==algorithmKey ){
return 8;
}
if( 1==algorithmKey || 2==algorithmKey || 3==algorithmKey || 4==algorithmKey || 9==algorithmKey || 10==algorithmKey){
return 16;
}
}
function inputDataLen(){
var data = $packet.data;
return data.inputData.length;
}
function getInfoLen(){
return Util.a2i( $final.getSection('data').getSection('infoLen') )
}
</script>
</packet>
+1 -1
View File
@@ -13,7 +13,7 @@ import java.io.InputStream;
* Created by Cheney on 2017/11/11. * Created by Cheney on 2017/11/11.
* 程序调用接口 * 程序调用接口
*/ */
public interface SydApi extends SydRawApi, SydCertApi, SydCryptionApi, SydGenApi, SydSVApi, SydHAApi, SydQNUCApi, SydPledge, SydPINOpt, SydManufactureApi { public interface SydApi extends SydRawApi, SydCertApi, SydCryptionApi, SydGenApi, SydSVApi, SydHAApi, SydQNUCApi, SydPledge, SydPINOpt, SydManufactureApi, SydZYOption {
byte ALG_AES = 0x30; byte ALG_AES = 0x30;
byte ALG_SM4 = 0x31; byte ALG_SM4 = 0x31;
@@ -0,0 +1,144 @@
package com.sunyard.entity;
import com.sunyard.util.MyUtil;
import java.nio.ByteBuffer;
import java.util.List;
/**
* @Auther: wp
* @Date: 2021/6/1 20:11
* @Description:
*/
//导出密钥分散结构体
public class Struct {
String ucKeyIdex; //导出密钥索引
int iKeyDivNum; //导出密钥分散级数
List<byte[]> ucKeyDivData; //导出密钥分散数据
int[] iKeyDivAlg; //导出密钥分散算法
List<byte[]> ucKeyDivIv; //导出密钥IV
int iCheckValueType; //导出密钥校验值生成类型
public int getiCheckValueType() {
return iCheckValueType;
}
public void setiCheckValueType(int iCheckValueType) {
this.iCheckValueType = iCheckValueType;
}
public Struct() {
}
public Struct(String ucKeyIdex, int iKeyDivNum, List<byte[]> ucKeyDivData, int[] iKeyDivAlg, List<byte[]> ucKeyDivIv, int iCheckValueType) {
this.setUcKeyIdex(ucKeyIdex);
this.iKeyDivNum = iKeyDivNum;
this.setUcKeyDivData(ucKeyDivData);
this.iKeyDivAlg = iKeyDivAlg;
this.setUcKeyDivIv(ucKeyDivIv);
this.iCheckValueType=iCheckValueType;
}
public String getUcKeyIdex() {
return ucKeyIdex;
}
public void setUcKeyIdex(String ucKeyIdex) {
String gId = "00000000" + ucKeyIdex;
gId = gId.substring(gId.length() - 8);
ucKeyIdex="0000000000000000000"+gId;
// byte[] b= new byte[27];
// System.arraycopy(ucKeyIdex,0,b,0,ucKeyIdex.length);
this.ucKeyIdex = ucKeyIdex;
}
public int getiKeyDivNum() {
return iKeyDivNum;
}
public void setiKeyDivNum(int iKeyDivNum) {
this.iKeyDivNum = iKeyDivNum;
}
public List<byte[]> getUcKeyDivData() {
return ucKeyDivData;
}
public void setUcKeyDivData(List<byte[]> ucKeyDivData) {
// byte[] b= new byte[48];
// System.arraycopy(ucKeyDivData,0,b,0,ucKeyDivData.length);
this.ucKeyDivData = ucKeyDivData;
}
public List<byte[]> getUcKeyDivIv() {
return ucKeyDivIv;
}
public void setUcKeyDivIv(List<byte[]> ucKeyDivIv) {
this.ucKeyDivIv = ucKeyDivIv;
}
public int[] getiKeyDivAlg() {
return iKeyDivAlg;
}
public void setiKeyDivAlg(int[] iKeyDivAlg) {
this.iKeyDivAlg = iKeyDivAlg;
}
public byte[] getByte() {
ByteBuffer byteBuffer = ByteBuffer.allocate(144);
//导出密钥索引
byteBuffer.put(ucKeyIdex.getBytes());
byteBuffer.put((byte) 0x0);
//分散级数,补充到4字节
byte[] bytes = MyUtil.int2ReverseByteArray(iKeyDivNum);
byte[] b1= new byte[4];
System.arraycopy(bytes,0,b1,0,bytes.length);
byteBuffer.put(b1);
//导出密钥分散数据
byte[] byteData= new byte[48];
int destPos=0;
for (byte[] b:ucKeyDivData ){
System.arraycopy(b,0,byteData,destPos,b.length);
destPos+=b.length;
}
byteBuffer.put(byteData);
//填充分散算法,每一个补充到4字节
for (int i = 0; i < 3; i++) {
byte[] bytes1;
if(i<iKeyDivAlg.length){
bytes1 = MyUtil.int2ReverseByteArray(MyUtil.transAlg(iKeyDivAlg[i]));
}else{
bytes1=new byte[4];
}
byte[] b2= new byte[4];
System.arraycopy(bytes1,0,b2,0,bytes1.length);
byteBuffer.put(b2);
}
//导出密钥IV
byte[] byteIv= new byte[48];
int destIvPos=0;
for (byte[] b:ucKeyDivIv ){
System.arraycopy(b,0,byteIv,destIvPos,b.length);
destPos+=b.length;
}
byteBuffer.put(byteIv);
//密钥校验值生成类型,补充到4字节
byte[] bytes1 = MyUtil.int2ReverseByteArray(iCheckValueType);
byte[] b2= new byte[4];
System.arraycopy(bytes1,0,b2,0,bytes1.length);
byteBuffer.put(b2);
return MyUtil.bytebuffer2ByteArray(byteBuffer);
}
}
@@ -371,6 +371,6 @@ interface SydSYMApi {
public String SYMDecrytByKeyIndex(String key,String intPutData); public String SYMDecrytByKeyIndex(String key,String intPutData);
//通过索引读取对称秘钥 //通过索引读取对称秘钥
String readKey(String index); RetWrap readKey(String index);
} }
@@ -0,0 +1,258 @@
package com.sunyard.inf;
import com.sunyard.RetWrap;
import com.sunyard.entity.Struct;
import java.util.List;
/**
* @Auther: wp
* @Date: 2021/6/1 19:59
* @Description: 中移电子指令接口
*/
public interface SydZYOption {
/**
* @param storageType 存储类型 0-使用内部密钥,1-使用外部密钥
* @param key 使用内部密钥时,该值传后八位密钥索引;使用外部密钥时,该值为外部密钥
* @param algFlag 算法类型支持算法:3DES、AES、SM1、SM4
* @param iv IV 数据域,当算法标识为3DES-CBC、DES-CBC 时,该域为8B。
* 当算法标识为AES-CBC、SM1-CBC、SM4-CBC 时,该域为16B。
* @param divNum 密钥分散级数 ,0~3
* @param divData 分散因子
* @param divAlgFlag 分散算法标识
* @param divIv 分散算法的初始向量
* @param inputData 输入数据
* @return byte[] 数据
* @author wp
* @Description:(A0)对称加密接口
* @date 2021/5/31
*/
byte[] SYMEncryt(int storageType, String key, int algFlag, byte[] iv, int divNum, List<byte[]> divData, int[] divAlgFlag, List<byte[]> divIv, byte[] inputData);
/**
* @param storageType 存储类型 0-使用内部密钥,1-使用外部密钥
* @param key 使用内部密钥时,该值传后八位密钥索引;使用外部密钥时,该值为外部密钥
* @param algFlag 算法类型支持算法:3DES、AES、SM1、SM4
* @param iv IV 数据域,当算法标识为3DES-CBC、DES-CBC 时,该域为8B。
* 当算法标识为AES-CBC、SM1-CBC、SM4-CBC 时,该域为16B。
* @param divNum 密钥分散级数 ,0~3
* @param divData 分散因子
* @param divAlgFlag 分散算法标识
* @param divIv 分散算法的初始向量
* @param inputData 输入数据
* @return byte[] 数据
* @author wp
* @Description:(A1)对称解密接口
* @date 2021/5/31
*/
byte[] SYMDecryt(int storageType, String key, int algFlag, byte[] iv, int divNum, List<byte[]> divData, int[] divAlgFlag, List<byte[]> divIv, byte[] inputData);
/**
* @param storageType 存储类型 0-使用内部密钥,1-使用外部密钥
* @param key 使用内部密钥时,该值传后八位密钥索引;使用外部密钥时,该值为外部密钥
* @param algFlag 当存储类型为0时:仅支持3DES-ECB(07)、3DES-CBC(08)
* 当存储类型为1时:仅支持3DES-ECB、3DES-CBC、HMAC-SHA256(14)
* @param iv 仅当算法为3DES-CBC模式下有此域
* @param divNum 密钥分散级数 ,0~3
* @param divData 分散因子
* @param divAlgFlag 分散算法标识
* @param divIv 分散算法的初始向量
* @param inputData 输入数据
* @param macDataLen 需要的MAC数据长度
* @return byte[] 输出的MAC数据
* @author wp
* @Description:(A2)产生MAC接口
* @date 2021/5/31
*/
byte[] genMAC(int storageType, String key, int algFlag, byte[] iv, int divNum, List<byte[]> divData, int[] divAlgFlag, List<byte[]> divIv, byte[] inputData, int macDataLen);
/**
* @param keyIndex 密钥索引
* @param iv 仅当算法为3DES-CBC模式下有此域
* @param divNum 密钥分散级数 ,0~3
* @param divData 分散因子
* @param divAlgFlag 分散算法标识
* @param divIv 分散算法的初始向量
* @param inputData 输入数据
* @return byte[] 输出的MacAndNextIv数据16字节,前8字节为MAC,后8字节为下一次IV
* @author wp
* @Description: (A3)尾端3DES-CBC算法计算MAC及下一次IV(内部密钥
* @date 2021/5/31
*/
byte[] genMacAndNextIv(String keyIndex, byte[] iv, int divNum, List<byte[]> divData, int[] divAlgFlag, List<byte[]> divIv, byte[] inputData);
/**
* @param storageType 存储类型,0-存储在内部 1-存储在外部
* @param algFlag 算法类型:仅支持RSA、SM2
* @param keyLength 密钥长度:RSA密钥长度:1024、2048 SM2密钥长度:256
* @param keyIndex 密钥索引
* @return com.sunyard.RetWrap publicKey:公钥, privateKey-私钥
* @author wp
* @Description: (A4)生成非对称密钥
* @date 2021/5/31
*/
RetWrap genSYMkey(int storageType, int algFlag, int keyLength, String keyIndex);
/**
* @param storageType 存储类型 0-使用内部密钥,1-使用外部密钥
* @param algFlag 算法类型:仅支持RSA、SM2
* @param key 使用内部密钥时,该值传后八位密钥索引;使用外部密钥时,该值为签名私钥
* @param inputData 数据
* @return byte[] 签名数据
* @author wp
* @Description: (A5)签名接口
* @date 2021/5/31
*/
byte[] signData(int storageType, int algFlag, String key, byte[] inputData);
/**
* @param storageType 存储类型 0-使用内部密钥,1-使用外部密钥
* @param algFlag 算法类型:仅支持RSA、SM2
* @param key 使用内部密钥时,该值传后八位密钥索引;使用外部密钥时,该值为验签公钥
* @param orgData 原数据
* @param signData 签名数据
* @return java.lang.Boolean
* @author wp
* @Description: (A6)验签接口——(自定义)
* @date 2021/5/31
*/
Boolean verifySignData(int storageType, int algFlag, String key, byte[] orgData, byte[] signData);
/**
* @param storageType 存储类型 0-使用内部密钥,1-使用外部密钥
* @param algFlag 算法类型:仅支持RSA、SM2
* @param key 使用内部密钥时,该值传后八位密钥索引;使用外部密钥时,该值为公钥
* @param inputData 明文
* @return byte[] 密文
* @author wp
* @Description: (A7)非对称加密接口——(自定义)
* @date 2021/5/31
*/
byte[] ASYMEnData(int storageType, int algFlag, String key, byte[] inputData);
/**
* @param storageType 存储类型 0-使用内部密钥,1-使用外部密钥
* @param algFlag 算法类型:仅支持RSA、SM2
* @param key 使用内部密钥时,该值传后八位密钥索引;使用外部密钥时,该值为私钥
* @param cipherText 密文
* @return byte[] 明文
* @author wp
* @Description: (A8)非对称解密接口
* @date 2021/5/31
*/
byte[] ASYMDeData(int storageType, int algFlag, String key, byte[] cipherText);
/**
* @author wp
* @Description:
* @date 2021/6/1
* @param protectedKeyIndex 保护密钥的索引
* @param algFlag 保护密钥算法
* @param iv IV 数据域
* @param protectedKeyDivNum 保护密钥分散级数
* @param protectedKeyDivData 分散因子
* @param protectedKeyDivAlgFlag 分散算法标识
* @param protectedKeyDivIv 分散算法的初始向量
* @param exportKeyNum 导出的密钥索引个数
* @param structList 导出的密钥结构体集合
* @return com.sunyard.RetWrap
*/
RetWrap exportKeyAndCalc(String protectedKeyIndex, int algFlag, byte[] iv, int protectedKeyDivNum, List<byte[]> protectedKeyDivData, int[] protectedKeyDivAlgFlag, List<byte[]> protectedKeyDivIv, int exportKeyNum, List<? extends Struct> structList);
/**
* @param keyIndex 密钥索引
* @param divNum 密钥分散级数 ,0~3
* @param divData 分散因子
* @param divAlgFlag 分散算法标识
* @param divIv 分散算法的初始向量
* @param clientRandom 客户端随机数
* @param serverRandom 服务端随机数
* @return byte[] 会话密钥
* @author wp
* @Description: (B1)HTTPS密钥协商
* @date 2021/5/31
*/
byte[] consultKey(String keyIndex, int divNum, List<byte[]> divData, int[] divAlgFlag, List<byte[]> divIv,
byte[] clientRandom, byte[] serverRandom);
/**
* @param key 外部密钥
* @param seed 种子
* @param outLen 输出数据长度
* @return byte[] pHash
* @author wp
* @Description:(B2)HTTPS PHash算法(外部密钥)
* @date 2021/5/31
*/
byte[] pHash(String key, String seed, int outLen);
/**
* @param decryptKeyIndex 存储类型 0-使用内部密钥,1-使用外部密钥
* @param decryptAlgFlag 解密算法类型
* @param decryptIv 解密初始向量
* @param decryptKeyDivNum 解密密钥分散级数
* @param decryptKeyDivData 解密分散因子
* @param decryptKeyDivAlgFlag 解密分散算法标识
* @param decryptKeyDivIv 解密分散算法的初始向量
* @param encryptKeyIndex 加密密钥索引
* @param encryptAlgFlag 加密密钥算法
* @param encryptIv 加密密钥IV
* @param encryptKeyDivNum 加密密钥分散级数
* @param encryptKeyDivData 加密分散因子
* @param encryptKeyDivAlgFlag 加密分散算法标识
* @param encryptKeyDivIv 加密分散算法的初始向量
* @param inputData 输入数据
* @return byte[] 加密后的数据
* @author wp
* @Description: (B3)内部密钥1解密并使用内部密钥2加密
* @date 2021/6/1
*/
byte[] decrytAndEn(String decryptKeyIndex, int decryptAlgFlag, byte[] decryptIv, int decryptKeyDivNum, List<byte[]> decryptKeyDivData, int[] decryptKeyDivAlgFlag, List<byte[]> decryptKeyDivIv,
String encryptKeyIndex, int encryptAlgFlag, byte[] encryptIv, int encryptKeyDivNum, List<byte[]> encryptKeyDivData, int[] encryptKeyDivAlgFlag, List<byte[]> encryptKeyDivIv,
byte[] inputData);
/**
* @param storageType 存储类型 0-使用内部密钥 1-使用外部密钥
* @param key 使用内部密钥时为解密私钥索引,使用外部密钥时为解密私钥
* @param decryptAlgFlag 解密算法类型
* @param inputData 待转加密的数据
* @param prefixIgnoreCount 使用解密后、加密前,需要对数据的前指定直接做截断(接口不做处理,提供给客户需要)
* @param suffixIgnoreCount 使用解密后、加密前,需要对数据的后指定直接做截断(接口不做处理,提供给客户需要)
* @return byte[] 使用加密机主密钥加密的对称密钥
* @author wp
* @Description:(B4)非对称密钥解密并输出主密钥加密对称密钥密文
* @date 2021/6/1
*/
byte[] ASYMDecryptAndEn(int storageType, String key, int decryptAlgFlag, byte[] inputData, int prefixIgnoreCount, int suffixIgnoreCount);
/**
* @param decryptKey 解密密钥
* @param decryptAlgFlag 解密算法类型
* @param decryptIv IV 数据域
* @param inputData 待转加密的数据
* @return byte[] 密码机主密钥加密的密钥密文
* @author wp
* @Description: (B5)外部对称密钥解密并输出主密钥加密对称密钥密文
* @date 2021/6/1
*/
byte[] SYMDecryptAndEn(String decryptKey, int decryptAlgFlag, byte[] decryptIv, byte[] inputData);
/**
* @param encryptKeyIndex enKeyIndex
* @param encryptAlgFlag 加密算法类型
* @param encryptIv 加密算法IV
* @param encryptKeyDivNum 加密密钥分散级数
* @param encryptKeyDivData 加密分散因子
* @param encryptKeyDivAlgFlag 加密分散算法标识
* @param encryptKeyDivIv 加密分散算法的初始向量
* @param inputData 待加密机主密钥解密的数据
* @return byte[] 离散密钥加密的数据密文
* @author wp
* @Description:(B6)主密钥解密并输出内部密钥加密的对称密钥密文
* @date 2021/6/1
*/
byte[] decryptByMainAndSYMEn(String encryptKeyIndex, int encryptAlgFlag, byte[] encryptIv, int encryptKeyDivNum,
List<byte[]> encryptKeyDivData, int[] encryptKeyDivAlgFlag, List<byte[]> encryptKeyDivIv, byte[] inputData);
}
+115
View File
@@ -0,0 +1,115 @@
package com.sunyard.util;
import com.sunyard.proto.Util;
import java.nio.ByteBuffer;
/**
* @Auther: wp
* @Date: 2021/6/1 17:02
* @Description:
*/
public class MyUtil {
/**
* byteBuffer 转 byte数组
*
* @param buffer
* @return
*/
public static byte[] bytebuffer2ByteArray(ByteBuffer buffer) {
//重置 limit 和postion 值
buffer.flip();
//获取buffer中有效大小
int len = buffer.limit() - buffer.position();
byte[] bytes = new byte[len];
for (int i = 0; i < bytes.length; i++) {
bytes[i] = buffer.get();
}
return bytes;
}
/**
* @param num
* @return byte[]
* @author wp
* @Description: 将int 专成指定格式的hex,"0*000000" 返回byte[]
* @date 2021/6/1
*/
public static byte[] int2ReverseByteArray(int num) {
// StringBuffer stringBuffer = new StringBuffer();
// while (num != 0) {
// int a = num % 10;
// stringBuffer.append(a);
// num /= 10;
// }
//
// return (stringBuffer.toString()).getBytes();
String gId = "00" + num;
gId = gId.substring(gId.length() - 2) + "0000";
return Util.hexString2Bytes(gId);
}
/**
* @param alg
* @return int
* @author wp
* @Description: 算法标识映射
* @date 2021/6/7
*/
public static int transAlg(int alg) {
int res;
switch (alg) {
case 11: //SM1-ECB
res = 1;
break;
case 12: //SM1-CBC
res = 2;
break;
case 21: //SM4-ECB
res = 3;
break;
case 22: //SM4-CBC
res = 4;
break;
case 31: //DES-ECB
res = 5;
break;
case 32: //DES-CBC
res = 6;
break;
case 41: //3DES-ECB
res = 7;
break;
case 42: //3DES-CBC
res = 8;
break;
case 51: //AES-ECB
res = 9;
break;
case 52: //AES-CBC
res = 10;
break;
case 101: //RSA
res = 11;
break;
case 102: //SM2
res = 12;
break;
case 111: //HMAC-SHA1
res = 13;
break;
case 112: //HMAC-SHA256
res = 14;
break;
default:
res = 0;
}
return res;
}
}
File diff suppressed because it is too large Load Diff
@@ -375,12 +375,10 @@ public enum TypeOptions {
soup.put("type$option", getTypeOptionIndex()); soup.put("type$option", getTypeOptionIndex());
} }
soup.put("full", Util.hexString2Bytes("30"));
if( null != full ){ if( null != full ){
soup.put("full", this.full); soup.put("full", this.full);
} }
soup.put("macLen", Util.hexString2Bytes("31"));
if( null != macLen ){ if( null != macLen ){
soup.put("macLen", this.macLen); soup.put("macLen", this.macLen);
} }
@@ -421,12 +419,10 @@ public enum TypeOptions {
this.type = ((PacketSection) soup.get("type")).getBytes(); this.type = ((PacketSection) soup.get("type")).getBytes();
} }
this.full = Util.hexString2Bytes("30");
if( soup.containsKey("full") ){ if( soup.containsKey("full") ){
this.full = ((PacketSection) soup.get("full")).getBytes(); this.full = ((PacketSection) soup.get("full")).getBytes();
} }
this.macLen = Util.hexString2Bytes("31");
if( soup.containsKey("macLen") ){ if( soup.containsKey("macLen") ){
this.macLen = ((PacketSection) soup.get("macLen")).getBytes(); this.macLen = ((PacketSection) soup.get("macLen")).getBytes();
} }
@@ -403,12 +403,10 @@ public enum TypeOptions {
soup.put("type$option", getTypeOptionIndex()); soup.put("type$option", getTypeOptionIndex());
} }
soup.put("full", Util.hexString2Bytes("30"));
if( null != full ){ if( null != full ){
soup.put("full", this.full); soup.put("full", this.full);
} }
soup.put("macLen", Util.hexString2Bytes("31"));
if( null != macLen ){ if( null != macLen ){
soup.put("macLen", this.macLen); soup.put("macLen", this.macLen);
} }
@@ -453,12 +451,10 @@ public enum TypeOptions {
this.type = ((PacketSection) soup.get("type")).getBytes(); this.type = ((PacketSection) soup.get("type")).getBytes();
} }
this.full = Util.hexString2Bytes("30");
if( soup.containsKey("full") ){ if( soup.containsKey("full") ){
this.full = ((PacketSection) soup.get("full")).getBytes(); this.full = ((PacketSection) soup.get("full")).getBytes();
} }
this.macLen = Util.hexString2Bytes("31");
if( soup.containsKey("macLen") ){ if( soup.containsKey("macLen") ){
this.macLen = ((PacketSection) soup.get("macLen")).getBytes(); this.macLen = ((PacketSection) soup.get("macLen")).getBytes();
} }
@@ -0,0 +1,577 @@
package com.sunyard.sydapi.test;
import com.sunyard.RetWrap;
import com.sunyard.entity.Struct;
import com.sunyard.proto.Util;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import racal.sunyard.main.SydApi4j;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class TestZY {
SydApi4j api;
String keyTye = "000";
String key1 = "1234567812345678";
String key2 = "X12345678123456781234567812345678";
String key6 = "U00000000000000000000000000000000";
String key3 = "Y123456781234567812345678123456781234567812345678";
String key4 = "X87654321876543218765432187654321";
String key5 = "1234567812345678";
String key7 = "12345678123456781234567812345678";
@Before
public void before() {
System.setProperty("com.sunyard.sydapi4j.debug", "true");
// api = (SydApi4j) new SydApi4j().connect("172.16.17.162", 8889, null, 1000);
// api = (SydApi4j) new SydApi4j().connect("47.118.63.165", 46889, null, 15000);
api = (SydApi4j) new SydApi4j().connect("192.168.0.99", 8889, null, 3000);
// api = (SydApi4j) new SydApi4j().connect("47.111.95.168", 43889, null,100000);
}
@After
public void after() {
try {
this.api.disconnect();
} catch (Exception e) {
e.printStackTrace();
}
}
//pass
@Test
public void testS0(){
ArrayList<byte[]> list1 = new ArrayList();
list1.add(Util.hexString2Bytes("65706917038051804927766430009625"));
list1.add(Util.hexString2Bytes("13000002031301110002031301110097"));
list1.add(Util.hexString2Bytes("01820001000000000000000000000000"));
// System.out.println(Util.hexString2Bytes("0000000000000000").length);
int[] i={41,41,42};
ArrayList<byte[]> list2 = new ArrayList();
list2.add(Util.hexString2Bytes("0000000000000000"));
list2.add(Util.hexString2Bytes("0000000000000000"));
list2.add(Util.hexString2Bytes("0000000000000000"));
// System.out.println(Util.hexString2Bytes("0000000000000000").length);
byte[] data=new byte[4*1024];
byte[] encrytData = api.SYMEncryt(1, "E198DB62C5D9753EF3D82E8056B3F72A", 42, Util.hexString2Bytes("0000000000000000"), 3, list1, i, list2, data);
System.out.println(Util.bytes2HexString(encrytData));
}
@Test
public void testS0_1(){
ArrayList<byte[]> list1 = new ArrayList();
list1.add(Util.hexString2Bytes("65706917038051804927766430009625"));
list1.add(Util.hexString2Bytes("13000002031301110002031301110097"));
list1.add(Util.hexString2Bytes("01820001000000000000000000000000"));
// System.out.println(Util.hexString2Bytes("0000000000000000").length);
int[] i={41,41,42};
ArrayList<byte[]> list2 = new ArrayList();
list2.add(Util.hexString2Bytes("0000000000000000"));
list2.add(Util.hexString2Bytes("0000000000000000"));
list2.add(Util.hexString2Bytes("0000000000000000"));
// System.out.println(Util.hexString2Bytes("0000000000000000").length);
byte[] data=Util.hexString2Bytes("0123456789ABCDEF8000000000000000");
byte[] encrytData = api.SYMEncryt(0, "1", 42, Util.hexString2Bytes("0000000000000000"), 3, list1, i, list2, data);
System.out.println(Util.bytes2HexString(encrytData));
}
//009300000000000000065330
//30
//303030303030303030303030303030303030303030303030303135
//3038
//0000000000000000
//33
//65706917038051804927766430009625
//13000002031301110002031301110097
//01820001000000000000000000000000
//303730373038
//0000000000000000
//0000000000000000
//0000000000000000
//30303136
//0123456789ABCDEF8000000000000000
//pass
@Test
public void testS1(){
ArrayList<byte[]> list1 = new ArrayList();
list1.add(Util.hexString2Bytes("65706917038051804927766430009625"));
list1.add(Util.hexString2Bytes("13000002031301110002031301110097"));
list1.add(Util.hexString2Bytes("01820001000000000000000000000000"));
// System.out.println(Util.hexString2Bytes("0000000000000000").length);
int[] i={41,41,42};
ArrayList<byte[]> list2 = new ArrayList();
list2.add(Util.hexString2Bytes("0000000000000000"));
list2.add(Util.hexString2Bytes("0000000000000000"));
list2.add(Util.hexString2Bytes("0000000000000000"));
// System.out.println(Util.hexString2Bytes("0000000000000000").length);
byte[] data=new byte[4*1024];
byte[] encrytData = api.SYMEncryt(1, "E198DB62C5D9753EF3D82E8056B3F72A", 42, Util.hexString2Bytes("0000000000000000"), 3, list1, i, list2, data);
byte[] decrytData = api.SYMDecryt(1, "E198DB62C5D9753EF3D82E8056B3F72A", 42, Util.hexString2Bytes("0000000000000000"), 3, list1, i, list2, encrytData);
System.out.println(decrytData.length);
System.out.println(Util.bytes2HexString(decrytData));
}
//pass
@Test
public void testS2(){
ArrayList<byte[]> list1 = new ArrayList();
list1.add(Util.hexString2Bytes("65706917038051804927766430009625"));
list1.add(Util.hexString2Bytes("13000002031301110002031301110097"));
list1.add(Util.hexString2Bytes("01820001000000000000000000000000"));
// System.out.println(Util.hexString2Bytes("0000000000000000").length);
int[] i={41,41,41};
ArrayList<byte[]> list2 = new ArrayList();
list2.add(Util.hexString2Bytes("0000000000000001"));
list2.add(Util.hexString2Bytes("0000000000000001"));
list2.add(Util.hexString2Bytes("0000000000000001"));
// System.out.println(Util.hexString2Bytes("0000000000000000").length);
byte[] data=new byte[4*1024];
byte[] mac = api.genMAC(1, "303030303030303030303030303030303030303030303030303031", 42, Util.hexString2Bytes("0000000000000001"), 3, list1, i, list2, data,8);
System.out.println(mac.length);
System.out.println(Util.bytes2HexString(mac));
}
//pass
@Test
public void testS3(){
ArrayList<byte[]> list1 = new ArrayList();
// list1.add(Util.hexString2Bytes("65706917038051804927766430009625"));
// list1.add(Util.hexString2Bytes("13000002031301110002031301110097"));
// list1.add(Util.hexString2Bytes("01820001000000000000000000000000"));
list1.add(Util.hexString2Bytes("53136418693065943411485091615091"));
list1.add(Util.hexString2Bytes("13000002031301110002031301110095"));
list1.add(Util.hexString2Bytes("01010001000000000000000000000000"));
// System.out.println(Util.hexString2Bytes("0000000000000000").length);
int[] i={41,41,42};
ArrayList<byte[]> list2 = new ArrayList();
list2.add(Util.hexString2Bytes("0000000000000000"));
list2.add(Util.hexString2Bytes("0000000000000000"));
list2.add(Util.hexString2Bytes("0000000000000000"));
// System.out.println(Util.hexString2Bytes("0000000000000000").length);
// byte[] data=new byte[4*1024];
byte[] data=Util.hexString2Bytes("0123456789ABCDEF8000000000000000");
byte[] macAndNextIv = api.genMacAndNextIv("1", Util.hexString2Bytes("0000000000000000"), 3, list1, i, list2, data);
System.out.println(macAndNextIv.length);
System.out.println(Util.bytes2HexString(macAndNextIv));
}
//009200000000000000005333
//303030303030303030303030303030303030303030303030303135
//3038
//0000000000000000
//33
//53136418693065943411485091615091
//13000002031301110002031301110095
//01010001000000000000000000000000
//303730373038
//0000000000000000
//0000000000000000
//0000000000000000
//30303136
//0123456789ABCDEF8000000000000000
//009200000000000000005333
//303030303030303030303030303030303030303030303030303031
//3038
//0000000000000000
//33
//53136418693065943411485091615091
//13000002031301110002031301110095
//01010001000000000000000000000000
//303730373038
//0000000000000000
//0000000000000000
//0000000000000000
//30303136
//0123456789ABCDEF8000000000000000
//pass
@Test
public void testS4(){
RetWrap retWrap = api.genSYMkey(0,102, 256, "12");
System.out.println(Util.bytes2HexString((byte[]) retWrap.get("publicKey")));
//000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E7C7FFA2613093243052A11E5EF33A9B52AD9601D2E9FD6DFEA2FFF957C3A3FFCE1CECDFAD44F0EBB6C253EEC4785AFFFB73CE7501D5DE183F1A74330AECA3A76DC9B78CD10ED1EB9C781DF483368F03A5813AB4C5C96B6E2C8D876A677094E6F2ECD695C173458907291A5AB59878089512A8EB9023F9E64E045D7C14F755A300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001
System.out.println(Util.bytes2HexString((byte[]) retWrap.get("privateKey")));
//00040000EA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736C3957DCE9A0F8AB800C0445F6F5F8BD97D9D761B9DBD5569BC68011D48C1138E9EE59D9A847428A44857BB02130D4610C4279B686B4D84878FDE8A1BE6DCA4D10975F8C172ADAFD5ED9A2E7854A458645DE3788872504A18FD0C1B0B307DAA112F4169EFA9C7110E59F22501397088144DF3796A4D326D626D83332AE6462E262EA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CD044C8CFF017DB7DEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CED2FC7E8C43401FAE99976774A2CA64DB4626F2AC33D6B721A0B78B4A46B516537BAD6A40C7EFF9593939CA536DF1DB8F7A0FAFA5943E189E5A9D565A1912D66CC2421287A6AA448191946BA6FB6D2143BBFFA19A4D8A4C82B2BC24D0A4F84EADEFD8CDF3377C99D9766698FE8ADF2C2DFFF1A13E8551C7C07CFB0339FB6EEC5EA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736C53B4DAF62632459A22CFBD829DD3E430ADEA1F2D958257805FFABCF70FE3807B76D48CA7923E361BE9CA56CA75F4C2A3F5C408AA6EA533DC90DFB4A92ABF44E8EA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736C2F246AEA61195F77713FE63245192CCD1AAB1A1F58CF212D1FB205F51E8F71EC89CBEE6470931674EF07881D924F16FC5EF6331A647C4509A1064656432F7FB6EA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CB3053D92AE7BA11A0DD5E2FA6D41743BDA331EB51E8624828F92E0A1FC3C9736A8A1718962080A8180EB88A9934E36B9EA392AAB16B7CD199A9F1DB88A0EBAA5EA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736C5136AE91766346BC8D0747C22A91DA29FB892C0733E7B9B578F5BCC2233013FDDAE60AAF2601322171ABCDAA2C146D61876913E24B9A44E82AE4DD280BA0F5EFEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CEA0171B8EF06736CAD1D91712D1D1FD54A40191428DE88E779FA673199397A8EE934B7A9114949E91221E929B8C8E41E1BC22795FE484DF74FD043518763D354062CDEDAB1B00C18
}
//pass
@Test
public void testS4_1(){
RetWrap retWrap = api.genSYMkey(1,101, 1024, "999999999999999999999999999");
System.out.println(Util.bytes2HexString((byte[]) retWrap.get("publicKey")));
// 00010000FCDB2CC48D4558AA3F94B09755717EB97688BAE052A8328CA3B7B0AA8F9C1AF0000000000000000000000000000000000000000000000000000000000000000009A7A29EE5BACAB3A56501139810B26473174771FC85037D3E22A9E89FE3974C0000000000000000000000000000000000000000000000000000000000000000
System.out.println(Util.bytes2HexString((byte[]) retWrap.get("privateKey")));
// 00010000E7C3EE38F300714D6DFE624B53DB3DB8D815464C974DB7AD58028445E1B86BA40000000000000000000000000000000000000000000000000000000000000000
}
//pass
@Test
public void testS5(){
byte[] data=new byte[4*1024];
byte[] bytes = api.signData(0, 102, "12", data);
System.out.println(Util.bytes2HexString(bytes));
//40000000116CAD79D94C067A995153EA396F073D13D832A32FB5EF11CF781ADB866D76E400000000000000000000000000000000000000000000000000000000000000007C79863307047B6BCA826AB3BC00EC3D8E768BFFEE8AE6E49C484123D5A0F2100000000000000000000000000000000000000000000000000000000000000000
}
//pass
@Test
public void testS6(){
byte[] data=new byte[4*1024];
byte[] bytes = api.signData(0, 102, "12", data);
Boolean aBoolean = api.verifySignData(0, 102, "12",data, bytes);
System.out.println(aBoolean);
//4000000039B267492C67F83627BD042BEAA50872A7DEB4E63130C9829FA39D627A65E581000000000000000000000000000000000000000000000000000000000000000078A982444C9848192F1FF680CFC6B453362C71DE33278F78E3FF8DF903BE6CA10000000000000000000000000000000000000000000000000000000000000000
}
//pass
@Test
public void testS6_1(){
String s="0100FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF003021300906052B0E03021A05000414E3A9A7A96D9AF6433A1D1E97CDF590B13BED0668";
byte[] data=Util.hexString2Bytes(s);
String pk="000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E7C7FFA2613093243052A11E5EF33A9B52AD9601D2E9FD6DFEA2FFF957C3A3FFCE1CECDFAD44F0EBB6C253EEC4785AFFFB73CE7501D5DE183F1A74330AECA3A76DC9B78CD10ED1EB9C781DF483368F03A5813AB4C5C96B6E2C8D876A677094E6F2ECD695C173458907291A5AB59878089512A8EB9023F9E64E045D7C14F755A300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001";
String sk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
String outKey="000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000A2C32395A7D4BE741EDDB411A59DCF1CFCC2B991F60C75D4DD7853A05F73408D4364819099036B033C7148A86C07B66A562A1E0D6D2506D227F443A7165E12754B638F5E9146F742834FEE4E3F6013FC2E41B9B35980EE1A12F1CADCEF22D2B6E3F9DFFE44ABBD2747D4C4F354D926C0E7612E8CD9CD125EC48336964B41F38B00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001";
// String signData="000400008000000059734D77FB5555CB3436BE9EE011A60E1E268DF619D96210E8AB91D1B30F3749A3F15B6E8F931DC27683CF6B46C8169177F0D51104E39BA0B892C59807A4CB29991C382A57D27612BDD19204A13EA6E39BE2F93EB2B02650547D6AD3C868AC3DBF4E51D4A1B8524BAA389BE8538D30EA74A3538B344A7464EC533B3770DF1E7C0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
byte[] bytes = api.signData(1, 101, sk, data);
System.out.println("签名结果signData="+Util.bytes2HexString(bytes));
Boolean aBoolean = api.verifySignData(1, 101, pk,data, bytes);
System.out.println(aBoolean);
//4000000039B267492C67F83627BD042BEAA50872A7DEB4E63130C9829FA39D627A65E581000000000000000000000000000000000000000000000000000000000000000078A982444C9848192F1FF680CFC6B453362C71DE33278F78E3FF8DF903BE6CA10000000000000000000000000000000000000000000000000000000000000000
}
//pass
@Test
public void testS7(){
byte[] data=new byte[4*1024];
byte[] bytes = api.ASYMEnData(0, 102, "1", data);
System.out.println(bytes.length);
System.out.println(Util.bytes2HexString(bytes));
}
//pass
@Test
public void testS8(){
byte[] data=new byte[4*1024];
byte[] bytes = api.ASYMEnData(0, 102, "12", data);
byte[] bytes1 = api.ASYMDeData(0, 102, "12", bytes);
System.out.println(Arrays.equals(bytes1, data));
}
@Test
public void testS8_1(){
// byte[] data=new byte[4*1024];
// byte[] bytes = api.ASYMEnData(0, 102, "12", data);
String key="00010000D2710E269E2CAED545E7642BE360DAB096979CE18BB506D22935AF35CA2E05040000000000000000000000000000000000000000000000000000000000000000";
byte[] bytes=Util.hexString2Bytes("308185022100F9FE33C22EE6C16F1E7B5FF60AA8EA41DD0F4D214B7E4A6071701B5ED3E07449022100CC65E72034ED373CAFBE4C0FFA44B49AAF1FC9D3A1E0E540FFE5E39C01881F1F04208166702645C47878E829584A82809C17A20CA495C0155C1A6964A600C48D81BB041B9EB8682E95BECF99C70BAC321AD31F8884F57661A2A5F3A4AAF8A8");
byte[] bytes1 = api.ASYMDeData(1, 102, key, bytes);
System.out.println(Util.bytes2HexString(bytes1));
// System.out.println(Arrays.equals(bytes1, data));
}
@Test
public void testASYMEnData(){
byte[] data=Util.hexString2Bytes("8765432187654321876543218765432187654321876543218765432187654321");
String key="000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000A2C32395A7D4BE741EDDB411A59DCF1CFCC2B991F60C75D4DD7853A05F73408D4364819099036B033C7148A86C07B66A562A1E0D6D2506D227F443A7165E12754B638F5E9146F742834FEE4E3F6013FC2E41B9B35980EE1A12F1CADCEF22D2B6E3F9DFFE44ABBD2747D4C4F354D926C0E7612E8CD9CD125EC48336964B41F38B00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010001";
byte[] bytes = api.ASYMEnData(1, 101,key, data);
// byte[] bytes1 = api.ASYMDeData(0, 102, "12", bytes);
System.out.println(Util.bytes2HexString(bytes));
// System.out.println(Arrays.equals(bytes1, data));
}
@Test
public void testS9(){
List<byte[]> protectedKeyDivData=new ArrayList<>();
protectedKeyDivData.add(Util.hexString2Bytes("31313131313131313131313131313131"));
protectedKeyDivData.add(Util.hexString2Bytes("32323232323232323232323232323232"));
protectedKeyDivData.add(Util.hexString2Bytes("33333333333333333333333333333333"));
List<Struct> structList=new ArrayList<>();
byte[] bytes = Util.hexString2Bytes("313131313131313131313131313131313232323232323232323232323232323233333333333333333333333333333333");
int[] i={41,41,41};
List<byte[]> protectedKeyDivIv=new ArrayList<>();
protectedKeyDivIv.add(Util.hexString2Bytes("00000000000000000000000000000000"));
protectedKeyDivIv.add(Util.hexString2Bytes("00000000000000000000000000000000"));
protectedKeyDivIv.add(Util.hexString2Bytes("00000000000000000000000000000000"));
Struct struct1=new Struct("1",3,protectedKeyDivData,i,protectedKeyDivIv,1);
Struct struct2=new Struct("2",3,protectedKeyDivData,i,protectedKeyDivIv,1);
structList.add(struct1);
structList.add(struct2);
RetWrap retWrap = api.exportKeyAndCalc("77777777",41, null, 0,protectedKeyDivData, new int[]{41,41,41},protectedKeyDivIv, 2, structList);
System.out.println(retWrap);
}
@Test
public void testS9_1(){
List<byte[]> protectedKeyDivData=new ArrayList<>();
protectedKeyDivData.add(Util.hexString2Bytes("31313131313131313131313131313131"));
protectedKeyDivData.add(Util.hexString2Bytes("32323232323232323232323232323232"));
protectedKeyDivData.add(Util.hexString2Bytes("33333333333333333333333333333333"));
List<Struct> structList=new ArrayList<>();
int[] i={41,41,42};
List<byte[]> divIv=new ArrayList<>();
divIv.add(Util.hexString2Bytes("00000000000000000000000000000000"));
divIv.add(Util.hexString2Bytes("00000000000000000000000000000000"));
divIv.add(Util.hexString2Bytes("00000000000000000000000000000000"));
List<byte[]> protectedKeyDivIv=new ArrayList<>();
protectedKeyDivIv.add(Util.hexString2Bytes("0000000000000000"));
protectedKeyDivIv.add(Util.hexString2Bytes("0000000000000000"));
protectedKeyDivIv.add(Util.hexString2Bytes("0000000000000000"));
Struct struct1=new Struct("1",3,protectedKeyDivData,i,divIv,3);
Struct struct2=new Struct("2",3,protectedKeyDivData,i,divIv,1);
Struct struct3=new Struct("3",3,protectedKeyDivData,i,divIv,3);
Struct struct4=new Struct("4",3,protectedKeyDivData,i,divIv,1);
Struct struct5=new Struct("5",3,protectedKeyDivData,i,divIv,1);
structList.add(struct1);
structList.add(struct2);
structList.add(struct3);
structList.add(struct4);
structList.add(struct5);
RetWrap retWrap = api.exportKeyAndCalc("77777777",52, Util.hexString2Bytes("00000000000000000000000000000000"), 3,protectedKeyDivData, i,protectedKeyDivIv, 5, structList);
System.out.println(retWrap);
}
@Test
public void testS9_2(){
List<byte[]> protectedKeyDivData=new ArrayList<>();
protectedKeyDivData.add(Util.hexString2Bytes("59243981728845760300152622870624"));
protectedKeyDivData.add(Util.hexString2Bytes("13000002031301110002031301110094"));
protectedKeyDivData.add(Util.hexString2Bytes("01810001000000000000000000000000"));
List<Struct> structList=new ArrayList<>();
byte[] bytes = Util.hexString2Bytes("313131313131313131313131313131313232323232323232323232323232323233333333333333333333333333333333");
int[] i={41,41};
List<byte[]> protectedKeyDivIv=new ArrayList<>();
protectedKeyDivIv.add(Util.hexString2Bytes("0000000000000000"));
protectedKeyDivIv.add(Util.hexString2Bytes("0000000000000000"));
protectedKeyDivIv.add(Util.hexString2Bytes("0000000000000000"));
List<byte[]> divData=new ArrayList<>();
divData.add(Util.hexString2Bytes("25637158699399449582953157027093"));
divData.add(Util.hexString2Bytes("13000002031301110002031301110094"));
List<byte[]> divIv=new ArrayList<>();
divIv.add(Util.hexString2Bytes("0000000000000000"));
divIv.add(Util.hexString2Bytes("0000000000000000"));
Struct struct1=new Struct("1",2,divData,i,divIv,1);
// Struct struct2=new Struct("2",3,protectedKeyDivData,i,protectedKeyDivIv,1);
structList.add(struct1);
// structList.add(struct2);
RetWrap retWrap = api.exportKeyAndCalc("77777777",42, Util.hexString2Bytes("0000000000000000"), 3,protectedKeyDivData, new int[]{41,41,42},protectedKeyDivIv, 1, structList);
System.out.println(retWrap);
System.out.println(Util.bytes2HexString((byte[]) retWrap.get("linkKeyOut")));
System.out.println(Util.bytes2HexString((byte[]) retWrap.get("linkKeyCheckOut")));
}
//PASS
@Test
public void testSA(){
String key = "";
List<byte[]> divData=new ArrayList<>();
divData.add(Util.hexString2Bytes("D1560001010001600000000100000000"));
divData.add(Util.hexString2Bytes("2000000910300305000910300305359C"));
int[] i={41,41};
List<byte[]> divIv=new ArrayList<>();
divIv.add(Util.hexString2Bytes("0000000000000000"));
divIv.add(Util.hexString2Bytes("0000000000000000"));
byte[] clientRandom=Util.hexString2Bytes("757E7FA47BC925A77BB5A75B5E455E5C574E4B24193A826A47B61FCCEA78B27C");
byte[] serverRandom=Util.hexString2Bytes("5F1E81531049D954D7F1C97663B7FFF14AF94C6CABF2301B70F119A0778EA3E8");
byte[] bytes = api.consultKey("1", 2, divData, i, divIv, clientRandom, serverRandom);
System.out.println(bytes.length);
System.out.println(Util.bytes2HexString(bytes));
}
//PASS
@Test
public void testSA_1(){
String key = "";
List<byte[]> divData=new ArrayList<>();
divData.add(Util.hexString2Bytes("D1560001010001600000000100000000"));
divData.add(Util.hexString2Bytes("2000000910300305000910300305359C"));
int[] i={41,41};
List<byte[]> divIv=new ArrayList<>();
divIv.add(Util.hexString2Bytes("0000000000000000"));
divIv.add(Util.hexString2Bytes("0000000000000000"));
byte[] clientRandom=Util.hexString2Bytes("757E7FA47BC925A77BB5A75B5E455E5C574E4B24193A826A47B61FCCEA78B27C");
byte[] serverRandom=Util.hexString2Bytes("5F1E81531049D954D7F1C97663B7FFF14AF94C6CABF2301B70F119A0778EA3E8");
byte[] bytes = api.consultKey("1", 2, divData, i, divIv, clientRandom, serverRandom);
System.out.println(bytes.length);
System.out.println(Util.bytes2HexString(bytes));
}
//000C00000000000000014232
//3241
//pass
@Test
public void testSB(){
String key = "E7E411C1C61C08756BE6D79AEACB602BBE95D15C3C16375EE56221873EA30C5B128959D6E8EFCC5BF8AEAD9A486F586A";
String seed= "636C69656E742066696E6973686564BAE3AFA00AA783D338CAFA00B899BB39C7FBDF5448A32136C0BE4D5CC164AA4B";
byte[] bytes = api.pHash(key, seed, 16);
System.out.println(bytes.length);
System.out.println(Util.bytes2HexString(bytes));
}
//pass
@Test
public void testSC(){
//分散因子
ArrayList<byte[]> decryptKeyDivData = new ArrayList();
decryptKeyDivData.add(Util.hexString2Bytes("65706917038051804927766430009625"));
decryptKeyDivData.add(Util.hexString2Bytes("13000002031301110002031301110097"));
decryptKeyDivData.add(Util.hexString2Bytes("01820001000000000000000000000000"));
//分散算法标识
int[] decryptKeyDivAlgFlag={41,42,51};
List<byte[]> decryptKeyDivIv=new ArrayList<>();
decryptKeyDivIv.add(Util.hexString2Bytes("0000000000000000"));
decryptKeyDivIv.add(Util.hexString2Bytes("0000000000000000"));
decryptKeyDivIv.add(Util.hexString2Bytes("00000000000000000000000000000000"));
// byte[] data=new byte[4*1024];
byte[] data=Util.hexString2Bytes("0123456789ABCDEF8000000000000000");
byte[] en = api.decrytAndEn("1", 52, Util.hexString2Bytes("00000000000000000000000000000000"), 3, decryptKeyDivData, decryptKeyDivAlgFlag, decryptKeyDivIv
, "1", 52, Util.hexString2Bytes("00000000000000000000000000000000"), 3, decryptKeyDivData, decryptKeyDivAlgFlag, decryptKeyDivIv, data);
System.out.println(en.length);
System.out.println(Util.bytes2HexString(en));
}
//pass
@Test
public void testSD(){
String data="30818C02206DDEC4FAE3F9FE1879DDF588DA5EF4EA25085444CD7CF9A368DBECAFB4181A46022100E60E7AF3B3B41F61DB252FFB89B7D336A6E39F0178271D8512AE3BCD4E68EE7E0420FDC0DA61B429D00490CAE56EAD90797298758A1D9054A348E00ECA58F239BF3104231A55B73872184DF779F54FCE756C88C65C06086241D6D1D85D879EE2E7511971E7E339";
byte[] bytes = api.ASYMDecryptAndEn(0, "2", 102, Util.hexString2Bytes(data), 0, 3);
System.out.println(bytes.length);
System.out.println(Util.bytes2HexString(bytes));
}
//pass
@Test
public void testSD_1(){
String key="000100000F46A8BF6B282E2EA4E01C620F741E256F45AB17150E9B08871176515042B6520000000000000000000000000000000000000000000000000000000000000000";
String data="30818C0221008EE7EDEBF4AEC4BABAAF80438BF08C597F2A7E7C071A4C279AEA0D839FE4BA3902202B4F6C9E3E387AA4F990C363B910002CD7A228CBFEE88A9075C9800CF0C4678004207515F4B1FB3716675137FD3DC49B70B7B09FC57D837E2B21F9C9B2C271A64D630423A298EC40AA9A7BD7420A9EA6083F78242D044A8241439F325F6FFF487EC7EE1CFCFB16";
byte[] bytes = api.ASYMDecryptAndEn(1, key, 102, Util.hexString2Bytes(data), 3, 0);
System.out.println(bytes.length);
System.out.println(Util.bytes2HexString(bytes));
}
//00E80000000000000000534431313230303638000100000F46A8BF6B282E2EA4E01C620F741E256F45AB17150E9B08871176515042B65200000000000000000000000000000000000000000000000000000000000000003031343330818C0221008EE7EDEBF4AEC4BABAAF80438BF08C597F2A7E7C071A4C279AEA0D839FE4BA3902202B4F6C9E3E387AA4F990C363B910002CD7A228CBFEE88A9075C9800CF0C4678004207515F4B1FB3716675137FD3DC49B70B7B09FC57D837E2B21F9C9B2C271A64D630423A298EC40AA9A7BD7420A9EA6083F78242D044A8241439F325F6FFF487EC7EE1CFCFB16
//00E80000000000000000534431313230303638000100000F46A8BF6B282E2EA4E01C620F741E256F45AB17150E9B08871176515042B65200000000000000000000000000000000000000000000000000000000000000003031343330818C0221008EE7EDEBF4AEC4BABAAF80438BF08C597F2A7E7C071A4C279AEA0D839FE4BA3902202B4F6C9E3E387AA4F990C363B910002CD7A228CBFEE88A9075C9800CF0C4678004207515F4B1FB3716675137FD3DC49B70B7B09FC57D837E2B21F9C9B2C271A64D630423A298EC40AA9A7BD7420A9EA6083F78242D044A8241439F325F6FFF487EC7EE1CFCFB16
//pass
@Test
public void testSE(){
byte[] en = api.SYMDecryptAndEn("E198DB62C5D9753EF3D82E8056B3F72A", 41, null, Util.hexString2Bytes("F1A03879E284895C1BCF643FFF1A1A63"));
System.out.println(en.length);
System.out.println(Util.bytes2HexString(en));
}
//pass
@Test
public void testSE_2(){
byte[] en = api.SYMDecryptAndEn("E198DB62C5D9753EF3D82E8056B3F72A", 42, Util.hexString2Bytes("0000000000000000"), Util.hexString2Bytes("5B068D4EA5631C2D965A15343EDBF4FA"));
System.out.println(en.length);
System.out.println(Util.bytes2HexString(en));
}
//pass
@Test
public void testSF(){
//分散因子
ArrayList<byte[]> list1 = new ArrayList();
list1.add(Util.hexString2Bytes("65706917038051804927766430009625"));
list1.add(Util.hexString2Bytes("13000002031301110002031301110097"));
list1.add(Util.hexString2Bytes("01820001000000000000000000000000"));
//分散算法标识
int[] i={41,41,52};
ArrayList<byte[]> list2 = new ArrayList();
list2.add(Util.hexString2Bytes("0000000000000000"));
list2.add(Util.hexString2Bytes("0000000000000000"));
list2.add(Util.hexString2Bytes("00000000000000000000000000000000"));
byte[] data=new byte[4*1024];
byte[] bytes = api.decryptByMainAndSYMEn("1", 41, null, 3, list1, i, list2, data);
System.out.println(bytes.length);
System.out.println(Util.bytes2HexString(bytes));
}
public static void main(String[] args) {
// int num=3;
// StringBuffer stringBuffer = new StringBuffer();
// while (num != 0) {
// int a = num % 10;
// stringBuffer.append(a);
// num /= 10;
// }
// System.out.println();
byte[] bytes = Util.hexString2Bytes("03000000");
System.out.println(Util.bytes2HexString(bytes));
}
@Test
public void B1_A0_B2(){
}
@Test
public void getVersion(){
RetWrap version = api.getDevInfo();
System.out.println(version);
}
}