1、添加QP指令对应的接口，修改E0,74，QQ等指令相关的接口。2、添加农行北分海淀支行-军队资金集中收付系统测试类。3、添加打印工具类及文件读取写入工具类

DProto/QP.xml

@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<packet extend="base">
+	<req>
+
+    <command>
+        <hex>QP</hex>
+    </command>
+    <data extend="data">
+        <privateKeyTag len="27" cn="密钥索引">
+            要导出密钥的索引
+            27位的索引号：16位机构号+3位密钥类型+8位密钥索引号
+        </privateKeyTag>
+    </data>
+
+	</req>
+	<res>
+
+    <command>
+        <hex>QR</hex>
+    </command>
+    <data>
+        <error len="2" cn="错误码" format="X" :catch="catchError('%s')">
+            <options>
+                <option cn="无错误">
+                    <hex>00</hex>
+                </option>
+                <option cn="无效的私钥类型">
+                    <hex>03</hex>
+                </option>
+                <option cn="无效私钥标记">
+                    <hex>04</hex>
+                </option>
+                <option cn="无效的哈希标识">
+                    <hex>05</hex>
+                </option>
+                <option cn="无效的签名标识">
+                    <hex>06</hex>
+                </option>
+                <option cn="无效的附加标识">
+                    <hex>07</hex>
+                </option>
+                <option cn="LMK 错误">
+                    LMK 错误；报告给管理员。
+                    <hex>13</hex>
+                </option>
+                <option cn="输入数据错">
+                    <hex>15</hex>
+                </option>
+                <option cn="DSP 错误">
+                    DSP 错误；报告给管理员。
+                    <hex>47</hex>
+                </option>
+                <option cn="私钥错误">
+                    私钥错误；报告给管理员。
+                    <hex>49</hex>
+                </option>
+                <option cn="无效摘要信息语法（仅仅无哈希模式）">
+                    <hex>74</hex>
+                </option>
+                <option cn="公钥长度错误">
+                    <hex>76</hex>
+                </option>
+                <option cn="私钥长度错误">
+                    <hex>78</hex>
+                </option>
+                <option cn="输入数据长度错误">
+                    <hex>80</hex>
+                </option>
+            </options>
+        </error>
+
+        <privateLen len="4" cn="私钥长度">
+            私钥的字节长度
+        </privateLen>
+
+        <privateKey :len="privateLen()" cn="私钥">
+            LMK下加密的私钥。
+        </privateKey>
+
+        <tailSep len="1" required="false" cn="尾分隔">
+            可选项。如果显示消息尾域，则该域必须显示。值为 “X’19”。
+            <hex>19</hex>
+        </tailSep>
+
+        <tail maxLen="32" required="false" cn="尾部">
+            可选项。最大长度为 32个字符。
+        </tail>
+    </data>
+
+
+
+	</res>
+	<script>function privateLen() {
+     return Util.a2i( $final.getSection('data').getSection('privateLen') )
+ }	</script>
+</packet>

src/main/java/com/sunyard/inf/SydCryptionApi.java

@@ -261,6 +261,60 @@ interface SydSYMApi {
      */
     boolean SYMDecryptDataWithFile(int nAlg, String seesionKey, String inputPath, String outputPath) throws Exception;
 
+    /**
+     * 使用SM4算法进行加密，其中加密模式为CBC,
+     * Ⅳ使用缺省值0X 00000000000000000000000000000000,
+     * 补位模式为 PKCS5 PADDING 。
+     * @param keyType 密钥类型 0: ZEK,1: TEK
+     * @param key 密钥
+     * @param inType 输入消息类型 0:二进制 1:扩展十六进制
+     * @param outType 输出消息类型 0:二进制 1:扩展十六进制
+     * @param inFilePath 需要加密的数据文件所在的路径
+     * @param outFilePath 加密后的密文数据将要保存的文件路径
+     * @return 加密是否成功。false为失败，true为成功
+     */
+    boolean SM4EncryptFileDataCBC(int keyType, String key, int inType, int outType, String inFilePath, String outFilePath);
+
+    /**
+     * 使用SM4算法进行加密，其中加密模式为CBC,
+     * Ⅳ使用缺省值0X 00000000000000000000000000000000,
+     * 补位模式为 PKCS5 PADDING 。
+     * @param keyType 密钥类型 0: ZEK,1: TEK
+     * @param key 密钥
+     * @param inType 输入消息类型 0:二进制 1:扩展十六进制
+     * @param outType 输出消息类型 0:二进制 1:扩展十六进制
+     * @param msg 消息数据
+     * @return 输出的报文密文
+     */
+    byte[] SM4EncryptDataCBC(int keyType, String key, int inType, int outType, byte[] msg);
+
+    /**
+     * 使用SM4算法进行解密，其中加密模式为CBC,
+     * Ⅳ使用缺省值0X 00000000000000000000000000000000,
+     * 补位模式为 PKCS5 PADDING 。
+     * @param keyType 密钥类型 0: ZEK,1: TEK
+     * @param key 密钥
+     * @param inType 输入消息类型 0:二进制 1:扩展十六进制
+     * @param outType 输出消息类型 0:二进制 1:扩展十六进制
+     * @param inFilePath 加密后的密文数据将要保存的文件路径
+     * @param outFilePath 解密后的数据文件所在的路径
+     * @return 解密是否成功。false为失败，true为成功
+     */
+    boolean SM4DecryptFileDataCBC(int keyType, String key, int inType, int outType, String inFilePath, String outFilePath);
+
+    /**
+     * 使用SM4算法进行解密，其中加密模式为CBC,
+     * Ⅳ使用缺省值0X 00000000000000000000000000000000,
+     * 补位模式为 PKCS5 PADDING 。
+     * @param keyType 密钥类型 0: ZEK,1: TEK
+     * @param key 密钥
+     * @param inType 输入消息类型 0:二进制 1:扩展十六进制
+     * @param outType 输出消息类型 0:二进制 1:扩展十六进制
+     * @param msg 加密后的消息数据
+     * @return 输出的报文明文
+     */
+    byte[] SM4DecryptDataCBC(int keyType, String key, int inType, int outType, byte[] msg);
+
     /**
      * 用输入的会话密钥，对指定报文数据进行加密处理。
      *

src/main/java/com/sunyard/inf/SydSVApi.java

@@ -47,6 +47,19 @@ interface SydNakedSVApi {
  */
 interface SydAttachedSVApi {
 
+    /**
+     * sm2私钥签名
+     * 用户id默认为1234567812345678
+     * 签名结果R/S序列串先进行der编码，再进行base64编码
+     *
+     * @param flag 私钥标志位，当为1时第二个参数传入存储私钥的索引，当为0时第二个参数传入私钥
+     * @param privateKey 当私钥标志位为1时传入存储私钥的索引，当为0时传入私钥
+     * @param publicKey 公钥
+     * @param orgData 要签名的信息
+     * @return 签名结果
+     */
+    String SM2SignC(int flag, String privateKey, byte[] publicKey, byte[] orgData);
+
     /**
      * SM2 私钥签名
      * @param pUserID 使用者的 ID，最大长度为 16 位数字，右对齐。
@@ -102,6 +115,16 @@ interface SydAttachedSVApi {
             byte[] orgData,
             byte[] sign);
 
+    /**
+     * sm2验签
+     * 用户id默认为1234567812345678
+     *
+     * @param publicKey 公钥的 DER 编码
+     * @param orgData 要签名的信息
+     * @param base64Sign 计算的签名，签名结果R/S序列串先进行der编码，再进行base64编码后的结果
+     * @return true 验签成功，false 验签失败
+     */
+    boolean SM2Verify(byte[] publicKey, byte[] orgData, String base64Sign);
 
     /**
      * 采用 SM2 算法，用指定的公钥对指定的原始数据进行数字签名验证。

src/main/java/com/sunyard/util/FileUtil.java

@@ -0,0 +1,86 @@
+package com.sunyard.util;
+
+import com.sunyard.SydApiException;
+
+import java.io.*;
+
+public class FileUtil {
+
+    /**
+     * 从文件中读取数据
+     * @param path
+     * @return
+     * @throws SydApiException
+     */
+    public static byte[] getDataFromFile(String path) throws SydApiException {
+
+        File file = new File(path);
+        if (!file.exists() || !file.isFile()) {
+            throw new SydApiException("该文件不存在", -27);
+        }
+
+        BufferedInputStream bis = null;
+        ByteArrayOutputStream baos = null;
+        try {
+            bis = new BufferedInputStream(new FileInputStream(file));
+            baos = new ByteArrayOutputStream(1024);
+
+            byte[] buf = new byte[1024];
+
+            int size = 0;
+
+            while ((size = bis.read(buf)) != -1) {
+                baos.write(buf, 0, size);
+            }
+
+            return baos.toByteArray();
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            if (bis != null) {
+                try {
+                    bis.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            if (baos != null) {
+                try {
+                    baos.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+
+        return null;
+    }
+
+
+    /**
+     * 将字符串数据存储到文件中
+     * 如果文件不存在则自动创建
+     * @param path 文件路径
+     * @param data 数据
+     */
+    public static void printDataToFile(String path, String data) {
+        OutputStreamWriter osw = null;
+        try {
+            osw = new OutputStreamWriter(new FileOutputStream(path));
+
+            osw.write(data);
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            if (osw != null) {
+                try {
+                    osw.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}

src/main/java/racal/sunyard/main/SydApi4j.java

@@ -12,6 +12,7 @@ import com.sunyard.proto.section.SectionValue;
 import com.sunyard.proto.value.Str;
 import com.sunyard.trans.PacketSN;
 import com.sunyard.util.CoderUtil;
+import com.sunyard.util.FileUtil;
 import com.sunyard.util.MyUtil;
 import com.sunyard.util.SYMUtil;
 import racal.sunyard.main.dto.*;
@@ -2727,6 +2728,49 @@ public class SydApi4j implements SydApi {
         return Util.bytes2HexString(((PacketSection) ret.get("publicKey")).getBytes());
     }
 
+    /**
+     * 通过密钥索引获得 SM2 公钥(DER 编码)。
+     * @param privateKeyTag 指示用户密钥存储区的27位地址，27位的索引号：16位机构号+3位密钥类型+8位密钥索引号
+     * @return 公钥数据的der编码
+     */
+    // 测试通过
+    public String SM2GetPublicKeyC(String privateKeyTag) {
+
+        ProtoQQ proto = new ProtoQQ();
+        HashMap<String, Object> packet = new HashMap<String, Object>();
+        HashMap<String, Object> data = new HashMap<String, Object>();
+        packet.put("data", data);
+        PacketSN sn = PacketSN.gen();
+        packet.put("header", sn.getSn().array());
+        data.put("privateKeyTag", privateKeyTag);
+        // 渲染发送
+        ByteBuffer bb = proto.rend(packet);
+        //System.out.println(Util.bytes2HexString(Util.toArray(bb)));
+        synchronized (this) {
+            // 响应解析
+            bb = syncRead(syncSend(bb));
+        }
+
+        //ProtocolParser parser = pset.getProtocolResParse();
+        Packet p = proto.parse(bb);
+        Map<String, Object> ret = p.toMap();
+        if (
+                !Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes())
+        ) {
+            throw new SydApiException("包序号不匹配", -4);
+        }
+        ret = (Map<String, Object>) ret.get("data");
+        PacketSection error = (PacketSection) ret.get("error");
+        if (!"00".equals(error.getString())) {
+            throw new SydApiException(error.getInfo(), error.autoInt());
+        }
+        int len = Integer.parseInt(((PacketSection) ret.get("publicLen")).getString());
+        if (len == 128) {
+            return "03420004" + ((PacketSection) ret.get("publicKey")).getString();
+        }
+
+        return ((PacketSection) ret.get("publicKey")).getString();
+    }
 
     @Override
     public String SM2GetPublicKeyC(String userId, int nKeyType) {
@@ -2768,6 +2812,53 @@ public class SydApi4j implements SydApi {
         return ((PacketSection) ret.get("publicKey")).getString();
     }
 
+    /**
+     * 导出一个SM2私钥。
+     * @param privateKeyTag 要导出密钥的索引，27位的索引号：16位机构号+3位密钥类型+8位密钥索引号
+     * @return LMK下加密的私钥
+     */
+    // 测试通过
+    public String SM2GetPrivateKeyC(String privateKeyTag) {
+
+        ProtoQP proto = new ProtoQP();
+        HashMap<String, Object> packet = new HashMap<String, Object>();
+        HashMap<String, Object> data = new HashMap<String, Object>();
+        packet.put("data", data);
+        PacketSN sn = PacketSN.gen();
+        packet.put("header", sn.getSn().array());
+        data.put("privateKeyTag", privateKeyTag);
+        // 渲染发送
+        ByteBuffer bb = proto.rend(packet);
+        //System.out.println(Util.bytes2HexString(Util.toArray(bb)));
+        synchronized (this) {
+            // 响应解析
+            bb = syncRead(syncSend(bb));
+        }
+
+        //ProtocolParser parser = pset.getProtocolResParse();
+        Packet p = proto.parse(bb);
+        Map<String, Object> ret = p.toMap();
+        if (
+                !Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes())
+        ) {
+            throw new SydApiException("包序号不匹配", -4);
+        }
+        ret = (Map<String, Object>) ret.get("data");
+        PacketSection error = (PacketSection) ret.get("error");
+        if (!"00".equals(error.getString())) {
+            throw new SydApiException(error.getInfo(), error.autoInt());
+        }
+
+        // 模长
+        String mod = "00010000";
+
+        // 填充
+        String fill = "0000000000000000000000000000000000000000000000000000000000000000";
+
+        return mod + ((PacketSection) ret.get("privateKey")).getString() + fill;
+    }
+
+
     /**
      * 通过私钥获取公钥
      *
@@ -2933,6 +3024,120 @@ public class SydApi4j implements SydApi {
 
     }
 
+
+    /**
+     * sm2私钥签名
+     * 用户id默认为1234567812345678
+     * 签名结果R/S序列串先进行der编码，再进行base64编码
+     *
+     * @param flag 私钥标志位，当为1时第二个参数传入存储私钥的索引，当为0时第二个参数传入私钥
+     * @param privateKey 当私钥标志位为1时传入存储私钥的索引，当为0时传入私钥
+     * @param publicKey 公钥
+     * @param orgData 要签名的信息
+     * @return 签名结果
+     */
+    // 测试通过
+    @Override
+    public String SM2SignC(int flag, String privateKey, byte[] publicKey, byte[] orgData) {
+
+        Proto74 proto = new Proto74();
+
+        // 填充数据
+        HashMap<String, Object> packet = new HashMap<>();
+        HashMap<String, Object> data = new HashMap<>();
+        packet.put("data", data);
+
+        PacketSN sn = PacketSN.gen();
+        packet.put("header", sn.getSn().array());
+        data.put("signatureDataType$option", 1);
+        data.put("userId", "1234567812345678".getBytes());
+        data.put("publicKey", publicKey);
+        data.put("infoData", orgData);
+        data.put("privateKeyTag", flag == 1 ? privateKey : "999999999999999999999999999");
+        data.put("privateKey", Util.hexString2Bytes(privateKey));
+
+        // 渲染发送
+        ByteBuffer bb = proto.rend(packet);
+        //System.out.println(Util.bytes2HexString(Util.toArray(bb)));
+        synchronized (this) {
+            // 响应解析
+            bb = syncRead(syncSend(bb));
+        }
+
+
+        SectionValue sv = new SectionValue();
+        sv.setValue(new byte[]{bb.get(12), bb.get(13)});
+        PacketSection error = new PacketSection(sv);
+        if (0 != error.autoInt()) {
+            throw new SydApiException(error.getInfo(), error.autoInt());
+        }
+
+        bb.position(14);
+        byte[] v = new byte[4];
+        bb.get(v, 0, v.length);
+        int a = Util.a2i(v, 10);
+        byte[] s = new byte[a];
+        bb.get(s, 0, a);
+
+        return SYMUtil.derSign2Base64Sign(s);
+
+    }
+
+    /**
+     * sm2验签
+     * 用户id默认为1234567812345678
+     *
+     * @param publicKey 公钥的 DER 编码
+     * @param orgData 签名信息
+     * @param base64Sign 计算的签名，签名结果R/S序列串先进行der编码，再进行base64编码后的结果
+     * @return true 验签成功，false 验签失败
+     */
+    // 测试通过
+    @Override
+    public boolean SM2Verify(byte[] publicKey, byte[] orgData, String base64Sign) {
+
+        Proto75 proto = new Proto75();  //pset.getProtocolReqRender("75");
+
+        byte[] sign = SYMUtil.base64Sign2DerSign(base64Sign);
+
+        // 填充数据
+        HashMap<String, Object> packet = new HashMap<String, Object>();
+        HashMap<String, Object> data = new HashMap<String, Object>();
+        packet.put("data", data);
+        PacketSN sn = PacketSN.gen();
+        packet.put("header", sn.getSn().array());
+        data.put("signatureDataType$option", 1);
+        data.put("signature", sign);
+        data.put("userId", "1234567812345678".getBytes());
+        data.put("infoData", orgData);
+        data.put("publicKey", publicKey);
+        // 渲染发送
+        ByteBuffer bb = proto.rend(packet);
+
+        long b = System.currentTimeMillis();
+
+        synchronized (this) {
+            // 响应解析
+            bb = syncRead(syncSend(bb));
+        }
+
+        Packet p = proto.parse(bb);
+        Map<String, Object> ret = p.toMap();
+
+        if (
+                !Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes())
+        ) {
+            throw new SydApiException("包序号不匹配", -4);
+        }
+        ret = (Map<String, Object>) ret.get("data");
+        PacketSection error = (PacketSection) ret.get("error");
+        if (!"00".equals(error.getString())) {
+
+            throw new SydApiException(error.getInfo(), error.autoInt());
+        }
+        return true;
+    }
+
     // 测试通过
     @Override
     public String SM2SignC(String pUserID, String certNo, int nOrgDataType, byte[] publicKey, byte[] orgData) {
@@ -4030,6 +4235,149 @@ public class SydApi4j implements SydApi {
         return rw;
     }
 
+    /**
+     * 使用SM4算法进行加密，其中加密模式为CBC,
+     * Ⅳ使用缺省值0X 00000000000000000000000000000000,
+     * 补位模式为 PKCS5 PADDING 。
+     * @param keyType 密钥类型 0: ZEK,1: TEK
+     * @param key 密钥
+     * @param inType 输入消息类型 0:二进制 1:扩展十六进制
+     * @param outType 输出消息类型 0:二进制 1:扩展十六进制
+     * @param inFilePath 需要加密的数据文件所在的路径
+     * @param outFilePath 加密后的密文数据将要保存的文件路径
+     * @return 加密是否成功。false为失败，true为成功
+     */
+    // 测试通过
+    @Override
+    public boolean SM4EncryptFileDataCBC(int keyType, String key, int inType, int outType, String inFilePath, String outFilePath) {
+
+        byte[] msg = FileUtil.getDataFromFile(inFilePath);
+
+        if (msg == null || msg.length == 0) {
+            throw new SydApiException("数据为空", -27);
+        }
+
+        // 调用加密接口将数据加密
+        byte[] result = SM4EncryptDataCBC(keyType, key, inType, outType, msg);
+        String str = Util.bytes2HexString(result);
+
+        FileUtil.printDataToFile(outFilePath, str);
+
+        return true;
+    }
+
+    /**
+     * 使用SM4算法进行加密，其中加密模式为CBC,
+     * Ⅳ使用缺省值0X 00000000000000000000000000000000,
+     * 补位模式为 PKCS5 PADDING 。
+     * @param keyType 密钥类型 0: ZEK,1: TEK
+     * @param key 密钥
+     * @param inType 输入消息类型 0:二进制 1:扩展十六进制
+     * @param outType 输出消息类型 0:二进制 1:扩展十六进制
+     * @param msg 消息数据
+     * @return 输出的报文密文
+     */
+    // 测试通过
+    @Override
+    public byte[] SM4EncryptDataCBC(int keyType, String key, int inType, int outType, byte[] msg) {
+
+        // 填充数据
+        HashMap<String, Object> packet = new HashMap<String, Object>();
+        HashMap<String, Object> data = new HashMap<String, Object>();
+        byte[] iv = new byte[32];
+        Arrays.fill(iv, (byte) 0x30);
+
+        data.put("alg$option", 0x8);
+        data.put("roundModel$option", 1);
+        data.put("iv", iv);
+        data.put("keyType$option", keyType);
+        data.put("key", key.getBytes());
+        data.put("inType$option", inType);
+        data.put("outType$option", outType);
+        data.put("fullMode$option", 1);
+        data.put("fullChar$option", 0);
+        data.put("fullType$option", 2);
+        data.put("msg", msg);
+
+        packet.put("data", data);
+
+        return repackEncrypt(packet);
+    }
+
+    /**
+     * 使用SM4算法进行解密，其中加密模式为CBC,
+     * Ⅳ使用缺省值0X 00000000000000000000000000000000,
+     * 补位模式为 PKCS5 PADDING 。
+     * @param keyType 密钥类型 0: ZEK,1: TEK
+     * @param key 密钥
+     * @param inType 输入消息类型 0:二进制 1:扩展十六进制
+     * @param outType 输出消息类型 0:二进制 1:扩展十六进制
+     * @param inFilePath 加密后的密文数据将要保存的文件路径
+     * @param outFilePath 解密后的数据文件所在的路径
+     * @return 解密是否成功。false为失败，true为成功
+     */
+    // 测试通过
+    @Override
+    public boolean SM4DecryptFileDataCBC(int keyType, String key, int inType, int outType, String inFilePath, String outFilePath) {
+
+        byte[] msg = FileUtil.getDataFromFile(inFilePath);
+
+        if (msg == null || msg.length == 0) {
+            throw new SydApiException("数据为空", -27);
+        }
+
+        // 调用加密接口将数据加密
+        byte[] result = SM4DecryptDataCBC(keyType, key, inType, outType, Util.hexString2Bytes(new String(msg)));
+
+        String str = new String(Util.hexString2Bytes(Util.bytes2HexString(result)));
+
+        FileUtil.printDataToFile(outFilePath, str);
+
+        return true;
+    }
+
+    /**
+     * 使用SM4算法进行解密，其中加密模式为CBC,
+     * Ⅳ使用缺省值0X 00000000000000000000000000000000,
+     * 补位模式为 PKCS5 PADDING 。
+     * @param keyType 密钥类型 0: ZEK,1: TEK
+     * @param key 密钥
+     * @param inType 输入消息类型 0:二进制 1:扩展十六进制
+     * @param outType 输出消息类型 0:二进制 1:扩展十六进制
+     * @param msg 加密后的消息数据
+     * @return 输出的报文明文
+     */
+    // 测试通过
+    @Override
+    public byte[] SM4DecryptDataCBC(int keyType, String key, int inType, int outType, byte[] msg) {
+
+        byte[] iv = new byte[32];
+        Arrays.fill(iv, (byte) 0x30);
+
+        // 填充数据
+        PacketSN sn = PacketSN.gen();
+        HashMap<String, Object> packet = new HashMap<String, Object>();
+        packet.put("header", sn.getSn().array());
+        HashMap<String, Object> data = new HashMap<String, Object>();
+
+        data.put("alg$option", 0x9);
+
+        data.put("roundModel$option", 1);
+        data.put("iv", iv);
+        data.put("keyType$option", keyType);
+        data.put("key", key.getBytes());
+        data.put("inType$option", inType);
+        data.put("outType$option", outType);
+        data.put("fullMode$option", 1);
+        data.put("fullChar$option", 0);
+        data.put("fullType$option", 2);
+        data.put("msg", msg);
+
+        packet.put("data", data);
+
+        return repackEncrypt(packet);
+    }
+
     @Override
     public byte[] SYMEncryptDataCBC(int nAlg, String seesionKey, byte[] pInData) {
         return SYMEncryptDataCBC(nAlg, seesionKey, 1, pInData);
@@ -6188,6 +6536,7 @@ public class SydApi4j implements SydApi {
      * @return DK: LMK14-15 加密下的密钥
      * keyCheck: 密钥校验值
      */
+    // 测试通过
     public RetWrap getTransmissionKey() {
         // 获取协议
         Proto60 proto = new Proto60();

src/test/java/com/sunyard/sydapi/example/ABCNorthBranch.java

@@ -0,0 +1,179 @@
+package com.sunyard.sydapi.example;
+
+import com.sunyard.RetWrap;
+import com.sunyard.proto.Util;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import racal.sunyard.main.SydApi4j;
+
+import static com.sunyard.sydapi.util.PrintUtil.printByteArray;
+import static com.sunyard.sydapi.util.PrintUtil.printRetWrap;
+
+/**
+ * 农行北分海淀支行-军队资金集中收付系统
+ */
+public class ABCNorthBranch {
+
+    SydApi4j api;
+
+    // SM2密钥索引
+    String SM2PrivateKeyTag = "111111111111111800000000001";
+    // SM2公钥
+    String SM2PublicKey = null;
+    // SM2私钥
+    String SM2PrivateKey = null;
+
+    // SM4密钥索引
+    String SM4PrivateKeyTag = "333333333333333300A00000001";
+    // SM4密钥
+    String SM4Key = null;
+
+
+    @Before
+    public void before() {
+        System.setProperty("com.sunyard.sydapi4j.debug", "true");
+        api = (SydApi4j) new SydApi4j().connect("192.168.1.7", 8889, null, 5000);
+
+        SM2PublicKey = api.SM2GetPublicKeyC(SM2PrivateKeyTag);
+        SM2PrivateKey = api.SM2GetPrivateKeyC(SM2PrivateKeyTag);
+        SM4Key = new String(Util.hexString2Bytes(Util.bytes2HexString((byte[]) api.readKey(SM4PrivateKeyTag).get("key"))));
+
+
+        System.out.println("=========================================密钥获取完成=========================================");
+    }
+
+    @After
+    public void after() {
+        try {
+            this.api.disconnect();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    // A4
+    @Test
+    public void testComposeKey() {
+        String[] strs = {"583034303438393445374238444531323942344646344546393838394535364132", "583934443335443836454631463332313344353543343738323246383744333835"};
+        RetWrap rw = api.composeKey("000", strs);
+
+        printRetWrap(rw);
+    }
+
+
+    // 测试通过
+    // 74
+    @Test
+    public void testSM2SignC2() {
+        String thisOrgData = "FFFFFFFFFFFFFFFF";
+
+        String s = api.SM2SignC(1, SM2PrivateKeyTag, Util.hexString2Bytes(SM2PublicKey), thisOrgData.getBytes());
+        System.out.println(s);
+    }
+
+    // 测试通过
+    // 74
+    @Test
+    public void testSM2SignC3() {
+        String thisOrgData = "FFFFFFFFFFFFFFFF";
+
+        String s = api.SM2SignC(0, SM2PrivateKey, Util.hexString2Bytes(SM2PublicKey), thisOrgData.getBytes());
+        System.out.println(s);
+    }
+
+    // 测试通过
+    // 75
+    @Test
+    public void testSM2Verify2() {
+        String thisOrgData = "FFFFFFFFFFFFFFFF";
+
+        String s = api.SM2SignC(0, SM2PrivateKey, Util.hexString2Bytes(SM2PublicKey), thisOrgData.getBytes());
+
+        System.out.println(s);
+        boolean b = api.SM2Verify( Util.hexString2Bytes(SM2PublicKey), thisOrgData.getBytes(), s);
+        System.out.println(b);
+    }
+
+    // 测试通过
+    // 75
+    @Test
+    public void testSM2Verify3() {
+
+        String thisOrgData = "FFFFFFFFFFFFFFFF";
+
+        String s = api.SM2SignC(1, SM2PrivateKeyTag, Util.hexString2Bytes(SM2PublicKey), thisOrgData.getBytes());
+
+        System.out.println(s);
+        boolean b = api.SM2Verify( Util.hexString2Bytes(SM2PublicKey), thisOrgData.getBytes(), s);
+        System.out.println(b);
+    }
+
+    // 测试通过
+    // E0
+    @Test
+    public void testSM4EncryptDataCBC() {
+        String msg = "1111111111111111111111";
+        byte[] bytes = api.SM4EncryptDataCBC(0, SM4Key, 0, 0 , msg.getBytes());
+        printByteArray(bytes);
+
+    }
+
+    // 测试通过
+    // E0
+    @Test
+    public void testSM4DecryptDataCBC() {
+        String msg = "11111111111";
+        byte[] bytes = api.SM4EncryptDataCBC(0, SM4Key, 0, 0 , msg.getBytes());
+
+        byte[] bytes1 = api.SM4DecryptDataCBC(0, SM4Key, 0, 0, bytes);
+
+        printByteArray(bytes1, false);
+    }
+
+    // 测试通过
+    // E0
+    @Test
+    public void testSM4EncryptFileDataCBC() {
+
+        String inFilePath = "C:\\Users\\edgar\\Desktop\\fsdownload\\test\\in1.txt";
+        String outFilePath = "C:\\Users\\edgar\\Desktop\\fsdownload\\test\\in2.txt";
+        boolean b = api.SM4EncryptFileDataCBC(0, SM4Key, 0, 0, inFilePath, outFilePath);
+        System.out.println(b);
+    }
+
+
+    // 测试通过
+    // E0
+    @Test
+    public void testSM4DecryptFileDataCBC() {
+
+        String outFilePath = "C:\\Users\\edgar\\Desktop\\fsdownload\\test\\in2.txt";
+        String outFilePath2 = "C:\\Users\\edgar\\Desktop\\fsdownload\\test\\out1.txt";
+        boolean b = api.SM4DecryptFileDataCBC(0, SM4Key, 0, 0, outFilePath, outFilePath2);
+        System.out.println(b);
+    }
+
+    // LF
+    @Test
+    public void testReadKey() {
+        RetWrap retWrap = api.readKey(SM4PrivateKeyTag);
+        printRetWrap(retWrap);
+    }
+
+    // QQ
+    @Test
+    public void testSM2GetPublicKeyC3() {
+
+        String s = api.SM2GetPublicKeyC(SM2PrivateKeyTag);
+        System.out.println(s);
+    }
+
+    // QP
+    @Test
+    public void testSM2GetPrivateKeyC() {
+        String s = api.SM2GetPrivateKeyC(SM2PrivateKeyTag);
+        System.out.println(s);
+    }
+
+}

src/test/java/com/sunyard/sydapi/test/TestAllMethods.java

@@ -4,6 +4,7 @@ import com.sunyard.RetWrap;
 import com.sunyard.SydApi;
 import com.sunyard.cert.X509;
 import com.sunyard.proto.Util;
+import com.sunyard.sydapi.util.PrintUtil;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -11,6 +12,9 @@ import racal.sunyard.main.SydApi4j;
 
 import java.io.*;
 
+import static com.sunyard.sydapi.util.PrintUtil.printByteArray;
+import static com.sunyard.sydapi.util.PrintUtil.printRetWrap;
+
 public class TestAllMethods {
 
     SydApi4j api;
@@ -34,32 +38,6 @@ 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()) {
-
-            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);
-            }
-        }
-    }
-
     // 获取证书
     public String getCertStr(String path) {
 
@@ -127,13 +105,14 @@ public class TestAllMethods {
      */
     public byte[] inputStream2ByteArray(String filePath) {
 
-        InputStream in = null;
+        BufferedInputStream in = null;
         ByteArrayOutputStream out = null;
         byte[] data = null;
         try {
-            in = new FileInputStream(filePath);
+            in = new BufferedInputStream(new FileInputStream(filePath));
 
             out = new ByteArrayOutputStream();
+
             byte[] buffer = new byte[1024 * 4];
             int n = 0;
             while ((n = in.read(buffer)) != -1) {
@@ -616,6 +595,82 @@ public class TestAllMethods {
         printRetWrap(retWrap, true);
     }
 
+    // 00650000000000000000
+    // 4530
+    // 30
+    // 38
+    // 3230583643454537343433323934393942343236434545373434333239343939423432303031303030303230303030303030303030303030303030303030303030303030303030303030303030423131313131313131313131
+
+    // 测试通过
+    // E0
+    @Test
+    public void testSM4EncryptDataCBC() {
+        String key = "X6CEE744329499B426CEE744329499B42";
+        String msg = "1111111111111111111111";
+        byte[] bytes = api.SM4EncryptDataCBC(0, key, 0, 0 , msg.getBytes());
+        printByteArray(bytes);
+
+    }
+
+    // 00200000000000000000
+    // 4531
+    // 303030
+    // 303130
+    // FF045D9DFA5DBE95CBC4285499719EF1
+
+    // 006A000000000000000245303039323058364345453734343332393439394234323643454537343433323934393942343230303130303030323030303030303030303030303030303030303030303030303030303030303030303130FF045D9DFA5DBE95CBC4285499719EF1
+    // 测试通过
+    // E0
+    @Test
+    public void testSM4DecryptDataCBC() {
+        String key = "X6CEE744329499B426CEE744329499B42";
+        String msg = "11111111111";
+        byte[] bytes = api.SM4EncryptDataCBC(0, key, 0, 0 , msg.getBytes());
+
+        byte[] bytes1 = api.SM4DecryptDataCBC(0, key, 0, 0, bytes);
+
+        printByteArray(bytes1, false);
+    }
+
+    // 00850000000000000000
+    // 4530
+    // 30
+    // 38
+    // 32
+    // 30
+    // 583643454537343433323934393942343236434545373434333239343939423432
+    // 30
+    // 30
+    // 31
+    // 30303030
+    // 32
+    // 3030303030303030303030303030303030303030303030303030303030303030
+    // 303242
+    // 31303130313131313131313131313131313131313131313030303030303030303031313131313131313131
+
+    // 测试通过
+    // E0
+    @Test
+    public void testSM4EncryptFileDataCBC() {
+        String key = "X6CEE744329499B426CEE744329499B42";
+        String inFilePath = "C:\\Users\\edgar\\Desktop\\fsdownload\\test\\in1.txt";
+        String outFilePath = "C:\\Users\\edgar\\Desktop\\fsdownload\\test\\in2.txt";
+        boolean b = api.SM4EncryptFileDataCBC(0, key, 0, 0, inFilePath, outFilePath);
+        System.out.println(b);
+    }
+
+
+    // 测试通过
+    // E0
+    @Test
+    public void testSM4DecryptFileDataCBC() {
+        String key = "X6CEE744329499B426CEE744329499B42";
+        String outFilePath = "C:\\Users\\edgar\\Desktop\\fsdownload\\test\\in2.txt";
+        String outFilePath2 = "C:\\Users\\edgar\\Desktop\\fsdownload\\test\\out1.txt";
+        boolean b = api.SM4DecryptFileDataCBC(0, key, 0, 0, outFilePath, outFilePath2);
+        System.out.println(b);
+    }
+
     // 测试通过
     // Y0
     @Test
@@ -642,7 +697,7 @@ public class TestAllMethods {
     // LF
     @Test
     public void testReadKey() {
-        String index = "000000000000000300000000003";
+        String index = "333333333333333300A00000001";
         RetWrap retWrap = api.readKey(index);
         printRetWrap(retWrap);
     }
@@ -784,13 +839,13 @@ public class TestAllMethods {
     // E2
     @Test
     public void testSM2OrRSAGenKeyPair() {
-        String index = "1111111111111115";
+        String index = "1111111111111118";
 
         // SM2
-//        RetWrap retWrap = api.SM2OrRSAGenKeyPair(1, index, 0);
+        RetWrap retWrap = api.SM2OrRSAGenKeyPair(1, index, 0);
 
         // RSA
-        RetWrap retWrap = api.SM2OrRSAGenKeyPair(0, index, 1024);
+//        RetWrap retWrap = api.SM2OrRSAGenKeyPair(0, index, 1024);
         printRetWrap(retWrap, true);
     }
 
@@ -868,6 +923,7 @@ public class TestAllMethods {
         printRetWrap(retWrap, true);
     }
 
+    // 测试通过
     // 60
     @Test
     public void testGetTransmissionKey() {
@@ -1083,6 +1139,35 @@ public class TestAllMethods {
         System.out.println(s);
     }
 
+    // 测试通过
+    // QQ
+    @Test
+    public void testSM2GetPublicKeyC2() {
+        String userId = "1111111111111117";
+
+        String s = api.SM2GetPublicKeyC(userId, 0);
+        System.out.println(s);
+    }
+
+    // 测试通过
+    // QQ
+    @Test
+    public void testSM2GetPublicKeyC3() {
+
+        String tag = "111111111111111800000000001";
+        String s = api.SM2GetPublicKeyC(tag);
+        System.out.println(s);
+    }
+
+    // 测试通过
+    // QP
+    @Test
+    public void testSM2GetPrivateKeyC() {
+        String tag = "111111111111111800000000001";
+        String s = api.SM2GetPrivateKeyC(tag);
+        System.out.println(s);
+    }
+
     // 测试通过
     // HI
     @Test
@@ -1175,6 +1260,71 @@ public class TestAllMethods {
         System.out.println(s);
     }
 
+    // 测试通过
+    // 74
+    @Test
+    public void testSM2SignC2() {
+        String thisPublicKey = "03420004549B6A1A09A5D0D9432C6829D443F85ED8785340FC1AB14118BB7637830C808F7A888DF0C4F988EA6FF2EE6C76ECD00C4B7CEC92CC8EA365F8EA291041CAB231";
+        String thisOrgData = "FFFFFFFFFFFFFFFF";
+
+        String s = api.SM2SignC(1, "111111111111111300000000001", Util.hexString2Bytes(thisPublicKey), thisOrgData.getBytes());
+        System.out.println(s);
+    }
+
+    // 测试通过
+    // 74
+    @Test
+    public void testSM2SignC3() {
+        String privateKey = "00010000D7DBFD26A371D3B5BA58D3ECA98EAEFC1BCB65FA0DBBCFBC551E4315B8B2A8700000000000000000000000000000000000000000000000000000000000000000";
+        String thisPublicKey = "034200042E624577E3BF1A510804346D1054B9205D97B4579D6528C25CAE6B74E5CDD19774AFA17CD9017E6BCBD8D9F3903492CD5288932941583E113C804537B69CDD46";
+        String thisOrgData = "FFFFFFFFFFFFFFFF";
+
+        String s = api.SM2SignC(0, privateKey, Util.hexString2Bytes(thisPublicKey), thisOrgData.getBytes());
+        System.out.println(s);
+    }
+
+    // 00C40000000000000001
+    // 3735
+    // 30303731
+    // 3045022100E5C51AE465EB085AC0A864414617D50776F7E93F9026F5E88FD8C1DC9DB38E9F022048A6E3CBE58837012FFF4281C8B53B98DCFBD6C250F0CD153C640C53FF8D78FB
+    // 31
+    // 3136
+    // 31323334353637383132333435363738
+    // 30303136
+    // 46464646464646464646464646464646
+    // 30303638
+    // 03420004549B6A1A09A5D0D9432C6829D443F85ED8785340FC1AB14118BB7637830C808F7A888DF0C4F988EA6FF2EE6C76ECD00C4B7CEC92CC8EA365F8EA291041CAB231
+
+    // 测试通过
+    // 75
+    @Test
+    public void testSM2Verify2() {
+        String privateKey = "00010000D7DBFD26A371D3B5BA58D3ECA98EAEFC1BCB65FA0DBBCFBC551E4315B8B2A8700000000000000000000000000000000000000000000000000000000000000000";
+        String thisPublicKey = "034200042E624577E3BF1A510804346D1054B9205D97B4579D6528C25CAE6B74E5CDD19774AFA17CD9017E6BCBD8D9F3903492CD5288932941583E113C804537B69CDD46";
+        String thisOrgData = "FFFFFFFFFFFFFFFF";
+
+        String s = api.SM2SignC(0, privateKey, Util.hexString2Bytes(thisPublicKey), thisOrgData.getBytes());
+
+        System.out.println(s);
+        boolean b = api.SM2Verify( Util.hexString2Bytes(thisPublicKey), thisOrgData.getBytes(), s);
+        System.out.println(b);
+    }
+
+    // 测试通过
+    // 75
+    @Test
+    public void testSM2Verify3() {
+
+        String thisPublicKey = "034200045AC5014ED6A2CA0F9F79F3A34ADF4B8B92383F09E2D2F2F5B56F3D6C05B3EE43A3D65E57D3979C6CE9F6CEC5E0E30DC564416BFCB9A3E2D071559098B6B6BEF6";
+        String thisOrgData = "FFFFFFFFFFFFFFFF";
+
+        String s = api.SM2SignC(1, "111111111111111700000000001", Util.hexString2Bytes(thisPublicKey), thisOrgData.getBytes());
+
+        System.out.println(s);
+        boolean b = api.SM2Verify( Util.hexString2Bytes(thisPublicKey), thisOrgData.getBytes(), s);
+        System.out.println(b);
+    }
+
     // 测试通过
     // 75
     @Test

src/test/java/com/sunyard/sydapi/util/PrintUtil.java

@@ -0,0 +1,45 @@
+package com.sunyard.sydapi.util;
+
+import com.sunyard.RetWrap;
+import com.sunyard.proto.Util;
+
+public class PrintUtil {
+
+    public static void printRetWrap(RetWrap rw) {
+        printRetWrap(rw, false);
+    }
+
+    /**
+     * 输出
+     * @param rw
+     */
+    public static void printRetWrap(RetWrap rw, boolean flag) {
+        for (String s : rw.keySet()) {
+
+            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);
+            }
+        }
+    }
+
+    public static void printByteArray(byte[] bytes) {
+        printByteArray(bytes, true);
+    }
+
+    public static void printByteArray(byte[] bytes, boolean flag) {
+        if (flag) {
+            System.out.println("输出为: " + Util.bytes2HexString(bytes));
+        } else {
+            System.out.println("输出为: " + new String(Util.hexString2Bytes(Util.bytes2HexString(bytes))));
+        }
+    }
+}