Sunyard/sydapi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

测试接口并修改一些错误

Browse Source
This commit is contained in:
zhoubin
2021-08-18 10:32:12 +08:00
parent d55a195656
commit ae5daa6c15
9 changed files with 812 additions and 478 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main/java/com/sunyard/inf/SydCryptionApi.java
+1
View File
@@ -179,6 +179,7 @@ interface SydSYMApi {
* @param fullMode 填充模式：0为饥饿模式，1为贪婪模式
* @param pInData 消息数据
* @param iv IV
* @param block 消息块号
* @return
* iv: IV 数据域
* msg_all: 消息数据
src/main/java/com/sunyard/inf/SydGenApi.java
+2
View File
@@ -44,6 +44,8 @@ public interface SydGenApi {
/**
* 生成一个对称密钥(*) -> pass (对比之前添加了可产生ZMK加密下的密钥)
*
* 默认加密输出密钥的密钥方案为X，业务标识为N。
* @param mode 是否产生ZMK加密下的密钥,0－产生密钥。1－产生密钥并在ZMK下加密
* @param keyType 密钥类型
* @param solution 密钥方案（LMK） 密钥长度/LMK下加密密钥的方案。
src/main/java/racal/sunyard/main/SydApi4j.java
+95 -47
View File
@@ -472,6 +472,7 @@ public class SydApi4j implements SydApi {
}
// 测试通过
@Override
public RetWrap genComposeKey(String[] keys) {
@@ -502,8 +503,8 @@ public class SydApi4j implements SydApi {
data.put("flag", 'N');
data.put("split", ";");
data.put("zmk", "Z");
data.put("lmk", "Z");
data.put("zmk", "X");
data.put("lmk", "X");
data.put("kcvType", "0");
ByteBuffer bb = proto.rend(packet);
@@ -530,7 +531,7 @@ public class SydApi4j implements SydApi {
System.arraycopy(lmkHeads, 0, bs, 0, lmkHeads.length);
System.arraycopy(lmks, 0, bs, lmkHeads.length, lmks.length);
retWrap.put("lmkKey", bs);
retWrap.put("keyCheck", ((PacketSection) ret.get("keyCheck")).getBytes());
retWrap.put("keyCheck", ((PacketSection) ret.get("kcv")).getBytes());
return retWrap;
}
}
@@ -538,6 +539,7 @@ public class SydApi4j implements SydApi {
}
// 测试通过
@Override
public RetWrap genComposeKey(String keyType, char keySolution, String keyClearPattern) {
@@ -2179,6 +2181,7 @@ public class SydApi4j implements SydApi {
return rw;
}
// 测试通过
@Override
public String GenerateRandom(int nRandomSize) {
//获取协议
@@ -2385,6 +2388,7 @@ public class SydApi4j implements SydApi {
}
// 测试通过
@Override
public RetWrap SM3Hash(int packSn, String userId, byte[] publicKey, byte[] msg, byte[] filterData) {
Proto76 proto = new Proto76();
@@ -2427,6 +2431,7 @@ public class SydApi4j implements SydApi {
}
}
// 测试通过
@Override
public RetWrap SM2OrRSAGenKeyPair(int keyType, String index, int length) {
@@ -2449,7 +2454,7 @@ public class SydApi4j implements SydApi {
packet.put("header", sn.getSn().array());
data.put("algorithmId$option", keyType);
data.put("keyLength", keyLength);
//data.put("flag", "P");
data.put("flag", "P");
data.put("index", SYMUtil.genPrivateKeyMark(index, "000", "00000001"));
data.put("startTime", date);
data.put("endTime", date);
@@ -2608,6 +2613,7 @@ public class SydApi4j implements SydApi {
}
//1.1生成一个对称密钥(*) -> pass (对比之前添加了可产生ZMK加密下的密钥)
// 测试通过
public RetWrap genSymKey(int mode, String keyType, char solution, String zmk) {
ProtoA0 proto = new ProtoA0();
HashMap<String, Object> packet = new HashMap();
@@ -3285,6 +3291,7 @@ public class SydApi4j implements SydApi {
}
}
// 测试通过
@Override
public byte[] encryptByPk(int alg, String pk, byte[] data) {
@@ -3751,6 +3758,7 @@ public class SydApi4j implements SydApi {
return ctx;
}
// 测试通过
@Override
public RetWrap SM2GenSessionKey(String publicKey) {
// 获取协议
@@ -4441,7 +4449,7 @@ public class SydApi4j implements SydApi {
* @return 所计算出的MAC hex 格式
*/
public byte[] MAC_Data(String TAK, String infoData, String IV) {
ProtoMA proto = new ProtoMA();
ProtoMAXF proto = new ProtoMAXF();
// 填充数据
HashMap<String, Object> packet = new HashMap<String, Object>();
@@ -4458,8 +4466,6 @@ public class SydApi4j implements SydApi {
data.put("TAK", TAK);
infoData += "80";
while (infoData.length() % 16 != 0) {
infoData += "00";
}
@@ -4504,6 +4510,7 @@ public class SydApi4j implements SydApi {
* @param iv IV
* @return 所计算出的MAC
*/
// 测试通过
public byte[] _calcPBOCMAC(int mode, int keyType, String key, byte[] odata, int block, byte[] iv) {
ProtoMU proto = new ProtoMU();
@@ -5297,6 +5304,7 @@ public class SydApi4j implements SydApi {
}
// 测试通过
@Override
public RetWrap outputKey(String keyType, char solution, String zmk, String key) {
@@ -5354,6 +5362,7 @@ public class SydApi4j implements SydApi {
return retWrap;
}
// 测试通过
@Override
public RetWrap inputKey(String keyType, char solution, String zmk, String key) {
@@ -5488,6 +5497,7 @@ public class SydApi4j implements SydApi {
* @return RetWrap
* lmkkey lmk 头 + LMK 加密下的密钥。
*/
// 测试通过
public RetWrap conversionKey(String keyType, String key, char solution) {
ProtoB0 proto = new ProtoB0();
@@ -5547,6 +5557,7 @@ public class SydApi4j implements SydApi {
* @return zmkKey: ZMK 加密下的ZPK
* keyCheck: 密钥校验值。
*/
// 测试通过
public RetWrap changZMK2LMK(String zmki, String zmk) {
ProtoBY proto = new ProtoBY();
@@ -5561,7 +5572,7 @@ public class SydApi4j implements SydApi {
data.put("zmk", zmk);
data.put("separator", ";");
data.put("zmkSolution", "X");
data.put("lmkSolution", "Z");
data.put("lmkSolution", "X");
data.put("keyCheckType", "0");
ByteBuffer bb = proto.rend(packet);
@@ -5615,6 +5626,7 @@ public class SydApi4j implements SydApi {
* EQUIPNO: 设备机具号
* SOFTVERSION: 设备内部软件版本号
*/
// 测试通过
@Override
public RetWrap getVersion(String num) {
ProtoHV proto = new ProtoHV();
@@ -5835,6 +5847,7 @@ public class SydApi4j implements SydApi {
* @param infoData 加押数据
* @return MAC: 密押，默认为8H
*/
// 测试通过
public RetWrap impose(String keyType, String key, byte[] infoData) {
// 获取协议
Proto62 proto = new Proto62();
@@ -5887,6 +5900,7 @@ public class SydApi4j implements SydApi {
* @param infoData 加押数据
* @return 是否正确
*/
// 测试通过
public Boolean verifyImpose(String keyType, String key, byte[] secret, byte[] infoData) {
// 获取协议
Proto63 proto = new Proto63();
@@ -5938,6 +5952,7 @@ public class SydApi4j implements SydApi {
* @return infoLen: 返回原数据长度
* info: 信息数据
*/
// 测试通过
public RetWrap encryAndDecry(String keyType, String key, byte[] infoData) {
// 获取协议
Proto64 proto = new Proto64();
@@ -5979,7 +5994,7 @@ public class SydApi4j implements SydApi {
}
RetWrap rw = new RetWrap();
rw.put("infoLen", ((PacketSection) ret.get("infoLen")).getString());
rw.put("info", ((PacketSection) ret.get("info")).getString());
rw.put("info", ((PacketSection) ret.get("info")).getBytes());
return rw;
}
@@ -5993,6 +6008,7 @@ public class SydApi4j implements SydApi {
* @return infoLen: 密文数据长度
* info: 密文数据
*/
// 测试通过
public RetWrap switchEncry(String keyType, String srcKey, String aimKey, byte[] infoData) {
// 获取协议
Proto65 proto = new Proto65();
@@ -6044,6 +6060,7 @@ public class SydApi4j implements SydApi {
* @param pin PIN数据
* @return PIN数据
*/
// 测试通过
public byte[] encryAndDecry4PIN(String key, byte[] pin) {
// 获取协议
Proto66 proto = new Proto66();
@@ -6184,6 +6201,7 @@ public class SydApi4j implements SydApi {
* @return keyLength: 公钥加密的密文长度
* key: 公钥加密的密文的DER编码
*/
// 测试通过
public RetWrap LMK2SM2(byte[] pk, String key) {
// 获取协议
Proto71 proto = new Proto71();
@@ -6220,7 +6238,7 @@ public class SydApi4j implements SydApi {
}
RetWrap rw = new RetWrap();
rw.put("keyLength", ((PacketSection) ret.get("keyLength")).getString());
rw.put("key", ((PacketSection) ret.get("key")).getString());
rw.put("key", ((PacketSection) ret.get("key")).getBytes());
return rw;
}
@@ -6291,6 +6309,7 @@ public class SydApi4j implements SydApi {
* @return filterData: 过渡消息数据.只对“消息块号”为 2、1 时有效
* hash: hash
*/
// 测试通过
public RetWrap conutHash(int hashType, int packSn, byte[] msg, byte[] filterData) {
Proto7D proto = new Proto7D();
HashMap<String, Object> packet = new HashMap();
@@ -6339,6 +6358,7 @@ public class SydApi4j implements SydApi {
* @param checkValue 校验值
* @return 是否成功
*/
// 测试通过
public Boolean loadKey(String index, String key, String checkValue) {
ProtoLB proto = new ProtoLB();
HashMap<String, Object> packet = new HashMap();
@@ -6350,8 +6370,8 @@ public class SydApi4j implements SydApi {
data.put("indexFlag", "K");
data.put("index", index);
data.put("key", key);
data.put("checkFlag", "P");
data.put("checkValue", checkValue);
// data.put("checkFlag", "P");
// data.put("checkValue", checkValue);
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
Date dt = new Date();
@@ -6394,6 +6414,7 @@ public class SydApi4j implements SydApi {
* @param index 索引地址,指示用户密钥存储区的27位地址
* @return key: 被加密的密钥
*/
// 测试通过
@Override
public RetWrap readKey(String index) {
ProtoLF proto = new ProtoLF();
@@ -6444,6 +6465,7 @@ public class SydApi4j implements SydApi {
* @param checkValue 校验值
* @return
*/
// 测试通过
public Boolean updateKey(String index, String key, String checkValue) {
ProtoLG proto = new ProtoLG();
HashMap<String, Object> packet = new HashMap();
@@ -6504,16 +6526,17 @@ public class SydApi4j implements SydApi {
* 数据转加密指令(Y0)(=) -> pass (注:密文数据那项不一定需要传加密出来的数据)
*
* @param srcType 源密钥类型
* @param sca 源算法SCA
* @param sca 源算法SCA 1：DES, 2：3DES, 3：IDEA, 4：SM1, 5：AES, 6：SM4
* @param desKeyType 目的秘钥类型
* @param dca 目的算法SCA
* @param roundModel 加密模式
* @param dca 目的算法SCA 1：DES, 2：3DES, 3：IDEA, 4：SM1, 5：AES, 6：SM4
* @param roundModel 加密模式 1：ECB, 2：CBC, 3：CFB, 4：OFB
* @param sDEK 源秘钥DEK
* @param dDEK 目的秘钥DEK
* @param infoData 密文数据
* @param vector 向量
* @return byte[] 目的密钥加密的密文数据
*/
// 测试通过
public byte[] switchEncryY(String srcType, int sca, String desKeyType, int dca, int roundModel, String sDEK, String dDEK, byte[] infoData, String vector) {
ProtoY0 proto = new ProtoY0();
HashMap<String, Object> packet = new HashMap();
@@ -6524,10 +6547,10 @@ public class SydApi4j implements SydApi {
packet.put("header", sn.getSn().array());
data.put("srcKeyType", srcType);
data.put("sca$option", sca);
data.put("sca$option", sca - 1);
data.put("desKeyType", desKeyType);
data.put("dca$option", dca);
data.put("roundModel$option", roundModel);
data.put("dca$option", dca - 1);
data.put("roundModel$option", roundModel - 1);
data.put("sDEK", sDEK);
data.put("dDEK", dDEK);
data.put("infoData", infoData);
@@ -6567,6 +6590,7 @@ public class SydApi4j implements SydApi {
* @param msg 消息块
* @return MAB: 当消息块号为“1”或“2”时，作为下一块的IV。当消息块号为“0”或“3”时，用于消息认证。
*/
// 测试通过
public RetWrap genMAB(int packSn, int keyType, int mode, String key, byte[] iv, byte[] msg) {
ProtoMS proto = new ProtoMS();
HashMap<String, Object> packet = new HashMap();
@@ -6578,9 +6602,9 @@ public class SydApi4j implements SydApi {
data.put("block$option", packSn);
data.put("keyType$option", keyType);
data.put("mode$option", mode);
data.put("dataType$option", 0);
data.put("dataType$option", 1);
data.put("key", key);
if (null != iv) {
if (null != iv && !"".equals(iv)) {
data.put("iv", iv);
}
data.put("msg", msg);
@@ -6615,6 +6639,7 @@ public class SydApi4j implements SydApi {
* @param account 账号中去除校验位的最右 12 位
* @return LMK 对（02-03）下加密的导出 PINBLOCK。（PINBLOCK格式默认为 01 格式）
*/
// 测试通过
public String genPIN(String account) {
ProtoJA proto = new ProtoJA();
HashMap<String, Object> packet = new HashMap();
@@ -6720,6 +6745,7 @@ public class SydApi4j implements SydApi {
* @param account 账号中去除校验位的最右 12 位
* @return 目的 ZPK 下加密的目的 PIN 块
*/
// 测试通过
@Override
public String transPINFromZPKToZPK(String zpk1, String zpk2, int sca, int dca, int spt, int dpt, String pin, String account) {
@@ -6735,12 +6761,12 @@ public class SydApi4j implements SydApi {
data.put("sourceZpk", zpk1);
data.put("purposeZpk", zpk2);
data.put("algorithmKey", 'P');
data.put("sca$option", sca);
data.put("dca$option", dca);
data.put("sca$option", sca - 1);
data.put("dca$option", dca - 1);
data.put("businessKey", 'N');
data.put("sourcePinBlock", pin);
data.put("sourcePinBlockFormat", 06);
data.put("purposePinBlockFormat", 06);
data.put("sourcePinBlockFormat", 01);
data.put("purposePinBlockFormat", 01);
data.put("account", account);
data.put("maxLength", 12);
@@ -6783,6 +6809,7 @@ public class SydApi4j implements SydApi {
* @param account 账号中去除校验位的最右 12 位
* @return PIN 块,LMK 对（02-03）下加密的 PIN
*/
// 测试通过
public String transPINFromZPKToLMK(String zpk, int sca, int dca, int pt, String pin, String account) {
ProtoJE proto = new ProtoJE();
@@ -6796,8 +6823,8 @@ public class SydApi4j implements SydApi {
data.put("zpk", zpk);
data.put("algorithmKey", 'P');
data.put("sca$option", sca);
data.put("dca$option", dca);
data.put("sca$option", sca - 1);
data.put("dca$option", dca - 1);
data.put("businessKey", 'N');
data.put("PinBlock", pin);
data.put("pinBlockFormat", pt);
@@ -6854,8 +6881,8 @@ public class SydApi4j implements SydApi {
data.put("zpk", zpk);
data.put("algorithmKey", 'P');
data.put("sca$option", sca);
data.put("dca$option", dca);
data.put("sca$option", sca - 1);
data.put("dca$option", dca - 1);
data.put("businessKey", 'N');
data.put("PinBlock", pin);
data.put("pinBlockFormat", pt);
@@ -6901,6 +6928,7 @@ public class SydApi4j implements SydApi {
* @param account 账号中去除校验位的最右 12 位
* @return 目的 ZPK 下加密的目的 PIN 块
*/
// 测试通过
public String transPINFromTPKToZPK(String tpk, String zpk, int sca, int dca, int spt, int dpt, String pin, String account) {
ProtoCA proto = new ProtoCA();
@@ -6914,8 +6942,8 @@ public class SydApi4j implements SydApi {
data.put("sourceZpk", tpk);
data.put("purposeZpk", zpk);
data.put("algorithmKey", 'P');
data.put("sca$option", sca);
data.put("dca$option", dca);
data.put("sca$option", sca - 1);
data.put("dca$option", dca - 1);
data.put("businessKey", 'N');
data.put("sourcePinBlock", pin);
data.put("sourcePinBlockFormat", spt);
@@ -6961,6 +6989,7 @@ public class SydApi4j implements SydApi {
* @param account 账号中去除校验位的最右 12 位
* @return LMK 对（02-03）下加密的 PIN
*/
// 测试通过
public String transPINFromTPKToLMK(String zpk, int sca, int dca, int pt, String pin, String account) {
ProtoJC proto = new ProtoJC();
@@ -6974,8 +7003,8 @@ public class SydApi4j implements SydApi {
data.put("zpk", zpk);
data.put("algorithmKey", 'P');
data.put("sca$option", sca);
data.put("dca$option", dca);
data.put("sca$option", sca - 1);
data.put("dca$option", dca - 1);
data.put("businessKey", 'N');
data.put("PinBlock", pin);
data.put("pinBlockFormat", pt);
@@ -7016,6 +7045,7 @@ public class SydApi4j implements SydApi {
* @param account 账号中去除校验位的最右12位
* @return LMK 对（02-03）下加密的 PIN
*/
// 测试通过
public String encryPIN(int alg, String pin, String account) {
ProtoBA proto = new ProtoBA();
@@ -7067,6 +7097,7 @@ public class SydApi4j implements SydApi {
* @param account 账号中去除校验位的最右12位。
* @return PIN
*/
// 测试通过
public String decryPIN(int alg, String PINBLOCK, String account) {
ProtoNG proto = new ProtoNG();
@@ -7136,8 +7167,8 @@ public class SydApi4j implements SydApi {
data.put("srcKey", srcKey);
data.put("desKey", desKey);
data.put("algorithmKey", 'P');
data.put("dca$option", dca);
data.put("sca$option", sca);
data.put("dca$option", dca - 1);
data.put("sca$option", sca - 1);
data.put("sPin", sPin);
data.put("sPinType$option", 0);
data.put("dPinType$option", 0);
@@ -7175,6 +7206,7 @@ public class SydApi4j implements SydApi {
* tmkKey: TMK 下加密的随机的 TAK
* keyCheck: 密钥校验值
*/
// 测试通过
public RetWrap genTAK(String tmk) {
ProtoHA proto = new ProtoHA();
HashMap<String, Object> packet = new HashMap();
@@ -7186,8 +7218,8 @@ public class SydApi4j implements SydApi {
data.put("tmk", tmk);
data.put("businessKey", 'N');
data.put("separator", ";");
data.put("tmkSolution", "Z");
data.put("lmkSolution", "Z");
data.put("tmkSolution", "X");
data.put("lmkSolution", "X");
data.put("keyCheckType", "0");
ByteBuffer bb = proto.rend(packet);
@@ -7236,6 +7268,7 @@ public class SydApi4j implements SydApi {
* @return lmkKey: LMK 对 16-17 下加密的 TAK
* keyCheck: 密钥校验值
*/
// 测试通过
public RetWrap transTAKFromZMKToLMK(String zmk, String tak) {
ProtoMF proto = new ProtoMF();
HashMap<String, Object> packet = new HashMap();
@@ -7248,8 +7281,8 @@ public class SydApi4j implements SydApi {
data.put("tak", tak);
data.put("businessKey", 'N');
data.put("separator", ";");
data.put("zmkSolution", "Z");
data.put("lmkSolution", "Z");
data.put("zmkSolution", "X");
data.put("lmkSolution", "X");
data.put("keyCheckType", "0");
ByteBuffer bb = proto.rend(packet);
@@ -7290,6 +7323,7 @@ public class SydApi4j implements SydApi {
* @return zmkKey: ZMK 下加密的 TAK
* keyCheck: 密钥校验值
*/
// 测试通过
public RetWrap transTAKFromLMKToZMK(String zmk, String tak) {
ProtoMG proto = new ProtoMG();
HashMap<String, Object> packet = new HashMap();
@@ -7302,8 +7336,8 @@ public class SydApi4j implements SydApi {
data.put("tak", tak);
data.put("businessKey", 'N');
data.put("separator", ";");
data.put("zmkSolution", "Z");
data.put("lmkSolution", "Z");
data.put("zmkSolution", "X");
data.put("lmkSolution", "X");
data.put("keyCheckType", "0");
ByteBuffer bb = proto.rend(packet);
@@ -7344,6 +7378,7 @@ public class SydApi4j implements SydApi {
* @return tmkKey: 转换后的 TAK；TMK 下加密
* keyCheck: 密钥校验值
*/
// 测试通过
public RetWrap transTAKFromLMKToTMK(String tmk, String tak) {
ProtoAG proto = new ProtoAG();
HashMap<String, Object> packet = new HashMap();
@@ -7356,8 +7391,8 @@ public class SydApi4j implements SydApi {
data.put("tak", tak);
data.put("businessKey", 'N');
data.put("separator", ";");
data.put("tmkSolution", "Z");
data.put("lmkSolution", "Z");
data.put("tmkSolution", "X");
data.put("lmkSolution", "U");
data.put("keyCheckType", "0");
ByteBuffer bb = proto.rend(packet);
@@ -7399,6 +7434,7 @@ public class SydApi4j implements SydApi {
* tmkKey: 当前的TMK (TPK或PVK)下加密的新密钥
* keyCheck: 密钥校验值
*/
// 测试通过
public RetWrap genKeyByTMKOrTPKOrPVK(String tmk) {
ProtoHC proto = new ProtoHC();
HashMap<String, Object> packet = new HashMap();
@@ -7411,8 +7447,8 @@ public class SydApi4j implements SydApi {
data.put("tmk", tmk);
data.put("businessKey", 'N');
data.put("separator", ";");
data.put("tmkSolution", "Z");
data.put("lmkSolution", "Z");
data.put("tmkSolution", "X");
data.put("lmkSolution", "X");
data.put("keyCheckType", "0");
ByteBuffer bb = proto.rend(packet);
@@ -7462,6 +7498,7 @@ public class SydApi4j implements SydApi {
* @return tmkKey: 当前密钥下加密的存储密钥
* keyCheck: 密钥校验值
*/
// 测试通过
public RetWrap tranKeyByTMKToAno(String tmkNow, String tmkStorage) {
ProtoAE proto = new ProtoAE();
HashMap<String, Object> packet = new HashMap();
@@ -7516,6 +7553,7 @@ public class SydApi4j implements SydApi {
* @return tmkKey: 当前密钥下加密的存储密钥
* keyCheck: 密钥校验值。
*/
// 测试通过
public RetWrap tranKeyByTMKFromZMKToLMK(String zmk, String tmk) {
ProtoFC proto = new ProtoFC();
HashMap<String, Object> packet = new HashMap();
@@ -7571,6 +7609,7 @@ public class SydApi4j implements SydApi {
* @return tmkKey: 当前密钥下加密的存储密钥
* keyCheck: 密钥校验值
*/
// 测试通过
public RetWrap tranKeyByTMKFromLMKToZMK(String zmk, String tmk) {
ProtoFE proto = new ProtoFE();
HashMap<String, Object> packet = new HashMap();
@@ -7584,8 +7623,8 @@ public class SydApi4j implements SydApi {
data.put("tmk", tmk);
data.put("businessKey", 'N');
data.put("separator", ";");
data.put("zmkSolution", "Z");
data.put("lmkSolution", "Z");
data.put("zmkSolution", "X");
data.put("lmkSolution", "X");
data.put("keyCheckType", "0");
ByteBuffer bb = proto.rend(packet);
@@ -7627,6 +7666,7 @@ public class SydApi4j implements SydApi {
* zmkKey: 转换后的 ZPK
* keyCheck: 密钥校验值。
*/
// 测试通过
public RetWrap genZEKOrZAK(int key, String zmk) {
ProtoFI proto = new ProtoFI();
HashMap<String, Object> packet = new HashMap();
@@ -7707,6 +7747,7 @@ public class SydApi4j implements SydApi {
* @return lmkKey: 当标志位为1时为LMK26-27对下加密的ZAK，当标志位为0时为LMK30-31对下加密的ZEK。
* keyCheck: 密钥校验值。
*/
// 测试通过
public RetWrap tranZEAKFromZMKToLMK(int key, String zmk, String zekOrzak) {
ProtoFK proto = new ProtoFK();
HashMap<String, Object> packet = new HashMap();
@@ -7773,6 +7814,7 @@ public class SydApi4j implements SydApi {
* @return zmkKey: 转换后的 ZPK。
* keyCheck: 密钥校验值。
*/
// 测试通过
public RetWrap tranZEAKFromLMKToZMK(int key, String zmk, String zekOrzak) {
ProtoFM proto = new ProtoFM();
HashMap<String, Object> packet = new HashMap();
@@ -7838,6 +7880,7 @@ public class SydApi4j implements SydApi {
* @return zmkKey: zmk 头 + ZMK 加密下的ZPK。
* keyCheck: 密钥校验值
*/
// 测试通过
public RetWrap genZPK(String zmk) {
ProtoIA proto = new ProtoIA();
HashMap<String, Object> packet = new HashMap();
@@ -7901,6 +7944,7 @@ public class SydApi4j implements SydApi {
* @return zpkKey: 转换后的 ZPK；由 LMK06-07 对加密
* keyCheck: 密钥校验值
*/
// 测试通过
public RetWrap tranZPKFromZMKToLMK(String zmk, String zpk) {
ProtoFA proto = new ProtoFA();
HashMap<String, Object> packet = new HashMap();
@@ -7957,6 +8001,7 @@ public class SydApi4j implements SydApi {
* @return zpkKey: 转换后的 ZPK；
* keyCheck: 密钥校验值
*/
// 测试通过
public RetWrap tranZPKFromLMKToZMK(String zmk, String zpk) {
ProtoGC proto = new ProtoGC();
HashMap<String, Object> packet = new HashMap();
@@ -8073,6 +8118,7 @@ public class SydApi4j implements SydApi {
* @return lmkKey: lmk 头 + LMK 加密下的密钥。
* keyCheck:
*/
// 测试通过
public RetWrap composeKey(String keyType, String[] keys) {
ProtoA4 proto = new ProtoA4();
@@ -8128,7 +8174,7 @@ public class SydApi4j implements SydApi {
System.arraycopy(lmkHeads, 0, bs, 0, lmkHeads.length);
System.arraycopy(lmks, 0, bs, lmkHeads.length, lmks.length);
retWrap.put("lmkKey", bs);
retWrap.put("keyCheck", ((PacketSection) ret.get("keyCheck")).getBytes());
retWrap.put("keyCheck", ((PacketSection) ret.get("kcv")).getBytes());
return retWrap;
}
}
@@ -8182,6 +8228,7 @@ public class SydApi4j implements SydApi {
}
//16.3由私钥解密随机密钥并以LMK加密输出(+) -> pass
// 测试通过
@Override
public RetWrap SM2ConfirmSessionKey(String sk, String cipherKey) {
// 获取协议
@@ -8241,6 +8288,7 @@ public class SydApi4j implements SydApi {
* key1: 密钥明文分量1
* key2: 密钥明文分量2
*/
// 测试通过
public RetWrap getPlainText(String key, int checkAlg) {
ProtoAB proto = new ProtoAB();
src/main/java/racal/sunyard/main/Vars.kt
-410
View File
@@ -1,410 +0,0 @@
package racal.sunyard.cloud
import com.sunyard.proto.PacketSection
import java.nio.charset.Charset
class Vars(val vars : Map<String, Any> = HashMap<String, Any>()) {
private inline fun remove(n : List<String>){
try {
var f : Any? = vars
for( i in 0..n.size-2 ){
val p = n.get(i)
if ( p.startsWith("[") && p.endsWith("]") ){
// 数组
f as MutableList<Any?>
val istr = p.substring(1, p.length -1)
var index = 0
if ( "" == istr ){
index = f.lastIndex
}else{
index = istr.toInt()
if ( index < 0 ){
index += f.size
}
}
if (index < 0){
index = 0
}
val fp = f.get( index )
if ( null == fp ){
return
}else {
f = fp
}
}else {
f as MutableMap<String, Any?>
val fp = f.get( p )
if ( null == fp){
return
}else{
f = fp
}
}
}
val nl = n.last()
if ( nl.startsWith("[") && nl.endsWith("]") ){
f as MutableList<Any?>
val istr = nl.substring(1, nl.length -1)
var index = 0
if ( "" == istr ){
index = f.lastIndex
}else{
index = istr.toInt()
if ( index < 0 ){
index += f.size
}
}
if (index < 0){
index = 0
}
f.removeAt( index )
}else{
f as MutableMap<String, Any>
f.remove(nl)
}
}catch ( e : ClassCastException){
throw e
}
}
private inline fun _set(n : List<String>, data : Any) {
try {
var f : Any? = vars
for( i in 0..n.size-2 ){
val p = n.get(i)
if ( p.startsWith("[") && p.endsWith("]") ){
// 数组
f as MutableList<Any?>
val istr = p.substring(1, p.length -1)
var index = 0
if ( "" == istr ){
index = f.size
}else{
index = istr.toInt()
if ( index < 0 ){
index += f.size
}
}
if (index < 0){
index = 0
}
var fp = f.get( index )
if ( null == fp ){
// 参考下一级推断类型
val pp = n.get(i + 1)
if( pp.startsWith("[") && pp.endsWith("]") ){
fp = mutableListOf<Any>()
}else{
fp = mutableMapOf<String, Any>()
}
f.set( index, fp)
}
f = fp
}else {
f as MutableMap<String, Any>
var fp = f.get( p )
if ( null == fp){
// 参考下一级推断类型
val pp = n.get(i + 1)
if( pp.startsWith("[") && pp.endsWith("]") ){
fp = mutableListOf<Any>()
}else{
fp = mutableMapOf<String, Any>()
}
f.set( p, fp)
}
f = fp
}
}
val nl = n.last()
if ( nl.startsWith("[") && nl.endsWith("]") ){
f as MutableList<Any?>
val istr = nl.substring(1, nl.length -1)
var index = 0
if ( "" == istr ){
index = f.size
}else{
index = istr.toInt()
if ( index < 0 ){
index += f.size
}
}
if (index < 0){
index = 0
}
f.add( index , data)
}else{
f as MutableMap<String, Any>
f.put(nl, data)
}
}catch ( e : ClassCastException){
throw e
}
}
private inline fun _get(n : List<String> ) : Any? {
try {
var f : Any? = vars
for( i in 0..n.size-1 ){
val p = n.get(i)
if ( p.startsWith("[") && p.endsWith("]") ){
// 数组
f as MutableList<Any?>
val istr = p.substring(1, p.length -1)
var index = 0
if ( "" == istr ){
index = f.lastIndex
}else{
index = istr.toInt()
if ( index < 0 ){
index += f.size
}
}
if (index < 0){
index = 0
}
val fp = f.get( index )
if ( null == fp ){
return null
}else {
f = fp
}
}else {
f as MutableMap<String, Any?>
val fp = f.get( p )
if ( null == fp){
return null
}else{
f = fp
}
}
}
return f
}catch ( e : ClassCastException){
throw e
}
}
fun cp(from: String, to: String) {
val v = _get( from.split(".") )
if ( null != v ){
set(to, v)
}
}
fun mv(from: String, to: String) {
val v = _get( from.split(".") )
if ( null != v ){
set(to, v)
}
rm( from )
}
fun map(name: String) {
_set( name.split(".") , mutableMapOf<String, Any>() )
}
fun arr(name: String) {
_set( name.split(".") , mutableListOf<Any>() )
}
fun get(name : String) : Any{
val v = _get( name.split(".") )
if ( null == v ){
throw RuntimeException("$name 的值为 null")
}
return v
}
fun getInt(name: String): Int {
val v = _get( name.split(".") )
if( null == v ){
return 0
}else{
if( v is Int ){
return v as Int
} else {
return v.toString().toInt()
}
}
}
fun getStr(name: String): String {
val v = _get( name.split(".") )
if( null == v ){
return ""
}else{
when( v ){
v is PacketSection -> return (v as PacketSection).getString()
v is ByteArray -> return String(v as ByteArray, Charset.forName("UTF-8") )
else -> return v.toString()
}
}
}
fun getMap(name: String): MutableMap<String, Any?> {
try {
val v = _get( name.split(".") )
if( null == v ){
return mutableMapOf()
}else{
return v as MutableMap<String, Any?>
}
}catch (e : Exception){
throw java.lang.RuntimeException("$name 的值不是一个 map")
}
}
fun getArr(name: String): MutableList<Any?> {
try {
val v = _get( name.split(".") )
if( null == v ){
return mutableListOf()
}else{
return v as MutableList<Any?>
}
}catch (e : Exception){
throw java.lang.RuntimeException("$name 的值不是一个 arr")
}
}
fun put(name: String, value : Any ){
_set( name.split("."), value )
}
fun set(name: String, value : Any ){
val names = name.split(".")
try {
_set( names, value )
}catch ( e : Exception){
remove( names )
_set( names, value )
}
}
fun rm(name : String ){
try {
remove( name.split(".") )
}catch (e : Exception){
// pass 忽略异常
}
}
fun contains(name: String) : Boolean {
try {
return null != _get( name.split(".") )
}catch (e : Exception){
// TODO 此处遇到过未知错误 故添加
return false
}
}
fun eq(k1: String, k2 : String): Boolean {
try {
val v1 = _get( k1.split(".") )
val v2 = _get( k2.split(".") )
if ( null == v1 && null == v2 ){
return true
}
if ( (null != v1 && null == v2) ||
(null == v1 && null != v2) ){
return false
}
return v1!!.equals( v2 )
}catch (e : Exception){
return false
}
}
fun eqs(key : String, other : String): Boolean {
try {
val v = getStr( key )
return other.equals( v )
}catch (e : Exception){
return false
}
}
fun bool(name: String): Boolean {
val v = _get( name.split("."))
if ( null == v ) {
return false
}else{
when( v ){
null -> {
return false
}
is Boolean ->{
return v
}
is Array<*> -> {
return v.size > 0
}
is List<*> ->{
return v.size > 0
}
is Map<*, *> ->{
return v.size > 0
}
is String -> {
return v.length > 0
}
}
return true
}
}
fun vars(): Set<String> {
return vars.keys
}
fun subVars(name : String) : Vars {
if( contains( name ) ){
val c = get( name )
if( c is Map<*, *> ){
return Vars( c as HashMap<String, Any> )
}
}
map( name )
val c = get( name )
return Vars(c as HashMap<String, Any>)
}
}
src/test/java/com/sunyard/sydapi/test/TestAllMethods.java
+704 -16
View File
@@ -7,10 +7,15 @@ import org.junit.Before;
import org.junit.Test;
import racal.sunyard.main.SydApi4j;
import java.util.ArrayList;
import java.util.Arrays;
public class TestAllMethods {
SydApi4j api;
String account = "157212737811";
@Before
public void before() {
System.setProperty("com.sunyard.sydapi4j.debug", "true");
@@ -28,20 +33,67 @@ public class TestAllMethods {
}
public void printRetWrap(RetWrap rw) {
printRetWrap(rw, false);
}
/**
* 输出
* @param rw
*/
public void printRetWrap(RetWrap rw, boolean flag) {
for (String s : rw.keySet()) {
System.out.println(s + ":" + rw.get(s));
Object o = rw.get(s);
if (o instanceof String) {
System.out.println(s + ":" + o);
} else if (o instanceof byte[]) {
if (flag) {
System.out.println(s + ": " + Util.bytes2HexString((byte[]) o));
} else {
System.out.println(s + ": " + new String(Util.hexString2Bytes(Util.bytes2HexString((byte[]) o))));
}
} else {
System.out.println(s + ":" + o);
}
}
}
/**
* 将hex类型的数组转为byte型
* {"X0404894E7B8DE129B4FF4EF9889E56A2", "X94D35D86EF1F3213D55C47822F87D385"}
* 转为
* [583034303438393445374238444531323942344646344546393838394535364132, 583934443335443836454631463332313344353543343738323246383744333835]
* @param strs
* @return
*/
public String[] strArr2BytesStrArr(String[] strs) {
String[] requestStrs = new String[strs.length];
for (int i = 0, len = strs.length; i < len; i++) {
String changeStr = Util.bytes2HexString(strs[i].getBytes());
requestStrs[i] = changeStr;
}
return requestStrs;
}
/**
* 删除字符串中的空格
* @param str
* @return
*/
public String changeStr(String str) {
return str.replaceAll(" ", "");
}
// A0 1.1.1 对称密钥产生,
// 验证成功
// 测试通过
@Test
public void testGenSymmetricKey() {
RetWrap retWrap = api.genSymmetricKey("000", 'X');
String lmkKey = new String(Util.hexString2Bytes(Util.bytes2HexString((byte[]) retWrap.get("lmkKey"))));
String keyCheck = new String(Util.hexString2Bytes(Util.bytes2HexString((byte[]) retWrap.get("keyCheck"))));
System.out.println("lmkKey:" + lmkKey);
System.out.println("keyCheck:" + keyCheck);
printRetWrap(retWrap);
}
// 002D3030303030303030
@@ -53,17 +105,13 @@ public class TestAllMethods {
// 58
// A0 1.1.2 对称密钥产生, 对比之前添加了可产生ZMK加密下的密钥，
// 验证成功
// 测试通过
@Test
public void testGenSymKey() {
// 此密钥方案为: 1A+K+27位的索引号
RetWrap retWrap = api.genSymKey(1, "000", 'X', "SK999999999999000000000000000");
String lmkKey = new String(Util.hexString2Bytes(Util.bytes2HexString((byte[]) retWrap.get("lmkKey"))));
String zmkKey = new String(Util.hexString2Bytes(Util.bytes2HexString((byte[]) retWrap.get("zmkKey"))));
String keyCheck = new String(Util.hexString2Bytes(Util.bytes2HexString((byte[]) retWrap.get("keyCheck"))));
System.out.println("lmkKey:" + lmkKey);
System.out.println("zmkKey:" + zmkKey);
System.out.println("keyCheck:" + keyCheck);
printRetWrap(retWrap);
}
// 00000000
@@ -74,6 +122,13 @@ public class TestAllMethods {
// 密钥成份1：X0404894E7B8DE129B4FF4EF9889E56A2
// 密钥成份2：X94D35D86EF1F3213D55C47822F87D385
// 003300000000000000004135
// 3030
// 58
// 4639334538393745423345383636413346314233324432303232324245333446
// 314246383237
// 测试通过
// A4
@Test
public void testComposeKey() {
@@ -83,19 +138,652 @@ public class TestAllMethods {
printRetWrap(rw);
}
// 00503030303030303030
// 4136
// 303030
// 584141414141414141414141414141414142424242424242424242424242424242
// 583934443335443836454631463332313344353543343738323246383744333835
// 58
// 00000000
// A6
// 000
// ZMK：XAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB
// ZMK下加密的密钥：X94D35D86EF1F3213D55C47822F87D385
// X
// 测试通过
// A6
@Test
public void testInputKey() {
RetWrap retWrap = api.inputKey("000", '0', "XAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB", "X94D35D86EF1F3213D55C47822F87D385");
RetWrap retWrap = api.inputKey("000", 'X', "XAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB", "X94D35D86EF1F3213D55C47822F87D385");
printRetWrap(retWrap);
}
// 00000000A8000XAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBX0404894E7B8DE129B4FF4EF9889E56A2X
// public void test
// 00000000
// A8
// 000
// XAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB
// X0404894E7B8DE129B4FF4EF9889E56A2
// X
// 测试通过
// A8
@Test
public void testOutputKey() {
RetWrap retWrap = api.outputKey("000", 'X', "XAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB", "X94D35D86EF1F3213D55C47822F87D385");
printRetWrap(retWrap);
}
// 测试通过
// B0
@Test
public void testConversionKey() {
RetWrap retWrap = api.conversionKey("000", "X0404894E7B8DE129B4FF4EF9889E56A2", 'U');
printRetWrap(retWrap);
}
// 测试通过
// AA
@Test
public void testAAGenComposeKey() {
RetWrap retWrap = api.genComposeKey("000", 'Y', "0404894E7B8DE129B4FF4EF9889E56A2129B4FF4EF9889E5");
printRetWrap(retWrap);
}
// 005130303030303030304759
// 32
// 583034303438393445374238444531323942344646344546393838394535364132
// 583934443335443836454631463332313344353543343738323246383744333835
// 3B
// 58
// 58
// 30
// 测试通过
// GY
@Test
public void testGYGenComposeKey() {
String[] strs = {"X0404894E7B8DE129B4FF4EF9889E56A2", "X94D35D86EF1F3213D55C47822F87D385"};
RetWrap retWrap = api.genComposeKey(strArr2BytesStrArr(strs));
printRetWrap(retWrap);
}
// 测试通过
// BY
@Test
public void testChangZMK2LMK() {
String[] strs = {"X0404894E7B8DE129B4FF4EF9889E56A2", "X94D35D86EF1F3213D55C47822F87D385"};
RetWrap retWrap = api.changZMK2LMK(strs[0], strs[1]);
printRetWrap(retWrap);
}
// 测试通过
// IA
@Test
public void testGenZPK() {
RetWrap retWrap = api.genZPK("X94D35D86EF1F3213D55C47822F87D385");
printRetWrap(retWrap);
}
// 测试通过
// FA
@Test
public void testTranZPKFromZMKToLMK() {
RetWrap retWrap = api.tranZPKFromZMKToLMK("X94D35D86EF1F3213D55C47822F87D385", "51101CCAFBFE8300");
printRetWrap(retWrap);
}
// 测试通过
// GC
@Test
public void testTranZPKFromLMKToZMK() {
RetWrap retWrap = api.tranZPKFromLMKToZMK("X94D35D86EF1F3213D55C47822F87D385", "958FA085C014833A");
printRetWrap(retWrap);
}
// 测试通过
// FI
@Test
public void testGenZEKOrZAK() {
RetWrap retWrap = api.genZEKOrZAK(0, "X94D35D86EF1F3213D55C47822F87D385");
printRetWrap(retWrap);
}
// 测试通过
// FK
@Test
public void testTranZEAKFromZMKToLMK() {
RetWrap retWrap = api.tranZEAKFromZMKToLMK(0, "X94D35D86EF1F3213D55C47822F87D385", "3B4887E5E9FDF339");
printRetWrap(retWrap);
}
// 测试通过
// FM
@Test
public void testTranZEAKFromLMKToZMK() {
RetWrap retWrap = api.tranZEAKFromLMKToZMK(0, "X94D35D86EF1F3213D55C47822F87D385", "1D969301FFA4FB13");
printRetWrap(retWrap);
}
// 测试通过
// HC
@Test
public void testGenKeyByTMKOrTPKOrPVK() {
RetWrap retWrap = api.genKeyByTMKOrTPKOrPVK("X94D35D86EF1F3213D55C47822F87D385");
printRetWrap(retWrap);
}
// 测试通过
// AE
@Test
public void testTranKeyByTMKToAno() {
RetWrap retWrap = api.tranKeyByTMKToAno("7E3F0E0A2335046B", "162FDF5B93DFE4B8");
printRetWrap(retWrap);
}
// 测试通过
// FC
@Test
public void testTranKeyByTMKFromZMKToLMK() {
RetWrap retWrap = api.tranKeyByTMKFromZMKToLMK("X94D35D86EF1F3213D55C47822F87D385", "51101CCAFBFE8300");
printRetWrap(retWrap);
}
// 测试通过
// FE
@Test
public void testTranKeyByTMKFromLMKToZMK() {
RetWrap retWrap = api.tranKeyByTMKFromLMKToZMK("X0404894E7B8DE129B4FF4EF9889E56A2", "X94D35D86EF1F3213D55C47822F87D385");
printRetWrap(retWrap);
}
// 测试通过
// HA
@Test
public void testGenTAK() {
RetWrap retWrap = api.genTAK("X0404894E7B8DE129B4FF4EF9889E56A2");
printRetWrap(retWrap);
}
// 测试通过
// MF
@Test
public void testTransTAKFromZMKToLMK() {
RetWrap retWrap = api.transTAKFromZMKToLMK("X94D35D86EF1F3213D55C47822F87D385", "X46928685CAFD050DBF5CCFC049E41BF5");
printRetWrap(retWrap);
}
// 测试通过
// MG
@Test
public void testTransTAKFromLMKToZMK() {
RetWrap retWrap = api.transTAKFromLMKToZMK("X94D35D86EF1F3213D55C47822F87D385", "X36CC70E4274AA879AD9AE5596124DFA7");
printRetWrap(retWrap);
}
// 测试通过
// AG
@Test
public void testTransTAKFromLMKToTMK() {
RetWrap retWrap = api.transTAKFromLMKToTMK("X94D35D86EF1F3213D55C47822F87D385", "X36CC70E4274AA879AD9AE5596124DFA7");
printRetWrap(retWrap);
}
// 测试通过
// JA
@Test
public void testGenPIN() {
String s = api.genPIN("157212737811");
System.out.println(s);
}
// 00713030303030303030
// 4343
// 583034303438393445374238444531323942344646344546393838394535364132
// 583934443335443836454631463332313344353543343738323246383744333835
// 50
// 31
// 31
// 3132
// 33373532373544313235363334384341
// 3031
// 3031
// 313537323132373337383131
// 测试通过
// CC
@Test
public void testTransPINFromZPKToZPK() {
String s = api.transPINFromZPKToZPK("X0404894E7B8DE129B4FF4EF9889E56A2", "X94D35D86EF1F3213D55C47822F87D385", 1, 1, 1, 1, "375275D1256348CA", "157212737811");
System.out.println(s);
}
// 测试通过
// JE
@Test
public void testTransPINFromZPKToLMK() {
String str = api.transPINFromZPKToLMK("X0404894E7B8DE129B4FF4EF9889E56A2", 1, 1, 01, "375275D1256348CA", "157212737811");
System.out.println(str);
}
// 测试通过
// JG
@Test
public void testTransPINFromLMKToZPK() {
String s = api.transPINFromLMKToZPK("958FA085C014833A", 1, 1, 01, "54367430851C073B", "157212737811");
System.out.println(s);
}
// 测试通过
// CA
@Test
public void testTransPINFromTPKToZPK() {
String s = api.transPINFromTPKToZPK("189A8A973A9FF7CF", "F4663B51F823CFDC", 1, 1, 1, 1, "5162F23A8354424E", "157212737811");
System.out.println(s);
}
// 测试通过
// JC
@Test
public void testTransPINFromTPKToLMK() {
String zpk = "189A8A973A9FF7CF";
String pin = "5162F23A8354424E";
String s = api.transPINFromTPKToLMK(zpk, 1, 1, 1, pin, account);
System.out.println(s);
}
// 测试通过
// BA
@Test
public void testEncryPIN() {
String pin = "06157212FFFFFFFF";
String s = api.encryPIN(0, pin, account);
System.out.println(s);
}
// 测试通过
// NG
@Test
public void testDecryPIN() {
String pin = "EB53196BFAD34C39";
String s = api.decryPIN(0, pin, account);
System.out.println(s);
}
// 006E00000000000000004342303030303030584B303030303030303030303030303030313030303030303030303031584B30303030303030303030303030303032303030303030303030303250313131313239384430324231433742433945303130313135373231323733373831314E
// CB
@Test
public void testTransPinFrOneKeyToAno() {
String srcKey = "XK000000000000000100000000001";
String desKey = "XK000000000000000200000000002";
String sPin = "11298D02B1C7BC9E";
String s = api.transPinFrOneKeyToAno("000", "000", srcKey, desKey, 1, 1, sPin, account);
System.out.println(s);
}
// 003B3030303030303030
// 4D41
// 583430423631363946363334393530363034304236313639463633343935303630
// 31353732313237333738313130303030
// 测试通过
// MAXF
@Test
public void testMAC_Data() {
String key = "X40B6169F6349506040B6169F63495060";
String macData = "1572127378110000";
byte[] bytes = api.MAC_Data( key, macData, null);
System.out.println(new String(bytes));
}
// MA
@Test
public void testMACCalc() {
}
// MC
@Test
public void testMACCheck() {
}
String key = "X40B6169F6349506040B6169F63495060";
String msg = "AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB";
// 测试通过
// MS
@Test
public void testGenMAB() {
RetWrap retWrap = api.genMAB(1, 0, 1, key, null, msg.getBytes());
printRetWrap(retWrap);
}
// 测试通过
// MU
@Test
public void test_calcPBOCMAC() {
byte[] bytes = api._calcPBOCMAC(1, 0, key, msg.getBytes(), 1, null);
System.out.println(new String(bytes));
}
// 00643030303030303030
// 4530
// 31
// 30
// 32
// 30
// 583430423631363946363334393530363034304236313639463633343935303630
// 31
// 31
// 30303030303030303030303030303030
// 303130
// 4141414141414141414141414141414142424242424242424242424242424242
// E0
@Test
public void testSYMEnDeData() {
String iv = "0000000000000000";
RetWrap retWrap = api.SYMEnDeData(true, 0, key, 2, 1, msg.getBytes(), iv.getBytes(), 1);
printRetWrap(retWrap);
}
// 测试通过
// Y0
@Test
public void testSwitchEncryY() {
String sDEK = "X40B6169F6349506040B6169F63495060";
String dDEK = "X94D35D86EF1F3213D55C47822F87D385";
String infoData = "93B0FB7F609A16E0C2D6BD0AC4AE0297";
byte[] bytes = api.switchEncryY("000", 2, "001", 2, 1, sDEK, dDEK, infoData.getBytes(), "0");
System.out.println(new String(bytes));
}
// 测试通过
// LB
@Test
public void testLoadKey() {
String index = "000000000000000300000000004";
String key = "X94D35D86EF1F3213D55C47822F87D385";
Boolean check = api.loadKey(index, key, null);
System.out.println(check);
}
// 测试通过
// LF
@Test
public void testReadKey() {
String index = "000000000000000300000000003";
RetWrap retWrap = api.readKey(index);
printRetWrap(retWrap);
}
// 测试通过
// LG
@Test
public void testUpdateKey() {
String index = "000000000000000300000000003";
String key = "X94D35D86EF1F3213D55C47822F87D385";
Boolean aBoolean = api.updateKey(index, key, "0000000000000000");
System.out.println(aBoolean);
}
// 测试通过
// 77
@Test
public void testEncryptByPk() {
String pk = "034200041CD47354867E12B9D138F098413C47D42EDEB2AD402EAB431C0C7AC2FE2D6DE9C67273C643C709F2A749188941B7FA7F9FF14F8E7D19316936DB4D4954FF3819";
String data = "FFFFFFFFFFFFFFFF";
byte[] bytes = api.encryptByPk(1, pk, data.getBytes());
System.out.println(Util.bytes2HexString(bytes));
}
// 78
@Test
public void testDecryptBySkC() {
String userId = "0000000000000001";
String data = "30 78 02 20 78 E2 C1 C9 72 1F 77 00 55 76 A3 1F 3F 99 18 E0 3D AC A8 7F 5B 48 27 52 51 D8 54 49 BD 70 A6 EC 02 20 46 B4 24 14 27 EB 96 81 D4 93 A1 7E 03 E0 37 24 94 C6 A0 5D 12 F2 06 BA 15 0A FD 67 2C 82 9A 90 04 20 4D 3E 6D 0F 4C 5D CC 2A 18 5F 01 B8 51 F7 F7 A2 EF 13 C7 D8 66 46 C8 34 5D A8 38 F6 04 D1 D3 61 04 10 7E 21 C5 BF 01 91 62 D3 FC 67 8C 85 55 12 3B B5";
byte[] bytes = api.decryptBySkC(1, userId, Util.hexString2Bytes(changeStr(data)));
System.out.println(Util.bytes2HexString(bytes));
}
// 7C
@Test
public void testRSAVerify() {
}
// 测试通过
// 7D
@Test
public void testConutHash() {
String data = "0101010101010101";
// RetWrap retWrap = api.conutHash(1, 0, data.getBytes(), null);
String filterData = "67 E6 09 6A 85 AE 67 BB 72 F3 6E 3C 3A F5 4F A5 7F 52 0E 51 8C 68 05 9B AB D9 83 1F 19 CD E0 5B 80 00 00 00 00 00 00 00 30 31 30 31 30 31 30 31 30 31 30 31 30 31 30 31 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 10 00 00 00 20 00 00 00";
RetWrap retWrap = api.conutHash(1, 3, data.getBytes(), Util.hexString2Bytes(changeStr(filterData)));
System.out.println("hash:" + Util.bytes2HexString((byte[]) retWrap.get("hash")));
}
// 测试通过
// E2
@Test
public void testSM2GenKeyPair() {
RetWrap retWrap = api.SM2GenKeyPair();
printRetWrap(retWrap, true);
}
// 测试通过
// E2
@Test
public void testSM2OrRSAGenKeyPair() {
String index = "0000000000000001";
// SM2
// RetWrap retWrap = api.SM2OrRSAGenKeyPair(1, index, 0);
// RSA
RetWrap retWrap = api.SM2OrRSAGenKeyPair(0, index, 1024);
printRetWrap(retWrap, true);
}
// 测试通过
// 72
@Test
public void testSM2GenSessionKey() {
String pk = "03 42 00 04 1C D4 73 54 86 7E 12 B9 D1 38 F0 98 41 3C 47 D4 2E DE B2 AD 40 2E AB 43 1C 0C 7A C2 FE 2D 6D E9 C6 72 73 C6 43 C7 09 F2 A7 49 18 89 41 B7 FA 7F 9F F1 4F 8E 7D 19 31 69 36 DB 4D 49 54 FF 38 19 ";
RetWrap retWrap = api.SM2GenSessionKey(changeStr(pk));
printRetWrap(retWrap);
}
// 73
@Test
public void testSM2ConfirmSessionKeyC() {
// RetWrap retWrap = api.SM2ConfirmSessionKeyC();
// printRetWrap(retWrap);
}
// 测试通过
// 73
@Test
public void testSM2ConfirmSessionKey() {
String sk = "00 01 00 00 6F D3 0C 96 79 22 C2 53 9B 47 3B 51 65 D7 9C 49 71 7A 5A 54 AA 24 9A 4F 8B AC DF 30 0B 31 59 61 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ";
String cipherKey = "30 78 02 20 61 2F 7E C1 4F 59 DB 2A C2 A9 FB 2E 13 61 69 3C 88 B3 6D 14 99 5B E8 B8 B7 53 5F 03 90 BB D2 DC 02 20 34 69 BA 09 93 08 0F 13 1F A1 EB 2C 2A 20 C5 48 18 32 A6 7E B6 07 E5 39 84 6B 9D 70 E9 1B 5D 5D 04 20 C5 EE D4 44 10 60 62 ED 77 74 C2 4D C1 71 12 2A 64 FF CA 48 CC 6E 44 EC BC 75 D2 31 DE 7E D0 D7 04 10 41 48 E5 D7 54 65 AE 2E 35 F5 07 84 06 4B 70 D6 ";
RetWrap retWrap = api.SM2ConfirmSessionKey(changeStr(sk), changeStr(cipherKey));
printRetWrap(retWrap);
}
// 74
@Test
public void testSYD_SM2_Sign_HA() {
}
// 75
@Test
public void testSYD_SM2_Verify_HA() {
}
// 测试通过
// 76
@Test
public void testSM3Hash() {
String userId = "1572127378000000";
String publicKey = "03 42 00 04 1C D4 73 54 86 7E 12 B9 D1 38 F0 98 41 3C 47 D4 2E DE B2 AD 40 2E AB 43 1C 0C 7A C2 FE 2D 6D E9 C6 72 73 C6 43 C7 09 F2 A7 49 18 89 41 B7 FA 7F 9F F1 4F 8E 7D 19 31 69 36 DB 4D 49 54 FF 38 19";
String msg = "0101010101010101";
RetWrap retWrap = api.SM3Hash(1, userId, Util.hexString2Bytes(changeStr(publicKey)), msg.getBytes(), null);
printRetWrap(retWrap, true);
}
// 测试通过
// 71
@Test
public void testLMK2SM2() {
String pk = "03 42 00 04 1C D4 73 54 86 7E 12 B9 D1 38 F0 98 41 3C 47 D4 2E DE B2 AD 40 2E AB 43 1C 0C 7A C2 FE 2D 6D E9 C6 72 73 C6 43 C7 09 F2 A7 49 18 89 41 B7 FA 7F 9F F1 4F 8E 7D 19 31 69 36 DB 4D 49 54 FF 38 19 ";
String key = "U5FAC0E768937E43D64FE2692F5F8C79F";
RetWrap retWrap = api.LMK2SM2(Util.hexString2Bytes(changeStr(pk)), key);
printRetWrap(retWrap, true);
}
// 60
@Test
public void testGetTransmissionKey() {
RetWrap retWrap = api.getTransmissionKey();
printRetWrap(retWrap);
}
// 测试通过
// Y8
@Test
public void testGenerateRandom() {
String s = api.GenerateRandom(16);
System.out.println(s);
}
// 测试通过
// AB
@Test
public void testGetPlainText() {
String key = "U51B737CE0EE1A14A6411B64EDE56020B";
RetWrap r = api.getPlainText(key, 0);
printRetWrap(r);
}
// 测试通过
// 62
@Test
public void testImpose() {
String key = "U51B737CE0EE1A14A6411B64EDE56020B";
String msg = "0101010101010101";
RetWrap retWrap = api.impose("002", key, msg.getBytes());
printRetWrap(retWrap);
}
// 测试通过
// 63
@Test
public void testVerifyImpose() {
String key = "U51B737CE0EE1A14A6411B64EDE56020B";
String secret = "3DCA1AD1";
String msg = "0101010101010101";
Boolean aBoolean = api.verifyImpose("002", key, secret.getBytes(), msg.getBytes());
System.out.println(aBoolean);
}
// 测试通过
// 64
@Test
public void testEncryAndDecry() {
String key = "U51B737CE0EE1A14A6411B64EDE56020B";
String infoData = "01010101";
RetWrap retWrap = api.encryAndDecry("002", key, infoData.getBytes());
printRetWrap(retWrap, true);
}
// 测试通过
// 65
@Test
public void testSwitchEncry() {
String srcKey = "U51B737CE0EE1A14A6411B64EDE56020B";
String aimKey = "X94D35D86EF1F3213D55C47822F87D385";
String infoData = "88888888";
RetWrap retWrap = api.switchEncry("002", srcKey, aimKey, infoData.getBytes());
printRetWrap(retWrap, true);
}
// 测试通过
// 66
@Test
public void testEncryAndDecry4PIN() {
String key = "U51B737CE0EE1A14A6411B64EDE56020B";
String pin = "06156760";
byte[] bytes = api.encryAndDecry4PIN(key, pin.getBytes());
System.out.println(Util.bytes2HexString(bytes));
}
// 67
@Test
public void testswitchEncry4PIN() {
String srcKey = "U51B737CE0EE1A14A6411B64EDE56020B";
String aimKey = "X94D35D86EF1F3213D55C47822F87D385";
String infoData = "6157212";
byte[] bytes = api.switchEncry4PIN(srcKey, aimKey, infoData.getBytes());
System.out.println(Util.bytes2HexString(bytes));
}
// QQ
@Test
public void testRSAGetPublicKeyC() {
String userId = "0000000000000001";
String s = api.RSAGetPublicKeyC(userId, 1);
System.out.println(s);
}
// HI
@Test
public void testGetStatus() {
RetWrap status = api.getStatus();
printRetWrap(status);
}
// 测试通过
// HV
@Test
public void testGetVersion() {
RetWrap version = api.getVersion(null);
printRetWrap(version);
}
}