diff --git a/DProto/HV.xml b/DProto/HV.xml index 8df2a60..5cdbe17 100644 --- a/DProto/HV.xml +++ b/DProto/HV.xml @@ -7,7 +7,7 @@ - + 授权响应码 diff --git a/DProto/S0.xml b/DProto/S0.xml new file mode 100644 index 0000000..94a4c05 --- /dev/null +++ b/DProto/S0.xml @@ -0,0 +1,204 @@ + + + + + + S0 + + + + + + + + + + + 仅当存储类型为1时有效 + 密钥长度 + + + + 仅当存储类型为1时有效 + 密钥密文 + + + + 仅当存储类型为0时有效 + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0。 + 注意：后八位密钥索引不允许输入全0 + + + + 支持算法：3DES、AES、SM1、SM4 + 取值参考数据字典 + + + + 仅当算法为非ECB模式下有此域 + 当算法标识为3DES-CBC、DES-CBC 时，该域为8B。 + 当算法标识为AES-CBC、SM1-CBC、SM4-CBC 时，该域为16B。 + 取值参考数据字典 + + + + 密钥分散级数，0～3 + + + + 仅当分散级数不为0时存在 + + + + 仅当分散级数不为0时存在 + + + + 仅当分散级数不为0时存在 + + + + 仅当分散级数不为0时存在 + 分散算法标识，定义每一次分散的分散算法，数量与密钥分散级数一致 + 如果算法类型为3DES、AES，则支持算法：3DES、AES； + 如果算法类型为SM1、SM4，则支持算法：SM1、SM4； + 取值参考数据字典 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 向量 + + + + 仅当分散级数不为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 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 + + + + 输入数据长度 + + + + 输入数据 + + + + + + + + + S1 + + + + + + + + + + 数据长度 + + + + 数据 + + + + + + diff --git a/DProto/S1.xml b/DProto/S1.xml new file mode 100644 index 0000000..9c38268 --- /dev/null +++ b/DProto/S1.xml @@ -0,0 +1,204 @@ + + + + + + S1 + + + + + + + + + + + 仅当存储类型为1时有效 + 密钥长度 + + + + 仅当存储类型为1时有效 + 密钥密文 + + + + 仅当存储类型为0时有效 + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0。 + 注意：后八位密钥索引不允许输入全0 + + + + 支持算法：3DES、AES、SM1、SM4 + 取值参考数据字典 + + + + 仅当算法为非ECB模式下有此域 + 当算法标识为3DES-CBC、DES-CBC 时，该域为8B。 + 当算法标识为AES-CBC、SM1-CBC、SM4-CBC 时，该域为16B。 + 取值参考数据字典 + + + + 密钥分散级数，0～3 + + + + 仅当分散级数不为0时存在 + + + + 仅当分散级数不为0时存在 + + + + 仅当分散级数不为0时存在 + + + + 仅当分散级数不为0时存在 + 分散算法标识，定义每一次分散的分散算法，数量与密钥分散级数一致 + 如果算法类型为3DES、AES，则支持算法：3DES、AES； + 如果算法类型为SM1、SM4，则支持算法：SM1、SM4； + 取值参考数据字典 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 向量 + + + + 仅当分散级数不为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 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 + + + + 输入数据长度 + + + + 输入数据 + + + + + + + + + S2 + + + + + + + + + + 数据长度 + + + + 数据 + + + + + + diff --git a/DProto/S2.xml b/DProto/S2.xml new file mode 100644 index 0000000..0cdb1ea --- /dev/null +++ b/DProto/S2.xml @@ -0,0 +1,190 @@ + + + + + + S2 + + + + + + + + + + + 仅当存储类型为1时有效 + 密钥长度 + + + + 仅当存储类型为1时有效 + 密钥密文 + + + + 仅当存储类型为0时有效 + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0。 + 注意：后八位密钥索引不允许输入全0 + + + + 当存储类型为0时：仅支持3DES-ECB(07)、3DES-CBC(08) + 当存储类型为1时：仅支持3DES-ECB、3DES-CBC、HMAC-SHA256(14) + 取值参考数据字典 + + + + 仅当算法为3DES-CBC模式下有此域 + + + + 密钥分散级数，0～3 + + + + 仅当分散级数不为0时存在 + + + + 仅当分散级数不为0时存在 + + + + 仅当分散级数不为0时存在 + + + + 仅当分散级数不为0时存在 + 分散算法标识，定义每一次分散的分散算法，数量与密钥分散级数一致 + 如果算法类型为3DES、AES，则支持算法：3DES、AES； + 如果算法类型为SM1、SM4，则支持算法：SM1、SM4； + 取值参考数据字典 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 向量 + + + + 仅当分散级数不为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 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 + + + + 输入数据长度 + + + + 输入数据 + + + + 需要的MAC数据长度 + + + + + + + + S3 + + + + + + + + + + 输出的MAC数据 + + + + + + diff --git a/DProto/S3.xml b/DProto/S3.xml new file mode 100644 index 0000000..3d82d9b --- /dev/null +++ b/DProto/S3.xml @@ -0,0 +1,157 @@ + + + + + + S3 + + + + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0 + 注意：后八位密钥索引不允许输入全0 + + + + 仅支持3DES-CBC + + + + 仅当算法为3DES-CBC模式下有此域 + + + + 密钥分散级数，0～3 + + + + 仅当分散级数不为0时存在 + + + + 仅当分散级数不为0时存在 + + + + 仅当分散级数不为0时存在 + + + + 仅当分散级数不为0时存在 + 分散算法标识，定义每一次分散的分散算法，数量与密钥分散级数一致 + 如果算法类型为3DES、AES，则支持算法：3DES、AES； + 如果算法类型为SM1、SM4，则支持算法：SM1、SM4； + 取值参考数据字典 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 向量 + + + + 仅当分散级数不为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 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 + + + + 输入数据长度 + + + + 输入数据 + + + + + + + + S4 + + + + + + + + + + 输出的MacAndNextIv数据 + 16字节 + 前8字节为MAC + 后8字节为下一次IV + + + + + + diff --git a/DProto/S4.xml b/DProto/S4.xml new file mode 100644 index 0000000..63cc9e7 --- /dev/null +++ b/DProto/S4.xml @@ -0,0 +1,78 @@ + + + + + + S4 + + + + + + + + + + + 仅支持RSA、SM2 + + + + RSA密钥长度：1024、2048 + SM2密钥长度：256 + + + + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0. + + + + + + + + + S5 + + + + + + + + + + 公钥长度 + + + + 公钥 + + + + 私钥长度 + + + + 私钥 + + + + + + diff --git a/DProto/S5.xml b/DProto/S5.xml new file mode 100644 index 0000000..108e9b7 --- /dev/null +++ b/DProto/S5.xml @@ -0,0 +1,87 @@ + + + + + + S5 + + + + + + + + + + + 仅支持RSA、SM2 + + + + 仅当存储类型为1时有效 + 签名私钥长度 + + + + 仅当存储类型为1时有效 + 签名私钥 + + + + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0 + 注意：后八位密钥索引不允许输入全0 + + + + 输入数据长度 + + + + 输入数据 + + + + + + + + S6 + + + + + + + + + + 签名数据长度 + + + + 签名数据 + + + + + + diff --git a/DProto/S6.xml b/DProto/S6.xml new file mode 100644 index 0000000..64a85eb --- /dev/null +++ b/DProto/S6.xml @@ -0,0 +1,87 @@ + + + + + + S6 + + + + + + + + + + + 仅支持RSA、SM2 + + + + 仅当存储类型为1时有效 + 验签公钥长度 + + + + 仅当存储类型为1时有效 + 验签公钥 + + + + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0 + 注意：后八位密钥索引不允许输入全0 + + + + 原数据长度 + + + + 原数据 + + + + 签名数据长度 + + + + 签名数据 + + + + + + + + S7 + + + + + + + + + + + + diff --git a/DProto/S7.xml b/DProto/S7.xml new file mode 100644 index 0000000..e12cdec --- /dev/null +++ b/DProto/S7.xml @@ -0,0 +1,88 @@ + + + + + + S7 + + + + + + + + + + + 仅支持RSA、SM2 + + + + 仅当存储类型为1时有效 + 公钥长度 + + + + 仅当存储类型为1时有效 + 公钥 + + + + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0 + 注意：后八位密钥索引不允许输入全0 + + + + 数据长度 + + + + 数据 + + + + + + + + S8 + + + + + + + + + + 密文长度 + + + + 密文 + + + + + + + diff --git a/DProto/S8.xml b/DProto/S8.xml new file mode 100644 index 0000000..cc2cd96 --- /dev/null +++ b/DProto/S8.xml @@ -0,0 +1,88 @@ + + + + + + S8 + + + + + + + + + + + 仅支持RSA、SM2 + + + + 仅当存储类型为1时有效 + 私钥长度 + + + + 仅当存储类型为1时有效 + 私钥 + + + + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0 + 注意：后八位密钥索引不允许输入全0 + + + + 密文长度 + + + + 密文 + + + + + + + + S9 + + + + + + + + + + 数据长度 + + + + 数据 + + + + + + + diff --git a/DProto/S9.xml b/DProto/S9.xml new file mode 100644 index 0000000..14f5103 --- /dev/null +++ b/DProto/S9.xml @@ -0,0 +1,178 @@ + + + + + + S9 + + + + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0 + + + + 支持算法：3DES、AES、SM1、SM4 + + + + 仅当算法为非ECB模式下有此域 + 当算法标识为3DES-CBC、DES-CBC 时，该域为8B。 + 当算法标识为AES-CBC、SM1-CBC、SM4-CBC 时，该域为16B。 + + + + 密钥分散级数，0～3 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + 分散算法标识，定义每一次分散的分散算法，数量与密钥分散级数一致 + 如果保护密钥算法类型为3DES、AES，则支持算法：3DES、AES； + 如果保护密钥算法类型为SM1、SM4，则支持算法：SM1、SM4； + 取值参考数据字典 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为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 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 + + + + 被导出的密钥索引个数,最大不超过50 + + + + 分散密钥结构体STC_KEYDIV + 结构体格式参考数据字典 + + + + + + + + + SA + + + + + + + + + + 依次连接所有密钥密文输出 + + + + 依次连接所有密钥校验值输出 + + + + + + diff --git a/DProto/SA.xml b/DProto/SA.xml new file mode 100644 index 0000000..4ee3860 --- /dev/null +++ b/DProto/SA.xml @@ -0,0 +1,184 @@ + + + + + + SA + + + + 仅当存储类型为0时有效 + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0。 + 注意：后八位密钥索引不允许输入全0 + + + + 密钥分散级数，0～3 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + 分散算法标识，定义每一次分散的分散算法，数量与密钥分散级数一致 + 如果保护密钥算法类型为3DES、AES，则支持算法：3DES、AES； + 如果保护密钥算法类型为SM1、SM4，则支持算法：SM1、SM4； + 取值参考数据字典 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为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 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 + + + + 主密钥标签长度，最大不超过256字节 + + + + 主密钥标签 + + + + 工作密钥标签长度，最大不超过256字节 + + + + 工作密钥标签 + + + + 客户端随机数长度，最大不超过2048 + + + + 客户端随机数 + + + + 服务端随机数长度，最大不超过2048 + + + + 服务端随机数 + + + + + + + + + B2 + + + + + + + + + + 输出会话密钥密文 + 数序如下： + masterKey（48字节） + clientWriteMacKey（32字节） + serverWriteMacKey（32字节） + clientWriteKey（16字节） + serverWriteKey（16字节） + clientWriteIv（16字节） + serverWriteIv（16字节） + + + + + + diff --git a/DProto/SB.xml b/DProto/SB.xml new file mode 100644 index 0000000..c5d1de3 --- /dev/null +++ b/DProto/SB.xml @@ -0,0 +1,70 @@ + + + + + + SB + + + + 外部密钥密文长度 + + + + 外部密钥密文 + + + + 种子长度 + + + + 种子 + + + + 输出数据长度 + + + + + + + + + SC + + + + + + + + + + 输出数据长度 + + + + 输出的指定长度的数据 + 若指定长度小于块长的整数倍，则取满足返回长度最小整数倍的前指定长度个字节 + + + + + + diff --git a/DProto/SC.xml b/DProto/SC.xml new file mode 100644 index 0000000..1672535 --- /dev/null +++ b/DProto/SC.xml @@ -0,0 +1,290 @@ + + + + + + SC + + + + 仅当存储类型为0时有效 + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0。 + 注意：后八位密钥索引不允许输入全0 + + + + 解密的算法 + 支持算法：3DES、AES、SM1、SM4 + + + + 仅当算法为非ECB模式下有此域 + 当算法标识为3DES-CBC、DES-CBC 时，该域为8B。 + 当算法标识为AES-CBC、SM1-CBC、SM4-CBC 时，该域为16B。 + 取值参考数据字典 + + + + 密钥分散级数，0～3 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + 分散算法标识，定义每一次分散的分散算法，数量与密钥分散级数一致 + 如果保护密钥算法类型为3DES、AES，则支持算法：3DES、AES； + 如果保护密钥算法类型为SM1、SM4，则支持算法：SM1、SM4； + 取值参考数据字典 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为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 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当存储类型为0时有效 + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0。 + 注意：后八位密钥索引不允许输入全0 + + + + 加密密钥算法，支持3DES、AES、SM1、SM4 + 取值参考数据字典 + + + + 仅当加密密钥算法为CBC模式时存在 + 加密密钥的初始向量 + + + + 密钥分散级数，0～3 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + 分散算法标识，定义每一次分散的分散算法，数量与密钥分散级数一致 + 如果保护密钥算法类型为3DES、AES，则支持算法：3DES、AES； + 如果保护密钥算法类型为SM1、SM4，则支持算法：SM1、SM4； + 取值参考数据字典 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为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 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 + + + + 待解密的数据长度 + + + + 待解密的数据 + + + + + + + + SD + + + + + + + + + + 加密后的数据长度 + + + + 加密后的数据 + + + + + + \ No newline at end of file diff --git a/DProto/SD.xml b/DProto/SD.xml new file mode 100644 index 0000000..df4897a --- /dev/null +++ b/DProto/SD.xml @@ -0,0 +1,87 @@ + + + + + + SD + + + + + + + + + + + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0 + + + + 解密算法 + 支持算法：RSA、SM2 + 取值参考数据字典 + + + + 仅当密钥索引全0时，存在此域 + 解密密钥长度 + + + + 仅当密钥索引全0时，存在此域 + 解密的非对称密钥私钥密文 + + + + 待转加密的数据长度 + + + + 待转加密的数据 + + + + + + + + SE + + + + + + + + + + 使用加密机主密钥加密的对称密钥长度 + + + + 使用加密机主密钥加密的对称密钥 + + + + + + diff --git a/DProto/SE.xml b/DProto/SE.xml new file mode 100644 index 0000000..c521b5b --- /dev/null +++ b/DProto/SE.xml @@ -0,0 +1,99 @@ + + + + + + SE + + + + + 仅当存储类型为1时有效 + 解密密钥密文长度 + + + + 仅当存储类型为1时有效 + 解密密钥密文 + + + + 解密算法 + 支持算法：SM4、3DES和AES + 取值参考数据字典 + + + + 仅当算法为非ECB模式下有此域 + 当算法标识为3DES-CBC 时，该域为8B。 + 当算法标识为AES-CBC、 SM4-CBC 时，该域为16B。 + 取值参考数据字典 + + + + 待转加密的数据长度 + + + + 待转加密的数据 + + + + + + + + SF + + + + + + + + + + 使用加密机主密钥加密的对称密钥长度 + + + + 使用加密机主密钥加密的对称密钥 + + + + + + diff --git a/DProto/SF.xml b/DProto/SF.xml new file mode 100644 index 0000000..748f4fc --- /dev/null +++ b/DProto/SF.xml @@ -0,0 +1,178 @@ + + + + + + SF + + + + 仅当存储类型为0时有效 + 内部密钥索引, 接口层对外限制8位，通讯层限制27位，16位机构号+3位密钥类型+8位密钥索引号。前19位补0。 + 注意：后八位密钥索引不允许输入全0 + + + + 加密算法类型 + 支持算法：3DES、AES、SM1、SM4 + + + + 仅当算法为非ECB模式下有此域 + 当算法标识为3DES-CBC 时，该域为8B。 + 当算法标识为AES-CBC、SM1-CBC、SM4-CBC 时，该域为16B。 + 取值参考数据字典 + + + + + 密钥分散级数，0～3 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + + + + 仅当保护密钥分散级数不为0时存在 + 分散算法标识，定义每一次分散的分散算法，数量与密钥分散级数一致 + 如果保护密钥算法类型为3DES、AES，则支持算法：3DES、AES； + 如果保护密钥算法类型为SM1、SM4，则支持算法：SM1、SM4； + 取值参考数据字典 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为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 + + + + 仅当分散级数不为0时存在，同上 + + + + 仅当分散级数不为0时存在，同上 + + + + 待加密机主密钥解密的数据长度 + + + + 待加密机主密钥解密的数据 + + + + + + + + SH + + + + + + + + + + 离散密钥加密的数据密文长度 + + + + 离散密钥加密的数据密文 + + + + + + \ No newline at end of file diff --git a/src/main/java/com/sunyard/SydApi.java b/src/main/java/com/sunyard/SydApi.java index bff4102..6f315f3 100644 --- a/src/main/java/com/sunyard/SydApi.java +++ b/src/main/java/com/sunyard/SydApi.java @@ -13,7 +13,7 @@ import java.io.InputStream; * 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_SM4 = 0x31; diff --git a/src/main/java/com/sunyard/entity/Struct.java b/src/main/java/com/sunyard/entity/Struct.java new file mode 100644 index 0000000..c472991 --- /dev/null +++ b/src/main/java/com/sunyard/entity/Struct.java @@ -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 ucKeyDivData; //导出密钥分散数据 + int[] iKeyDivAlg; //导出密钥分散算法 + List 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 ucKeyDivData, int[] iKeyDivAlg, List 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 getUcKeyDivData() { + return ucKeyDivData; + } + + public void setUcKeyDivData(List ucKeyDivData) { +// byte[] b= new byte[48]; +// System.arraycopy(ucKeyDivData,0,b,0,ucKeyDivData.length); + this.ucKeyDivData = ucKeyDivData; + } + + public List getUcKeyDivIv() { + return ucKeyDivIv; + } + + public void setUcKeyDivIv(List 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 divData, int[] divAlgFlag, List 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 divData, int[] divAlgFlag, List 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 divData, int[] divAlgFlag, List 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 divData, int[] divAlgFlag, List 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 protectedKeyDivData, int[] protectedKeyDivAlgFlag, List protectedKeyDivIv, int exportKeyNum, List 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 divData, int[] divAlgFlag, List 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 decryptKeyDivData, int[] decryptKeyDivAlgFlag, List decryptKeyDivIv, + String encryptKeyIndex, int encryptAlgFlag, byte[] encryptIv, int encryptKeyDivNum, List encryptKeyDivData, int[] encryptKeyDivAlgFlag, List 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 encryptKeyDivData, int[] encryptKeyDivAlgFlag, List encryptKeyDivIv, byte[] inputData); + +} diff --git a/src/main/java/com/sunyard/util/MyUtil.java b/src/main/java/com/sunyard/util/MyUtil.java new file mode 100644 index 0000000..6b77353 --- /dev/null +++ b/src/main/java/com/sunyard/util/MyUtil.java @@ -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; + } + +} diff --git a/src/main/java/racal/sunyard/main/SydApi4j.java b/src/main/java/racal/sunyard/main/SydApi4j.java index 87678ec..c223fd4 100644 --- a/src/main/java/racal/sunyard/main/SydApi4j.java +++ b/src/main/java/racal/sunyard/main/SydApi4j.java @@ -4,6 +4,7 @@ import com.sunyard.RetWrap; import com.sunyard.SydApi; import com.sunyard.SydApiException; import com.sunyard.cert.X509; +import com.sunyard.entity.Struct; import com.sunyard.proto.Packet; import com.sunyard.proto.PacketSection; import com.sunyard.proto.Util; @@ -11,6 +12,7 @@ import com.sunyard.proto.section.SectionValue; import com.sunyard.proto.value.Str; import com.sunyard.trans.PacketSN; import com.sunyard.util.CoderUtil; +import com.sunyard.util.MyUtil; import com.sunyard.util.SYMUtil; import racal.sunyard.main.dto.*; import racal.sunyard.main.proto.*; @@ -5593,6 +5595,16 @@ public class SydApi4j implements SydApi { } + /** + * @Description 加密机版本号 -> pass + * @Param [num] + * @Return com.sunyard.RetWrap + * @Author wp + * @Date 2020/9/30 16:42 + **/ + public RetWrap getDevInfo() { + return getVersion(null); + } /** * 获取加密机设备信息 @@ -5612,7 +5624,10 @@ public class SydApi4j implements SydApi { packet.put("data", data); PacketSN sn = PacketSN.gen(); packet.put("header", sn.getSn().array()); - data.put("num", num); + if (num != null && !"".equals(num)){ + data.put("num", num); + } + // 渲染发送 ByteBuffer bb = proto.rend(packet); @@ -6380,7 +6395,7 @@ public class SydApi4j implements SydApi { * @return key: 被加密的密钥 */ @Override - public String readKey(String index) { + public RetWrap readKey(String index) { ProtoLF proto = new ProtoLF(); HashMap packet = new HashMap(); HashMap data = new HashMap(); @@ -6414,9 +6429,9 @@ public class SydApi4j implements SydApi { byte[] bs = new byte[keys.length + keyHeads.length]; System.arraycopy(keyHeads, 0, bs, 0, keyHeads.length); System.arraycopy(keys, 0, bs, keyHeads.length, keys.length); -// rw.put("key", bs); + rw.put("key", bs); //rw.put("keyCheck", ((PacketSection) ret.get("keyCheck")).getBytes()); - return new String(bs); //返回HEX格式 + return rw; } } } @@ -8121,6 +8136,9 @@ public class SydApi4j implements SydApi { } + + + /** * 17.9 角色认证（+） -> -> : code = 2 ( 0x2 ) msg = 签名验证错误 * @@ -8294,7 +8312,7 @@ public class SydApi4j implements SydApi { @Override public String SYMEncrytByKeyIndex(String index, String intPutData) { - RetWrap retWrap = this.SYMEnDeData(true, 1, this.readKey(index), 1, 1, intPutData.getBytes(), null, 0); + RetWrap retWrap = this.SYMEnDeData(true, 1, new String((byte[]) this.readKey(index).get("key")), 1, 1, intPutData.getBytes(), null, 0); String msg_all_en = Util.bytes2HexString((byte[]) retWrap.get("msg_all")); return msg_all_en; } @@ -8302,7 +8320,7 @@ public class SydApi4j implements SydApi { @Override public String SYMDecrytByKeyIndex(String index, String intPutData) { - RetWrap retWrap = this.SYMEnDeData(false, 1, this.readKey(index), 1, 1, Util.hexString2Bytes(intPutData), null, 0); + RetWrap retWrap = this.SYMEnDeData(false, 1, new String((byte[]) this.readKey(index).get("key")), 1, 1, Util.hexString2Bytes(intPutData), null, 0); String msg_all_de = new String(Util.hexString2Bytes(Util.bytes2HexString((byte[]) retWrap.get("msg_all")))); return msg_all_de; } @@ -8538,4 +8556,1204 @@ public class SydApi4j implements SydApi { // retWrap.put( "equipNo", equipNo.getString() ); //设备序号 // retWrap.put( "authenCode", authenCode.getBytes() ); //认证码 } + + + // ------------------------中移指令接口-------------------------------- + + /** + * @param storageType 存储类型 0-使用内部密钥，1-使用外部密钥 + * @param key 使用内部密钥时，该值传后八位密钥索引;使用外部密钥时，该值为外部密钥hex格式 + * @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 + */ + @Override + public byte[] SYMEncryt(int storageType, String key, int algFlag, byte[] iv, int divNum, List divData, int[] divAlgFlag, List divIv, byte[] inputData) { + ProtoS0 proto = new ProtoS0(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + //存储类型 + data.put("storageType$option", storageType); + if (1 == storageType) { + //密钥从外部传入 + data.put("key", Util.hexString2Bytes(key)); + } + if (0 == storageType) { + //传入密钥索引 +// byte[] b1="0000000000000000000".getBytes(); +// byte[] bytes = new byte[b1.length+key.length]; +// System.arraycopy(b1,0,bytes,0,b1.length); +// System.arraycopy(key,0,bytes,b1.length,key.length); +// if (0 == Long.parseLong(key)) { +// throw new SydApiException("输入的数据格式错误", 21); +// } + String gId = "00000000" + key; + gId = gId.substring(gId.length() - 8, gId.length()); + data.put("keyIndex", "0000000000000000000" + gId); + } + //算法类型支持算法：3DES、AES、SM1、SM4 + data.put("algorithmKey", MyUtil.transAlg(algFlag)); + data.put("iv", iv); + //密钥分散级数 + data.put("keyScatterLevel", divNum); + if (1 <= divNum) { + //分散因子1 + data.put("scatterFactor1", divData.get(0)); + //分散算法标识1 + data.put("scatterAlgorithmKey1", MyUtil.transAlg(divAlgFlag[0])); + //分散算法的初始向量1 + data.put("scatterAlgorithmVector1", divIv.get(0)); + } + if (2 <= divNum) { + data.put("scatterFactor2", divData.get(1)); + data.put("scatterAlgorithmKey2", MyUtil.transAlg(divAlgFlag[1])); + data.put("scatterAlgorithmVector2", divIv.get(1)); + } + if (3 == divNum) { + data.put("scatterFactor3", divData.get(2)); + data.put("scatterAlgorithmKey3", MyUtil.transAlg(divAlgFlag[2])); + data.put("scatterAlgorithmVector3", divIv.get(2)); + } + //输入数据 + data.put("inputData", inputData); + // 渲染发送 + ByteBuffer bb = proto.rend(packet); + + synchronized (this) { + // 响应解析 + bb = syncRead(syncSend(bb)); + } + + Packet p = proto.parse(bb); + Map ret = p.toMap(); + + if ( + !Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes()) + ) { + throw new SydApiException("包序号不匹配", -4); + } + ret = (Map) ret.get("data"); + + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + return ((PacketSection) ret.get("info")).getBytes(); + } + } + + /** + * @param storageType 存储类型 0-使用内部密钥，1-使用外部密钥 + * @param key 使用内部密钥时，该值传后八位密钥索引;使用外部密钥时，该值为外部密钥（hex格式） + * @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 + */ + @Override + public byte[] SYMDecryt(int storageType, String key, int algFlag, byte[] iv, int divNum, List divData, int[] divAlgFlag, List divIv, byte[] inputData) { + ProtoS1 proto = new ProtoS1(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + //存储类型 + data.put("storageType$option", storageType); + if (1 == storageType) { + //密钥从外部传入 + data.put("key", Util.hexString2Bytes(key)); + } + if (0 == storageType) { + //传入密钥索引 +// byte[] b1="0000000000000000000".getBytes(); +// byte[] bytes = new byte[b1.length+key.length]; +// System.arraycopy(b1,0,bytes,0,b1.length); +// System.arraycopy(key,0,bytes,b1.length,key.length); +// if (0 == Long.parseLong(key)) { +// throw new SydApiException("输入的数据格式错误", 21); +// } + String gId = "00000000" + key; + gId = gId.substring(gId.length() - 8, gId.length()); + data.put("keyIndex", "0000000000000000000" + gId); + } + //算法类型支持算法：3DES、AES、SM1、SM4 + data.put("algorithmKey", MyUtil.transAlg(algFlag)); + data.put("iv", iv); + //密钥分散级数 + data.put("keyScatterLevel", divNum); + if (1 <= divNum) { + //分散因子1 + data.put("scatterFactor1", divData.get(0)); + //分散算法标识1 + data.put("scatterAlgorithmKey1", MyUtil.transAlg(divAlgFlag[0])); + //分散算法的初始向量1 + data.put("scatterAlgorithmVector1", divIv.get(0)); + } + if (2 <= divNum) { + data.put("scatterFactor2", divData.get(1)); + data.put("scatterAlgorithmKey2", MyUtil.transAlg(divAlgFlag[1])); + data.put("scatterAlgorithmVector2", divIv.get(1)); + } + if (3 == divNum) { + data.put("scatterFactor3", divData.get(2)); + data.put("scatterAlgorithmKey3", MyUtil.transAlg(divAlgFlag[2])); + data.put("scatterAlgorithmVector3", divIv.get(2)); + } + //输入数据 + data.put("inputData", inputData); + // 渲染发送 + ByteBuffer bb = proto.rend(packet); + + synchronized (this) { + // 响应解析 + bb = syncRead(syncSend(bb)); + } + + Packet p = proto.parse(bb); + Map ret = p.toMap(); + + if ( + !Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes()) + ) { + throw new SydApiException("包序号不匹配", -4); + } + ret = (Map) ret.get("data"); + + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + return ((PacketSection) ret.get("info")).getBytes(); + } + } + + /** + * @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 + */ + @Override + public byte[] genMAC(int storageType, String key, int algFlag, byte[] iv, int divNum, List divData, int[] divAlgFlag, List divIv, byte[] inputData, int macDataLen) { + ProtoS2 proto = new ProtoS2(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + //存储类型 + data.put("storageType$option", storageType); + if (1 == storageType) { + //密钥从外部传入 + data.put("key", Util.hexString2Bytes(key)); + } + if (0 == storageType) { + //传入密钥索引 +// byte[] b1="0000000000000000000".getBytes(); +// byte[] bytes = new byte[b1.length+key.length]; +// System.arraycopy(b1,0,bytes,0,b1.length); +// System.arraycopy(key,0,bytes,b1.length,key.length); +// if (0 == Long.parseLong(key)) { +// throw new SydApiException("输入的数据格式错误", 21); +// } + String gId = "00000000" + key; + gId = gId.substring(gId.length() - 8, gId.length()); + data.put("keyIndex", "0000000000000000000" + gId); + } + //算法类型 + data.put("algorithmKey", MyUtil.transAlg(algFlag)); + data.put("iv", iv); + //密钥分散级数 + data.put("keyScatterLevel", divNum); + if (1 <= divNum) { + //分散因子1 + data.put("scatterFactor1", divData.get(0)); + //分散算法标识1 + data.put("scatterAlgorithmKey1", MyUtil.transAlg(divAlgFlag[0])); + //分散算法的初始向量1 + data.put("scatterAlgorithmVector1", divIv.get(0)); + } + if (2 <= divNum) { + data.put("scatterFactor2", divData.get(1)); + data.put("scatterAlgorithmKey2", MyUtil.transAlg(divAlgFlag[1])); + data.put("scatterAlgorithmVector2", divIv.get(1)); + } + if (3 == divNum) { + data.put("scatterFactor3", divData.get(2)); + data.put("scatterAlgorithmKey3", MyUtil.transAlg(divAlgFlag[2])); + data.put("scatterAlgorithmVector3", divIv.get(2)); + } + //输入数据 + data.put("inputData", inputData); + //需要的MAC长度 + data.put("macLen", macDataLen); + + // 渲染发送 + ByteBuffer bb = proto.rend(packet); + + synchronized (this) { + // 响应解析 + bb = syncRead(syncSend(bb)); + } + + Packet p = proto.parse(bb, packet); + Map ret = p.toMap(); + + if ( + !Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes()) + ) { + throw new SydApiException("包序号不匹配", -4); + } + ret = (Map) ret.get("data"); + + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + return ((PacketSection) ret.get("mac")).getBytes(); + } + } + + /** + * @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 + */ + @Override + public byte[] genMacAndNextIv(String keyIndex, byte[] iv, int divNum, List divData, int[] divAlgFlag, List divIv, byte[] inputData) { + ProtoS3 proto = new ProtoS3(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + + //传入密钥索引 +// byte[] b1="0000000000000000000".getBytes(); +// byte[] bytes = new byte[b1.length+key.length]; +// System.arraycopy(b1,0,bytes,0,b1.length); +// System.arraycopy(key,0,bytes,b1.length,key.length); +// if (0 == Long.parseLong(keyIndex)) { +// throw new SydApiException("输入的数据格式错误", 21); +// } + String gId = "00000000" + keyIndex; + gId = gId.substring(gId.length() - 8); + data.put("keyIndex", "0000000000000000000" + gId); + + //算法类型支持算法：仅支持3DES-CBC + data.put("algorithmKey", 8); + data.put("iv", iv); + //密钥分散级数 + data.put("keyScatterLevel", divNum); + if (1 <= divNum) { + //分散因子1 + data.put("scatterFactor1", divData.get(0)); + //分散算法标识1 + data.put("scatterAlgorithmKey1", MyUtil.transAlg(divAlgFlag[0])); + //分散算法的初始向量1 + data.put("scatterAlgorithmVector1", divIv.get(0)); + } + if (2 <= divNum) { + data.put("scatterFactor2", divData.get(1)); + data.put("scatterAlgorithmKey2", MyUtil.transAlg(divAlgFlag[1])); + data.put("scatterAlgorithmVector2", divIv.get(1)); + } + if (3 == divNum) { + data.put("scatterFactor3", divData.get(2)); + data.put("scatterAlgorithmKey3", MyUtil.transAlg(divAlgFlag[2])); + data.put("scatterAlgorithmVector3", divIv.get(2)); + } + //输入数据 + data.put("inputData", inputData); + + // 渲染发送 + ByteBuffer bb = proto.rend(packet); + + synchronized (this) { + // 响应解析 + bb = syncRead(syncSend(bb)); + } + + Packet p = proto.parse(bb, packet); + Map ret = p.toMap(); + + if ( + !Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes()) + ) { + throw new SydApiException("包序号不匹配", -4); + } + ret = (Map) ret.get("data"); + + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + return ((PacketSection) ret.get("macAndNextIv")).getBytes(); + } + } + + /** + * @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 + */ + @Override + public RetWrap genSYMkey(int storageType, int algFlag, int keyLength, String keyIndex) { + ProtoS4 proto = new ProtoS4(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + + data.put("storageType$option", storageType); + data.put("algorithmKey", MyUtil.transAlg(algFlag)); + data.put("keyLen", keyLength); + // + String gId = "00000000" + keyIndex; + gId = gId.substring(gId.length() - 8); + data.put("keyIndex", "0000000000000000000" + gId); + + ByteBuffer bb = proto.rend(packet); + + synchronized (this) { + bb = syncRead(syncSend(bb)); + } + + Map ret; + Packet p = proto.parse(bb); + ret = p.toMap(); + if (!Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes())) { + throw new SydApiException("包序号不匹配", -4); + } else { + ret = (Map) ret.get("data"); + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + RetWrap rw = new RetWrap(); + rw.put("publicKey", ((PacketSection) ret.get("publicKey")).getBytes()); + rw.put("privateKey", ((PacketSection) ret.get("privateKey")).getBytes()); + return rw; + } + } + } + + /** + * @param storageType 存储类型 0-使用内部密钥，1-使用外部密钥 + * @param algFlag 算法类型：仅支持RSA、SM2 + * @param key 使用内部密钥时，该值传后八位密钥索引;使用外部密钥时，该值为签名私钥 + * @param inputData 数据 + * @return byte[] 签名数据 + * @author wp + * @Description: (A5)签名接口 + * @date 2021/5/31 + */ + @Override + public byte[] signData(int storageType, int algFlag, String key, byte[] inputData) { + ProtoS5 proto = new ProtoS5(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + + data.put("storageType$option", storageType); + data.put("algorithmKey", MyUtil.transAlg(algFlag)); + + if (1 == storageType) { + //密钥从外部传入 + data.put("privateKey", Util.hexString2Bytes(key)); + } + if (0 == storageType) { + //传入密钥索引 +// byte[] b1="0000000000000000000".getBytes(); +// byte[] bytes = new byte[b1.length+key.length]; +// System.arraycopy(b1,0,bytes,0,b1.length); +// System.arraycopy(key,0,bytes,b1.length,key.length); +// if (0 == Long.parseLong(key)) { +// throw new SydApiException("输入的数据格式错误", 21); +// } + String gId = "00000000" + key; + gId = gId.substring(gId.length() - 8, gId.length()); + data.put("keyIndex", "0000000000000000000" + gId); + } + + data.put("inputData", inputData); + + ByteBuffer bb = proto.rend(packet); + + synchronized (this) { + bb = syncRead(syncSend(bb)); + } + + Map ret = null; + Packet p = proto.parse(bb); + ret = p.toMap(); + if (!Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes())) { + throw new SydApiException("包序号不匹配", -4); + } else { + ret = (Map) ret.get("data"); + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + return ((PacketSection) ret.get("signData")).getBytes(); + } + } + } + + /** + * @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 + */ + @Override + public Boolean verifySignData(int storageType, int algFlag, String key, byte[] orgData, byte[] signData) { + ProtoS6 proto = new ProtoS6(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + + data.put("storageType$option", storageType); + data.put("algorithmKey", MyUtil.transAlg(algFlag)); + + if (1 == storageType) { + //密钥从外部传入 + data.put("publicKey", Util.hexString2Bytes(key)); + } + if (0 == storageType) { + //传入密钥索引 +// byte[] b1="0000000000000000000".getBytes(); +// byte[] bytes = new byte[b1.length+key.length]; +// System.arraycopy(b1,0,bytes,0,b1.length); +// System.arraycopy(key,0,bytes,b1.length,key.length); +// if (0 == Long.parseLong(key)) { +// throw new SydApiException("输入的数据格式错误", 21); +// } + String gId = "00000000" + key; + gId = gId.substring(gId.length() - 8, gId.length()); + data.put("keyIndex", "0000000000000000000" + gId); + } + data.put("orgData", orgData); + data.put("inputData", signData); + + ByteBuffer bb = proto.rend(packet); + + synchronized (this) { + bb = syncRead(syncSend(bb)); + } + + Map ret = null; + Packet p = proto.parse(bb); + ret = p.toMap(); + if (!Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes())) { + throw new SydApiException("包序号不匹配", -4); + } else { + ret = (Map) ret.get("data"); + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + return true; + } + } + } + + /** + * @param storageType 存储类型 0-使用内部密钥，1-使用外部密钥 + * @param algFlag 算法类型：仅支持RSA、SM2 + * @param key 使用内部密钥时，该值传后八位密钥索引;使用外部密钥时，该值为公钥 + * @param inputData 明文 + * @return byte[] 密文 + * @author wp + * @Description: (A7)非对称加密接口——（自定义） + * @date 2021/5/31 + */ + @Override + public byte[] ASYMEnData(int storageType, int algFlag, String key, byte[] inputData) { + ProtoS7 proto = new ProtoS7(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + + data.put("storageType$option", storageType); + data.put("algorithmKey", MyUtil.transAlg(algFlag)); + + if (1 == storageType) { + //密钥从外部传入 + data.put("publicKey", Util.hexString2Bytes(key)); + } + if (0 == storageType) { + //传入密钥索引 +// byte[] b1="0000000000000000000".getBytes(); +// byte[] bytes = new byte[b1.length+key.length]; +// System.arraycopy(b1,0,bytes,0,b1.length); +// System.arraycopy(key,0,bytes,b1.length,key.length); +// if (0 == Long.parseLong(key)) { +// throw new SydApiException("输入的数据格式错误", 21); +// } + String gId = "00000000" + key; + gId = gId.substring(gId.length() - 8); + data.put("keyIndex", "0000000000000000000" + gId); + } + + data.put("inputData", inputData); + + ByteBuffer bb = proto.rend(packet); + + synchronized (this) { + bb = syncRead(syncSend(bb)); + } + + Map ret = null; + Packet p = proto.parse(bb); + ret = p.toMap(); + if (!Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes())) { + throw new SydApiException("包序号不匹配", -4); + } else { + ret = (Map) ret.get("data"); + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + return ((PacketSection) ret.get("cipher")).getBytes(); + } + } + } + + /** + * @param storageType 存储类型 0-使用内部密钥，1-使用外部密钥 + * @param algFlag 算法类型：仅支持RSA、SM2 + * @param key 使用内部密钥时，该值传后八位密钥索引;使用外部密钥时，该值为私钥 + * @param cipherText 密文 + * @return byte[] 明文 + * @author wp + * @Description: (A8)非对称解密接口 + * @date 2021/5/31 + */ + @Override + public byte[] ASYMDeData(int storageType, int algFlag, String key, byte[] cipherText) { + ProtoS8 proto = new ProtoS8(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + + data.put("storageType$option", storageType); + data.put("algorithmKey", MyUtil.transAlg(algFlag)); + + if (1 == storageType) { + //密钥从外部传入 + data.put("privateKey", Util.hexString2Bytes(key)); + } + if (0 == storageType) { + //传入密钥索引 +// byte[] b1="0000000000000000000".getBytes(); +// byte[] bytes = new byte[b1.length+key.length]; +// System.arraycopy(b1,0,bytes,0,b1.length); +// System.arraycopy(key,0,bytes,b1.length,key.length); +// if (0 == Long.parseLong(key)) { +// throw new SydApiException("输入的数据格式错误", 21); +// } + String gId = "00000000" + key; + gId = gId.substring(gId.length() - 8, gId.length()); + data.put("keyIndex", "0000000000000000000" + gId); + } + + data.put("inputData", cipherText); + + ByteBuffer bb = proto.rend(packet); + + synchronized (this) { + bb = syncRead(syncSend(bb)); + } + + Map ret = null; + Packet p = proto.parse(bb); + ret = p.toMap(); + if (!Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes())) { + throw new SydApiException("包序号不匹配", -4); + } else { + ret = (Map) ret.get("data"); + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + return ((PacketSection) ret.get("info")).getBytes(); + } + } + } + + /** + * @param protectedKeyIndex 保护密钥的索引 + * @param algFlag 保护密钥算法 + * @param iv IV 数据域 + * @param protectedKeyDivNum 保护密钥分散级数 + * @param protectedKeyDivData 分散因子 + * @param protectedKeyDivAlgFlag 分散算法标识 + * @param protectedKeyDivIv 分散算法的初始向量 + * @param exportKeyNum 导出的密钥索引个数 + * @param structList 导出的密钥结构体集合 + * @return com.sunyard.RetWrap + * @author wp + * @Description: + * @date 2021/6/1 + */ + @Override + public RetWrap exportKeyAndCalc(String protectedKeyIndex, int algFlag, byte[] iv, int protectedKeyDivNum, List protectedKeyDivData, int[] protectedKeyDivAlgFlag, List protectedKeyDivIv, int exportKeyNum, List structList) { + ProtoS9 proto = new ProtoS9(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + + String gId = "00000000" + protectedKeyIndex; + gId = gId.substring(gId.length() - 8); + data.put("protectedKeyIndex", "0000000000000000000" + gId); + + data.put("algorithmKey", MyUtil.transAlg(algFlag)); + data.put("iv", iv); + data.put("keyScatterLevel", protectedKeyDivNum); + if (1 <= protectedKeyDivNum) { + //分散因子1 + data.put("scatterFactor1", protectedKeyDivData.get(0)); + //分散算法标识1 + data.put("scatterAlgorithmKey1", MyUtil.transAlg(protectedKeyDivAlgFlag[0])); + //分散算法的初始向量1 + data.put("scatterAlgorithmVector1", protectedKeyDivIv.get(0)); + } + if (2 <= protectedKeyDivNum) { + data.put("scatterFactor2", protectedKeyDivData.get(1)); + data.put("scatterAlgorithmKey2", MyUtil.transAlg(protectedKeyDivAlgFlag[1])); + data.put("scatterAlgorithmVector2", protectedKeyDivIv.get(1)); + } + if (3 == protectedKeyDivNum) { + data.put("scatterFactor3", protectedKeyDivData.get(2)); + data.put("scatterAlgorithmKey3", MyUtil.transAlg(protectedKeyDivAlgFlag[2])); + data.put("scatterAlgorithmVector3", protectedKeyDivIv.get(2)); + } + //导出的密钥索引个数 + data.put("exportKeyNum", exportKeyNum); + + //导出的密钥结构体 + byte[] b = new byte[144 * exportKeyNum]; + int destPos = 0; + for (Struct struct : structList) { + System.arraycopy(struct.getByte(), 0, b, destPos, struct.getByte().length); + destPos += struct.getByte().length; + } + data.put("exportKey", b); + + + ByteBuffer bb = proto.rend(packet); + synchronized (this) { + bb = syncRead(syncSend(bb)); + } + + Map ret = null; + Packet p = proto.parse(bb, packet); + ret = p.toMap(); + if (!Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes())) { + throw new SydApiException("包序号不匹配", -4); + } else { + ret = (Map) ret.get("data"); + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + RetWrap res = new RetWrap(); + res.put("linkKeyOut", ((PacketSection) ret.get("linkKeyOut")).getBytes()); + res.put("linkKeyCheckOut", ((PacketSection) ret.get("linkKeyCheckOut")).getBytes()); + return res; + } + } + } + + /** + * @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 + */ + @Override + public byte[] consultKey(String keyIndex, int divNum, List divData, int[] divAlgFlag, List divIv, + byte[] clientRandom, byte[] serverRandom) { + ProtoSA proto = new ProtoSA(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + + //传入密钥索引 +// byte[] b1="0000000000000000000".getBytes(); +// byte[] bytes = new byte[b1.length+key.length]; +// System.arraycopy(b1,0,bytes,0,b1.length); +// System.arraycopy(key,0,bytes,b1.length,key.length); +// if (0 == Long.parseLong(keyIndex)) { +// throw new SydApiException("输入的数据格式错误", 21); +// } + String gId = "00000000" + keyIndex; + gId = gId.substring(gId.length() - 8); + data.put("keyIndex", "0000000000000000000" + gId); + + data.put("keyScatterLevel", divNum); + if (1 <= divNum) { + //分散因子1 + data.put("scatterFactor1", divData.get(0)); + //分散算法标识1 + data.put("scatterAlgorithmKey1", MyUtil.transAlg(divAlgFlag[0])); + //分散算法的初始向量1 + data.put("scatterAlgorithmVector1", divIv.get(0)); + } + if (2 <= divNum) { + data.put("scatterFactor2", divData.get(1)); + data.put("scatterAlgorithmKey2", MyUtil.transAlg(divAlgFlag[1])); + data.put("scatterAlgorithmVector2", divIv.get(1)); + } + if (3 == divNum) { + data.put("scatterFactor3", divData.get(2)); + data.put("scatterAlgorithmKey3", MyUtil.transAlg(divAlgFlag[2])); + data.put("scatterAlgorithmVector3", divIv.get(2)); + } + + data.put("masterKeyLabel", Util.hexString2Bytes("6D617374657220736563726574")); + data.put("workKeyLabel", Util.hexString2Bytes("6B657920657870616E73696F6E")); + data.put("clientRandomNum", clientRandom); + data.put("serverRandomNum", serverRandom); + + ByteBuffer bb = proto.rend(packet); + synchronized (this) { + bb = syncRead(syncSend(bb)); + } + + Map ret = null; + Packet p = proto.parse(bb, packet); + ret = p.toMap(); + if (!Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes())) { + throw new SydApiException("包序号不匹配", -4); + } else { + ret = (Map) ret.get("data"); + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + return ((PacketSection) ret.get("sessionKey")).getBytes(); + } + } + } + + /** + * @param key 外部密钥 + * @param seed 种子 + * @param outLen 输出数据长度 + * @return byte[] pHash + * @author wp + * @Description:(B2)HTTPS PHash算法（外部密钥） + * @date 2021/5/31 + */ + @Override + public byte[] pHash(String key, String seed, int outLen) { + ProtoSB proto = new ProtoSB(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + + data.put("key", Util.hexString2Bytes(key)); + data.put("seed", Util.hexString2Bytes(seed)); + data.put("outLen", outLen); + + ByteBuffer bb = proto.rend(packet); + synchronized (this) { + bb = syncRead(syncSend(bb)); + } + + Map ret = null; + Packet p = proto.parse(bb, packet); + ret = p.toMap(); + if (!Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes())) { + throw new SydApiException("包序号不匹配", -4); + } else { + ret = (Map) ret.get("data"); + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + return ((PacketSection) ret.get("pHash")).getBytes(); + } + } + } + + /** + * @param decryptKeyIndex 解密密钥索引 + * @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 + */ + @Override + public byte[] decrytAndEn(String decryptKeyIndex, int decryptAlgFlag, byte[] decryptIv, int decryptKeyDivNum, List decryptKeyDivData, int[] decryptKeyDivAlgFlag, List decryptKeyDivIv, + String encryptKeyIndex, int encryptAlgFlag, byte[] encryptIv, int encryptKeyDivNum, List encryptKeyDivData, int[] encryptKeyDivAlgFlag, List encryptKeyDivIv, + byte[] inputData) { + ProtoSC proto = new ProtoSC(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + //传入密钥索引 +// byte[] b1="0000000000000000000".getBytes(); +// byte[] bytes = new byte[b1.length+key.length]; +// System.arraycopy(b1,0,bytes,0,b1.length); +// System.arraycopy(key,0,bytes,b1.length,key.length); +// if (0 == Long.parseLong(decryptKeyIndex)) { +// throw new SydApiException("输入的数据格式错误", 21); +// } + String gId = "00000000" + decryptKeyIndex; + gId = gId.substring(gId.length() - 8, gId.length()); + data.put("deKeyIndex", "0000000000000000000" + gId); + + //算法类型支持算法：3DES、AES、SM1、SM4 + data.put("algorithmKey", MyUtil.transAlg(decryptAlgFlag)); + data.put("scatterAlgorithmVector", decryptIv); + //解密密钥分散级数 + data.put("deKeyScatterLevel", decryptKeyDivNum); + if (1 <= decryptKeyDivNum) { + //分散因子1 + data.put("deScatterFactor1", decryptKeyDivData.get(0)); + //分散算法标识1 + data.put("deScatterAlgorithmKey1", MyUtil.transAlg(decryptKeyDivAlgFlag[0])); + //分散算法的初始向量1 + data.put("deScatterAlgorithmVector1", decryptKeyDivIv.get(0)); + } + if (2 <= decryptKeyDivNum) { + data.put("deScatterFactor2", decryptKeyDivData.get(1)); + data.put("deScatterAlgorithmKey2", MyUtil.transAlg(decryptKeyDivAlgFlag[1])); + data.put("deScatterAlgorithmVector2", decryptKeyDivIv.get(1)); + } + if (3 == decryptKeyDivNum) { + data.put("deScatterFactor3", decryptKeyDivData.get(2)); + data.put("deScatterAlgorithmKey3", MyUtil.transAlg(decryptKeyDivAlgFlag[2])); + data.put("deScatterAlgorithmVector3", decryptKeyDivIv.get(2)); + } + + //加密密钥索引 +// if (0 == Long.parseLong(encryptKeyIndex)) { +// throw new SydApiException("输入的数据格式错误", 21); +// } + String en = "00000000" + encryptKeyIndex; + en = en.substring(en.length() - 8, en.length()); + data.put("enKeyIndex", "0000000000000000000" + en); + data.put("encryptAlgFlag", MyUtil.transAlg(encryptAlgFlag)); + data.put("encryptIv", encryptIv); + + data.put("enKeyScatterLevel", encryptKeyDivNum); + if (1 <= encryptKeyDivNum) { + //分散因子1 + data.put("enScatterFactor1", encryptKeyDivData.get(0)); + //分散算法标识1 + data.put("enScatterAlgorithmKey1", MyUtil.transAlg(encryptKeyDivAlgFlag[0])); + //分散算法的初始向量1 + data.put("enScatterAlgorithmVector1", encryptKeyDivIv.get(0)); + } + if (2 <= encryptKeyDivNum) { + data.put("enScatterFactor2", encryptKeyDivData.get(1)); + data.put("enScatterAlgorithmKey2", MyUtil.transAlg(encryptKeyDivAlgFlag[1])); + data.put("enScatterAlgorithmVector2", encryptKeyDivIv.get(1)); + } + if (3 == encryptKeyDivNum) { + data.put("enScatterFactor3", encryptKeyDivData.get(2)); + data.put("enScatterAlgorithmKey3", MyUtil.transAlg(encryptKeyDivAlgFlag[2])); + data.put("enScatterAlgorithmVector3", encryptKeyDivIv.get(2)); + } + + //输入数据 + data.put("inputData", inputData); + // 渲染发送 + ByteBuffer bb = proto.rend(packet); + + synchronized (this) { + // 响应解析 + bb = syncRead(syncSend(bb)); + } + + Packet p = proto.parse(bb); + Map ret = p.toMap(); + + if ( + !Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes()) + ) { + throw new SydApiException("包序号不匹配", -4); + } + ret = (Map) ret.get("data"); + + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + return ((PacketSection) ret.get("info")).getBytes(); + } + } + + /** + * @param storageType 存储类型 0-使用内部密钥 1-使用外部密钥 + * @param key 使用内部密钥时为解密私钥索引，使用外部密钥时为解密私钥 + * @param decryptAlgFlag 解密算法类型 + * @param inputData 待转加密的数据 + * @param prefixIgnoreCount 使用解密后、加密前，需要对数据的前指定直接做截断 + * @param suffixIgnoreCount 使用解密后、加密前，需要对数据的后指定直接做截断 + * @return byte[] 使用加密机主密钥加密的对称密钥 + * @author wp + * @Description:(B4)非对称密钥解密并输出主密钥加密对称密钥密文 + * @date 2021/6/1 + */ + @Override + public byte[] ASYMDecryptAndEn(int storageType, String key, int decryptAlgFlag, byte[] inputData, int prefixIgnoreCount, int suffixIgnoreCount) { + ProtoSD proto = new ProtoSD(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + + data.put("storageType$option", storageType); + if (0 == storageType) { + String gId = "00000000" + key; + gId = gId.substring(gId.length() - 8); + data.put("keyIndex", "0000000000000000000" + gId); + + } + + data.put("algorithmKey", MyUtil.transAlg(decryptAlgFlag)); + + if (1 == storageType) { + data.put("privateKey", Util.hexString2Bytes(key)); + } + + data.put("inputData", inputData); + data.put("prefixIgnoreCount", prefixIgnoreCount); + data.put("suffixIgnoreCount", suffixIgnoreCount); + + ByteBuffer bb = proto.rend(packet); + synchronized (this) { + bb = syncRead(syncSend(bb)); + } + + Map ret; + Packet p = proto.parse(bb, packet); + ret = p.toMap(); + if (!Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes())) { + throw new SydApiException("包序号不匹配", -4); + } else { + ret = (Map) ret.get("data"); + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + return ((PacketSection) ret.get("keyCiphertext")).getBytes(); + } + } + } + + /** + * @param decryptKey 解密密钥 + * @param decryptAlgFlag 解密算法类型 + * @param decryptIv IV 数据域 + * @param inputData 待转加密的数据 + * @return byte[] 密码机主密钥加密的密钥密文 + * @author wp + * @Description: (B5)外部对称密钥解密并输出主密钥加密对称密钥密文 + * @date 2021/6/1 + */ + @Override + public byte[] SYMDecryptAndEn(String decryptKey, int decryptAlgFlag, byte[] decryptIv, byte[] inputData) { + ProtoSE proto = new ProtoSE(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + + data.put("key", Util.hexString2Bytes(decryptKey)); + data.put("algorithmKey", MyUtil.transAlg(decryptAlgFlag)); + data.put("iv", decryptIv); + data.put("inputData", inputData); + + ByteBuffer bb = proto.rend(packet); + synchronized (this) { + bb = syncRead(syncSend(bb)); + } + + Map ret; + Packet p = proto.parse(bb, packet); + ret = p.toMap(); + if (!Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes())) { + throw new SydApiException("包序号不匹配", -4); + } else { + ret = (Map) ret.get("data"); + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + return ((PacketSection) ret.get("keyCiphertext")).getBytes(); + } + } + } + + /** + * @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 + */ + @Override + public byte[] decryptByMainAndSYMEn(String encryptKeyIndex, int encryptAlgFlag, byte[] encryptIv, int encryptKeyDivNum, + List encryptKeyDivData, int[] encryptKeyDivAlgFlag, List encryptKeyDivIv, byte[] inputData) { + ProtoSF proto = new ProtoSF(); + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + + String gId = "00000000" + encryptKeyIndex; + gId = gId.substring(gId.length() - 8); + data.put("enKeyIndex", "0000000000000000000" + gId); + data.put("algorithmKey", MyUtil.transAlg(encryptAlgFlag)); + data.put("iv", encryptIv); + + data.put("enKeyScatterLevel", encryptKeyDivNum); + if (1 <= encryptKeyDivNum) { + //分散因子1 + data.put("enScatterFactor1", encryptKeyDivData.get(0)); + //分散算法标识1 + data.put("enScatterAlgorithmKey1", MyUtil.transAlg(encryptKeyDivAlgFlag[0])); + //分散算法的初始向量1 + data.put("enScatterAlgorithmVector1", encryptKeyDivIv.get(0)); + } + if (2 <= encryptKeyDivNum) { + data.put("enScatterFactor2", encryptKeyDivData.get(1)); + data.put("enScatterAlgorithmKey2", MyUtil.transAlg(encryptKeyDivAlgFlag[1])); + data.put("enScatterAlgorithmVector2", encryptKeyDivIv.get(1)); + } + if (3 == encryptKeyDivNum) { + data.put("enScatterFactor3", encryptKeyDivData.get(2)); + data.put("enScatterAlgorithmKey3", MyUtil.transAlg(encryptKeyDivAlgFlag[2])); + data.put("enScatterAlgorithmVector3", encryptKeyDivIv.get(2)); + } + + //输入数据 + data.put("inputData", inputData); + + ByteBuffer bb = proto.rend(packet); + synchronized (this) { + bb = syncRead(syncSend(bb)); + } + + Map ret = null; + Packet p = proto.parse(bb, packet); + ret = p.toMap(); + if (!Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes())) { + throw new SydApiException("包序号不匹配", -4); + } else { + ret = (Map) ret.get("data"); + PacketSection error = (PacketSection) ret.get("error"); + if (!"00".equals(error.getString())) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } else { + return ((PacketSection) ret.get("info")).getBytes(); + } + } + } + + // ---------------------中移指令结束-------------------------------- } diff --git a/src/main/java/racal/sunyard/main/dto/DTO4D41.java b/src/main/java/racal/sunyard/main/dto/DTO4D41.java index 2927a2a..230aa5a 100644 --- a/src/main/java/racal/sunyard/main/dto/DTO4D41.java +++ b/src/main/java/racal/sunyard/main/dto/DTO4D41.java @@ -375,12 +375,10 @@ public enum TypeOptions { soup.put("type$option", getTypeOptionIndex()); } - soup.put("full", Util.hexString2Bytes("30")); if( null != full ){ soup.put("full", this.full); } - soup.put("macLen", Util.hexString2Bytes("31")); if( null != macLen ){ soup.put("macLen", this.macLen); } @@ -421,12 +419,10 @@ public enum TypeOptions { this.type = ((PacketSection) soup.get("type")).getBytes(); } - this.full = Util.hexString2Bytes("30"); if( soup.containsKey("full") ){ this.full = ((PacketSection) soup.get("full")).getBytes(); } - this.macLen = Util.hexString2Bytes("31"); if( soup.containsKey("macLen") ){ this.macLen = ((PacketSection) soup.get("macLen")).getBytes(); } diff --git a/src/main/java/racal/sunyard/main/dto/DTO4D43.java b/src/main/java/racal/sunyard/main/dto/DTO4D43.java index ce80a57..916c8e2 100644 --- a/src/main/java/racal/sunyard/main/dto/DTO4D43.java +++ b/src/main/java/racal/sunyard/main/dto/DTO4D43.java @@ -403,12 +403,10 @@ public enum TypeOptions { soup.put("type$option", getTypeOptionIndex()); } - soup.put("full", Util.hexString2Bytes("30")); if( null != full ){ soup.put("full", this.full); } - soup.put("macLen", Util.hexString2Bytes("31")); if( null != macLen ){ soup.put("macLen", this.macLen); } @@ -453,12 +451,10 @@ public enum TypeOptions { this.type = ((PacketSection) soup.get("type")).getBytes(); } - this.full = Util.hexString2Bytes("30"); if( soup.containsKey("full") ){ this.full = ((PacketSection) soup.get("full")).getBytes(); } - this.macLen = Util.hexString2Bytes("31"); if( soup.containsKey("macLen") ){ this.macLen = ((PacketSection) soup.get("macLen")).getBytes(); } diff --git a/src/test/java/com/sunyard/sydapi/test/TestZY.java b/src/test/java/com/sunyard/sydapi/test/TestZY.java new file mode 100644 index 0000000..b48dae7 --- /dev/null +++ b/src/test/java/com/sunyard/sydapi/test/TestZY.java @@ -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 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 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 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 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 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 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 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 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 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 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"))); + 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 + } + //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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tring 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 protectedKeyDivData=new ArrayList<>(); + protectedKeyDivData.add(Util.hexString2Bytes("31313131313131313131313131313131")); + protectedKeyDivData.add(Util.hexString2Bytes("32323232323232323232323232323232")); + protectedKeyDivData.add(Util.hexString2Bytes("33333333333333333333333333333333")); + + List structList=new ArrayList<>(); + byte[] bytes = Util.hexString2Bytes("313131313131313131313131313131313232323232323232323232323232323233333333333333333333333333333333"); + int[] i={41,41,41}; + + + List 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 protectedKeyDivData=new ArrayList<>(); + protectedKeyDivData.add(Util.hexString2Bytes("31313131313131313131313131313131")); + protectedKeyDivData.add(Util.hexString2Bytes("32323232323232323232323232323232")); + protectedKeyDivData.add(Util.hexString2Bytes("33333333333333333333333333333333")); + + List structList=new ArrayList<>(); + int[] i={41,41,42}; + + List divIv=new ArrayList<>(); + divIv.add(Util.hexString2Bytes("00000000000000000000000000000000")); + divIv.add(Util.hexString2Bytes("00000000000000000000000000000000")); + divIv.add(Util.hexString2Bytes("00000000000000000000000000000000")); + + + List 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 protectedKeyDivData=new ArrayList<>(); + protectedKeyDivData.add(Util.hexString2Bytes("59243981728845760300152622870624")); + protectedKeyDivData.add(Util.hexString2Bytes("13000002031301110002031301110094")); + protectedKeyDivData.add(Util.hexString2Bytes("01810001000000000000000000000000")); + + List structList=new ArrayList<>(); + byte[] bytes = Util.hexString2Bytes("313131313131313131313131313131313232323232323232323232323232323233333333333333333333333333333333"); + int[] i={41,41}; + + + List protectedKeyDivIv=new ArrayList<>(); + protectedKeyDivIv.add(Util.hexString2Bytes("0000000000000000")); + protectedKeyDivIv.add(Util.hexString2Bytes("0000000000000000")); + protectedKeyDivIv.add(Util.hexString2Bytes("0000000000000000")); + + List divData=new ArrayList<>(); + divData.add(Util.hexString2Bytes("25637158699399449582953157027093")); + divData.add(Util.hexString2Bytes("13000002031301110002031301110094")); + + List 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 divData=new ArrayList<>(); + divData.add(Util.hexString2Bytes("D1560001010001600000000100000000")); + divData.add(Util.hexString2Bytes("2000000910300305000910300305359C")); + int[] i={41,41}; + List 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 divData=new ArrayList<>(); + divData.add(Util.hexString2Bytes("D1560001010001600000000100000000")); + divData.add(Util.hexString2Bytes("2000000910300305000910300305359C")); + int[] i={41,41}; + List 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 decryptKeyDivData = new ArrayList(); + decryptKeyDivData.add(Util.hexString2Bytes("65706917038051804927766430009625")); + decryptKeyDivData.add(Util.hexString2Bytes("13000002031301110002031301110097")); + decryptKeyDivData.add(Util.hexString2Bytes("01820001000000000000000000000000")); + //分散算法标识 + int[] decryptKeyDivAlgFlag={41,42,51}; + + List 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 list1 = new ArrayList(); + list1.add(Util.hexString2Bytes("65706917038051804927766430009625")); + list1.add(Util.hexString2Bytes("13000002031301110002031301110097")); + list1.add(Util.hexString2Bytes("01820001000000000000000000000000")); + //分散算法标识 + int[] i={41,41,52}; + + ArrayList 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); + } +}