3510 lines
149 KiB
Java
3510 lines
149 KiB
Java
package test;
|
||
|
||
import com.sunyard.SydApiException;
|
||
import com.sunyard.log.ILogFactory;
|
||
import com.sunyard.log.ILogger;
|
||
import com.sunyard.proto.Util;
|
||
import com.sunyard.sge.database.*;
|
||
import com.sunyard.sge.log.LogbackFactory;
|
||
|
||
import java.util.ArrayList;
|
||
import java.util.Arrays;
|
||
import java.util.List;
|
||
|
||
/**
|
||
* 功能确认
|
||
*/
|
||
public class FuncTest {
|
||
private ILogFactory iLogFactory = new LogbackFactory();
|
||
private ILogger log = iLogFactory.getLogger(FuncTest.class);
|
||
|
||
public static final int ECB_DEC = 0;
|
||
public static final int ECB_ENC = 1;
|
||
|
||
private Config config;
|
||
|
||
private boolean isShortLink = false;
|
||
private int connectTimeout = 1000;
|
||
private int dealTimeout = 2000;
|
||
|
||
public FuncTest(Config config) {
|
||
this.config = config;
|
||
}
|
||
|
||
|
||
public SydApi connect() {
|
||
if (isShortLink) {
|
||
|
||
System.out.println("short");
|
||
SydApi api = new SydApi4Database();
|
||
api.SYD_Short_Connect_Ex(config.getIps(), config.getPorts(), connectTimeout, dealTimeout);
|
||
return api;
|
||
} else {
|
||
System.out.println("long");
|
||
SydApiBuilder builder = new SydApiBuilder(
|
||
config.getIps(),
|
||
config.getPorts(),
|
||
connectTimeout,
|
||
dealTimeout
|
||
);
|
||
SydApi api = builder.build();
|
||
return api;
|
||
}
|
||
}
|
||
|
||
private void changeConnect(boolean is_short_link){
|
||
isShortLink = is_short_link;
|
||
if(isShortLink){
|
||
System.out.println("-------- 设置为短连模式 --------\n");
|
||
} else {
|
||
System.out.println("-------- 设置为长连模式 --------\n");
|
||
}
|
||
}
|
||
|
||
public void connectFunc() {
|
||
String[] pcIpList = {"172.1.41.129", "172.1.41.216"};
|
||
String[] pcIpList_1 = {"1.1.1.1", "2.2.2.2"}; //测试 没有正确的IP和端口
|
||
int[] iPortList = {8889, 8889};
|
||
int[] iPortList_1 = {8889, 0}; //测试 部分IP端口对应关系无法访问
|
||
int[] iPortList_2 = {8889}; //测试 端口号个数与加密机未一一对应
|
||
int[] iPortList_3 = {0,0}; //测试 没有正确的IP和端口
|
||
|
||
log("-------- 设置短连接参数与获取短连接功能测试开始 --------", true);
|
||
|
||
printBegin();
|
||
try{
|
||
SydApi api = new SydApi4Database();
|
||
api.SYD_Short_Connect_Ex(pcIpList, iPortList, connectTimeout, dealTimeout);
|
||
System.out.println("输入正确的加密机IP，端口,设置短连接参数与获取短连接成功");
|
||
} catch(SydApiException e){
|
||
printException("输入正确的加密机IP，端口,设置短连接参数与获取短连接失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
SydApi api = new SydApi4Database();
|
||
api.SYD_Short_Connect_Ex(pcIpList, iPortList_1, connectTimeout, dealTimeout);
|
||
System.out.println("部分IP端口对应关系无法访问,设置短连接参数与获取短连接成功");
|
||
} catch(SydApiException e){
|
||
printException("部分IP端口对应关系无法访问,设置短连接参数与获取短连接失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
SydApi api = new SydApi4Database();
|
||
api.SYD_Short_Connect_Ex(pcIpList, iPortList_2, connectTimeout, dealTimeout);
|
||
System.out.println("端口号个数与加密机未一一对应,设置短连接参数与获取短连接成功");
|
||
} catch(Exception e){
|
||
System.out.println("端口号个数与加密机未一一对应,设置短连接参数与获取短连接失败 异常:" + e.getMessage());
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
SydApi api = new SydApi4Database();
|
||
api.SYD_Short_Connect_Ex(pcIpList_1, iPortList_3, connectTimeout, dealTimeout);
|
||
System.out.println("没有正确的IP和端口,设置短连接参数与获取短连接成功");
|
||
} catch(SydApiException e){
|
||
printException("没有正确的IP和端口,设置短连接参数与获取短连接失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
log("-------- 设置短连接参数与获取短连接功能测试结束 --------\n", true);
|
||
}
|
||
|
||
public void disconnectFunc() {
|
||
String[] pcIpList = {"172.1.41.129", "172.1.41.216"};
|
||
int[] iPortList = {8889, 8889};
|
||
|
||
log("-------- 断开短连接功能测试开始 --------", true);
|
||
|
||
printBegin();
|
||
try{
|
||
SydApi api = new SydApi4Database();
|
||
api.SYD_Short_Connect_Ex(pcIpList, iPortList, connectTimeout, dealTimeout);
|
||
System.out.println("输入正确的加密机IP，端口,设置短连接参数与获取短连接成功");
|
||
|
||
api.SYD_Disconnect_Ex();
|
||
System.out.println("已与设备连接，断开连接成功");
|
||
} catch(SydApiException e){
|
||
printException("已与设备连接，断开连接失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
SydApi api = new SydApi4Database();
|
||
api.SYD_Disconnect_Ex();
|
||
System.out.println("未与设备连接，断开连接成功");
|
||
} catch(SydApiException e){
|
||
printException("未与设备连接，断开连接失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
|
||
log("-------- 断开短连接功能测试结束 --------\n", true);
|
||
}
|
||
|
||
public void longConnectFunc() {
|
||
String[] pcIpList = {"172.1.41.129", "172.1.41.216"};
|
||
String[] pcIpList_1 = {"1.1.1.1", "2.2.2.2"}; //测试 没有正确的IP和端口
|
||
int[] iPortList = {8889, 8889};
|
||
int[] iPortList_1 = {8889, 0}; //测试 部分IP端口对应关系无法访问
|
||
int[] iPortList_2 = {8889}; //测试 端口号个数与加密机未一一对应
|
||
int[] iPortList_3 = {0,0}; //测试 没有正确的IP和端口
|
||
|
||
log("-------- 设置长连接参数与获取长连接功能测试开始 --------", true);
|
||
|
||
printBegin();
|
||
try{
|
||
SydApiBuilder builder = new SydApiBuilder(
|
||
pcIpList,
|
||
iPortList,
|
||
connectTimeout,
|
||
dealTimeout
|
||
);
|
||
SydApi api = builder.build();
|
||
System.out.println("输入正确的加密机IP，端口,设置长连接参数与获取长连接成功");
|
||
} catch(SydApiException e){
|
||
printException("输入正确的加密机IP，端口,设置长连接参数与获取长连接失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
SydApiBuilder builder = new SydApiBuilder(
|
||
pcIpList,
|
||
iPortList_1,
|
||
connectTimeout,
|
||
dealTimeout
|
||
);
|
||
SydApi api = builder.build();
|
||
System.out.println("部分IP端口对应关系无法访问,设置长连接参数与获取长连接成功");
|
||
} catch(SydApiException e){
|
||
printException("部分IP端口对应关系无法访问,设置长连接参数与获取长连接失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
SydApiBuilder builder = new SydApiBuilder(
|
||
pcIpList,
|
||
iPortList_2,
|
||
connectTimeout,
|
||
dealTimeout
|
||
);
|
||
SydApi api = builder.build();
|
||
System.out.println("端口号个数与加密机未一一对应,设置长连接参数与获取长连接成功");
|
||
} catch(Exception e){
|
||
System.out.println("端口号个数与加密机未一一对应,设置长连接参数与获取长连接失败 异常:" + e.getMessage());
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
SydApiBuilder builder = new SydApiBuilder(
|
||
pcIpList_1,
|
||
iPortList_3,
|
||
connectTimeout,
|
||
dealTimeout
|
||
);
|
||
SydApi api = builder.build();
|
||
System.out.println("没有正确的IP和端口,设置长连接参数与获取长连接成功");
|
||
} catch(SydApiException e){
|
||
printException("没有正确的IP和端口,设置长连接参数与获取长连接失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
log("-------- 设置长连接参数与获取长连接功能测试结束 --------\n", true);
|
||
}
|
||
|
||
public void sm3ShortFunc() {
|
||
System.out.println("-------- SM3短数据功能测试开始 --------");
|
||
|
||
SydApi api = connect();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=1; i<=1024; i++){
|
||
byte[] data = new byte[i];
|
||
log("sm3ShortFunc_明文：" + Util.bytes2HexString(data), false);
|
||
|
||
byte[] res = api.SYD_SM3_Hash_ShortData(data);
|
||
log("sm3ShortFunc_res:" + Util.bytes2HexString(res), false);
|
||
|
||
ISM3 sm3 = api.initSM3();
|
||
sm3.update(data);
|
||
byte[] res_2 = sm3.digest();
|
||
log("sm3ShortFunc_res_2:" + Util.bytes2HexString(res_2), false);
|
||
|
||
if(!(Util.bytes2HexString(res).equals(Util.bytes2HexString(res_2))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc) {
|
||
System.out.println("正常传参,hash计算成功");
|
||
} else {
|
||
System.out.println("正常传参,hash计算失败");
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("正常传参，hash计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try {
|
||
api.SYD_SM3_Hash_ShortData(new byte[1025]);
|
||
System.out.println("输入数据长度超过1K, hash计算成功");
|
||
} catch (SydApiException e) {
|
||
printException("输入数据长度超过1K", e);
|
||
}
|
||
printEnd();
|
||
|
||
System.out.println("-------- SM3短数据功能测试结束 --------\n");
|
||
}
|
||
|
||
public void sm3LongFunc() {
|
||
System.out.println("-------- SM3长数据功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=1; i<=1024; i++){
|
||
byte[] data = new byte[i];
|
||
log("sm3LongFunc_明文：" + Util.bytes2HexString(data), false);
|
||
|
||
byte[] res = api.SYD_SM3_Hash_ShortData(data);
|
||
log("sm3LongFunc_res:" + Util.bytes2HexString(res), false);
|
||
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM3_Hash_LongData(data, 0, null);
|
||
byte[] res_2 = longDataReturn.getData();
|
||
log("sm3LongFunc_res_2:" + Util.bytes2HexString(res_2), false);
|
||
|
||
if(!(Util.bytes2HexString(res).equals(Util.bytes2HexString(res_2))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc) {
|
||
System.out.println("包序号输入0,hash计算成功");
|
||
} else {
|
||
System.out.println("包序号输入0,hash计算失败");
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("包序号输入0", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=1; i<=1024; i++){
|
||
byte[] data = new byte[i];
|
||
log("sm3LongFunc_明文：" + Util.bytes2HexString(data), false);
|
||
|
||
byte[] res = api.SYD_SM3_Hash_ShortData(data);
|
||
log("sm3LongFunc_res:" + Util.bytes2HexString(res), false);
|
||
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM3_Hash_LongData(data, 1, null);
|
||
log("sm3LongFunc_ProcData:" + Util.bytes2HexString(longDataReturn.getProcData()), false);
|
||
|
||
longDataReturn = api.SYD_SM3_Hash_LongData(new byte[0], 3, longDataReturn.getProcData());
|
||
byte[] res_2 = longDataReturn.getData();
|
||
log("sm3LongFunc_res_2:" + Util.bytes2HexString(res_2), false);
|
||
|
||
if(!(Util.bytes2HexString(res).equals(Util.bytes2HexString(res_2))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc) {
|
||
System.out.println("包序号输入1,3,hash计算成功");
|
||
} else {
|
||
System.out.println("包序号输入1,3,hash计算失败");
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("包序号输入1,3", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=1; i<=1024; i++){
|
||
byte[] data = new byte[i];
|
||
log("sm3LongFunc_明文：" + Util.bytes2HexString(data), false);
|
||
|
||
byte[] res = api.SYD_SM3_Hash_ShortData(data);
|
||
log("sm3LongFunc_res:" + Util.bytes2HexString(res), false);
|
||
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM3_Hash_LongData(data, 1, null);
|
||
log("sm3LongFunc_ProcData1:" + Util.bytes2HexString(longDataReturn.getProcData()), false);
|
||
|
||
longDataReturn = api.SYD_SM3_Hash_LongData(new byte[0], 2, longDataReturn.getProcData());
|
||
log("sm3LongFunc_ProcData2:" + Util.bytes2HexString(longDataReturn.getProcData()), false);
|
||
|
||
longDataReturn = api.SYD_SM3_Hash_LongData(new byte[0], 3, longDataReturn.getProcData());
|
||
byte[] res_2 = longDataReturn.getData();
|
||
log("sm3LongFunc_res_2:" + Util.bytes2HexString(res_2), false);
|
||
|
||
if(!(Util.bytes2HexString(res).equals(Util.bytes2HexString(res_2))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc) {
|
||
System.out.println("包序号输入1,2,3,hash计算成功");
|
||
} else {
|
||
System.out.println("包序号输入1,2,3,hash计算失败");
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("包序号输入1,2,3", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM3_Hash_LongData(new byte[1024], 4, null);
|
||
System.out.println("包序号输入4, 成功");
|
||
} catch(SydApiException e){
|
||
printException("包序号输入4", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM3_Hash_LongData(new byte[1024], 1, null);
|
||
longDataReturn = api.SYD_SM3_Hash_LongData(new byte[1024], 2, null);
|
||
System.out.println("包序号输入1,2，但pcProcData无输入, 成功");
|
||
} catch(SydApiException e){
|
||
printException("包序号输入1,2，但pcProcData无输入", e);
|
||
}
|
||
printEnd();
|
||
|
||
System.out.println("-------- SM3长数据功能测试结束 --------\n");
|
||
}
|
||
|
||
public void sm3LongFunc_ISM3() {
|
||
System.out.println("-------- (ISM3)SM3长数据功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=1; i<=1024; i++){
|
||
byte[] data = genBytes(i);
|
||
log("sm3LongFunc_ISM3___明文: " + Util.bytes2HexString(data), false);
|
||
byte[] res1 = api.SYD_SM3_Hash_ShortData(data);
|
||
log("sm3LongFunc_ISM3___res1: " + Util.bytes2HexString(res1), false);
|
||
|
||
ISM3 sm3 = api.initSM3();
|
||
sm3.update(data);
|
||
byte[] res2 = sm3.digest();
|
||
log("sm3LongFunc_ISM3___res2: " + Util.bytes2HexString(res2), false);
|
||
if(!(Util.bytes2HexString(res1).equals(Util.bytes2HexString(res2)))){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(isSuc){
|
||
System.out.println("输入正确的入参,计算成功" );
|
||
} else {
|
||
System.out.println("输入正确的入参,计算失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确的入参,计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[4070];
|
||
ISM3 sm3 = api.initSM3();
|
||
sm3.update(data);
|
||
byte[] res = sm3.digest();
|
||
System.out.println("输入数据长度超过4064,结果:" + Util.bytes2HexString(res));
|
||
} catch (SydApiException e){
|
||
printException("输入数据长度超过4064,计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
System.out.println("-------- (ISM3)SM3长数据功能测试结束 --------\n");
|
||
}
|
||
|
||
public void sm4ShortFunc() {
|
||
System.out.println("-------- SM4短数据加解密功能测试开始 --------");
|
||
SydApi api = connect();
|
||
int key = 0;
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=1; i<=1024; i++){
|
||
byte[] data = new byte[i];
|
||
log("sm4ShortFunc_明文: " + Util.bytes2HexString(data), false);
|
||
|
||
byte[] enc = api.SYD_SM4_ShortData(key, data, ECB_ENC);
|
||
log("sm4ShortFunc_加密后: " + Util.bytes2HexString(enc), false);
|
||
|
||
byte[] dec = api.SYD_SM4_ShortData(key, enc, ECB_DEC);
|
||
log("sm4ShortFunc_解密后: " + Util.bytes2HexString(dec), false);
|
||
|
||
if(!(Util.bytes2HexString(data).equals(Util.bytes2HexString(dec))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc){
|
||
System.out.println("正确传参，加密成功,解密成功");
|
||
} else {
|
||
System.out.println("正确传参，加密失败,解密失败");
|
||
}
|
||
}catch(SydApiException e){
|
||
printException("正确传参", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try {
|
||
byte[] enc = api.SYD_SM4_ShortData(-1, new byte[1024], ECB_ENC);
|
||
System.out.println("输入不正确的会话密钥索引，输入加密标识，加密成功");
|
||
} catch (SydApiException e) {
|
||
printException("输入不正确的会话密钥索引，输入加密标识", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try {
|
||
byte[] enc = api.SYD_SM4_ShortData(key, new byte[1024], ECB_ENC);
|
||
System.out.println("正常传参，加密成功");
|
||
byte[] dec = api.SYD_SM4_ShortData(-1, enc, ECB_DEC);
|
||
System.out.println("输入不正确的会话密钥索引，输入解密标识，解密成功");
|
||
} catch (SydApiException e) {
|
||
printException("输入不正确的会话密钥索引，输入解密标识", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try {
|
||
byte[] enc = api.SYD_SM4_ShortData(key, new byte[1025], ECB_ENC);
|
||
System.out.println("输入数据长度超过1024，加密成功");
|
||
} catch (SydApiException e) {
|
||
printException("输入数据长度超过1024", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try {
|
||
byte[] dec = api.SYD_SM4_ShortData(key, new byte[1050], ECB_DEC);
|
||
System.out.println("输入数据长度超过1024+16，解密成功");
|
||
} catch (SydApiException e) {
|
||
printException("输入数据长度超过1024+16", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try {
|
||
byte[] enc = api.SYD_SM4_ShortData(key, new byte[1024], -1);
|
||
System.out.println("输入不正确的加解密标识，加解密成功");
|
||
} catch (SydApiException e) {
|
||
printException("输入不正确的加解密标识", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try {
|
||
byte[] data = new byte[1024];
|
||
byte[] enc = api.SYD_SM4_ShortData(key, data, ECB_ENC);
|
||
System.out.println("正常传参，加密成功,密文: " + Util.bytes2HexString(enc));
|
||
Arrays.fill(enc, 10, 30, (byte)0); //把enc改成不正确的
|
||
System.out.println("修改密文后: " + Util.bytes2HexString(enc));
|
||
byte[] dec = api.SYD_SM4_ShortData(key, enc, ECB_DEC);
|
||
if(Util.bytes2HexString(data).equals(Util.bytes2HexString(dec))){
|
||
System.out.println("输入不正确密文信息，解密对比成功");
|
||
} else {
|
||
System.out.println("输入不正确密文信息，解密对比失败");
|
||
}
|
||
} catch (SydApiException e) {
|
||
printException("输入不正确密文信息, 解密失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
|
||
System.out.println("-------- SM4短数据加解密功能测试结束 --------\n");
|
||
}
|
||
|
||
public void sm4LongFunc() {
|
||
System.out.println("-------- SM4长数据加解密功能测试开始 --------");
|
||
SydApi api = connect();
|
||
int key = 0;
|
||
int key_incorrect = -1;
|
||
|
||
printBegin();
|
||
try{
|
||
|
||
boolean isSuc = true;
|
||
for(int i=1; i<=1024; i++) {
|
||
byte[] data = new byte[i];
|
||
log("sm4LongFunc_明文: " + Util.bytes2HexString(data), false);
|
||
|
||
byte[] enc_1 = api.SYD_SM4_LongData(key, data, 0, ECB_ENC);
|
||
log("sm4LongFunc_enc_1: " + Util.bytes2HexString(enc_1), false);
|
||
|
||
byte[] enc_2 = api.SYD_SM4_ShortData(key, data, ECB_ENC);
|
||
log("sm4LongFunc_enc_2: " + Util.bytes2HexString(enc_2), false);
|
||
|
||
if(!(Util.bytes2HexString(enc_1).equals(Util.bytes2HexString(enc_2))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc){
|
||
System.out.println("输入加密标识，包序号为0 加密成功");
|
||
} else {
|
||
System.out.println("输入加密标识，包序号为0 加密失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入加密标识，包序号为0", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=1; i<=1024; i++) {
|
||
byte[] data = new byte[i];
|
||
log("sm4LongFunc_明文: " + Util.bytes2HexString(data), false);
|
||
|
||
byte[] enc = api.SYD_SM4_LongData(key, data, 0, ECB_ENC);
|
||
log("sm4LongFunc_enc: " + Util.bytes2HexString(enc), false);
|
||
|
||
byte[] dec = api.SYD_SM4_LongData(key, enc, 0, ECB_DEC);
|
||
log("sm4LongFunc_dec: " + Util.bytes2HexString(dec), false);
|
||
|
||
if(!(Util.bytes2HexString(data).equals(Util.bytes2HexString(dec))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc){
|
||
System.out.println("输入解密标识，包序号为0 解密成功");
|
||
} else {
|
||
System.out.println("输入解密标识，包序号为0 解密失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入解密标识，包序号为0 ", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=16; i<=1024; i++) {
|
||
byte[] data = new byte[i];
|
||
log("sm4LongFunc_明文: " + Util.bytes2HexString(data), false);
|
||
|
||
byte[] data1 = new byte[16]; //为了测试 包序号为1，3 的情况，将明文数据拆成2份
|
||
byte[] data2 = new byte[i-16];
|
||
byte[] enc_1 = api.SYD_SM4_LongData(key, data1, 1, ECB_ENC);
|
||
log("sm4LongFunc_enc_1: " + Util.bytes2HexString(enc_1), false);
|
||
|
||
byte[] enc_2 = api.SYD_SM4_LongData(key, data2, 3, ECB_ENC);
|
||
log("sm4LongFunc_enc_2: " + Util.bytes2HexString(enc_2), false);
|
||
|
||
byte[] enc = mergeByteArrays(enc_1, enc_2);
|
||
|
||
byte[] enc_short = api.SYD_SM4_ShortData(key, data, ECB_ENC);
|
||
log("sm4LongFunc_enc_short: " + Util.bytes2HexString(enc_short), false);
|
||
|
||
if(!(Util.bytes2HexString(enc).equals(Util.bytes2HexString(enc_short))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc){
|
||
System.out.println("输入加密标识，包序号为1，3 加密成功");
|
||
} else {
|
||
System.out.println("输入加密标识，包序号为1，3 加密失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入加密标识，包序号为1，3", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=16; i<=1024; i++) {
|
||
byte[] data = new byte[i];
|
||
log("sm4LongFunc_明文: " + Util.bytes2HexString(data), false);
|
||
|
||
byte[] enc = api.SYD_SM4_LongData(key, data, 0, ECB_ENC);
|
||
log("sm4LongFunc_enc: " + Util.bytes2HexString(enc), false);
|
||
|
||
byte[] enc_1 = Arrays.copyOfRange(enc, 0, 16);
|
||
byte[] enc_2 = Arrays.copyOfRange(enc, 16, enc.length);
|
||
byte[] dec_1 = api.SYD_SM4_LongData(key, enc_1, 1, ECB_DEC);
|
||
log("sm4LongFunc_dec_1: " + Util.bytes2HexString(dec_1), false);
|
||
|
||
byte[] dec_2 = api.SYD_SM4_LongData(key, enc_2, 3, ECB_DEC);
|
||
log("sm4LongFunc_dec_2: " + Util.bytes2HexString(dec_2), false);
|
||
|
||
byte[] dec = mergeByteArrays(dec_1, dec_2);
|
||
log("sm4LongFunc_dec: " + Util.bytes2HexString(dec), false);
|
||
|
||
if(!(Util.bytes2HexString(data).equals(Util.bytes2HexString(dec))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc){
|
||
System.out.println("输入解密标识，包序号为1,3 解密成功");
|
||
} else {
|
||
System.out.println("输入解密标识，包序号为1,3 解密失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入解密标识，包序号为1,3 ", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=32; i<=1024; i++) {
|
||
byte[] data = new byte[i];
|
||
log("sm4LongFunc_明文: " + Util.bytes2HexString(data), false);
|
||
|
||
byte[] data1 = new byte[16]; //为了测试 包序号为1，2,3 的情况，将明文数据拆成
|
||
byte[] data2 = new byte[16];
|
||
byte[] data3 = new byte[i-32];
|
||
byte[] enc_1 = api.SYD_SM4_LongData(key, data1, 1, ECB_ENC);
|
||
log("sm4LongFunc_enc_1: " + Util.bytes2HexString(enc_1), false);
|
||
|
||
byte[] enc_2 = api.SYD_SM4_LongData(key, data2, 2, ECB_ENC);
|
||
log("sm4LongFunc_enc_2: " + Util.bytes2HexString(enc_2), false);
|
||
|
||
byte[] enc_3 = api.SYD_SM4_LongData(key, data3, 3, ECB_ENC);
|
||
log("sm4LongFunc_enc_3: " + Util.bytes2HexString(enc_3), false);
|
||
|
||
byte[] enc = mergeByteArrays(enc_1, enc_2,enc_3);
|
||
|
||
byte[] enc_short = api.SYD_SM4_ShortData(key, data, ECB_ENC);
|
||
log("sm4LongFunc_enc_short: " + Util.bytes2HexString(enc_short), false);
|
||
|
||
if(!(Util.bytes2HexString(enc).equals(Util.bytes2HexString(enc_short))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc){
|
||
System.out.println("输入加密标识，包序号为1,2,3 加密成功");
|
||
} else {
|
||
System.out.println("输入加密标识，包序号为1,2,3 加密失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入加密标识，包序号为1,2,3 ", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=32; i<=1024; i++) {
|
||
byte[] data = new byte[i];
|
||
log("sm4LongFunc_明文: " + Util.bytes2HexString(data), false);
|
||
|
||
byte[] enc = api.SYD_SM4_LongData(key, data, 0, ECB_ENC);
|
||
log("sm4LongFunc_enc: " + Util.bytes2HexString(enc), false);
|
||
|
||
byte[] enc_1 = Arrays.copyOfRange(enc, 0, 16);
|
||
byte[] enc_2 = Arrays.copyOfRange(enc, 16, 32);
|
||
byte[] enc_3 = Arrays.copyOfRange(enc, 32, enc.length);
|
||
byte[] dec_1 = api.SYD_SM4_LongData(key, enc_1, 1, ECB_DEC);
|
||
log("sm4LongFunc_dec_1: " + Util.bytes2HexString(dec_1), false);
|
||
byte[] dec_2 = api.SYD_SM4_LongData(key, enc_2, 2, ECB_DEC);
|
||
log("sm4LongFunc_dec_2: " + Util.bytes2HexString(dec_2), false);
|
||
byte[] dec_3 = api.SYD_SM4_LongData(key, enc_3, 3, ECB_DEC);
|
||
log("sm4LongFunc_dec_3: " + Util.bytes2HexString(dec_3), false);
|
||
byte[] dec = mergeByteArrays(dec_1, dec_2,dec_3);
|
||
|
||
if(!(Util.bytes2HexString(data).equals(Util.bytes2HexString(dec))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc){
|
||
System.out.println("输入解密标识，包序号为1,2,3 解密成功");
|
||
} else {
|
||
System.out.println("输入解密标识，包序号为1,2,3 解密失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入解密标识，包序号为1,2,3", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
byte[] enc = api.SYD_SM4_LongData(key_incorrect, data, 0, ECB_ENC);
|
||
System.out.println("输入错误的会话密钥索引，输入加密标识 计算成功");
|
||
} catch (SydApiException e){
|
||
printException("输入错误的会话密钥索引，输入加密标识",e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
byte[] enc = api.SYD_SM4_LongData(key, data, 0, ECB_ENC);
|
||
System.out.println("先正常传参，算出密文");
|
||
byte[] dec = api.SYD_SM4_LongData(key_incorrect, enc, 0, ECB_DEC);
|
||
System.out.println("输入错误的会话密钥索引，输入解密标识 计算成功");
|
||
} catch (SydApiException e){
|
||
printException("输入错误的会话密钥索引，输入解密标识", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
byte[] enc = api.SYD_SM4_LongData(key, data, 0, -1);
|
||
System.out.println("输入错误的加解密标识 计算成功");
|
||
} catch (SydApiException e){
|
||
printException("输入错误的加解密标识", e);
|
||
}
|
||
printEnd();
|
||
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[4070];
|
||
byte[] enc = api.SYD_SM4_LongData(key, data, 0, ECB_ENC);
|
||
System.out.println("输入明文大于4064 计算成功");
|
||
} catch (SydApiException e){
|
||
printException("输入明文大于4064", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
byte[] enc = api.SYD_SM4_LongData(key, data, 0, ECB_ENC);
|
||
byte[] dec = api.SYD_SM4_LongData(key, new byte[2048], 0, ECB_DEC);
|
||
if(Util.bytes2HexString(data).equals(Util.bytes2HexString(dec))){
|
||
System.out.println("输入解密标识,输入错误的密文信息 计算成功");
|
||
} else {
|
||
System.out.println("输入解密标识,输入错误的密文信息 计算失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入解密标识,输入错误的密文信息", e);
|
||
}
|
||
printEnd();
|
||
|
||
System.out.println("-------- SM4长数据加解密功能测试结束 --------\n");
|
||
}
|
||
|
||
public void sm4LongFunc_ISM4() {
|
||
System.out.println("-------- (ISM4)SM4长数据加解密功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=1; i<=1024; i++){
|
||
byte[] data = genBytes(i);
|
||
log("sm4LongFunc_ISM4___明文:" + Util.bytes2HexString(data), false);
|
||
|
||
ISM4 en = api.initSM4(0, ECB_ENC);
|
||
byte[] enc1 = en.update(data);
|
||
byte[] enc2 = en.finish();
|
||
byte[] enc = mergeByteArrays(enc1, enc2);
|
||
log("sm4LongFunc_ISM4___加密:" +Util.bytes2HexString(enc), false);
|
||
|
||
ISM4 de = api.initSM4(0, ECB_DEC);
|
||
byte[] dec1 = de.update(enc);
|
||
byte[] dec2 = de.finish();
|
||
byte[] dec = mergeByteArrays(dec1, dec2);
|
||
log("sm4LongFunc_ISM4___解密:" +Util.bytes2HexString(dec), false);
|
||
|
||
if(!(Util.bytes2HexString(data).equals(Util.bytes2HexString(dec)))){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(isSuc){
|
||
System.out.println("输入正确的入参,加密成功，解密成功");
|
||
} else {
|
||
System.out.println("输入正确的入参,加密失败，解密失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确的入参,加密失败，解密失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
ISM4 en = api.initSM4(0, ECB_ENC);
|
||
byte[] enc1 = en.update(new byte[5000]);
|
||
byte[] enc2 = en.finish();
|
||
byte[] enc = mergeByteArrays(enc1, enc2);
|
||
System.out.println("输入数据长度超过4064，输入加密标识 加密成功:" + Util.bytes2HexString(enc));
|
||
} catch (SydApiException e){
|
||
printException("输入数据长度超过4064，输入加密标识 加密失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
ISM4 de = api.initSM4(0, ECB_DEC);
|
||
byte[] dec1 = de.update(new byte[5000]);
|
||
byte[] dec2 = de.finish();
|
||
byte[] dec = mergeByteArrays(dec1, dec2);
|
||
System.out.println("输入数据长度超过4064，输入解密标识 解密成功:" + Util.bytes2HexString(dec));
|
||
} catch (SydApiException e){
|
||
printException("输入数据长度超过4064，输入解密标识 解密失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
ISM4 en = api.initSM4(-1, ECB_ENC);
|
||
byte[] enc1 = en.update(new byte[1024]);
|
||
byte[] enc2 = en.finish();
|
||
byte[] enc = mergeByteArrays(enc1, enc2);
|
||
System.out.println("输入不正确的密钥索引，输入加密标识 加密成功:" + Util.bytes2HexString(enc));
|
||
} catch (SydApiException e){
|
||
printException("输入不正确的密钥索引，输入加密标识 加密失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
ISM4 en = api.initSM4(0, ECB_ENC);
|
||
byte[] enc1 = en.update(new byte[1024]);
|
||
byte[] enc2 = en.finish();
|
||
byte[] enc = mergeByteArrays(enc1, enc2);
|
||
System.out.println("正常传参，加密成功:" + Util.bytes2HexString(enc));
|
||
|
||
ISM4 de = api.initSM4(-1, ECB_DEC);
|
||
byte[] dec1 = de.update(new byte[1024]);
|
||
byte[] dec2 = de.finish();
|
||
byte[] dec = mergeByteArrays(dec1, dec2);
|
||
System.out.println("输入不正确的密钥索引，输入解密标识 解密成功:" + Util.bytes2HexString(dec));
|
||
} catch (SydApiException e){
|
||
printException("输入不正确的密钥索引，输入解密标识 解密失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
ISM4 en = api.initSM4(0, ECB_ENC);
|
||
byte[] enc1 = en.update(data);
|
||
byte[] enc2 = en.finish();
|
||
byte[] enc = mergeByteArrays(enc1, enc2);
|
||
System.out.println("正常传参，加密成功:" + Util.bytes2HexString(enc));
|
||
|
||
Arrays.fill(enc, 10, 30, (byte)0);
|
||
System.out.println("修改密文后:" + Util.bytes2HexString(enc));
|
||
ISM4 de = api.initSM4(0, ECB_DEC);
|
||
byte[] dec1 = de.update(enc);
|
||
byte[] dec2 = de.finish();
|
||
byte[] dec = mergeByteArrays(dec1, dec2);
|
||
System.out.println("输入不正确的密文信息，输入解密标识 解密后:" + Util.bytes2HexString(dec));
|
||
if(Util.bytes2HexString(data).equals(Util.bytes2HexString(dec))){
|
||
System.out.println("输入不正确的密文信息，输入解密标识 解密成功");
|
||
} else {
|
||
System.out.println("输入不正确的密文信息，输入解密标识 解密对比失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入不正确的密文信息，输入解密标识 解密失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
|
||
System.out.println("-------- (ISM4)SM4长数据加解密功能测试结束 --------");
|
||
}
|
||
|
||
public void sm4macShortFunc() {
|
||
System.out.println("-------- SM4MAC短数据功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
int key = 0; //正常索引
|
||
int key_incorrect = -1; //不正确的密钥索引
|
||
byte[] data = new byte[1024]; //正常数据
|
||
byte[] data_toolong = new byte[1025]; //测试数据超过长度限制
|
||
byte[] pcMac_incorrect = new byte[15]; //测试pcmac不为16字节的情况
|
||
byte[] pcMac_bad = new byte[16]; //测试pcmac和实际算出的pcmac不一样的情况
|
||
|
||
printBegin();
|
||
try{
|
||
List<String> verifyDatas = new ArrayList<>(); //用第三方工具算出的sm4mac，和接口算的对比
|
||
verifyDatas.add("7CEDAE1E836889962F8C06C0501613F8");//对应计算的明文（“01”）（明文为16进制数据）
|
||
verifyDatas.add("CE088A908C8902F3B97AF3788FC7DF03");//对应计算的明文（“0102”）
|
||
verifyDatas.add("77F320521CE785E1561A3C3048DDC109");//对应计算的明文（“010203”）
|
||
verifyDatas.add("9785D703722AA20388A3DA1EFC94A9A4");//对应计算的明文（“01020304”）
|
||
verifyDatas.add("D188E611873AE220A61F9F1C0616357A");//对应计算的明文（“0102030405”）
|
||
verifyDatas.add("1A6599B031786511B9E3A8C1FDC12B8D");//对应计算的明文（“010203040506”）
|
||
verifyDatas.add("7C8BC8CADC9C70677492EDD393963E12");//对应计算的明文（“01020304050607”）
|
||
verifyDatas.add("EBC4DEC72A537C82AA40E14FC5586B6A");//对应计算的明文（“0102030405060708”）
|
||
verifyDatas.add("AED342547B4615210CC1B194D6166D9A");//对应计算的明文（“010203040506070809”）
|
||
verifyDatas.add("2AD7BAE1AB13880263335F7BA829A91A");//对应计算的明文（“0102030405060708090A”）
|
||
verifyDatas.add("FCECADBAB814904302CB4FD5C1509D7D");//对应计算的明文（“0102030405060708090A0B”）
|
||
verifyDatas.add("8125EA5F71B67C7FACFB581497723C2D");//对应计算的明文（“0102030405060708090A0B0C”）
|
||
verifyDatas.add("3CEB76630ABA335B14D9A5092A32203D");//对应计算的明文（“0102030405060708090A0B0C0D”）
|
||
verifyDatas.add("37E63B7EE45337C7B3B760E648A74B8D");//对应计算的明文（“0102030405060708090A0B0C0D0E”）
|
||
verifyDatas.add("3C6D5E1FE647AB510E09812DD1F4F286");//对应计算的明文（“0102030405060708090A0B0C0D0E0F”）
|
||
verifyDatas.add("90D7B07D7D3A548A2C4D3EAE20BDCA63");//对应计算的明文（“0102030405060708090A0B0C0D0E0F10”）
|
||
boolean isSuc = true;
|
||
for (int i=1; i<=16; i++){
|
||
byte[] dataBytes = genBytes(i);
|
||
log("sm4macShortFunc___明文: " + Util.bytes2HexString(dataBytes), false);
|
||
byte[] res = api.SYD_SM4Mac_ShortData(key, dataBytes);
|
||
log("sm4macShortFunc___计算后:: " + Util.bytes2HexString(res), false);
|
||
if(!(verifyDatas.get(i-1).equals(Util.bytes2HexString(res)))){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(isSuc){
|
||
System.out.println("输入正确入参,计算成功" );
|
||
} else {
|
||
System.out.println("输入正确入参,计算失败 " );
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确入参，计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=1; i<=16; i++){
|
||
byte[] dataBytes = genBytes(i);
|
||
log("sm4macShortFunc___明文: " + Util.bytes2HexString(dataBytes), false);
|
||
byte[] res = api.SYD_SM4Mac_ShortData(key, dataBytes);
|
||
log("sm4macShortFunc___计算后:: " + Util.bytes2HexString(res), false);
|
||
boolean check = api.SYD_SM4Mac_ShortData(key, dataBytes, res);
|
||
log("sm4macShortFunc___校验:: " + check, false);
|
||
if(!check){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(isSuc){
|
||
System.out.println("输入正确入参,校验成功" );
|
||
} else {
|
||
System.out.println("输入正确入参,校验失败 " );
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确入参，校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] res = api.SYD_SM4Mac_ShortData(key_incorrect, data);
|
||
System.out.println("输入不正确的密钥索引,计算成功: " + Util.bytes2HexString(res));
|
||
} catch (SydApiException e){
|
||
printException("输入不正确的密钥索引,计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] res = api.SYD_SM4Mac_ShortData(key, data);
|
||
System.out.println("输入正确入参,计算: " + Util.bytes2HexString(res));
|
||
boolean check = api.SYD_SM4Mac_ShortData(key_incorrect, data, res);
|
||
System.out.println("输入不正确的密钥索引,校验结果:" + check);
|
||
} catch (SydApiException e){
|
||
printException("输入不正确的密钥索引,校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] res = api.SYD_SM4Mac_ShortData(key, data_toolong);
|
||
System.out.println("数据长度大于1024,计算成功: " + Util.bytes2HexString(res));
|
||
} catch (SydApiException e){
|
||
printException("数据长度大于1024,计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] res = api.SYD_SM4Mac_ShortData(key, data);
|
||
System.out.println("输入正确入参,计算成功: " + Util.bytes2HexString(res));
|
||
boolean check = api.SYD_SM4Mac_ShortData(key, data_toolong, res);
|
||
System.out.println("数据长度大于1024,校验结果:" + check);
|
||
} catch (SydApiException e){
|
||
printException("数据长度大于1024,校验失败", e);
|
||
} catch (Exception e){
|
||
e.printStackTrace();
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean check = api.SYD_SM4Mac_ShortData(key, data, null);
|
||
System.out.println("pcMac为空,校验结果:" + check);
|
||
} catch (SydApiException e){
|
||
printException("pcMac为空,校验失败", e);
|
||
} catch (Exception e){
|
||
e.printStackTrace();
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean check = api.SYD_SM4Mac_ShortData(key, data, pcMac_incorrect);
|
||
System.out.println("pcMac不为16字节,校验结果:" + check);
|
||
} catch (SydApiException e){
|
||
printException("pcMac不为16字节,校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean check = api.SYD_SM4Mac_ShortData(key, data, pcMac_bad);
|
||
System.out.println("pcMac不正确,校验结果:" + check);
|
||
} catch (SydApiException e){
|
||
printException("pcMac不正确,校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
System.out.println("-------- SM4MAC短数据功能测试结束 --------\n");
|
||
}
|
||
|
||
public void sm4macLongFunc() {
|
||
System.out.println("-------- SM4MAC长数据功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
int key = 0;
|
||
int key_incorrect = -1;
|
||
|
||
|
||
List<String> verifyDatas = new ArrayList<>(); //用第三方工具算出的sm4mac，和接口算的对比
|
||
verifyDatas.add("7CEDAE1E836889962F8C06C0501613F8");//对应计算的明文（“01”）（明文为16进制数据）
|
||
verifyDatas.add("CE088A908C8902F3B97AF3788FC7DF03");//对应计算的明文（“0102”）
|
||
verifyDatas.add("77F320521CE785E1561A3C3048DDC109");//对应计算的明文（“010203”）
|
||
verifyDatas.add("9785D703722AA20388A3DA1EFC94A9A4");//对应计算的明文（“01020304”）
|
||
verifyDatas.add("D188E611873AE220A61F9F1C0616357A");//对应计算的明文（“0102030405”）
|
||
verifyDatas.add("1A6599B031786511B9E3A8C1FDC12B8D");//对应计算的明文（“010203040506”）
|
||
verifyDatas.add("7C8BC8CADC9C70677492EDD393963E12");//对应计算的明文（“01020304050607”）
|
||
verifyDatas.add("EBC4DEC72A537C82AA40E14FC5586B6A");//对应计算的明文（“0102030405060708”）
|
||
verifyDatas.add("AED342547B4615210CC1B194D6166D9A");//对应计算的明文（“010203040506070809”）
|
||
verifyDatas.add("2AD7BAE1AB13880263335F7BA829A91A");//对应计算的明文（“0102030405060708090A”）
|
||
verifyDatas.add("FCECADBAB814904302CB4FD5C1509D7D");//对应计算的明文（“0102030405060708090A0B”）
|
||
verifyDatas.add("8125EA5F71B67C7FACFB581497723C2D");//对应计算的明文（“0102030405060708090A0B0C”）
|
||
verifyDatas.add("3CEB76630ABA335B14D9A5092A32203D");//对应计算的明文（“0102030405060708090A0B0C0D”）
|
||
verifyDatas.add("37E63B7EE45337C7B3B760E648A74B8D");//对应计算的明文（“0102030405060708090A0B0C0D0E”）
|
||
verifyDatas.add("3C6D5E1FE647AB510E09812DD1F4F286");//对应计算的明文（“0102030405060708090A0B0C0D0E0F”）
|
||
verifyDatas.add("90D7B07D7D3A548A2C4D3EAE20BDCA63");//对应计算的明文（“0102030405060708090A0B0C0D0E0F10”）
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=1; i<=16; i++){
|
||
byte[] data = genBytes(i);
|
||
log("sm4macLongFunc___明文: " + Util.bytes2HexString(data), false );
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
log("sm4macLongFunc___计算结果: " + Util.bytes2HexString(longDataReturn.getData()), false );
|
||
if(!(verifyDatas.get(i-1).equals(Util.bytes2HexString(longDataReturn.getData()))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (isSuc) {
|
||
System.out.println("输入正确的入参，包序号为0，SM4MAC长数据测试成功");
|
||
} else {
|
||
System.out.println("输入正确的入参，包序号为0，SM4MAC长数据测试失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确的入参，包序号为0，SM4MAC长数据测试失败",e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=1; i<=1024; i++){
|
||
byte[] data = genBytes(i);
|
||
log("sm4macLongFunc___明文: " + Util.bytes2HexString(data), false );
|
||
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
log("sm4macLongFunc___计算结果: " + Util.bytes2HexString(longDataReturn.getData()), false );
|
||
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null, longDataReturn.getData());
|
||
log("sm4macLongFunc___校验结果: " + booleanLongDataReturn.getData(), false );
|
||
|
||
if(!booleanLongDataReturn.getData()){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (isSuc) {
|
||
System.out.println("输入正确的入参，包序号为0，SM4MAC长数据校验成功");
|
||
} else {
|
||
System.out.println("输入正确的入参，包序号为0，SM4MAC长数据校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确的入参，包序号为0，SM4MAC长数据校验失败",e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=16; i<=1024; i++){
|
||
byte[] data = genBytes(i);
|
||
log("sm4macLongFunc___明文: " + Util.bytes2HexString(data), false );
|
||
|
||
byte[] data1 = Arrays.copyOfRange(data, 0, 16);
|
||
byte[] data2 = Arrays.copyOfRange(data, 16, data.length);
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data1, 1, null);
|
||
log("sm4macLongFunc___计算结果1: " + Util.bytes2HexString(longDataReturn.getProcData()), false );
|
||
|
||
longDataReturn = api.SYD_SM4Mac_LongData(key, data2, 3, longDataReturn.getProcData());
|
||
log("sm4macLongFunc___计算结果2: " + Util.bytes2HexString(longDataReturn.getData()), false );
|
||
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null, longDataReturn.getData());
|
||
log("sm4macLongFunc___校验结果: " + booleanLongDataReturn.getData(), false );
|
||
|
||
if(!booleanLongDataReturn.getData() ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (isSuc) {
|
||
System.out.println("输入正确的入参，包序号为1,3，SM4MAC长数据测试成功");
|
||
} else {
|
||
System.out.println("输入正确的入参，包序号为1,3，SM4MAC长数据测试失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确的入参，包序号为1,3，SM4MAC长数据测试失败",e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=16; i<=1024; i++){
|
||
byte[] data = genBytes(i);
|
||
log("sm4macLongFunc___明文: " + Util.bytes2HexString(data), false );
|
||
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
log("sm4macLongFunc___计算结果: " + Util.bytes2HexString(longDataReturn.getData()), false );
|
||
|
||
byte[] data1 = Arrays.copyOfRange(data, 0, 16);
|
||
byte[] data2 = Arrays.copyOfRange(data, 16, data.length);
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data1, 1, null, longDataReturn.getData());
|
||
log("sm4macLongFunc___校验结果1: " + Util.bytes2HexString(booleanLongDataReturn.getProcData()), false );
|
||
booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data2, 3, booleanLongDataReturn.getProcData(), longDataReturn.getData());
|
||
log("sm4macLongFunc___校验结果2: " + booleanLongDataReturn.getData(), false );
|
||
|
||
if(!booleanLongDataReturn.getData() ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (isSuc) {
|
||
System.out.println("输入正确的入参，包序号为1,3，SM4MAC长数据校验成功");
|
||
} else {
|
||
System.out.println("输入正确的入参，包序号为1,3，SM4MAC长数据校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确的入参，包序号为1,3，SM4MAC长数据校验失败",e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=32; i<=1024; i++){
|
||
byte[] data = genBytes(i);
|
||
log("sm4macLongFunc___明文: " + Util.bytes2HexString(data), false );
|
||
|
||
byte[] data1 = Arrays.copyOfRange(data, 0, 16);
|
||
byte[] data2 = Arrays.copyOfRange(data, 16, 32);
|
||
byte[] data3 = Arrays.copyOfRange(data, 32, data.length);
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data1, 1, null);
|
||
log("sm4macLongFunc___计算结果1: " + Util.bytes2HexString(longDataReturn.getProcData()), false );
|
||
longDataReturn = api.SYD_SM4Mac_LongData(key, data2, 2, longDataReturn.getProcData());
|
||
log("sm4macLongFunc___计算结果2: " + Util.bytes2HexString(longDataReturn.getProcData()), false );
|
||
longDataReturn = api.SYD_SM4Mac_LongData(key, data3, 3, longDataReturn.getProcData());
|
||
log("sm4macLongFunc___计算结果3: " + Util.bytes2HexString(longDataReturn.getData()), false );
|
||
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null, longDataReturn.getData());
|
||
log("sm4macLongFunc___校验结果: " + booleanLongDataReturn.getData(), false );
|
||
|
||
if(!booleanLongDataReturn.getData() ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (isSuc) {
|
||
System.out.println("输入正确的入参，包序号为1,2,3，SM4MAC长数据测试成功");
|
||
} else {
|
||
System.out.println("输入正确的入参，包序号为1,2,3，SM4MAC长数据测试失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确的入参，包序号为1,2,3，SM4MAC长数据测试失败",e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=32; i<=1024; i++){
|
||
byte[] data = genBytes(i);
|
||
log("sm4macLongFunc___明文: " + Util.bytes2HexString(data), false );
|
||
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
log("sm4macLongFunc___计算结果: " + Util.bytes2HexString(longDataReturn.getData()), false );
|
||
|
||
byte[] data1 = Arrays.copyOfRange(data, 0, 16);
|
||
byte[] data2 = Arrays.copyOfRange(data, 16, 32);
|
||
byte[] data3 = Arrays.copyOfRange(data, 32, data.length);
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data1, 1, null, longDataReturn.getData());
|
||
log("sm4macLongFunc___校验结果1: " + Util.bytes2HexString(booleanLongDataReturn.getProcData()), false );
|
||
booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data2, 2, booleanLongDataReturn.getProcData(), longDataReturn.getData());
|
||
log("sm4macLongFunc___校验结果2: " + Util.bytes2HexString(booleanLongDataReturn.getProcData()), false );
|
||
booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data3, 3, booleanLongDataReturn.getProcData(), longDataReturn.getData());
|
||
log("sm4macLongFunc___校验结果3: " + booleanLongDataReturn.getData(), false );
|
||
|
||
if(!booleanLongDataReturn.getData() ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (isSuc) {
|
||
System.out.println("输入正确的入参，包序号为1,2,3，SM4MAC长数据校验成功");
|
||
} else {
|
||
System.out.println("输入正确的入参，包序号为1,2,3，SM4MAC长数据校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确的入参，包序号为1,2,3，SM4MAC长数据校验失败",e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key_incorrect, data, 0, null);
|
||
System.out.println("调用长数据MAC计算接口，输入不正确的密钥索引，SM4MAC长数据测试成功");
|
||
} catch (SydApiException e){
|
||
printException("调用长数据MAC计算接口，输入不正确的密钥索引，SM4MAC长数据测试失败",e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
System.out.println("正常传参，SM4MAC长数据计算成功");
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key_incorrect, data, 0, null, longDataReturn.getData());
|
||
System.out.println("调用长数据MAC校验接口，输入不正确的密钥索引，SM4MAC长数据校验成功");
|
||
} catch (SydApiException e){
|
||
printException("调用长数据MAC校验接口，输入不正确的密钥索引，SM4MAC长数据校验失败",e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
System.out.println("正常传参，SM4MAC长数据计算成功");
|
||
|
||
byte[] data1 = Arrays.copyOfRange(data, 0, 16);
|
||
byte[] data2 = Arrays.copyOfRange(data, 16, 32);
|
||
byte[] data3 = Arrays.copyOfRange(data, 32, data.length);
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data1, 1, null, longDataReturn.getData());
|
||
System.out.println("包序号为1时，计算成功");
|
||
booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data2, 2, null, longDataReturn.getData());
|
||
System.out.println("包序号为2时，pcProcData无输入，SM4MAC长数据校验成功");
|
||
} catch (SydApiException e){
|
||
printException("包序号为2时，pcProcData无输入，SM4MAC长数据校验失败",e);
|
||
} catch (Exception e){
|
||
e.printStackTrace();
|
||
}
|
||
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
System.out.println("正常传参，SM4MAC长数据计算成功");
|
||
|
||
byte[] data1 = Arrays.copyOfRange(data, 0, 16);
|
||
byte[] data2 = Arrays.copyOfRange(data, 16, 32);
|
||
byte[] data3 = Arrays.copyOfRange(data, 32, data.length);
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data1, 1, null, longDataReturn.getData());
|
||
booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data2, 2, booleanLongDataReturn.getProcData(), longDataReturn.getData());
|
||
System.out.println("包序号为1,2时，计算成功");
|
||
booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data3, 3, null, longDataReturn.getData());
|
||
System.out.println("包序号为3时，pcProcData无输入，SM4MAC长数据校验成功");
|
||
} catch (SydApiException e){
|
||
printException("包序号为3时，pcProcData无输入，SM4MAC长数据校验失败",e);
|
||
} catch (Exception e){
|
||
e.printStackTrace();
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
System.out.println("正常传参，SM4MAC长数据计算成功");
|
||
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null, null);
|
||
if(booleanLongDataReturn.getData()){
|
||
System.out.println("包序号为0时，PCMAC无输入，SM4MAC长数据校验成功");
|
||
} else {
|
||
System.out.println("包序号为0时，PCMAC无输入，SM4MAC长数据校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("包序号为0时，PCMAC无输入，SM4MAC长数据校验失败",e);
|
||
}
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
System.out.println("正常传参，SM4MAC长数据计算成功");
|
||
|
||
byte[] data1 = Arrays.copyOfRange(data, 0, 16);
|
||
byte[] data2 = Arrays.copyOfRange(data, 16, 32);
|
||
byte[] data3 = Arrays.copyOfRange(data, 32, data.length);
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data1, 1, null, null);
|
||
if(booleanLongDataReturn.getData()){
|
||
System.out.println("包序号为1时，PCMAC无输入，SM4MAC长数据校验成功");
|
||
} else {
|
||
System.out.println("包序号为1时，PCMAC无输入，SM4MAC长数据校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("包序号为1时，PCMAC无输入，SM4MAC长数据校验失败",e);
|
||
}
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
System.out.println("正常传参，SM4MAC长数据计算成功");
|
||
|
||
byte[] data1 = Arrays.copyOfRange(data, 0, 16);
|
||
byte[] data2 = Arrays.copyOfRange(data, 16, 32);
|
||
byte[] data3 = Arrays.copyOfRange(data, 32, data.length);
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data1, 1, null, longDataReturn.getData());
|
||
System.out.println("包序号为1时，计算成功");
|
||
booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data2, 2, booleanLongDataReturn.getProcData(), null);
|
||
if(booleanLongDataReturn.getData()){
|
||
System.out.println("包序号为2时，PCMAC无输入，SM4MAC长数据校验成功");
|
||
} else {
|
||
System.out.println("包序号为2时，PCMAC无输入，SM4MAC长数据校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("包序号为2时，PCMAC无输入，SM4MAC长数据校验失败",e);
|
||
}
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
System.out.println("正常传参，SM4MAC长数据计算成功");
|
||
|
||
byte[] data1 = Arrays.copyOfRange(data, 0, 16);
|
||
byte[] data2 = Arrays.copyOfRange(data, 16, 32);
|
||
byte[] data3 = Arrays.copyOfRange(data, 32, data.length);
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data1, 1, null, longDataReturn.getData());
|
||
booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data2, 2, booleanLongDataReturn.getProcData(), longDataReturn.getData());
|
||
System.out.println("包序号为1,2时，计算成功");
|
||
booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data3, 3, booleanLongDataReturn.getProcData(), null);
|
||
if(booleanLongDataReturn.getData()){
|
||
System.out.println("包序号为3时，PCMAC无输入，SM4MAC长数据校验成功");
|
||
} else {
|
||
System.out.println("包序号为3时，PCMAC无输入，SM4MAC长数据校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("包序号为3时，PCMAC无输入，SM4MAC长数据校验失败",e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 4, null);
|
||
System.out.println("输入包序号不为0-3，SM4MAC长数据计算成功");
|
||
} catch (SydApiException e){
|
||
printException("输入包序号不为0-3，SM4MAC长数据计算失败",e);
|
||
} catch (Exception e){
|
||
e.printStackTrace();
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[1024];
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
System.out.println("正常传参，SM4MAC长数据计算成功");
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data, 4, null, longDataReturn.getData());
|
||
if(booleanLongDataReturn.getData()){
|
||
System.out.println("输入包序号不为0-3，SM4MAC长数据校验成功");
|
||
} else{
|
||
System.out.println("输入包序号不为0-3，SM4MAC长数据校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入包序号不为0-3，SM4MAC长数据校验失败",e);
|
||
} catch (Exception e){
|
||
e.printStackTrace();
|
||
}
|
||
printEnd();
|
||
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[5000];
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
System.out.println("输入大于4064的数据长度，SM4MAC长数据计算成功");
|
||
} catch (SydApiException e){
|
||
printException("输入大于4064的数据长度，SM4MAC长数据计算失败",e);
|
||
} catch (Exception e){
|
||
e.printStackTrace();
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[4000];
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
System.out.println("正常传参，SM4MAC长数据计算成功");
|
||
byte[] dataNew = mergeByteArrays(data, new byte[1000]); //dataNew长度为5000
|
||
System.out.println("明文数据长度改成: " + dataNew.length);
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, dataNew, 0, null, longDataReturn.getData());
|
||
if(booleanLongDataReturn.getData()){
|
||
System.out.println("输入大于4064的数据长度，SM4MAC长数据校验成功");
|
||
} else{
|
||
System.out.println("输入大于4064的数据长度，SM4MAC长数据校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入大于4064的数据长度，SM4MAC长数据校验失败",e);
|
||
} catch (Exception e){
|
||
e.printStackTrace();
|
||
}
|
||
printEnd();
|
||
|
||
|
||
System.out.println("-------- SM4MAC长数据功能测试结束 --------\n");
|
||
|
||
|
||
|
||
// try:
|
||
// input = bytes(4080)
|
||
// opt2 = conn.sm4_mac_init(0)
|
||
// for _ in range(10):
|
||
// opt2.update(input)
|
||
// res2 = opt2.digest()
|
||
// System.out.println('SM4MAC长数据长度超出测试失败')
|
||
// except SmxApiException as e:
|
||
// System.out.println('SM4MAC长数据长度超出测试成功')
|
||
//
|
||
// try:
|
||
// input = bytes(17)
|
||
// opt2 = conn.sm4_mac_init(0)
|
||
// for _ in range(10):
|
||
// opt2.update(input)
|
||
// res2 = opt2.digest()
|
||
// System.out.println('SM4MAC长数据16字节未对齐测试失败')
|
||
// except SmxApiException as e:
|
||
// System.out.println('SM4MAC长数据16字节未对齐测试成功')
|
||
//
|
||
// System.out.println('-------- SM4MAC长数据功能测试结束 --------\n')
|
||
}
|
||
|
||
public void sm4macLongFunc_ISM4Mac() {
|
||
System.out.println("-------- (ISM4Mac)SM4MAC长数据功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
int key = 0;
|
||
byte[] pcMac_incorrect = new byte[15]; //测试数据长度不对的mac
|
||
byte[] pcMac_bad = new byte[16]; //测试数据长度正常，但是值和原本的mac值不一样的情况
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=1; i<=1024; i++){
|
||
byte[] data = genBytes(i);
|
||
log("sm4macLongFunc_ISM4Mac___明文: " + Util.bytes2HexString(data), false);
|
||
byte[] res1 = api.SYD_SM4Mac_ShortData(key, data);
|
||
log("sm4macLongFunc_ISM4Mac___res1: " + Util.bytes2HexString(res1), false);
|
||
|
||
ISM4Mac sm4mac = api.initSM4Mac(key);
|
||
sm4mac.update(data);
|
||
byte[] res2 = sm4mac.digest();
|
||
log("sm4macLongFunc_ISM4Mac___res2: " + Util.bytes2HexString(res2), false);
|
||
if(!(Util.bytes2HexString(res1).equals(Util.bytes2HexString(res2)))){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(isSuc){
|
||
System.out.println("输入正确的入参,pcMac无输入,计算成功" );
|
||
} else {
|
||
System.out.println("输入正确的入参,pcMac无输入,计算失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确的入参,pcMac无输入,计算失败",e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> dataList = new ArrayList<>();
|
||
List<byte[]> macList = new ArrayList<>();
|
||
for(int i=1; i<=1024; i++){
|
||
byte[] data = genBytes(i);
|
||
log("sm4macLongFunc_ISM4Mac___明文: " + Util.bytes2HexString(data), false);
|
||
dataList.add(data);
|
||
|
||
ISM4Mac sm4mac = api.initSM4Mac(key);
|
||
sm4mac.update(data);
|
||
byte[] res = sm4mac.digest();
|
||
log("sm4macLongFunc_ISM4Mac___res: " + Util.bytes2HexString(res), false);
|
||
macList.add(res);
|
||
}
|
||
|
||
boolean isSuc = true;
|
||
for(int i=1; i<=1024; i++){
|
||
byte[] data = dataList.get(i-1);
|
||
log("sm4macLongFunc_ISM4Mac___明文: " + Util.bytes2HexString(data), false);
|
||
|
||
ISM4Mac sm4mac = api.initSM4Mac(key);
|
||
sm4mac.update(data);
|
||
boolean check = sm4mac.checkDigest(macList.get(i-1));
|
||
log("sm4macLongFunc_ISM4Mac___校验结果: " + check, false);
|
||
|
||
if(!check){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(isSuc){
|
||
System.out.println("pcMac有正确MAC输入，输入正确的入参,校验成功" );
|
||
} else {
|
||
System.out.println("pcMac有正确MAC输入，输入正确的入参,校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("pcMac有正确MAC输入，输入正确的入参,校验失败",e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[5000];
|
||
ISM4Mac sm4mac = api.initSM4Mac(key);
|
||
sm4mac.update(data);
|
||
byte[] res = sm4mac.digest();
|
||
System.out.println("输入数据长度超过4064,计算成功:" + Util.bytes2HexString(res));
|
||
} catch (SydApiException e){
|
||
printException("输入数据长度超过4064，计算失败",e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[2048];
|
||
ISM4Mac sm4mac = api.initSM4Mac(key);
|
||
sm4mac.update(data);
|
||
byte[] res = sm4mac.digest();
|
||
System.out.println("输入明文（2048字节的0）,计算结果:" + Util.bytes2HexString(res));
|
||
|
||
sm4mac = api.initSM4Mac(key);
|
||
sm4mac.update(data);
|
||
boolean isSuc = sm4mac.checkDigest(pcMac_incorrect);
|
||
System.out.println("pcMac不为16字节,校验:" + isSuc);
|
||
} catch (SydApiException e){
|
||
printException("pcMac不为16字节，校验失败",e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
byte[] data = new byte[2048];
|
||
ISM4Mac sm4mac = api.initSM4Mac(key);
|
||
sm4mac.update(data);
|
||
byte[] res = sm4mac.digest();
|
||
System.out.println("输入明文（2048字节的0）,计算mac:" + Util.bytes2HexString(res));
|
||
|
||
sm4mac = api.initSM4Mac(key);
|
||
sm4mac.update(data);
|
||
boolean isSuc = sm4mac.checkDigest(pcMac_bad);
|
||
System.out.println("pcMac为16字节但不正确,校验:" + isSuc);
|
||
} catch (SydApiException e){
|
||
printException("pcMac为16字节但不正确,校验失败",e);
|
||
}
|
||
printEnd();
|
||
|
||
System.out.println("-------- (ISM4Mac)SM4MAC长数据功能测试结束 --------\n");
|
||
}
|
||
|
||
public void sm4BatchFunc() {
|
||
System.out.println("-------- SM4批量数据加解密功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
List<byte[]> data = new ArrayList<>(); //正常明文
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
List<byte[]> data_tooLong = new ArrayList<>(); //明文数据超过指定长度
|
||
data_tooLong.add(new byte[1025]);
|
||
data_tooLong.add(new byte[1025]);
|
||
data_tooLong.add(new byte[1025]);
|
||
data_tooLong.add(new byte[1025]);
|
||
data_tooLong.add(new byte[1025]);
|
||
data_tooLong.add(new byte[1025]);
|
||
data_tooLong.add(new byte[1025]);
|
||
List<byte[]> endata = new ArrayList<>(); //正常密文
|
||
endata.add(new byte[1024]);
|
||
endata.add(new byte[1024]);
|
||
endata.add(new byte[1024]);
|
||
endata.add(new byte[1024]);
|
||
endata.add(new byte[1024]);
|
||
endata.add(new byte[1024]);
|
||
endata.add(new byte[1024]);
|
||
List<byte[]> endata_tooLong = new ArrayList<>(); //密文数据超过指定长度
|
||
endata_tooLong.add(new byte[1050]);
|
||
endata_tooLong.add(new byte[1050]);
|
||
endata_tooLong.add(new byte[1050]);
|
||
endata_tooLong.add(new byte[1050]);
|
||
endata_tooLong.add(new byte[1050]);
|
||
endata_tooLong.add(new byte[1050]);
|
||
endata_tooLong.add(new byte[1050]);
|
||
|
||
|
||
int[] key = new int[]{0, 0, 0, 0, 0, 0, 0}; //正常传参密钥
|
||
int[] key_incorrect = new int[]{-1, -1, -1, -1, -1, -1, -1}; //无效密钥测试
|
||
int[] key_insufficient = new int[]{0, 0, 0}; //密钥个数和明文数据个数不一致测试
|
||
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> datas = new ArrayList<>();
|
||
int[] keys = new int[1024];
|
||
for (int i=1; i<=1024; i++){
|
||
datas.add(new byte[i]);
|
||
keys[i-1] = 0;
|
||
}
|
||
List<byte[]> en_data = api.SYD_SM4_BatchData(keys, datas, ECB_ENC);
|
||
List<byte[]> de_data = api.SYD_SM4_BatchData(keys, en_data, ECB_DEC);
|
||
|
||
for(int i=0; i<datas.size(); i++){
|
||
log("sm4BatchFunc_明文: " + Util.bytes2HexString(datas.get(i)), false);
|
||
log("sm4BatchFunc_加密后: " + Util.bytes2HexString(en_data.get(i)), false);
|
||
log("sm4BatchFunc_解密后: " + Util.bytes2HexString(de_data.get(i)), false);
|
||
}
|
||
|
||
if ( contentEquals(datas, de_data)) {
|
||
System.out.println("正常传参，加解密对比成功");
|
||
} else {
|
||
System.out.println("正常传参，加解密对比失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("正常传参,加解密", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> en_data = api.SYD_SM4_BatchData(key_incorrect, data, ECB_ENC);
|
||
System.out.println("输入不正确的密钥索引，输入加密标识，加密成功");
|
||
} catch (SydApiException e) {
|
||
printException("输入不正确的密钥索引，输入加密标识", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> en_data = api.SYD_SM4_BatchData(key, data, ECB_ENC);
|
||
System.out.println("正常传参，加密成功");
|
||
List<byte[]> de_data = api.SYD_SM4_BatchData(key_incorrect, en_data, ECB_DEC);
|
||
System.out.println("输入不正确的密钥索引，输入解密标识，解密成功");
|
||
} catch (SydApiException e) {
|
||
printException("输入不正确的密钥索引，输入解密标识", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> en_data = api.SYD_SM4_BatchData(key, data, -1);
|
||
System.out.println("输入不存在的标识，加解密成功");
|
||
} catch (SydApiException e) {
|
||
printException("输入不存在的标识", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> en_data = api.SYD_SM4_BatchData(key_insufficient, data, ECB_ENC);
|
||
System.out.println("密钥索引个数和明文数据个数不一致，加密成功");
|
||
} catch (SydApiException e) {
|
||
printException("密钥索引个数和明文数据个数不一致，加密失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> en_data = api.SYD_SM4_BatchData(key, data, ECB_ENC);
|
||
System.out.println("正常传参，加密成功");
|
||
List<byte[]> de_data = api.SYD_SM4_BatchData(key_insufficient, en_data, ECB_DEC);
|
||
System.out.println("密钥索引个数和密文数据个数不一致，解密成功");
|
||
} catch (SydApiException e) {
|
||
printException("密钥索引个数和密文数据个数不一致，解密失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> en_data = api.SYD_SM4_BatchData(key, data_tooLong, ECB_ENC);
|
||
System.out.println("明文数据长度超过1024，加密成功");
|
||
} catch (SydApiException e) {
|
||
printException("明文数据长度超过1024", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> de_data = api.SYD_SM4_BatchData(key, endata_tooLong, ECB_DEC);
|
||
System.out.println("密文超过1024+16，解密成功");
|
||
} catch (SydApiException e) {
|
||
printException("密文超过1024+16", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> en_data = api.SYD_SM4_BatchData(key, data, ECB_ENC);
|
||
List<byte[]> de_data = api.SYD_SM4_BatchData(key, endata, ECB_DEC);
|
||
if(contentEquals(de_data, data)){
|
||
System.out.println("输入错误的密文,解密后和之前明文一致");
|
||
} else {
|
||
System.out.println("输入错误的密文,解密后和之前明文不一致");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入错误的密文,解密失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
System.out.println("-------- SM4批量数据加解密功能测试结束 --------\n");
|
||
}
|
||
|
||
public void sm4macBatchFunc() {
|
||
System.out.println("-------- SM4MAC批量数据功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
List<byte[]> data = new ArrayList<>();
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
List<byte[]> data_toolong = new ArrayList<>(); //数据长度大于1024 测试
|
||
data_toolong.add(new byte[1025]);
|
||
data_toolong.add(new byte[1025]);
|
||
data_toolong.add(new byte[1025]);
|
||
data_toolong.add(new byte[1025]);
|
||
|
||
int[] keyIdx = new int[]{0, 0, 0, 0};
|
||
int[] keyIdx_incorrect = new int[]{-1, -1, -1, -1}; //不正确索引测试
|
||
int[] keyIdx_insufficient = new int[]{0, 0}; //索引个数与数据个数不一致
|
||
|
||
List<byte[]> pcMac = new ArrayList<>();
|
||
pcMac.add(new byte[1024]);
|
||
pcMac.add(new byte[1024]);
|
||
pcMac.add(new byte[1024]);
|
||
pcMac.add(new byte[1024]);
|
||
List<byte[]> pcMac_toolong = new ArrayList<>();
|
||
pcMac_toolong.add(new byte[1050]);
|
||
pcMac_toolong.add(new byte[1050]);
|
||
pcMac_toolong.add(new byte[1050]);
|
||
pcMac_toolong.add(new byte[1050]);
|
||
|
||
|
||
printBegin();
|
||
try{
|
||
List<String> verifyDatas = new ArrayList<>(); //用第三方工具算出的sm4mac，和接口算的对比
|
||
verifyDatas.add("7CEDAE1E836889962F8C06C0501613F8");//对应计算的明文（“01”）（明文为16进制数据）
|
||
verifyDatas.add("CE088A908C8902F3B97AF3788FC7DF03");//对应计算的明文（“0102”）
|
||
verifyDatas.add("77F320521CE785E1561A3C3048DDC109");//对应计算的明文（“010203”）
|
||
verifyDatas.add("9785D703722AA20388A3DA1EFC94A9A4");//对应计算的明文（“01020304”）
|
||
verifyDatas.add("D188E611873AE220A61F9F1C0616357A");//对应计算的明文（“0102030405”）
|
||
verifyDatas.add("1A6599B031786511B9E3A8C1FDC12B8D");//对应计算的明文（“010203040506”）
|
||
verifyDatas.add("7C8BC8CADC9C70677492EDD393963E12");//对应计算的明文（“01020304050607”）
|
||
verifyDatas.add("EBC4DEC72A537C82AA40E14FC5586B6A");//对应计算的明文（“0102030405060708”）
|
||
verifyDatas.add("AED342547B4615210CC1B194D6166D9A");//对应计算的明文（“010203040506070809”）
|
||
verifyDatas.add("2AD7BAE1AB13880263335F7BA829A91A");//对应计算的明文（“0102030405060708090A”）
|
||
verifyDatas.add("FCECADBAB814904302CB4FD5C1509D7D");//对应计算的明文（“0102030405060708090A0B”）
|
||
verifyDatas.add("8125EA5F71B67C7FACFB581497723C2D");//对应计算的明文（“0102030405060708090A0B0C”）
|
||
verifyDatas.add("3CEB76630ABA335B14D9A5092A32203D");//对应计算的明文（“0102030405060708090A0B0C0D”）
|
||
verifyDatas.add("37E63B7EE45337C7B3B760E648A74B8D");//对应计算的明文（“0102030405060708090A0B0C0D0E”）
|
||
verifyDatas.add("3C6D5E1FE647AB510E09812DD1F4F286");//对应计算的明文（“0102030405060708090A0B0C0D0E0F”）
|
||
verifyDatas.add("90D7B07D7D3A548A2C4D3EAE20BDCA63");//对应计算的明文（“0102030405060708090A0B0C0D0E0F10”）
|
||
List<byte[]> datas = new ArrayList<>();
|
||
int[] keys = new int[16];
|
||
for (int i=1; i<=16; i++){
|
||
datas.add(genBytes(i));
|
||
keys[i-1] = 0;
|
||
}
|
||
List<byte[]> s = api.SYD_SM4Mac_BatchData(keys, datas);
|
||
|
||
for(int i=0; i<datas.size(); i++){
|
||
log("sm4macBatchFunc___明文: " + Util.bytes2HexString(datas.get(i)), false );
|
||
log("sm4macBatchFunc___计算结果: " + Util.bytes2HexString(s.get(i)), false );
|
||
}
|
||
|
||
boolean isSuc = true;
|
||
for(int i=0; i<datas.size(); i++){
|
||
if(!(verifyDatas.get(i).equals(Util.bytes2HexString(s.get(i)))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if (isSuc) {
|
||
System.out.println("输入正确的数据，数据大于1组，SM4MAC批量数据测试成功");
|
||
} else {
|
||
System.out.println("输入正确的数据，数据大于1组，SM4MAC批量数据测试失败");
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("输入正确的数据，数据大于1组", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> datas = new ArrayList<>();
|
||
int[] keys = new int[16];
|
||
for (int i=1; i<=16; i++){
|
||
datas.add(genBytes(i));
|
||
keys[i-1] = 0;
|
||
}
|
||
List<byte[]> s = api.SYD_SM4Mac_BatchData(keys, datas);
|
||
boolean[] check = api.SYD_SM4Mac_BatchData(keys, datas, s);
|
||
for(int i=0; i<datas.size(); i++){
|
||
log("sm4macBatchFunc___明文: " + Util.bytes2HexString(datas.get(i)), false );
|
||
log("sm4macBatchFunc___计算结果: " + Util.bytes2HexString(s.get(i)), false );
|
||
log("sm4macBatchFunc___校验结果: " + check[i], false );
|
||
}
|
||
|
||
if (isAllTrue(check)) {
|
||
System.out.println("输入正确的数据，数据大于1组，SM4MAC批量数据校验成功");
|
||
} else {
|
||
System.out.println("输入正确的数据，数据大于1组，SM4MAC批量数据校验失败");
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("输入正确的数据，数据大于1组", e);
|
||
}
|
||
printEnd();
|
||
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> s = api.SYD_SM4Mac_BatchData(keyIdx_incorrect, data);
|
||
System.out.println("输入不正确的密钥索引信息，数据大于1组，mac计算成功");
|
||
}catch (SydApiException e){
|
||
printException("输入不正确的密钥索引信息，数据大于1组，mac计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> s = api.SYD_SM4Mac_BatchData(keyIdx, data);
|
||
System.out.println("正常传参，mac计算成功");
|
||
boolean[] check = api.SYD_SM4Mac_BatchData(keyIdx_incorrect, data, s);
|
||
if(isAllTrue(check)){
|
||
System.out.println("调用批量数据MAC校验接口，输入不正确的密钥索引信息，数据大于1组，mac校验成功");
|
||
} else {
|
||
System.out.println("调用批量数据MAC校验接口，输入不正确的密钥索引信息，数据大于1组，mac校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("调用批量数据MAC校验接口，输入不正确的密钥索引信息，数据大于1组，mac校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> s = api.SYD_SM4Mac_BatchData(keyIdx, data);
|
||
System.out.println("正常传参，mac计算成功");
|
||
boolean[] check = api.SYD_SM4Mac_BatchData(keyIdx, data, pcMac);
|
||
if(isAllTrue(check)){
|
||
System.out.println("pcMAC输入不正确的MAC值，mac校验成功");
|
||
} else {
|
||
System.out.println("pcMAC输入不正确的MAC值，mac校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("pcMAC输入不正确的MAC值，mac校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> s = api.SYD_SM4Mac_BatchData(keyIdx, data_toolong);
|
||
System.out.println("数据大于1组，单个数据长度大于1024，mac计算成功");
|
||
} catch (SydApiException e){
|
||
printException("数据大于1组，单个数据长度大于1024，mac计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> s = api.SYD_SM4Mac_BatchData(keyIdx, data);
|
||
System.out.println("正常传参，mac计算成功");
|
||
boolean[] check = api.SYD_SM4Mac_BatchData(keyIdx, data, pcMac_toolong);
|
||
if(isAllTrue(check)){
|
||
System.out.println("pcMac数据长度大于1024+16，mac校验成功");
|
||
} else {
|
||
System.out.println("pcMac数据长度大于1024+16，mac校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("pcMac数据长度大于1024+16，mac校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> s = api.SYD_SM4Mac_BatchData(keyIdx_insufficient, data);
|
||
System.out.println("索引个数与明文个数不一致，mac计算成功");
|
||
} catch (Exception e){
|
||
System.out.println("索引个数与明文个数不一致，mac计算失败 " + e.getMessage());
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<byte[]> s = api.SYD_SM4Mac_BatchData(keyIdx, data);
|
||
System.out.println("正常传参，mac计算成功");
|
||
boolean[] check = api.SYD_SM4Mac_BatchData(keyIdx_insufficient, data, s);
|
||
if(isAllTrue(check)){
|
||
System.out.println("索引个数与密文个数不一致，mac校验成功");
|
||
} else {
|
||
System.out.println("索引个数与密文个数不一致，mac校验失败");
|
||
}
|
||
} catch (Exception e){
|
||
System.out.println("索引个数与密文个数不一致，mac校验 异常:" + e.getMessage());
|
||
}
|
||
printEnd();
|
||
|
||
|
||
System.out.println("-------- SM4MAC批量数据功能测试结束 --------\n");
|
||
}
|
||
|
||
public void sm4ShortMacFunc() {
|
||
System.out.println("-------- 短数据加密计算MAC功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
int keyEnc = 0;
|
||
int keyEnc_incorrect = -1;
|
||
int keyMac = 0;
|
||
int keyMac_incorrect = -1;
|
||
byte[] data = new byte[1024];
|
||
byte[] data_incorrect = new byte[1025];
|
||
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=1; i<=1024; i++){
|
||
byte[] bytes = genBytes(i);
|
||
log("sm4ShortMacFunc___明文:" + Util.bytes2HexString(bytes), false);
|
||
|
||
DataAndMac en_data = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, bytes);
|
||
log("sm4ShortMacFunc___计算后密文:" + Util.bytes2HexString(en_data.getData()), false);
|
||
log("sm4ShortMacFunc___计算后mac:" + Util.bytes2HexString(en_data.getMac()), false);
|
||
|
||
DataAndMacCheck dataAndMacCheck = api.SYD_SM4_CheckMacAndDecrypt_ShortData(keyEnc, keyMac, en_data.getData(), en_data.getMac());
|
||
log("sm4ShortMacFunc___计算后明文:" + Util.bytes2HexString(dataAndMacCheck.getData()), false);
|
||
log("sm4ShortMacFunc___计算后校验结果:" + dataAndMacCheck.getMacCheck(), false);
|
||
|
||
if(!(Util.bytes2HexString(bytes).equals(Util.bytes2HexString(dataAndMacCheck.getData())))){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
if(!dataAndMacCheck.getMacCheck()){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(isSuc){
|
||
System.out.println("输入正确入参, 计算成功");
|
||
} else {
|
||
System.out.println("输入正确入参, 计算失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确入参,计算失败", e);
|
||
} catch (Exception e){
|
||
e.printStackTrace();
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
DataAndMac en_data = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc_incorrect, keyMac, data);
|
||
System.out.println("输入不正确的加密密钥索引,密文:" + Util.bytes2HexString(en_data.getData()));
|
||
System.out.println("输入不正确的加密密钥索引,mac:" + Util.bytes2HexString(en_data.getMac()));
|
||
} catch (SydApiException e){
|
||
printException("输入不正确的加密密钥索引,计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
DataAndMac en_data = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac_incorrect, data);
|
||
System.out.println("输入不正确的MAC密钥索引,密文:" + Util.bytes2HexString(en_data.getData()));
|
||
System.out.println("输入不正确的MAC密钥索引,mac:" + Util.bytes2HexString(en_data.getMac()));
|
||
} catch (SydApiException e){
|
||
printException("输入不正确的MAC密钥索引,计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
DataAndMac en_data = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, data_incorrect);
|
||
System.out.println("输入数据长度大于1K,密文:" + Util.bytes2HexString(en_data.getData()));
|
||
System.out.println("输入数据长度大于1K,mac:" + Util.bytes2HexString(en_data.getMac()));
|
||
} catch (SydApiException e){
|
||
printException("输入数据长度大于1K,计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
|
||
// System.out.println("step1");
|
||
// DataAndMac en_data1 = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, data);
|
||
// System.out.println("step2");
|
||
// DataAndMacCheck de_data1 = api.SYD_SM4_CheckMacAndDecrypt_ShortData(keyEnc, keyMac, en_data1.getData(), en_data1.getMac());
|
||
// System.out.println("step3 " + de_data1.getMacCheck());
|
||
//
|
||
// //错误测试
|
||
// System.out.println("MAC校验失败，不继续进行解密测试");
|
||
// DataAndMacCheck de_data_err = api.SYD_SM4_CheckMacAndDecrypt_ShortData(keyEnc, keyMac, en_data1.getData(), new byte[16]);
|
||
// System.out.println("错误测试返回MAC校验结果："+de_data_err.getMacCheck());
|
||
|
||
// try {
|
||
// DataAndMac en_data2 = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, data);
|
||
// System.out.println("step4");
|
||
// } catch (SydApiException e) {
|
||
// if (e.getRetCode() == 0x1000001) {
|
||
// System.out.println("SYD_SM4_EncryptAndMac_ShortData 不支持数据长度为 0， 测试通过");
|
||
// } else {
|
||
// System.out.println("SYD_SM4_EncryptAndMac_ShortData 不支持数据长度为 0， 测试失败");
|
||
// e.printStackTrace();
|
||
// }
|
||
// }
|
||
|
||
// try {
|
||
// DataAndMacCheck de_data2 = api.SYD_SM4_CheckMacAndDecrypt_ShortData(keyEnc, keyMac, new byte[15], new byte[0]);
|
||
// System.out.println("step5");
|
||
// } catch (SydApiException e) {
|
||
// if (e.getRetCode() == 0x1000001) {
|
||
// System.out.println("SYD_SM4_CheckMacAndDecrypt_ShortData 不支持数据长度为非 16 字节， 测试通过");
|
||
// } else {
|
||
// System.out.println("SYD_SM4_CheckMacAndDecrypt_ShortData 不支持数据长度为非 16 字节， 测试失败");
|
||
// }
|
||
// }
|
||
|
||
//
|
||
// try {
|
||
// data = new byte[1025];
|
||
// api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, data);
|
||
// System.out.println("短数据加密计算MAC，校验MAC解密长度超出测试失败");
|
||
// } catch (SydApiException e) {
|
||
// System.out.println("短数据加密计算MAC，校验MAC解密长度超出测试成功");
|
||
// }
|
||
|
||
// if ( ! isShortLink ){
|
||
// System.out.println("long link");
|
||
// EncryptAndMac.conformance_testcase1_SYD_SM4_EncryptAndMac_ShortData((SydApiLongLinkWrap) api);
|
||
// EncryptAndMac.conformance_testcase2_SYD_SM4_EncryptAndMac_ShortData((SydApiLongLinkWrap) api);
|
||
// } else {
|
||
// System.out.println("short link");
|
||
// }
|
||
|
||
System.out.println("-------- 短数据加密计算MAC功能测试结束 --------\n");
|
||
}
|
||
|
||
public void sm4ShortMacFunc_check() {
|
||
System.out.println("-------- 短数据校验MAC解密功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
int keyEnc = 0;
|
||
int keyEnc_incorrect = -1;
|
||
int keyMac = 0;
|
||
int keyMac_incorrect = -1;
|
||
byte[] data = new byte[1024];
|
||
byte[] data_incorrect = new byte[1025];
|
||
byte[] endata_incorrect = new byte[1050]; //测试密文数据长度大于1024+16
|
||
byte[] endata_bad = new byte[1024]; //测试密文信息不正确
|
||
byte[] pcMac_incorrect = new byte[16]; //测试输入MAC长度为16字节但不正确
|
||
byte[] pcMac_bad = new byte[15]; //测试输入MAC长度不为16字节
|
||
|
||
printBegin();
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=1; i<=1024; i++){
|
||
byte[] bytes = genBytes(i);
|
||
log("sm4ShortMacFunc___明文:" + Util.bytes2HexString(bytes), false);
|
||
|
||
DataAndMac en_data = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, bytes);
|
||
log("sm4ShortMacFunc___计算后密文:" + Util.bytes2HexString(en_data.getData()), false);
|
||
log("sm4ShortMacFunc___计算后mac:" + Util.bytes2HexString(en_data.getMac()), false);
|
||
|
||
DataAndMacCheck dataAndMacCheck = api.SYD_SM4_CheckMacAndDecrypt_ShortData(keyEnc, keyMac, en_data.getData(), en_data.getMac());
|
||
log("sm4ShortMacFunc___计算后明文:" + Util.bytes2HexString(dataAndMacCheck.getData()), false);
|
||
log("sm4ShortMacFunc___计算后校验结果:" + dataAndMacCheck.getMacCheck(), false);
|
||
|
||
if(!(Util.bytes2HexString(bytes).equals(Util.bytes2HexString(dataAndMacCheck.getData())))){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
if(!dataAndMacCheck.getMacCheck()){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(isSuc){
|
||
System.out.println("输入正确入参, 校验成功");
|
||
} else {
|
||
System.out.println("输入正确入参, 校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确入参，校验失败", e);
|
||
e.printStackTrace();
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
DataAndMac en_data = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, data);
|
||
System.out.println("明文:1024个字节的0");
|
||
System.out.println("输入正确入参,密文:" + Util.bytes2HexString(en_data.getData()));
|
||
System.out.println("输入正确入参,mac:" + Util.bytes2HexString(en_data.getMac()));
|
||
DataAndMacCheck de_data = api.SYD_SM4_CheckMacAndDecrypt_ShortData(keyEnc_incorrect, keyMac, en_data.getData(), en_data.getMac());
|
||
if(Util.bytes2HexString(data).equals(de_data.getData())){
|
||
System.out.println("输入不正确的加密密钥索引,解密得到明文:" + Util.bytes2HexString(de_data.getData()));
|
||
} else {
|
||
System.out.println("输入不正确的加密密钥索引,解密得到明文失败");
|
||
}
|
||
System.out.println("输入不正确的加密密钥索引,mac校验:" + de_data.getMacCheck());
|
||
} catch (SydApiException e){
|
||
printException("输入不正确的加密密钥索引, 计算校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
DataAndMac en_data = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, data);
|
||
System.out.println("明文:1024个字节的0");
|
||
System.out.println("输入正确入参,密文:" + Util.bytes2HexString(en_data.getData()));
|
||
System.out.println("输入正确入参,mac:" + Util.bytes2HexString(en_data.getMac()));
|
||
DataAndMacCheck de_data = api.SYD_SM4_CheckMacAndDecrypt_ShortData(keyEnc, keyMac_incorrect, en_data.getData(), en_data.getMac());
|
||
if(Util.bytes2HexString(data).equals(de_data.getData())){
|
||
System.out.println("输入不正确的MAC密钥索引,解密得到明文:" + Util.bytes2HexString(de_data.getData()));
|
||
} else {
|
||
System.out.println("输入不正确的MAC密钥索引,解密得到明文失败");
|
||
}
|
||
System.out.println("输入不正确的MAC密钥索引,mac校验:" + de_data.getMacCheck());
|
||
} catch (SydApiException e){
|
||
printException("输入不正确的MAC密钥索引,计算校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
DataAndMac en_data = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, data);
|
||
System.out.println("明文:1024个字节的0");
|
||
System.out.println("输入正确入参,密文:" + Util.bytes2HexString(en_data.getData()));
|
||
System.out.println("输入正确入参,mac:" + Util.bytes2HexString(en_data.getMac()));
|
||
DataAndMacCheck de_data = api.SYD_SM4_CheckMacAndDecrypt_ShortData(keyEnc, keyMac, endata_incorrect, en_data.getMac());
|
||
System.out.println("密文数据长度大于1024+16,解密得到明文:" + Util.bytes2HexString(de_data.getData()));
|
||
System.out.println("密文数据长度大于1024+16,mac校验:" + de_data.getMacCheck());
|
||
} catch (SydApiException e){
|
||
printException("密文数据长度大于1024+16,计算校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
DataAndMac en_data = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, data);
|
||
System.out.println("明文:1024个字节的0");
|
||
System.out.println("输入正确入参,密文:" + Util.bytes2HexString(en_data.getData()));
|
||
System.out.println("输入正确入参,mac:" + Util.bytes2HexString(en_data.getMac()));
|
||
DataAndMacCheck de_data = api.SYD_SM4_CheckMacAndDecrypt_ShortData(keyEnc, keyMac, en_data.getData(), pcMac_incorrect);
|
||
if(Util.bytes2HexString(data).equals(de_data.getData())){
|
||
System.out.println("输入MAC长度为16字节但不正确,解密得到明文:" + Util.bytes2HexString(de_data.getData()));
|
||
} else {
|
||
System.out.println("输入MAC长度为16字节但不正确,解密得到明文失败");
|
||
}
|
||
System.out.println("输入MAC长度为16字节但不正确,mac校验:" + de_data.getMacCheck());
|
||
} catch (SydApiException e){
|
||
printException("输入MAC长度为16字节但不正确,计算校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
DataAndMac en_data = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, data);
|
||
System.out.println("明文:1024个字节的0");
|
||
System.out.println("输入正确入参,密文:" + Util.bytes2HexString(en_data.getData()));
|
||
System.out.println("输入正确入参,mac:" + Util.bytes2HexString(en_data.getMac()));
|
||
DataAndMacCheck de_data = api.SYD_SM4_CheckMacAndDecrypt_ShortData(keyEnc, keyMac, en_data.getData(), pcMac_bad);
|
||
if(Util.bytes2HexString(data).equals(de_data.getData())){
|
||
System.out.println("输入MAC长度不为16字节,解密得到明文:" + Util.bytes2HexString(de_data.getData()));
|
||
} else {
|
||
System.out.println("输入MAC长度不为16字节,解密得到明文失败");
|
||
}
|
||
System.out.println("输入MAC长度不为16字节,mac校验:" + de_data.getMacCheck());
|
||
} catch (SydApiException e){
|
||
printException("输入MAC长度不为16字节,计算校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
DataAndMac en_data = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, data);
|
||
System.out.println("明文:1024个字节的0");
|
||
System.out.println("输入正确入参,密文:" + Util.bytes2HexString(en_data.getData()));
|
||
System.out.println("输入正确入参,mac:" + Util.bytes2HexString(en_data.getMac()));
|
||
DataAndMacCheck de_data = api.SYD_SM4_CheckMacAndDecrypt_ShortData(keyEnc, keyMac, endata_bad, en_data.getMac());
|
||
if(Util.bytes2HexString(data).equals(de_data.getData())){
|
||
System.out.println("密文信息不正确,解密得到明文:" + Util.bytes2HexString(de_data.getData()));
|
||
} else {
|
||
System.out.println("密文信息不正确,解密得到明文失败");
|
||
}
|
||
System.out.println("密文信息不正确,mac校验:" + de_data.getMacCheck());
|
||
} catch (SydApiException e){
|
||
printException("密文信息不正确,计算校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
System.out.println("-------- 短数据校验MAC解密功能测试结束 --------\n");
|
||
}
|
||
|
||
public void sm4BatchMacFunc() {
|
||
System.out.println("-------- 批量数据加密计算MAC功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
List<byte[]> data = new ArrayList<>();
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
List<byte[]> data_toolong = new ArrayList<>();
|
||
data_toolong.add(new byte[1025]);
|
||
data_toolong.add(new byte[1025]);
|
||
data_toolong.add(new byte[1025]);
|
||
data_toolong.add(new byte[1025]);
|
||
data_toolong.add(new byte[1025]);
|
||
data_toolong.add(new byte[1025]);
|
||
data_toolong.add(new byte[1025]);
|
||
int[] keyEnc = new int[]{0, 0, 0, 0, 0, 0, 0};
|
||
int[] keyEnc_incorrect = new int[]{-1, -1, -1, -1, -1, -1, -1};
|
||
int[] keyMac = new int[]{0, 0, 0, 0, 0, 0, 0};
|
||
int[] keyMac_incorrect = new int[]{-1, -1, -1, -1, -1, -1, -1};
|
||
|
||
printBegin();
|
||
try{
|
||
int max = 1024;
|
||
List<byte[]> data_test = new ArrayList<>();
|
||
int[] keytest = new int[max];
|
||
for(int i=0; i<max; i++){
|
||
data_test.add(new byte[1024]);
|
||
}
|
||
|
||
boolean isSuc = true;
|
||
|
||
List<DataAndMac> en_data = api.SYD_SM4_EncryptAndMac_BatchData(keytest, keytest, data_test);
|
||
List<DataAndMacCheck> de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keytest, keytest, en_data);
|
||
for(int i=0; i<en_data.size(); i++) {
|
||
log("sm4BatchMacFunc___明文:" + Util.bytes2HexString(data_test.get(i)), false);
|
||
log("sm4BatchMacFunc___加密后:" + Util.bytes2HexString(en_data.get(i).getData()), false);
|
||
log("sm4BatchMacFunc___加密后mac:" + Util.bytes2HexString(en_data.get(i).getMac()), false);
|
||
log("sm4BatchMacFunc___解密后:" + Util.bytes2HexString(de_data.get(i).getData()), false);
|
||
log("sm4BatchMacFunc___校验:" + de_data.get(i).getMacCheck(), false);
|
||
if(!(Util.bytes2HexString(data_test.get(i)).equals(Util.bytes2HexString(de_data.get(i).getData())))){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
if(!de_data.get(i).getMacCheck()){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc){
|
||
System.out.println("输入正确入参,计算成功");
|
||
} else {
|
||
System.out.println("输入正确入参,计算失败");
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("输入正确入参,计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<DataAndMac> en_data = api.SYD_SM4_EncryptAndMac_BatchData(keyEnc_incorrect, keyMac, data);
|
||
System.out.println("明文: 7组数据，每组数据都是1024个字节的0");
|
||
for(DataAndMac content:en_data) {
|
||
System.out.println("输入不正确的加密密钥索引,密文:" + Util.bytes2HexString(content.getData()));
|
||
System.out.println("输入不正确的加密密钥索引,mac:" + Util.bytes2HexString(content.getMac()));
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("输入不正确的加密密钥索引,计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<DataAndMac> en_data = api.SYD_SM4_EncryptAndMac_BatchData(keyEnc, keyMac_incorrect, data);
|
||
System.out.println("明文: 7组数据，每组数据都是1024个字节的0");
|
||
for(DataAndMac content:en_data) {
|
||
System.out.println("输入不正确的MAC密钥索引,密文:" + Util.bytes2HexString(content.getData()));
|
||
System.out.println("输入不正确的MAC密钥索引,mac:" + Util.bytes2HexString(content.getMac()));
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("输入不正确的MAC密钥索引,计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<DataAndMac> en_data = api.SYD_SM4_EncryptAndMac_BatchData(keyEnc, keyMac, data_toolong);
|
||
for(DataAndMac content:en_data) {
|
||
System.out.println("输入加密数据长度超过1K,密文:" + Util.bytes2HexString(content.getData()));
|
||
System.out.println("输入加密数据长度超过1K,mac:" + Util.bytes2HexString(content.getMac()));
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("输入加密数据长度超过1K,计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
|
||
// if ( ! isShortLink ){
|
||
// System.out.println("long link");
|
||
// EncryptAndMac.conformance_testcase1_sm4BatchMacFunc((SydApiLongLinkWrap) api);
|
||
// EncryptAndMac.conformance_testcase2_sm4BatchMacFunc((SydApiLongLinkWrap) api);
|
||
// } else {
|
||
// System.out.println("short link");
|
||
// }
|
||
|
||
System.out.println("-------- 批量数据加密计算MAC功能测试结束 --------\n");
|
||
}
|
||
|
||
public void sm4BatchMacFunc_check() {
|
||
System.out.println("-------- 批量数据校验MAC解密功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
List<byte[]> data = new ArrayList<>();
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
data.add(new byte[1024]);
|
||
|
||
|
||
int[] keyEnc = new int[]{0, 0, 0, 0, 0, 0, 0};
|
||
int[] keyEnc_incorrect = new int[]{-1, -1, -1, -1, -1, -1, -1};
|
||
int[] keyMac = new int[]{0, 0, 0, 0, 0, 0, 0};
|
||
int[] keyMac_incorrect = new int[]{-1, -1, -1, -1, -1, -1, -1};
|
||
|
||
printBegin();
|
||
try{
|
||
int max = 1024;
|
||
List<byte[]> data_test = new ArrayList<>();
|
||
int[] keytest = new int[max];
|
||
for(int i=0; i<max; i++){
|
||
data_test.add(new byte[1024]);
|
||
}
|
||
|
||
boolean isSuc = true;
|
||
|
||
List<DataAndMac> en_data = api.SYD_SM4_EncryptAndMac_BatchData(keytest, keytest, data_test);
|
||
List<DataAndMacCheck> de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keytest, keytest, en_data);
|
||
for(int i=0; i<en_data.size(); i++) {
|
||
log("sm4BatchMacFunc_check___明文:" + Util.bytes2HexString(data_test.get(i)), false);
|
||
log("sm4BatchMacFunc_check___加密后:" + Util.bytes2HexString(en_data.get(i).getData()), false);
|
||
log("sm4BatchMacFunc_check___加密后mac:" + Util.bytes2HexString(en_data.get(i).getMac()), false);
|
||
log("sm4BatchMacFunc_check___解密后:" + Util.bytes2HexString(de_data.get(i).getData()), false);
|
||
log("sm4BatchMacFunc_check___校验:" + de_data.get(i).getMacCheck(), false);
|
||
if(!(Util.bytes2HexString(data_test.get(i)).equals(Util.bytes2HexString(de_data.get(i).getData())))){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
if(!de_data.get(i).getMacCheck()){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc){
|
||
System.out.println("输入正确入参,计算成功");
|
||
} else {
|
||
System.out.println("输入正确入参,计算失败");
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("输入正确入参,计算失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<DataAndMac> en_data = api.SYD_SM4_EncryptAndMac_BatchData(keyEnc, keyMac, data);
|
||
System.out.println("明文: 7组数据，每组数据都是1024个字节的0");
|
||
for(DataAndMac content:en_data) {
|
||
System.out.println("输入正确入参,密文:" + Util.bytes2HexString(content.getData()));
|
||
System.out.println("输入正确入参,mac:" + Util.bytes2HexString(content.getMac()));
|
||
}
|
||
System.out.println("输入不正确的加密密钥索引，解密及校验如下");
|
||
List<DataAndMacCheck> de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keyEnc_incorrect, keyMac, en_data);
|
||
for(DataAndMacCheck content:de_data) {
|
||
System.out.println("输入不正确的加密密钥索引,解密后:" + Util.bytes2HexString(content.getData()));
|
||
System.out.println("输入不正确的加密密钥索引,mac校验:" + content.getMacCheck() );
|
||
}
|
||
}catch(SydApiException e){
|
||
printException("输入不正确的加密密钥索引,校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<DataAndMac> en_data = api.SYD_SM4_EncryptAndMac_BatchData(keyEnc, keyMac, data);
|
||
System.out.println("明文: 7组数据，每组数据都是1024个字节的0");
|
||
for(DataAndMac content:en_data) {
|
||
System.out.println("输入正确入参,密文:" + Util.bytes2HexString(content.getData()));
|
||
System.out.println("输入正确入参,mac:" + Util.bytes2HexString(content.getMac()));
|
||
}
|
||
System.out.println("输入不正确的MAC密钥索引，解密及校验如下");
|
||
List<DataAndMacCheck> de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keyEnc, keyMac_incorrect, en_data);
|
||
for(DataAndMacCheck content:de_data) {
|
||
System.out.println("输入不正确的MAC密钥索引,解密后:" + Util.bytes2HexString(content.getData()));
|
||
System.out.println("输入不正确的MAC密钥索引,mac校验:" + content.getMacCheck() );
|
||
}
|
||
}catch(SydApiException e){
|
||
printException("输入不正确的MAC密钥索引,校验失败", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<DataAndMac> en_data = api.SYD_SM4_EncryptAndMac_BatchData(keyEnc, keyMac, data);
|
||
System.out.println("明文: 7组数据，每组数据都是1024个字节的0");
|
||
for(DataAndMac content:en_data) {
|
||
System.out.println("输入正确入参,密文:" + Util.bytes2HexString(content.getData()));
|
||
System.out.println("输入正确入参,mac:" + Util.bytes2HexString(content.getMac()));
|
||
}
|
||
System.out.println("密文数据长度大于1024+16，解密及校验如下");
|
||
for(DataAndMac dataTemp : en_data){
|
||
dataTemp.setData(mergeByteArrays(dataTemp.getData(),new byte[1024]));
|
||
}
|
||
List<DataAndMacCheck> de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keyEnc, keyMac, en_data);
|
||
for(DataAndMacCheck content:de_data) {
|
||
System.out.println("密文数据长度大于1024+16,解密后:" + Util.bytes2HexString(content.getData()));
|
||
System.out.println("密文数据长度大于1024+16,mac校验:" + content.getMacCheck() );
|
||
}
|
||
}catch(SydApiException e){
|
||
printException("密文数据长度大于1024+16", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<DataAndMac> en_data = api.SYD_SM4_EncryptAndMac_BatchData(keyEnc, keyMac, data);
|
||
System.out.println("明文: 7组数据，每组数据都是1024个字节的0");
|
||
for(DataAndMac content:en_data) {
|
||
System.out.println("输入正确入参,密文:" + Util.bytes2HexString(content.getData()));
|
||
System.out.println("输入正确入参,mac:" + Util.bytes2HexString(content.getMac()));
|
||
}
|
||
System.out.println("密文校验值长度不为16，解密及校验如下");
|
||
for(DataAndMac dataTemp : en_data){
|
||
dataTemp.setMac(new byte[15]);
|
||
}
|
||
List<DataAndMacCheck> de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keyEnc, keyMac, en_data);
|
||
for(DataAndMacCheck content:de_data) {
|
||
if(content.getData() == null){
|
||
System.out.println("密文校验值长度不为16,解密后: 明文数据为空");
|
||
} else {
|
||
System.out.println("密文校验值长度不为16,解密后:" + Util.bytes2HexString(content.getData()));
|
||
}
|
||
System.out.println("密文校验值长度不为16,mac校验:" + content.getMacCheck() );
|
||
}
|
||
}catch(SydApiException e){
|
||
printException("密文校验值长度不为16", e);
|
||
}catch (Exception e){
|
||
e.printStackTrace();
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<DataAndMac> en_data = api.SYD_SM4_EncryptAndMac_BatchData(keyEnc, keyMac, data);
|
||
System.out.println("明文: 7组数据，每组数据都是1024个字节的0");
|
||
for(DataAndMac content:en_data) {
|
||
System.out.println("输入正确入参,密文:" + Util.bytes2HexString(content.getData()));
|
||
System.out.println("输入正确入参,mac:" + Util.bytes2HexString(content.getMac()));
|
||
}
|
||
System.out.println("密文校验值长度为16但不正确，解密及校验如下");
|
||
for(DataAndMac dataTemp : en_data){
|
||
dataTemp.setMac(new byte[16]);
|
||
}
|
||
List<DataAndMacCheck> de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keyEnc, keyMac, en_data);
|
||
for(DataAndMacCheck content:de_data) {
|
||
if(content.getData() == null){
|
||
System.out.println("密文校验值长度为16但不正确,解密后: 明文数据为空");
|
||
} else {
|
||
System.out.println("密文校验值长度为16但不正确,解密后:" + Util.bytes2HexString(content.getData()));
|
||
}
|
||
System.out.println("密文校验值长度为16但不正确,mac校验:" + content.getMacCheck() );
|
||
}
|
||
}catch(SydApiException e){
|
||
printException("密文校验值长度为16但不正确", e);
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
List<DataAndMac> en_data = api.SYD_SM4_EncryptAndMac_BatchData(keyEnc, keyMac, data);
|
||
System.out.println("明文: 7组数据，每组数据都是1024个字节的0");
|
||
for(DataAndMac content:en_data) {
|
||
System.out.println("输入正确入参,密文:" + Util.bytes2HexString(content.getData()));
|
||
System.out.println("输入正确入参,mac:" + Util.bytes2HexString(content.getMac()));
|
||
}
|
||
System.out.println("输入密文不正确，解密及校验如下");
|
||
for(DataAndMac dataTemp : en_data){
|
||
Arrays.fill(dataTemp.getData(), 10, 30, (byte)0);
|
||
}
|
||
List<DataAndMacCheck> de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keyEnc, keyMac, en_data);
|
||
for(DataAndMacCheck content:de_data) {
|
||
if(content.getData() == null){
|
||
System.out.println("输入密文不正确,解密后: 明文数据为空");
|
||
} else {
|
||
System.out.println("输入密文不正确,解密后:" + Util.bytes2HexString(content.getData()));
|
||
}
|
||
System.out.println("输入密文不正确,mac校验:" + content.getMacCheck() );
|
||
}
|
||
}catch(SydApiException e){
|
||
printException("输入密文不正确", e);
|
||
}
|
||
printEnd();
|
||
|
||
// if ( ! isShortLink ){
|
||
// System.out.println("long link");
|
||
// EncryptAndMac.conformance_testcase1_sm4BatchMacFunc((SydApiLongLinkWrap) api);
|
||
// EncryptAndMac.conformance_testcase2_sm4BatchMacFunc((SydApiLongLinkWrap) api);
|
||
// } else {
|
||
// System.out.println("short link");
|
||
// }
|
||
|
||
System.out.println("-------- 批量数据校验MAC解密功能测试结束 --------\n");
|
||
}
|
||
|
||
public void loggerFunc() {
|
||
String pcLogPath = "./logs";
|
||
|
||
System.out.println("-------- 设置日志配置功能测试开始 --------");
|
||
|
||
printBegin();
|
||
try{
|
||
for(int i=0; i<4; i++){
|
||
SydApi.SYD_SetLogConfig(pcLogPath,i );
|
||
}
|
||
System.out.println("调用该接口设置日志路径，分别日志级别为0，1，2，3, 设置成功");
|
||
} catch (Exception e){
|
||
System.out.println("调用该接口设置日志路径，分别日志级别为0，1，2，3, 设置失败 异常: " + e.getMessage());
|
||
}
|
||
printEnd();
|
||
|
||
printBegin();
|
||
try{
|
||
SydApi.SYD_SetLogConfig("testlogpath/",3);
|
||
System.out.println("日志路径不存在, 设置成功");
|
||
} catch (Exception e){
|
||
System.out.println("日志路径不存在, 设置失败 异常: " + e.getMessage());
|
||
}
|
||
try{
|
||
SydApi.SYD_SetLogConfig("./logs",5);
|
||
System.out.println("日志级别不存在, 设置成功");
|
||
} catch (Exception e){
|
||
System.out.println("日志级别不存在, 设置失败 异常: " + e.getMessage());
|
||
}
|
||
printEnd();
|
||
|
||
System.out.println("-------- 设置日志配置功能测试结束 --------\n");
|
||
|
||
}
|
||
|
||
|
||
public void funcAll() {
|
||
//切换短链接 长连接 对这几个测试无影响
|
||
this.loggerFunc();
|
||
this.connectFunc();
|
||
this.longConnectFunc();
|
||
this.disconnectFunc();
|
||
|
||
this.changeConnect(false); //设置成长连接把相关功能测试下
|
||
this.sm3ShortFunc();
|
||
this.sm3LongFunc();
|
||
this.sm4ShortFunc();
|
||
this.sm4LongFunc();
|
||
this.sm4macShortFunc();
|
||
this.sm4macLongFunc();
|
||
this.sm4BatchFunc();
|
||
this.sm4macBatchFunc();
|
||
this.sm4ShortMacFunc();
|
||
this.sm4BatchMacFunc();
|
||
this.sm4ShortMacFunc_check();
|
||
this.sm4BatchMacFunc_check();
|
||
this.sm4macLongFunc_ISM4Mac();
|
||
this.sm4LongFunc_ISM4();
|
||
this.sm3LongFunc_ISM3();
|
||
|
||
this.changeConnect(true); //设置成短连接把相关功能测试下
|
||
this.sm3ShortFunc();
|
||
this.sm3LongFunc();
|
||
this.sm4ShortFunc();
|
||
this.sm4LongFunc();
|
||
this.sm4macShortFunc();
|
||
this.sm4macLongFunc();
|
||
this.sm4BatchFunc();
|
||
this.sm4macBatchFunc();
|
||
this.sm4ShortMacFunc();
|
||
this.sm4BatchMacFunc();
|
||
this.sm4ShortMacFunc_check();
|
||
this.sm4BatchMacFunc_check();
|
||
this.sm4macLongFunc_ISM4Mac();
|
||
this.sm4LongFunc_ISM4();
|
||
this.sm3LongFunc_ISM3();
|
||
|
||
}
|
||
|
||
public void funcMenu(Config config, Choise choise, FuncTest test) throws Exception {
|
||
|
||
boolean flag = true;
|
||
SydApi.SYD_SetLogConfig("./logs", 3);
|
||
while (flag) {
|
||
System.out.println("请选择测试项：");
|
||
System.out.println("1. 日志测试");
|
||
System.out.println("2. 短链接测试");
|
||
System.out.println("3. 长链接测试");
|
||
|
||
System.out.println("4. SM3短数据");
|
||
|
||
|
||
System.out.println("5. SM4 短数据加解密");
|
||
System.out.println("6. SM4 批量数据加解密");
|
||
System.out.println("7. SM4MAC 短数据");
|
||
System.out.println("8. SM4MAC 批量数据");
|
||
|
||
System.out.println("9. SM4短数据加密后生成MAC");
|
||
System.out.println("10. SM4批量数据加密后生成MAC");
|
||
|
||
System.out.println("11. SM4长数据MAC");
|
||
System.out.println("12. SM4长数据加解密");
|
||
|
||
System.out.println("13. SM3长数据");
|
||
|
||
System.out.println("14. SM4长数据MAC(ISM4Mac)");
|
||
System.out.println("15. SM4长数据加解密(ISM4)");
|
||
System.out.println("16. SM3长数据(ISM3)");
|
||
|
||
System.out.println("17. SM4短数据解密验证MAC");
|
||
System.out.println("18. SM4批量数据验证MAC解密");
|
||
|
||
System.out.println("19. 断开短链接测试");
|
||
|
||
System.out.println("20. 切换连接为长连接模式");
|
||
System.out.println("21. 切换连接为短连接模式");
|
||
|
||
System.out.println("-1.退出");
|
||
|
||
switch (choise.getAsInt()) {
|
||
case 1:
|
||
test.loggerFunc();
|
||
break;
|
||
case 2:
|
||
test.connectFunc();
|
||
break;
|
||
case 3:
|
||
test.longConnectFunc();
|
||
break;
|
||
case 4:
|
||
test.sm3ShortFunc();
|
||
break;
|
||
case 5:
|
||
test.sm4ShortFunc();
|
||
break;
|
||
case 6:
|
||
test.sm4BatchFunc();
|
||
break;
|
||
|
||
case 7:
|
||
test.sm4macShortFunc();
|
||
break;
|
||
case 8: {
|
||
test.sm4macBatchFunc();
|
||
break;
|
||
}
|
||
case 9: {
|
||
test.sm4ShortMacFunc();
|
||
break;
|
||
}
|
||
case 10: {
|
||
test.sm4BatchMacFunc();
|
||
break;
|
||
}
|
||
case 11:
|
||
test.sm4macLongFunc();
|
||
break;
|
||
case 12:
|
||
test.sm4LongFunc();
|
||
break;
|
||
case 13:
|
||
test.sm3LongFunc();
|
||
break;
|
||
case 14:
|
||
test.sm4macLongFunc_ISM4Mac();
|
||
break;
|
||
case 15:
|
||
test.sm4LongFunc_ISM4();
|
||
break;
|
||
case 16:
|
||
test.sm3LongFunc_ISM3();
|
||
break;
|
||
case 17:
|
||
test.sm4ShortMacFunc_check();
|
||
break;
|
||
case 18:
|
||
test.sm4BatchMacFunc_check();
|
||
break;
|
||
case 19:
|
||
test.disconnectFunc();
|
||
break;
|
||
case 20:
|
||
test.changeConnect(false);
|
||
break;
|
||
case 21:
|
||
test.changeConnect(true);
|
||
break;
|
||
case -1:
|
||
flag = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
public static void main(String[] args) throws Exception {
|
||
Config config = config = Config.loadConfig();
|
||
if (config == null || config.isDebug()) {
|
||
System.setProperty("com.sunyard.sydapi4j.debug", "true");
|
||
}
|
||
|
||
System.out.println("ips=" + Arrays.toString(config.getIps()));
|
||
System.out.println("ports=" + Arrays.toString(config.getPorts()));
|
||
System.out.println("debug=" + config.isDebug());
|
||
|
||
Choise choise = new Choise(args);
|
||
|
||
FuncTest funcTest = new FuncTest(config);
|
||
SydApi.SYD_SetLogConfig("./logs", 3);
|
||
funcTest.funcMenu(config, choise, funcTest);
|
||
|
||
}
|
||
|
||
|
||
private void printBegin(){
|
||
System.out.println("============begin============");
|
||
}
|
||
|
||
private void printEnd(){
|
||
System.out.println("============end============\n");
|
||
}
|
||
|
||
private boolean compareLists(List<byte[]> byteList, List<String> hexList) {
|
||
// 1. 检查列表长度
|
||
if (byteList.size() != hexList.size()) {
|
||
System.err.println("列表大小不同："
|
||
+ byteList.size() + " vs " + hexList.size());
|
||
return false;
|
||
}
|
||
|
||
// 2. 逐项比较
|
||
for (int i = 0; i < byteList.size(); i++) {
|
||
byte[] byteData = byteList.get(i);
|
||
String hexStr = hexList.get(i);
|
||
|
||
// 方法1：字节转十六进制比较
|
||
String convertedHex = Util.bytes2HexString(byteData);
|
||
if (!convertedHex.equals(hexStr)) {
|
||
System.err.printf("第 %d 项不匹配:\n期望: %s\n实际: %s\n",
|
||
i, hexStr.substring(0, 32) + "..." + hexStr.substring(hexStr.length() - 32),
|
||
convertedHex.substring(0, 32) + "..." + convertedHex.substring(convertedHex.length() - 32)
|
||
);
|
||
return false;
|
||
}
|
||
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
private boolean contentEquals(List<byte[]> list1, List<byte[]> list2) {
|
||
// 1. 检查基础条件
|
||
if (list1 == list2) return true;
|
||
if (list1 == null || list2 == null) return false;
|
||
if (list1.size() != list2.size()) return false;
|
||
|
||
// 2. 逐项比较数组内容
|
||
for (int i = 0; i < list1.size(); i++) {
|
||
byte[] arr1 = list1.get(i);
|
||
byte[] arr2 = list2.get(i);
|
||
|
||
if (!Arrays.equals(arr1, arr2)) {
|
||
// 可添加调试信息
|
||
System.err.printf("差异位置: %d\n数组1: %s\n数组2: %s\n",
|
||
i, Arrays.toString(arr1), Arrays.toString(arr2));
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
private boolean isAllTrue(boolean[] check){
|
||
if(check == null || check.length <= 0){
|
||
return false;
|
||
}
|
||
for (int i = 0; i < check.length; i++) {
|
||
if (!check[i]) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
private void log(String msg, boolean isPrintln){
|
||
if(isPrintln) {
|
||
System.out.println(msg);
|
||
}
|
||
log.debug(msg);
|
||
}
|
||
|
||
private void printException(String msg, SydApiException e){
|
||
System.out.println(msg + " 异常,retcode:" + e.getRetCode() + ",msg:" + e.getMessage());
|
||
if(false) { //需要输出到文本，可以改为true
|
||
log.debug(msg + " 异常,retcode:" + e.getRetCode() + ",msg:" + e.getMessage());
|
||
}
|
||
}
|
||
|
||
private byte[] mergeByteArrays(byte[] array1, byte[] array2) {
|
||
// 创建新数组（长度为两个数组长度之和）
|
||
byte[] merged = new byte[array1.length + array2.length];
|
||
|
||
// 复制第一个数组到新数组开头位置
|
||
System.arraycopy(array1, 0, merged, 0, array1.length);
|
||
|
||
// 复制第二个数组到第一个数组之后的位置
|
||
System.arraycopy(array2, 0, merged, array1.length, array2.length);
|
||
|
||
return merged;
|
||
}
|
||
|
||
private byte[] mergeByteArrays(byte[]... arrays) {
|
||
// 校验输入
|
||
if (arrays == null) {
|
||
throw new IllegalArgumentException("输入数组集合不能为null");
|
||
}
|
||
|
||
// 1. 计算总长度
|
||
int totalLength = 0;
|
||
for (byte[] array : arrays) {
|
||
if (array != null) {
|
||
totalLength += array.length;
|
||
}
|
||
}
|
||
|
||
// 空数组处理
|
||
if (totalLength == 0) {
|
||
return new byte[0];
|
||
}
|
||
|
||
// 2. 创建合并目标数组
|
||
byte[] merged = new byte[totalLength];
|
||
|
||
// 3. 逐数组复制
|
||
int currentPosition = 0;
|
||
for (byte[] array : arrays) {
|
||
if (array != null && array.length > 0) {
|
||
System.arraycopy(array, 0, merged, currentPosition, array.length);
|
||
currentPosition += array.length;
|
||
}
|
||
}
|
||
|
||
return merged;
|
||
}
|
||
|
||
private byte[] genBytes(int num){
|
||
byte[] result = new byte[num];
|
||
for(int i=0; i<num; i++){
|
||
result[i] = (byte)(i+1);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
public void zc_sm3ShortFunc() {
|
||
System.out.println("-------- SM3短数据功能测试开始 --------");
|
||
|
||
SydApi api = connect();
|
||
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=1; i<=1024; i++){
|
||
byte[] data = new byte[i];
|
||
byte[] res = api.SYD_SM3_Hash_ShortData(data);
|
||
|
||
ISM3 sm3 = api.initSM3();
|
||
sm3.update(data);
|
||
byte[] res_2 = sm3.digest();
|
||
|
||
if(!(Util.bytes2HexString(res).equals(Util.bytes2HexString(res_2))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc) {
|
||
System.out.println("正常传参,hash计算成功");
|
||
} else {
|
||
System.out.println("正常传参,hash计算失败");
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("正常传参，hash计算失败", e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- SM3短数据功能测试结束 --------\n");
|
||
}
|
||
|
||
public void zc_sm3LongFunc() {
|
||
System.out.println("-------- SM3长数据功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=1; i<=1024; i++){
|
||
byte[] data = new byte[i];
|
||
|
||
byte[] res = api.SYD_SM3_Hash_ShortData(data);
|
||
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM3_Hash_LongData(data, 1, null);
|
||
longDataReturn = api.SYD_SM3_Hash_LongData(new byte[0], 2, longDataReturn.getProcData());
|
||
longDataReturn = api.SYD_SM3_Hash_LongData(new byte[0], 3, longDataReturn.getProcData());
|
||
byte[] res_2 = longDataReturn.getData();
|
||
|
||
if(!(Util.bytes2HexString(res).equals(Util.bytes2HexString(res_2))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc) {
|
||
System.out.println("包序号输入1,2,3,hash计算成功");
|
||
} else {
|
||
System.out.println("包序号输入1,2,3,hash计算失败");
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("包序号输入1,2,3", e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- SM3长数据功能测试结束 --------\n");
|
||
}
|
||
|
||
public void zc_sm4ShortFunc() {
|
||
System.out.println("-------- SM4短数据加解密功能测试开始 --------");
|
||
SydApi api = connect();
|
||
int key = 0;
|
||
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=1; i<=1024; i++){
|
||
byte[] data = new byte[i];
|
||
|
||
byte[] enc = api.SYD_SM4_ShortData(key, data, ECB_ENC);
|
||
|
||
byte[] dec = api.SYD_SM4_ShortData(key, enc, ECB_DEC);
|
||
|
||
if(!(Util.bytes2HexString(data).equals(Util.bytes2HexString(dec))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc){
|
||
System.out.println("正确传参，加密成功,解密成功");
|
||
} else {
|
||
System.out.println("正确传参，加密失败,解密失败");
|
||
}
|
||
}catch(SydApiException e){
|
||
printException("正确传参", e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- SM4短数据加解密功能测试结束 --------\n");
|
||
}
|
||
|
||
public void zc_sm4LongFunc() {
|
||
System.out.println("-------- SM4长数据加解密功能测试开始 --------");
|
||
SydApi api = connect();
|
||
int key = 0;
|
||
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=1; i<=1024; i++) {
|
||
byte[] data = new byte[i];
|
||
byte[] enc = api.SYD_SM4_LongData(key, data, 0, ECB_ENC);
|
||
byte[] dec = api.SYD_SM4_LongData(key, enc, 0, ECB_DEC);
|
||
|
||
if(!(Util.bytes2HexString(data).equals(Util.bytes2HexString(dec))) ){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc){
|
||
System.out.println("输入解密标识，包序号为0 解密成功");
|
||
} else {
|
||
System.out.println("输入解密标识，包序号为0 解密失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入解密标识，包序号为0 ", e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- SM4长数据加解密功能测试结束 --------\n");
|
||
}
|
||
|
||
public void zc_sm4macShortFunc() {
|
||
System.out.println("-------- SM4MAC短数据功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
int key = 0; //正常索引
|
||
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=1; i<=16; i++){
|
||
byte[] dataBytes = genBytes(i);
|
||
byte[] res = api.SYD_SM4Mac_ShortData(key, dataBytes);
|
||
boolean check = api.SYD_SM4Mac_ShortData(key, dataBytes, res);
|
||
if(!check){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(isSuc){
|
||
System.out.println("输入正确入参,校验成功" );
|
||
} else {
|
||
System.out.println("输入正确入参,校验失败 " );
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确入参，校验失败", e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- SM4MAC短数据功能测试结束 --------\n");
|
||
}
|
||
|
||
public void zc_sm4macLongFunc() {
|
||
System.out.println("-------- SM4MAC长数据功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
int key = 0;
|
||
|
||
try{
|
||
boolean isSuc = true;
|
||
for (int i=1; i<=1024; i++){
|
||
byte[] data = genBytes(i);
|
||
|
||
LongDataReturn<byte[], byte[]> longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null);
|
||
|
||
LongDataReturn<byte[], Boolean> booleanLongDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null, longDataReturn.getData());
|
||
|
||
if(!booleanLongDataReturn.getData()){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (isSuc) {
|
||
System.out.println("输入正确的入参，包序号为0，SM4MAC长数据校验成功");
|
||
} else {
|
||
System.out.println("输入正确的入参，包序号为0，SM4MAC长数据校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确的入参，包序号为0，SM4MAC长数据校验失败",e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- SM4MAC长数据功能测试结束 --------\n");
|
||
}
|
||
|
||
public void zc_sm4BatchFunc() {
|
||
System.out.println("-------- SM4批量数据加解密功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
try{
|
||
List<byte[]> datas = new ArrayList<>();
|
||
int[] keys = new int[1024];
|
||
for (int i=1; i<=1024; i++){
|
||
datas.add(new byte[i]);
|
||
keys[i-1] = 0;
|
||
}
|
||
List<byte[]> en_data = api.SYD_SM4_BatchData(keys, datas, ECB_ENC);
|
||
List<byte[]> de_data = api.SYD_SM4_BatchData(keys, en_data, ECB_DEC);
|
||
|
||
if ( contentEquals(datas, de_data)) {
|
||
System.out.println("正常传参，加解密对比成功");
|
||
} else {
|
||
System.out.println("正常传参，加解密对比失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("正常传参,加解密", e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- SM4批量数据加解密功能测试结束 --------\n");
|
||
}
|
||
|
||
public void zc_sm4macBatchFunc() {
|
||
System.out.println("-------- SM4MAC批量数据功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
try{
|
||
List<byte[]> datas = new ArrayList<>();
|
||
int[] keys = new int[16];
|
||
for (int i=1; i<=16; i++){
|
||
datas.add(genBytes(i));
|
||
keys[i-1] = 0;
|
||
}
|
||
List<byte[]> s = api.SYD_SM4Mac_BatchData(keys, datas);
|
||
boolean[] check = api.SYD_SM4Mac_BatchData(keys, datas, s);
|
||
|
||
if (isAllTrue(check)) {
|
||
System.out.println("输入正确的数据，数据大于1组，SM4MAC批量数据校验成功");
|
||
} else {
|
||
System.out.println("输入正确的数据，数据大于1组，SM4MAC批量数据校验失败");
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("输入正确的数据，数据大于1组", e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- SM4MAC批量数据功能测试结束 --------\n");
|
||
}
|
||
|
||
public void zc_sm4ShortMacFunc() {
|
||
System.out.println("-------- 短数据加密计算MAC功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
int keyEnc = 0;
|
||
int keyMac = 0;
|
||
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=1; i<=1024; i++){
|
||
byte[] bytes = genBytes(i);
|
||
|
||
DataAndMac en_data = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, bytes);
|
||
DataAndMacCheck dataAndMacCheck = api.SYD_SM4_CheckMacAndDecrypt_ShortData(keyEnc, keyMac, en_data.getData(), en_data.getMac());
|
||
|
||
if(!(Util.bytes2HexString(bytes).equals(Util.bytes2HexString(dataAndMacCheck.getData())))){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
if(!dataAndMacCheck.getMacCheck()){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(isSuc){
|
||
System.out.println("输入正确入参, 计算成功");
|
||
} else {
|
||
System.out.println("输入正确入参, 计算失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确入参,计算失败", e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- 短数据加密计算MAC功能测试结束 --------\n");
|
||
}
|
||
|
||
public void zc_sm4BatchMacFunc() {
|
||
System.out.println("-------- 批量数据加密计算MAC功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
try{
|
||
boolean isSuc = true;
|
||
List<byte[]> dataList = new ArrayList<>();
|
||
int[] keys = new int[1024];
|
||
for(int i=1; i<=1024; i++){
|
||
dataList.add(genBytes(i));
|
||
keys[i-1] = 0;
|
||
}
|
||
|
||
List<DataAndMac> en_data = api.SYD_SM4_EncryptAndMac_BatchData(keys, keys, dataList);
|
||
List<DataAndMacCheck> de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keys, keys, en_data);
|
||
for(int i=0; i<en_data.size(); i++) {
|
||
if(!(Util.bytes2HexString(dataList.get(i)).equals(Util.bytes2HexString(de_data.get(i).getData())))){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
if(!de_data.get(i).getMacCheck()){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc){
|
||
System.out.println("输入正确入参,计算成功");
|
||
} else {
|
||
System.out.println("输入正确入参,计算失败");
|
||
}
|
||
} catch(SydApiException e){
|
||
printException("输入正确入参,计算失败", e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- 批量数据加密计算MAC功能测试结束 --------\n");
|
||
}
|
||
|
||
public void zc_sm4ShortMacFunc_check() {
|
||
System.out.println("-------- 短数据校验MAC解密功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
int keyEnc = 0;
|
||
int keyMac = 0;
|
||
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=1; i<=1024; i++){
|
||
byte[] bytes = genBytes(i);
|
||
|
||
DataAndMac en_data = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, bytes);
|
||
DataAndMacCheck dataAndMacCheck = api.SYD_SM4_CheckMacAndDecrypt_ShortData(keyEnc, keyMac, en_data.getData(), en_data.getMac());
|
||
|
||
if(!(Util.bytes2HexString(bytes).equals(Util.bytes2HexString(dataAndMacCheck.getData())))){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
if(!dataAndMacCheck.getMacCheck()){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(isSuc){
|
||
System.out.println("输入正确入参, 校验成功");
|
||
} else {
|
||
System.out.println("输入正确入参, 校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确入参，校验失败", e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- 短数据校验MAC解密功能测试结束 --------\n");
|
||
}
|
||
|
||
public void zc_sm4BatchMacFunc_check() {
|
||
System.out.println("-------- 批量数据校验MAC解密功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
try{
|
||
boolean isSuc = true;
|
||
List<byte[]> dataList = new ArrayList<>();
|
||
int[] keys = new int[1024];
|
||
for(int i=1; i<=1024; i++){
|
||
dataList.add(genBytes(i));
|
||
keys[i-1] = 0;
|
||
}
|
||
|
||
List<DataAndMac> en_data = api.SYD_SM4_EncryptAndMac_BatchData(keys, keys, dataList);
|
||
List<DataAndMacCheck> de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keys, keys, en_data);
|
||
for(int i=0; i<en_data.size(); i++) {
|
||
if(!(Util.bytes2HexString(dataList.get(i)).equals(Util.bytes2HexString(de_data.get(i).getData())))){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
if(!de_data.get(i).getMacCheck()){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
if(isSuc){
|
||
System.out.println("输入正确入参,计算成功");
|
||
} else {
|
||
System.out.println("输入正确入参,计算失败");
|
||
}
|
||
}catch(SydApiException e){
|
||
printException("输入正确入参,计算失败", e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- 批量数据校验MAC解密功能测试结束 --------\n");
|
||
}
|
||
|
||
public void zc_sm4macLongFunc_ISM4Mac() {
|
||
System.out.println("-------- (ISM4Mac)SM4MAC长数据功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
int key = 0;
|
||
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=1; i<=1024; i++){
|
||
byte[] data = genBytes(i);
|
||
|
||
ISM4Mac sm4mac = api.initSM4Mac(key);
|
||
sm4mac.update(data);
|
||
byte[] res = sm4mac.digest();
|
||
boolean check = sm4mac.checkDigest(res);
|
||
|
||
if(!check){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(isSuc){
|
||
System.out.println("pcMac有正确MAC输入，输入正确的入参,校验成功" );
|
||
} else {
|
||
System.out.println("pcMac有正确MAC输入，输入正确的入参,校验失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("pcMac有正确MAC输入，输入正确的入参,校验失败",e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- (ISM4Mac)SM4MAC长数据功能测试结束 --------\n");
|
||
}
|
||
|
||
public void zc_sm4LongFunc_ISM4() {
|
||
System.out.println("-------- (ISM4)SM4长数据加解密功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=1; i<=1024; i++){
|
||
byte[] data = genBytes(i);
|
||
|
||
ISM4 en = api.initSM4(0, ECB_ENC);
|
||
byte[] enc1 = en.update(data);
|
||
byte[] enc2 = en.finish();
|
||
byte[] enc = mergeByteArrays(enc1, enc2);
|
||
|
||
ISM4 de = api.initSM4(0, ECB_DEC);
|
||
byte[] dec1 = de.update(enc);
|
||
byte[] dec2 = de.finish();
|
||
byte[] dec = mergeByteArrays(dec1, dec2);
|
||
|
||
if(!(Util.bytes2HexString(data).equals(Util.bytes2HexString(dec)))){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(isSuc){
|
||
System.out.println("输入正确的入参,加密成功，解密成功");
|
||
} else {
|
||
System.out.println("输入正确的入参,加密失败，解密失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确的入参,加密失败，解密失败", e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- (ISM4)SM4长数据加解密功能测试结束 --------");
|
||
}
|
||
|
||
public void zc_sm3LongFunc_ISM3() {
|
||
System.out.println("-------- (ISM3)SM3长数据功能测试开始 --------");
|
||
SydApi api = connect();
|
||
|
||
try{
|
||
boolean isSuc = true;
|
||
for(int i=1; i<=1024; i++){
|
||
byte[] data = genBytes(i);
|
||
|
||
byte[] res1 = api.SYD_SM3_Hash_ShortData(data);
|
||
|
||
ISM3 sm3 = api.initSM3();
|
||
sm3.update(data);
|
||
byte[] res2 = sm3.digest();
|
||
|
||
if(!(Util.bytes2HexString(res1).equals(Util.bytes2HexString(res2)))){
|
||
isSuc = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(isSuc){
|
||
System.out.println("输入正确的入参,计算成功" );
|
||
} else {
|
||
System.out.println("输入正确的入参,计算失败");
|
||
}
|
||
} catch (SydApiException e){
|
||
printException("输入正确的入参,计算失败", e);
|
||
} finally {
|
||
api.SYD_Disconnect_Ex();
|
||
}
|
||
|
||
System.out.println("-------- (ISM3)SM3长数据功能测试结束 --------\n");
|
||
}
|
||
|
||
private void executeTestsWithIsolation(List<Runnable> tests) {
|
||
for (Runnable test : tests) {
|
||
try {
|
||
test.run();
|
||
} catch (Exception e) {
|
||
e.printStackTrace();
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|