diff --git a/src/main/java/com/sunyard/sge/database/SydApi4Database.java b/src/main/java/com/sunyard/sge/database/SydApi4Database.java index 1c0f4de..b2e5d8f 100644 --- a/src/main/java/com/sunyard/sge/database/SydApi4Database.java +++ b/src/main/java/com/sunyard/sge/database/SydApi4Database.java @@ -1,5 +1,6 @@ package com.sunyard.sge.database; +import com.sunyard.SydApiException; import com.sunyard.log.ILogFactory; import com.sunyard.log.ILogger; import com.sunyard.sge.database.pool.HsmLinkInfo; @@ -33,7 +34,7 @@ public class SydApi4Database extends SydApiBaseFunction { } if ( iKeyIndex.length != pcData.size() ) { - throw new IllegalArgumentException("批量输入数据密钥和数据数量不等"); + throw new SydApiException("批量输入数据密钥和数据数量不等", 0x01000001); } if ( 0 == iKeyIndex.length ) { diff --git a/src/main/java/com/sunyard/sge/database/SydApiBaseFunction.java b/src/main/java/com/sunyard/sge/database/SydApiBaseFunction.java index 7937edb..e0120b0 100644 --- a/src/main/java/com/sunyard/sge/database/SydApiBaseFunction.java +++ b/src/main/java/com/sunyard/sge/database/SydApiBaseFunction.java @@ -161,10 +161,10 @@ public class SydApiBaseFunction implements SydApi { } if (null == pcData) { - throw new SydApiException("输入内容为 null", 19); + throw new SydApiException("输入内容为 null", 0x01000001); } if (pcData.length > 1024) { - throw new SydApiException("输入内容为空", 19); + throw new SydApiException("输入数据长度超过限制", 0x01000001); } SydApiException le = new SydApiException(-1); @@ -222,8 +222,16 @@ public class SydApiBaseFunction implements SydApi { if (null == this.hsms || this.hsms.length < 1) { throw new SydApiException(-1); } + + if ( iPkgNum < 0 || iPkgNum > 3) { + throw new SydApiException("参数错误（入参不符合接口条件）", 0x01000001); + } + byte[] procData = null; if (2 == iPkgNum || 3 == iPkgNum) { + if(null == pcProcData){ + throw new SydApiException("参数错误（入参不符合接口条件）", 0x01000001); + } procData = pcProcData; log.debug("Util.hexString2Bytes方法返回值：{}", Arrays.toString(procData)); @@ -298,10 +306,12 @@ public class SydApiBaseFunction implements SydApi { if (0 == pcData.length || pcData.length > 1024) { throw new SydApiException("输入内容长度错误", 0x01000001); } - } else { + } else if(Consts.ECB_DEC == iFlag){ if (0 == pcData.length || pcData.length % 16 != 0 || pcData.length > 1040) { throw new SydApiException("输入密文数据长度错误", 0x01000014); } + } else { + throw new SydApiException("加解密标识错误", 0x01000001); } updateLastUseTime(); String keyIndex = String.format("%08d", iKeyIndex); @@ -381,16 +391,20 @@ public class SydApiBaseFunction implements SydApi { return new ArrayList<>(); } + if(iFlag !=Consts.ECB_DEC && iFlag != Consts.ECB_ENC){ + throw new SydApiException("加解密标识错误", 0x01000001); + } + if (iFlag == Consts.ECB_DEC) { for (byte[] pcdata : pcData) { if (pcdata.length == 0 || pcdata.length % 16 != 0 || pcdata.length > 1040) { - throw new SydApiException(0x01000015); + throw new SydApiException("数据长度错误",0x01000001); } } } else { for (byte[] pcdata : pcData) { if (pcdata.length > 1024) { - throw new SydApiException(19); + throw new SydApiException("数据长度错误",0x01000001); } } } @@ -466,9 +480,18 @@ public class SydApiBaseFunction implements SydApi { throw new SydApiException(0x01000001); } + if(iFlag != Consts.ECB_ENC && iFlag != Consts.ECB_DEC){ + throw new SydApiException("加解密标识错误", 0x01000001); + } + if (iFlag == Consts.ECB_DEC && (null == pcData || pcData.length == 0 || pcData.length % 16 != 0)) { throw new SydApiException(0x01000015); } + + if(null == pcData || pcData.length > 4064){ + throw new SydApiException("数据长度错误", 0x01000001); + } + if (null == this.hsms || this.hsms.length < 1) { throw new SydApiException(-1); } @@ -706,12 +729,23 @@ public class SydApiBaseFunction implements SydApi { throw new SydApiException(-1); } + if(iPkgNum<0 || iPkgNum>3){ + throw new SydApiException("包序号错误", 0x01000001); + } + + if(pcData != null && pcData.length > 4064){ + throw new SydApiException("数据长度超过限制", 0x01000001); + } + String keyIndex = String.format("%08d", iKeyIndex); byte[] iv = null; // 仅一包 和 第一包 忽略 pcProcData 参数 if (Consts.PkgNumAll != iPkgNum && Consts.PkgNumHead != iPkgNum) { + if(null == pcProcData){ + throw new SydApiException("中间包为空", 0x01000001); + } iv = Util.bytes2HexString(pcProcData).getBytes(); } SydApiException le = new SydApiException(-1); @@ -876,22 +910,22 @@ public class SydApiBaseFunction implements SydApi { public boolean SYD_SM4Mac_ShortData(int iKeyIndex, byte[] pcData, int limitDataLen, byte[] pcMac) { - + if (null == pcMac) { + throw new SydApiException("mac为空", 0x01000001); + } + if (log.isDebugEnabled()) { log.debug("SYD_SM4Mac_ShortData 方法接收参数：{}", iKeyIndex, Util.bytes2HexString(pcData), Util.bytes2HexString(pcMac)); } if (null == pcData || pcData.length > limitDataLen) { - throw new SydApiException("输入内容超长", 19); + throw new SydApiException("输入内容超长", 0x01000001); } if (null == this.hsms || this.hsms.length < 1) { throw new SydApiException(-1); } - if (null == pcMac) { - throw new IllegalArgumentException(); - } updateLastUseTime(); byte[] mac = this.SYD_SM4Mac_ShortData(iKeyIndex, pcData, limitDataLen); log.debug(this + ".SYD_SM4Mac_ShortData方法返回值：{}", mac); diff --git a/src/main/java/com/sunyard/sge/database/SydApiLongLinkWrap.java b/src/main/java/com/sunyard/sge/database/SydApiLongLinkWrap.java index 214bedc..1841ab1 100644 --- a/src/main/java/com/sunyard/sge/database/SydApiLongLinkWrap.java +++ b/src/main/java/com/sunyard/sge/database/SydApiLongLinkWrap.java @@ -396,6 +396,9 @@ public class SydApiLongLinkWrap implements SydApi { try { return task.get(); } catch (Exception e) { + if (e.getCause() instanceof SydApiException) { + throw (SydApiException) e.getCause(); + } throw new SydApiException("并行任务执行失败", 0xC101, e); } } @@ -517,6 +520,9 @@ public class SydApiLongLinkWrap implements SydApi { try { return task.get(); } catch (Exception e) { + if (e.getCause() instanceof SydApiException) { + throw (SydApiException) e.getCause(); + } throw new SydApiException("并行任务执行失败", 0xC101, e); } } @@ -545,7 +551,7 @@ public class SydApiLongLinkWrap implements SydApi { } if (iKeyIndex.length != pcData.size()) { - throw new IllegalArgumentException("批量输入数据密钥和数据数量不等"); + throw new SydApiException("批量输入数据密钥和数据数量不等", 0x01000001); } if (0 == iKeyIndex.length) { @@ -624,7 +630,7 @@ public class SydApiLongLinkWrap implements SydApi { } if (iKeyIndex.length != pcData.size()) { - throw new IllegalArgumentException("批量输入数据密钥和数据数量不等"); + throw new SydApiException("批量输入数据密钥和数据数量不等", 0x01000001); } if (0 == iKeyIndex.length) { @@ -699,7 +705,7 @@ public class SydApiLongLinkWrap implements SydApi { } if (iKeyIndex.length != pcData.size()) { - throw new IllegalArgumentException("批量输入数据密钥和数据数量不等"); + throw new SydApiException("批量输入数据密钥和数据数量不等", 0x01000001); } if (0 == iKeyIndex.length) { diff --git a/src/main/java/com/sunyard/sge/database/SydSM3.java b/src/main/java/com/sunyard/sge/database/SydSM3.java index 312af03..c1c6f12 100644 --- a/src/main/java/com/sunyard/sge/database/SydSM3.java +++ b/src/main/java/com/sunyard/sge/database/SydSM3.java @@ -20,7 +20,7 @@ public class SydSM3 implements ISM3 { pcData = new byte[0]; } if (pcData.length > 4064) { - throw new IllegalArgumentException(); + throw new SydApiException(0x01000001); } if (null == this.pcProcData) { LongDataReturn stringStringLongDataReturn = api.SYD_SM3_Hash_LongData(pcData, 1, null); diff --git a/src/main/java/com/sunyard/sge/database/SydSM4.java b/src/main/java/com/sunyard/sge/database/SydSM4.java index 3d88b3f..ae46b63 100644 --- a/src/main/java/com/sunyard/sge/database/SydSM4.java +++ b/src/main/java/com/sunyard/sge/database/SydSM4.java @@ -33,7 +33,7 @@ public class SydSM4 implements ISM4 { throw new SydApiException(0x8007); } if (plength > 4064) { - throw new SydApiException(0x8006); + throw new SydApiException(0x01000001); } if (iFlag == 1) { if (0 == queue.getLength()) { diff --git a/src/main/java/com/sunyard/sge/database/SydSM4Mac.java b/src/main/java/com/sunyard/sge/database/SydSM4Mac.java index 9cd9ec7..d6adefc 100644 --- a/src/main/java/com/sunyard/sge/database/SydSM4Mac.java +++ b/src/main/java/com/sunyard/sge/database/SydSM4Mac.java @@ -32,16 +32,21 @@ public class SydSM4Mac implements ISM4Mac { throw new SydApiException(0x8007); } if (length > 4064) { - throw new SydApiException(0x8006); + throw new SydApiException(0x01000001); } if (0 == queue.getLength()) { - if (length < 16) { - queue.push(pcData); - } - if (length % 16 != 0) { - queue.push(pcData); - pcdataResult = queue.pop(16, 0); +// if (length < 16) { +// queue.push(pcData); +// } +// if (length % 16 != 0) { +// } + + queue.push(pcData); + pcdataResult = queue.pop(16, 0); + if ( null == pcdataResult || pcdataResult.length == 0 ) { + return; } + if (null == this.pcMac || this.pcMac.length == 0) { LongDataReturn stringStringLongDataReturn = api.SYD_SM4Mac_LongData(iKeyIndex, pcdataResult, iPkgNum, pcProcData); pcProcData = stringStringLongDataReturn.getProcData(); @@ -74,6 +79,7 @@ public class SydSM4Mac implements ISM4Mac { @Override public boolean checkDigest(byte[] mac) { + this.pcMac = this.digest(); return mac != null && Arrays.equals(this.pcMac, mac); } @@ -92,7 +98,8 @@ public class SydSM4Mac implements ISM4Mac { byte[] pop = queue.pop(); LongDataReturn stringStringLongDataReturn = api.SYD_SM4Mac_LongData(iKeyIndex, pop, iPkgNum, pcProcData); - return stringStringLongDataReturn.getData(); + this.pcMac = stringStringLongDataReturn.getData(); + return this.pcMac; } diff --git a/src/test/java/test/FuncTest.java b/src/test/java/test/FuncTest.java index 25a2ed7..16f0d4b 100644 --- a/src/test/java/test/FuncTest.java +++ b/src/test/java/test/FuncTest.java @@ -1,8 +1,13 @@ 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; @@ -11,6 +16,8 @@ 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; @@ -44,18 +51,172 @@ public class FuncTest { } } + 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() { - isShortLink = true; - System.out.println("-------- 切换到短连模式 --------"); + 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() { - System.out.println("-------- 设置长连接参数与获取长连接功能测试开始 --------"); - SydApi api = connect(); - System.out.println("设置长连接参数与获取长连接成功"); + 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和端口 - System.out.println("-------- 设置长连接参数与获取长连接功能测试结束 --------\n"); + 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() { @@ -63,26 +224,44 @@ public class FuncTest { SydApi api = connect(); - byte[] res1 = api.SYD_SM3_Hash_ShortData(new byte[1024]); - byte[] res2 = api.SYD_SM3_Hash_ShortData(new byte[0]); + printBegin(); + try{ + boolean isSuc = true; + for (int i=1; i<=1024; i++){ + byte[] data = new byte[i]; + log("sm3ShortFunc_明文：" + Util.bytes2HexString(data), false); - if (res1.equals(CalcRes.SM3_SHORT_RESULT1) && res2.equals(CalcRes.SM3_SHORT_RESULT2)) { - System.out.println("SM3短数据测试成功"); - } else { - System.out.println("SM3短数据测试失败"); - System.out.println("计算结果：" + res1); - System.out.println("预期结果：" + CalcRes.SM3_SHORT_RESULT1); - System.out.println("计算结果：" + res2); - System.out.println("预期结果：" + CalcRes.SM3_SHORT_RESULT2); + 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[4096]); - System.out.println("SM3短数据超出测试失败"); + api.SYD_SM3_Hash_ShortData(new byte[1025]); + System.out.println("输入数据长度超过1K, hash计算成功"); } catch (SydApiException e) { - System.out.println("SM3短数据超出错误检测成功"); + printException("输入数据长度超过1K", e); } - + printEnd(); System.out.println("-------- SM3短数据功能测试结束 --------\n"); } @@ -91,78 +270,270 @@ public class FuncTest { System.out.println("-------- SM3长数据功能测试开始 --------"); SydApi api = connect(); - ISM3 sm3 = api.initSM3(); - byte[] data = new byte[2]; - for (int i = 0; i < 16; i++) { - sm3.update(data); - } - byte[] res1 = sm3.digest(); - if (Arrays.equals(res1, Util.hexString2Bytes(CalcRes.SM3_LONG_RESULT1)) - ) { - System.out.println("SM3长数据测试成功"); - } else { - System.out.println("SM3长数据测试失败"); - System.out.println("计算结果：" + Util.bytes2HexString(res1)); - System.out.println("预期结果：" + CalcRes.SM3_LONG_RESULT1); - } + 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); - data = new byte[0]; - sm3 = api.initSM3(); - for (int i = 0; i < 10; i++) { - sm3.update(data); + LongDataReturn 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(); - byte[] res2 = sm3.digest(); + printBegin(); + try{ + boolean isSuc = true; + for (int i=1; i<=1024; i++){ + byte[] data = new byte[i]; + log("sm3LongFunc_明文：" + Util.bytes2HexString(data), false); - if (Arrays.equals(res2, Util.hexString2Bytes(CalcRes.SM3_LONG_RESULT2)) - ) { - System.out.println("SM3长数据测试成功"); - } else { - System.out.println("SM3长数据测试失败"); - System.out.println("计算结果：" + Util.bytes2HexString(res2)); - System.out.println("预期结果：" + CalcRes.SM3_LONG_RESULT2); + byte[] res = api.SYD_SM3_Hash_ShortData(data); + log("sm3LongFunc_res:" + Util.bytes2HexString(res), false); + + LongDataReturn 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 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 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 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; - byte[] enc1 = api.SYD_SM4_ShortData(key, new byte[1024], ECB_ENC); - byte[] dec1 = api.SYD_SM4_ShortData(key, enc1, ECB_DEC); + printBegin(); + try{ + boolean isSuc = true; + for (int i=1; i<=1024; i++){ + byte[] data = new byte[i]; + log("sm4ShortFunc_明文: " + Util.bytes2HexString(data), false); - byte[] enc2 = api.SYD_SM4_ShortData(key, new byte[0], ECB_ENC); - byte[] dec2 = api.SYD_SM4_ShortData(key, enc2, ECB_DEC); + byte[] enc = api.SYD_SM4_ShortData(key, data, ECB_ENC); + log("sm4ShortFunc_加密后: " + Util.bytes2HexString(enc), false); - String res1 = Util.bytes2HexString(enc1); - String res2 = Util.bytes2HexString(enc2); + byte[] dec = api.SYD_SM4_ShortData(key, enc, ECB_DEC); + log("sm4ShortFunc_解密后: " + Util.bytes2HexString(dec), false); - if (res1.equals(CalcRes.SM4_SHORT_RESULT1) && res2.equals(CalcRes.SM4_SHORT_RESULT2) - && Arrays.equals(dec1, new byte[1024]) && Arrays.equals(dec2, new byte[0])) { - System.out.println("SM4短数据测试成功"); - } else { - System.out.println("SM4短数据测试失败"); - System.out.println("加密计算结果：" + res1); - System.out.println("加密预期结果：" + CalcRes.SM4_SHORT_RESULT1); - System.out.println("解密计算结果：" + Util.bytes2HexString(dec1)); - System.out.println("解密预期结果：" + Util.bytes2HexString(new byte[1024])); - System.out.println("加密计算结果：" + res2); - System.out.println("加密预期结果：" + CalcRes.SM4_SHORT_RESULT2); - System.out.println("解密计算结果：" + Util.bytes2HexString(dec2)); - System.out.println("解密预期结果：" + Util.bytes2HexString(new byte[0])); + 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 { - enc1 = api.SYD_SM4_ShortData(key, new byte[1025], ECB_ENC); - dec1 = api.SYD_SM4_ShortData(key, enc1, ECB_DEC); - System.out.println("SM4短数据长度超出测试失败"); + byte[] enc = api.SYD_SM4_ShortData(-1, new byte[1024], ECB_ENC); + System.out.println("输入不正确的会话密钥索引，输入加密标识，加密成功"); } catch (SydApiException e) { - System.out.println("SM4短数据长度超出测试成功"); + 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"); } @@ -170,47 +541,544 @@ public class FuncTest { public void sm4LongFunc() { System.out.println("-------- SM4长数据加解密功能测试开始 --------"); SydApi api = connect(); - boolean ret = LongDataTest.case1(api); - if (!ret) { - System.out.println("-------- SM4长数据加解密功能测试失败 --------\n"); - } else { - System.out.println("-------- SM4长数据加解密功能测试结束 --------\n"); - } + 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; - byte[] data1 = new byte[1024]; - byte[] data2 = new byte[0]; + 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不一样的情况 - byte[] res1 = api.SYD_SM4Mac_ShortData(key, data1); - boolean check1 = api.SYD_SM4Mac_ShortData(key, data1, res1); + printBegin(); + try{ + List 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; + } + } - byte[] res2 = api.SYD_SM4Mac_ShortData(key, data2); - boolean check2 = api.SYD_SM4Mac_ShortData(key, data2, res2); - - if (res1.equals(CalcRes.SM4MAC_SHORT_RESULT1) && res2.equals(CalcRes.SM4MAC_SHORT_RESULT2) - && check1 && check2) { - System.out.println("SM4MAC短数据测试成功"); - } else { - System.out.println("SM4MAC短数据测试失败"); - System.out.println("计算结果：" + res1); - System.out.println("预期结果：" + CalcRes.SM4MAC_SHORT_RESULT1); - System.out.println("计算结果：" + res2); - System.out.println("预期结果：" + CalcRes.SM4MAC_SHORT_RESULT2); + if(isSuc){ + System.out.println("输入正确入参,计算成功" ); + } else { + System.out.println("输入正确入参,计算失败 " ); + } + } catch (SydApiException e){ + printException("输入正确入参，计算失败", e); } + printEnd(); - try { - res1 = api.SYD_SM4Mac_ShortData(key, new byte[1025]); - check1 = api.SYD_SM4Mac_ShortData(key, new byte[1025], res1); - System.out.println("SM4MAC短数据长度超出测试失败"); - } catch (SydApiException e) { - System.out.println("SM4MAC短数据长度超出测试成功"); + 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){ + System.out.println("数据长度大于1024 异常: " + e.getMessage()); + } + 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){ + System.out.println("pcMac为空 异常: " + e.getMessage()); + } + 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"); } @@ -219,32 +1087,420 @@ public class FuncTest { System.out.println("-------- SM4MAC长数据功能测试开始 --------"); SydApi api = connect(); - byte[] data1 = new byte[2048]; int key = 0; - ISM4Mac sm4mac = api.initSM4Mac(key); - for (int i = 0; i < 10; i++) { - sm4mac.update(data1); - } - byte[] res1 = sm4mac.digest(); + int key_incorrect = -1; - // 64 x 16 = 1024 - byte[] data2 = new byte[16]; - sm4mac = api.initSM4Mac(key); - for (int i = 0; i < 64; i++) { - sm4mac.update(data2); - } - byte[] res2 = sm4mac.digest(); - byte[] r = api.SYD_SM4Mac_ShortData(0, new byte[1024]); + List 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”） - System.out.println( Util.bytes2HexString(r) ); - if ( Arrays.equals(res2, r ) - && Arrays.equals(r, Util.hexString2Bytes("E04F0975D47219AE9B949CB185C303E9")) - ) { - System.out.println("SM4MAC长数据测试成功"); - } else { - System.out.println("SM4MAC长数据测试失败"); + printBegin(); + try{ + boolean isSuc = true; + for (int i=1; i<=16; i++){ + byte[] data = genBytes(i); + log("sm4macLongFunc___明文: " + Util.bytes2HexString(data), false ); + LongDataReturn 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 longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null); + log("sm4macLongFunc___计算结果: " + Util.bytes2HexString(longDataReturn.getData()), false ); + + LongDataReturn 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 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 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 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 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 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 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 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 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 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 longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null); + System.out.println("正常传参，SM4MAC长数据计算成功"); + LongDataReturn 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 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 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){ + System.out.println("包序号为2时，pcProcData无输入 异常: " + e.getMessage()); + } + + try{ + byte[] data = new byte[1024]; + LongDataReturn 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 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){ + System.out.println("包序号为3时，pcProcData无输入 异常: " + e.getMessage()); + } + printEnd(); + + printBegin(); + try{ + byte[] data = new byte[1024]; + LongDataReturn longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null); + System.out.println("正常传参，SM4MAC长数据计算成功"); + + LongDataReturn 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 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 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 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 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 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 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 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){ + System.out.println("输入包序号不为0-3 异常: " + e.getMessage()); + } + printEnd(); + + printBegin(); + try{ + byte[] data = new byte[1024]; + LongDataReturn longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null); + System.out.println("正常传参，SM4MAC长数据计算成功"); + LongDataReturn 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){ + System.out.println("输入包序号不为0-3 异常: " + e.getMessage()); + } + printEnd(); + + + printBegin(); + try{ + byte[] data = new byte[5000]; + LongDataReturn longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null); + System.out.println("输入大于4064的数据长度，SM4MAC长数据计算成功"); + } catch (SydApiException e){ + printException("输入大于4064的数据长度，SM4MAC长数据计算失败",e); + } catch (Exception e){ + System.out.println("输入大于4064的数据长度 异常: " + e.getMessage()); + } + printEnd(); + + printBegin(); + try{ + byte[] data = new byte[4000]; + LongDataReturn 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 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){ + System.out.println("输入大于4064的数据长度 异常: " + e.getMessage()); + } + printEnd(); + + + System.out.println("-------- SM4MAC长数据功能测试结束 --------\n"); + // try: @@ -270,11 +1526,139 @@ public class FuncTest { // 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 dataList = new ArrayList<>(); + List 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 data = new ArrayList<>(); + List data = new ArrayList<>(); //正常明文 data.add(new byte[1024]); data.add(new byte[1024]); data.add(new byte[1024]); @@ -282,22 +1666,144 @@ public class FuncTest { data.add(new byte[1024]); data.add(new byte[1024]); data.add(new byte[1024]); - int[] key = new int[]{0, 0, 0, 0, 0, 0, 0}; + List 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 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 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]); - List en_data = api.SYD_SM4_BatchData(key, data, ECB_ENC); + 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}; //密钥个数和明文数据个数不一致测试 - List de_data = api.SYD_SM4_BatchData(key, en_data, ECB_DEC); - if (en_data.equals(CalcRes.SM4_BATCH_RESULT) && data.equals(de_data)) { - System.out.println("SM4批量数据加解密测试成功"); - } else { - System.out.println("SM4批量数据加解密测试失败"); -// System.out.println("加密计算结果：" + en_data); - System.out.println("加密预期结果：" + CalcRes.SM4_BATCH_RESULT); -// System.out.println("解密计算结果：" + de_data); -// System.out.println("解密预期结果：" + data); + printBegin(); + try{ + List 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 en_data = api.SYD_SM4_BatchData(keys, datas, ECB_ENC); + List de_data = api.SYD_SM4_BatchData(keys, en_data, ECB_DEC); + + for(int i=0; i en_data = api.SYD_SM4_BatchData(key_incorrect, data, ECB_ENC); + System.out.println("输入不正确的密钥索引，输入加密标识，加密成功"); + } catch (SydApiException e) { + printException("输入不正确的密钥索引，输入加密标识", e); + } + printEnd(); + + printBegin(); + try{ + List en_data = api.SYD_SM4_BatchData(key, data, ECB_ENC); + System.out.println("正常传参，加密成功"); + List de_data = api.SYD_SM4_BatchData(key_incorrect, en_data, ECB_DEC); + System.out.println("输入不正确的密钥索引，输入解密标识，解密成功"); + } catch (SydApiException e) { + printException("输入不正确的密钥索引，输入解密标识", e); + } + printEnd(); + + printBegin(); + try{ + List en_data = api.SYD_SM4_BatchData(key, data, -1); + System.out.println("输入不存在的标识，加解密成功"); + } catch (SydApiException e) { + printException("输入不存在的标识", e); + } + printEnd(); + + printBegin(); + try{ + List en_data = api.SYD_SM4_BatchData(key_insufficient, data, ECB_ENC); + System.out.println("密钥索引个数和明文数据个数不一致，加密成功"); + } catch (SydApiException e) { + printException("密钥索引个数和明文数据个数不一致，加密失败", e); + } + printEnd(); + + printBegin(); + try{ + List en_data = api.SYD_SM4_BatchData(key, data, ECB_ENC); + System.out.println("正常传参，加密成功"); + List de_data = api.SYD_SM4_BatchData(key_insufficient, en_data, ECB_DEC); + System.out.println("密钥索引个数和密文数据个数不一致，解密成功"); + } catch (SydApiException e) { + printException("密钥索引个数和密文数据个数不一致，解密失败", e); + } + printEnd(); + + printBegin(); + try{ + List 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 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 en_data = api.SYD_SM4_BatchData(key, data, ECB_ENC); + List 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"); } @@ -311,100 +1817,486 @@ public class FuncTest { data.add(new byte[1024]); data.add(new byte[1024]); data.add(new byte[1024]); + List 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 s = api.SYD_SM4Mac_BatchData(keyIdx, data); + List pcMac = new ArrayList<>(); + pcMac.add(new byte[1024]); + pcMac.add(new byte[1024]); + pcMac.add(new byte[1024]); + pcMac.add(new byte[1024]); + List 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]); - boolean[] check = api.SYD_SM4Mac_BatchData(keyIdx, data, s); - boolean flag = true; - if (null != s) { - for (int i = 0; i < check.length; i++) { - if (!check[i]) { - flag = false; + printBegin(); + try{ + List 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 datas = new ArrayList<>(); + int[] keys = new int[16]; + for (int i=1; i<=16; i++){ + datas.add(genBytes(i)); + keys[i-1] = 0; + } + List s = api.SYD_SM4Mac_BatchData(keys, datas); + + for(int i=0; i datas = new ArrayList<>(); + int[] keys = new int[16]; + for (int i=1; i<=16; i++){ + datas.add(genBytes(i)); + keys[i-1] = 0; + } + List s = api.SYD_SM4Mac_BatchData(keys, datas); + boolean[] check = api.SYD_SM4Mac_BatchData(keys, datas, s); + for(int i=0; i s = api.SYD_SM4Mac_BatchData(keyIdx_incorrect, data); + System.out.println("输入不正确的密钥索引信息，数据大于1组，mac计算成功"); + }catch (SydApiException e){ + printException("输入不正确的密钥索引信息，数据大于1组，mac计算失败", e); + } + printEnd(); + + printBegin(); + try{ + List 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 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 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 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 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 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，校验MAC解密功能测试开始 --------"); + System.out.println("-------- 短数据加密计算MAC功能测试开始 --------"); SydApi api = connect(); int keyEnc = 0; + int keyEnc_incorrect = -1; int keyMac = 0; - byte[] data1 = new byte[1024]; - byte[] data2 = new byte[0]; - System.out.println("step1"); - DataAndMac en_data1 = api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, data1); - 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()); + int keyMac_incorrect = -1; + byte[] data = new byte[1024]; + byte[] data_incorrect = new byte[1025]; - //错误测试 - 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, data2); - 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(); + 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; + } } - } - 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 字节， 测试通过"); + if(isSuc){ + System.out.println("输入正确入参, 计算成功"); } else { - System.out.println("SYD_SM4_CheckMacAndDecrypt_ShortData 不支持数据长度为非 16 字节， 测试失败"); + System.out.println("输入正确入参, 计算失败"); } + } catch (SydApiException e){ + printException("输入正确入参,计算失败", e); } + printEnd(); - - try { - data1 = new byte[1025]; - api.SYD_SM4_EncryptAndMac_ShortData(keyEnc, keyMac, data1); - System.out.println("短数据加密计算MAC，校验MAC解密长度超出测试失败"); - } catch (SydApiException e) { - System.out.println("短数据加密计算MAC，校验MAC解密长度超出测试成功"); + 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(); - 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"); + 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(); - System.out.println("-------- 短数据加密计算MAC，校验MAC解密功能测试结束 --------\n"); + 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); + } + 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，校验MAC解密功能测试开始 --------"); + System.out.println("-------- 批量数据加密计算MAC功能测试开始 --------"); SydApi api = connect(); List data = new ArrayList<>(); @@ -415,81 +2307,411 @@ public class FuncTest { data.add(new byte[1024]); data.add(new byte[1024]); data.add(new byte[1024]); + List 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}; - List en_data = api.SYD_SM4_EncryptAndMac_BatchData(keyEnc, keyMac, data); - List de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keyEnc, keyMac, en_data); + printBegin(); + try{ + if(false){ + int max = 7; + List data_test = new ArrayList<>(); + int[] keytest = new int[max]; + for(int i=0; i en_test = api.SYD_SM4_EncryptAndMac_BatchData(keytest, keytest, data_test); + System.out.println("计算成功!!! " + en_test.size()); + } - boolean flag = true; - for (DataAndMacCheck deDatum : de_data) { - flag = flag & deDatum.getMacCheck(); + boolean isSuc = true; + + List en_data = api.SYD_SM4_EncryptAndMac_BatchData(keyEnc, keyMac, data); + List de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keyEnc, keyMac, en_data); + for(int i=0; i 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(); - 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"); + printBegin(); + try{ + List 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(); - System.out.println("批量数据mac校验并解密，mac校验失败测试"); - - en_data.get(1).setMac(new byte[16]); - - List de_data1 = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keyEnc, keyMac, en_data); - int index = 0; - for (DataAndMacCheck item : de_data1) { - boolean macCheck = item.getMacCheck(); - - System.out.println("索引 " + (index++) + ":"+"MAC校验结果为："+macCheck); + printBegin(); + try{ + List 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(); - System.out.println("-------- 批量数据加密计算MAC，校验MAC解密功能测试结束 --------\n"); + +// 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 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{ + boolean isSuc = true; + + List en_data = api.SYD_SM4_EncryptAndMac_BatchData(keyEnc, keyMac, data); + List de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keyEnc, keyMac, en_data); + for(int i=0; i 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 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 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 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 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 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); + }catch (Exception e){ + System.out.println("密文数据长度大于1024+16 异常: " + e.getMessage()); + } + printEnd(); + + printBegin(); + try{ + List 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 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){ + System.out.println("密文校验值长度不为16 异常: " + e.getMessage()); + } + printEnd(); + + printBegin(); + try{ + List 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 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 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 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("-------- 设置日志配置功能测试开始 --------"); - SydApi.SYD_SetLogConfig("./logs", 3); - System.out.println("日志配置成功，存储路径./logs，级别3"); + + 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.sm4BatchFunc(); - - + 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.sm4LongFunc(); - this.sm4macLongFunc(); + 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 zc_funcAll() { + List tests = Arrays.asList( + this::zc_sm3ShortFunc, + this::zc_sm3LongFunc, + this::zc_sm4ShortFunc, + this::zc_sm4LongFunc, + this::zc_sm4macShortFunc, + this::zc_sm4macLongFunc, + this::zc_sm4BatchFunc, + this::zc_sm4macBatchFunc, + this::zc_sm4ShortMacFunc, + this::zc_sm4BatchMacFunc, + this::zc_sm4ShortMacFunc_check, + this::zc_sm4BatchMacFunc_check, + this::zc_sm4macLongFunc_ISM4Mac, + this::zc_sm4LongFunc_ISM4, + this::zc_sm3LongFunc_ISM3 + ); + +// this.changeConnect(true); //设置成短连接把相关功能测试下 +// executeTestsWithIsolation(tests); + + this.changeConnect(false); //设置成长连接把相关功能测试下 + executeTestsWithIsolation(tests); + } + public void funcMenu(Config config, Choise choise, FuncTest test) throws Exception { boolean flag = true; @@ -508,15 +2730,26 @@ public class FuncTest { System.out.println("7. SM4MAC 短数据"); System.out.println("8. SM4MAC 批量数据"); - System.out.println("9. SM4短数据加密后生成MAC，解密验证MAC"); - System.out.println("10. SM4批量数据加密后生成MAC，验证MAC解密"); + 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()) { @@ -532,7 +2765,6 @@ public class FuncTest { case 4: test.sm3ShortFunc(); break; - case 5: test.sm4ShortFunc(); break; @@ -564,6 +2796,30 @@ public class FuncTest { 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; @@ -590,4 +2846,677 @@ public class FuncTest { } + + private void printBegin(){ + System.out.println("============begin============"); + } + + private void printEnd(){ + System.out.println("============end============\n"); + } + + private boolean compareLists(List byteList, List 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 list1, List 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 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 longDataReturn = api.SYD_SM4Mac_LongData(key, data, 0, null); + + LongDataReturn 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 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 en_data = api.SYD_SM4_BatchData(keys, datas, ECB_ENC); + List 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 datas = new ArrayList<>(); + int[] keys = new int[16]; + for (int i=1; i<=16; i++){ + datas.add(genBytes(i)); + keys[i-1] = 0; + } + List 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 dataList = new ArrayList<>(); + int[] keys = new int[1024]; + for(int i=1; i<=1024; i++){ + dataList.add(genBytes(i)); + keys[i-1] = 0; + } + + List en_data = api.SYD_SM4_EncryptAndMac_BatchData(keys, keys, dataList); + List de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keys, keys, en_data); + for(int i=0; i dataList = new ArrayList<>(); + int[] keys = new int[1024]; + for(int i=1; i<=1024; i++){ + dataList.add(genBytes(i)); + keys[i-1] = 0; + } + + List en_data = api.SYD_SM4_EncryptAndMac_BatchData(keys, keys, dataList); + List de_data = api.SYD_SM4_CheckMacAndDecrypt_BatchData(keys, keys, en_data); + for(int i=0; i tests) { + for (Runnable test : tests) { + try { + test.run(); + } catch (Exception e) { + e.printStackTrace(); + } + } + } + }