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/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);
}
}