diff --git a/pom.xml b/pom.xml index 0b5b9ca..112db16 100644 --- a/pom.xml +++ b/pom.xml @@ -33,47 +33,6 @@ test - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - com.sunyard @@ -81,6 +40,19 @@ 1.1.20221215 + + + + com.google.zxing + core + 3.5.0 + + + com.google.zxing + javase + 3.5.0 + + org.apache.jmeter ApacheJMeter_java @@ -92,19 +64,22 @@ org.bouncycastle bcpkix-jdk15on - 1.65 + 1.68 + org.bouncycastle bcprov-jdk15on - 1.65 + 1.68 + cn.hutool hutool-all 5.8.4.M1 + @@ -149,8 +124,8 @@ - 6 - 6 + 7 + 7 groovy-eclipse-compiler true true diff --git a/src/main/java/com/sunyard/SydApiException.java b/src/main/java/com/sunyard/SydApiException.java index 3dd897b..009b0e3 100644 --- a/src/main/java/com/sunyard/SydApiException.java +++ b/src/main/java/com/sunyard/SydApiException.java @@ -68,6 +68,11 @@ public class SydApiException extends RuntimeException{ break; } + case 0x8004 : { + msg = "证书已过期"; + break; + } + case 32770: msg = "签名验证错误(P7) "; break; diff --git a/src/main/java/com/sunyard/inf/SydCertApi.java b/src/main/java/com/sunyard/inf/SydCertApi.java index b602898..3b91048 100644 --- a/src/main/java/com/sunyard/inf/SydCertApi.java +++ b/src/main/java/com/sunyard/inf/SydCertApi.java @@ -151,6 +151,8 @@ public interface SydCertApi { RetWrap importCert(byte[] certData, byte[] organizationId, CertUsage... us); RetWrap importCert(byte[] certData, byte[] organizationId); + String importCert(String cert); + /** * 从加密设备中删除指定 DN 的公钥证书 diff --git a/src/main/java/com/sunyard/inf/SydGenApi.java b/src/main/java/com/sunyard/inf/SydGenApi.java index b7bdac6..708d421 100644 --- a/src/main/java/com/sunyard/inf/SydGenApi.java +++ b/src/main/java/com/sunyard/inf/SydGenApi.java @@ -240,6 +240,9 @@ public interface SydGenApi { */ RetWrap generateDEByDn(String certSerial, byte[] oData); + + RetWrap generateDEByDnICBC(String certSerial,String iv, byte[] oData,int roundmod); + RetWrap generateDEByDnRSA(int alg,String certSerial, byte[] oData); /** @@ -323,6 +326,8 @@ public interface SydGenApi { * orgCode 如果有机构码的话会返回机构码 */ RetWrap decryptDEByDN(String certSerial, byte[] pCipherKey); + + RetWrap decryptDEByDNICBC(String certSerial, String IV,String pCipherKey,int roundmod); RetWrap decryptDEByDNRSA(int alg,String certSerial, byte[] pCipherKey); /** * 接收用私钥解密数字信封，还原对称密钥。 diff --git a/src/main/java/com/sunyard/util/CertUtil.java b/src/main/java/com/sunyard/util/CertUtil.java index ec4013f..af2b6d9 100644 --- a/src/main/java/com/sunyard/util/CertUtil.java +++ b/src/main/java/com/sunyard/util/CertUtil.java @@ -46,12 +46,14 @@ public class CertUtil { return (X509Certificate) CF.generateCertificate(new ByteArrayInputStream(certificateString.getBytes())); // 将文件流的证书转化为证书类 } - public static String convertToPem(X509Certificate cert) throws CertificateEncodingException { + public static String convertToPem(String cert) throws CertificateEncodingException { String cert_begin = "-----BEGIN CERTIFICATE-----\n"; String end_cert = "\n-----END CERTIFICATE-----"; - byte[] derCert = cert.getEncoded(); + // byte[] derCert = cert.getEncoded(); + + byte[] derCert = cert.getBytes(); String pemCertPre = new String(Base64.encode(derCert, true)); String pemCert = cert_begin + pemCertPre + end_cert; return pemCert; @@ -98,6 +100,25 @@ public class CertUtil { return signAlg.toUpperCase().indexOf("SM2") >= 0; } + + public static String getDN(String cert) { + String pemCert; + if(cert.contains("-----BEGIN CERTIFICATE-----")){ + pemCert =cert; + }else { + String cert_begin = "-----BEGIN CERTIFICATE-----\n"; + String end_cert = "\n-----END CERTIFICATE-----"; + pemCert = cert_begin + cert + end_cert; + } + X509Certificate certificate = null; + try { + certificate = convertToX509Cert(pemCert); + } catch (Exception e) { + throw new SydApiException( 0xC101, e ); + } + return certificate.getSubjectDN().toString(); + } + /** * 判断 p7 是否是国密证书签的 * diff --git a/src/main/java/com/sunyard/util/QRCodeUtil.java b/src/main/java/com/sunyard/util/QRCodeUtil.java new file mode 100644 index 0000000..2b7e0a8 --- /dev/null +++ b/src/main/java/com/sunyard/util/QRCodeUtil.java @@ -0,0 +1,140 @@ +package com.sunyard.util; + +import com.google.zxing.*; +import com.google.zxing.client.j2se.BufferedImageLuminanceSource; +import com.google.zxing.client.j2se.MatrixToImageWriter; +import com.google.zxing.common.BitMatrix; +import com.google.zxing.common.HybridBinarizer; +import com.google.zxing.qrcode.QRCodeReader; +import com.sunyard.SydApiException; + +import javax.imageio.ImageIO; +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import java.util.Hashtable; + +public class QRCodeUtil { + + public static void genQRCode(String data,String filepath){ + // 图片的尺寸（宽度和高度） + int width = 300; + int height = 300; + + // 设置二维码的相关参数 + Hashtable hintMap = new Hashtable<>(); + hintMap.put(EncodeHintType.MARGIN, 1); // 设置二维码的空白边距 + + try { + // 创建二维码矩阵 + BitMatrix bitMatrix = new MultiFormatWriter().encode( + data, + BarcodeFormat.QR_CODE, + width, + height, + hintMap + ); + + // 将二维码矩阵转换为图片，并保存 + File outputFile = new File(filepath); + MatrixToImageWriter.writeToFile(bitMatrix, "PNG", outputFile); + + } catch (Exception e) { + System.err.println("Error occurred while generating QR code: " + e.getMessage()); + throw new SydApiException(1001,e); + + } + } + + public static void genBarCode(String data,String filepath){ + // 图片的尺寸（宽度和高度） + int width = 300; + int height = 300; + + // 设置二维码的相关参数 + Hashtable hintMap = new Hashtable<>(); + hintMap.put(EncodeHintType.MARGIN, 1); // 设置二维码的空白边距 + + try { + // 生成 Code 128 条形码 + BitMatrix bitMatrix= new MultiFormatWriter().encode( + data, + BarcodeFormat.PDF_417, + width, + height, + hintMap + ); + + // 将二维码矩阵转换为图片，并保存 + File outputFile = new File(filepath); + MatrixToImageWriter.writeToFile(bitMatrix, "PNG", outputFile); + + } catch (Exception e) { + System.err.println("Error occurred while generating QR code: " + e.getMessage()); + throw new SydApiException(1001,e); + + } + } + + + + + public static String readQRCode(String filepath){ + // 加载二维码图像 + File qrCodeImage = new File(filepath); + + // 读取二维码图像 + BufferedImage bufferedImage = null; + try { + bufferedImage = ImageIO.read(qrCodeImage); + } catch (IOException e) { + throw new RuntimeException(e); + } + + // 使用 ZXing 的 QRCodeReader 进行解码 + QRCodeReader reader = new QRCodeReader(); + LuminanceSource source = new BufferedImageLuminanceSource(bufferedImage); + BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source)); + + try { + // 解码二维码 + Result result = reader.decode(bitmap); + + // 提取二维码中的数据 + return result.getText(); + + } catch (NotFoundException e) { + throw new SydApiException(1003,e); + } catch (ChecksumException e) { + throw new SydApiException(1004,e); + } catch (FormatException e) { + throw new SydApiException(1005,e); + } + } + + + public static String readBarCode(String filepath){ + // 加载二维码图像 + File BarCodeImage = new File(filepath); + + try { + // 读取条形码图像 + BufferedImage bufferedImage = ImageIO.read(BarCodeImage); + + // 使用 ZXing 的 MultiFormatReader 进行解码 + MultiFormatReader reader = new MultiFormatReader(); + LuminanceSource source = new BufferedImageLuminanceSource(bufferedImage); + BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source)); + + // 解码条形码 + Result result = reader.decode(bitmap); + + // 提取条形码中的数据 + return result.getText(); + } catch (NotFoundException e) { + throw new SydApiException(1006,e); + } catch (IOException e) { + throw new SydApiException(1007,e); + } + } +} diff --git a/src/main/java/racal/sunyard/main/SydApi4j.java b/src/main/java/racal/sunyard/main/SydApi4j.java index 491ba4f..5b9de24 100644 --- a/src/main/java/racal/sunyard/main/SydApi4j.java +++ b/src/main/java/racal/sunyard/main/SydApi4j.java @@ -5,6 +5,7 @@ import com.sunyard.RetWrap; import com.sunyard.SYMEnDeLongData; import com.sunyard.SydApi; import com.sunyard.SydApiException; +import com.sunyard.cert.Cert; import com.sunyard.cert.X509; import com.sunyard.constant.CertUsage; import com.sunyard.entity.Struct; @@ -48,6 +49,7 @@ import java.text.SimpleDateFormat; import java.util.*; import static com.sunyard.util.DnUtil.verifyDn; +import static org.bouncycastle.asn1.ASN1Encoding.DL; public class SydApi4j implements SydApi { @@ -549,6 +551,87 @@ public class SydApi4j implements SydApi { } } + + public void QRCodeSign(String orgData, String sCertDN,String filepath) { + byte[] sign = null; + if (orgData == null) { + throw new IllegalArgumentException("输入数据为 null"); + } else { + sign = orgData.length() < 4096 ? this.SYD_NakedSign(sCertDN, orgData.getBytes(), (byte[])null) : this.SYD_NakedSign_OuterHash(orgData.getBytes(), sCertDN); + } + QRCodeUtil.genQRCode(orgData+"+"+Util.bytes2HexString(sign),filepath); + } + + + public void QRCodeSignRSA(int rFlag, String orgData, String sCertDN,String filepath) { + byte[] sign = null; + if (orgData == null) { + throw new IllegalArgumentException("输入数据为 null"); + } else { + sign = orgData.length() < 4096 ? this.SYD_NakedSign(rFlag,sCertDN, orgData.getBytes(), (byte[])null) : this.SYD_NakedSign_OuterHash(rFlag,orgData.getBytes(), sCertDN); + } + QRCodeUtil.genQRCode(orgData+"+"+Util.bytes2HexString(sign),filepath); + + } + + public boolean QRCodeVer( String sCertDN,String filepath) { + String s = QRCodeUtil.readQRCode(filepath); + String[] split = s.split("\\+"); + byte[] orgData = split[0].getBytes(); + byte[] sign = Util.hexString2Bytes(split[1]); + return orgData.length < 4096 ? this.SYD_NakedVerify(sCertDN, sign, orgData, (byte[])null) : this.SYD_NakedVerify_OuterHash(orgData, sign, sCertDN); + } + + + public boolean QRCodeVerRSA( int rFlag,String sCertDN,String filepath) { + String s = QRCodeUtil.readQRCode(filepath); + String[] split = s.split("\\+"); + byte[] orgData = split[0].getBytes(); + byte[] sign = Util.hexString2Bytes(split[1]); + return orgData.length < 4096 ? this.SYD_NakedVerify(rFlag,sCertDN, sign, orgData, (byte[])null) : this.SYD_NakedVerify_OuterHash(rFlag,orgData, sign, sCertDN); + } + + + + public void BarCodeSign(String orgData, String sCertDN,String filepath) { + byte[] sign = null; + if (orgData == null) { + throw new IllegalArgumentException("输入数据为 null"); + } else { + sign = orgData.length() < 4096 ? this.SYD_NakedSign(sCertDN, orgData.getBytes(), (byte[])null) : this.SYD_NakedSign_OuterHash(orgData.getBytes(), sCertDN); + } + QRCodeUtil.genBarCode(orgData+"+"+Util.bytes2HexString(sign),filepath); + } + + + public void BarCodeSignRSA(int rFlag, String orgData, String sCertDN,String filepath) { + byte[] sign = null; + if (orgData == null) { + throw new IllegalArgumentException("输入数据为 null"); + } else { + sign = orgData.length() < 4096 ? this.SYD_NakedSign(rFlag,sCertDN, orgData.getBytes(), (byte[])null) : this.SYD_NakedSign_OuterHash(rFlag,orgData.getBytes(), sCertDN); + } + QRCodeUtil.genBarCode(orgData+"+"+Util.bytes2HexString(sign),filepath); + + } + + public boolean BarCodeVer( String sCertDN,String filepath) { + String s = QRCodeUtil.readBarCode(filepath); + String[] split = s.split("\\+"); + byte[] orgData = split[0].getBytes(); + byte[] sign = Util.hexString2Bytes(split[1]); + return orgData.length < 4096 ? this.SYD_NakedVerify(sCertDN, sign, orgData, (byte[])null) : this.SYD_NakedVerify_OuterHash(orgData, sign, sCertDN); + } + + + public boolean BarCodeVerRSA( int rFlag,String sCertDN,String filepath) { + String s = QRCodeUtil.readBarCode(filepath); + String[] split = s.split("\\+"); + byte[] orgData = split[0].getBytes(); + byte[] sign = Util.hexString2Bytes(split[1]); + return orgData.length < 4096 ? this.SYD_NakedVerify(rFlag,sCertDN, sign, orgData, (byte[])null) : this.SYD_NakedVerify_OuterHash(rFlag,orgData, sign, sCertDN); + } + public byte[] SYD_NakedSign(String sCertDN, byte[] orgData, byte[] hash) { Proto8003 proto = new Proto8003(); @@ -1129,6 +1212,90 @@ public class SydApi4j implements SydApi { } + public boolean detachedVerify(byte[] orgData, String sign){ + try { + if( orgData.length<4096 ){ + return detachedVerify(DATA_ORIGIN,orgData,sign); + }else { + RetWrap retWrap = ASN1Util.takeOutOriginDataFromPKCS7Sign(sign); + byte[] pk =(byte[]) retWrap.get("pk"); + byte[] hash = this.SM3Hash(Util.bytes2HexString(pk), orgData); + return detachedVerify(DATA_HASH,hash,sign); + } + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + + public String getCertBySign(String sign){ + RetWrap retWrap = null; + try { + retWrap = ASN1Util.takeOutOriginDataFromPKCS7Sign(sign); + } catch (IOException e) { + throw new RuntimeException(e); + } + String cert = (String) retWrap.get("cert"); + String pemCert; + if(cert.contains("-----BEGIN CERTIFICATE-----")){ + pemCert =cert; + }else { + String cert_begin = "-----BEGIN CERTIFICATE-----\n"; + String end_cert = "\n-----END CERTIFICATE-----"; + pemCert = cert_begin + cert + end_cert; + } + return pemCert; + } + + + public HashMap getCertTime(String dn){ + String cert = null; + try { + cert = getCertByDn(dn); + } catch (UnsupportedEncodingException e) { + throw new RuntimeException(e); + } + String pemCert; + if(cert.contains("-----BEGIN CERTIFICATE-----")){ + pemCert =cert; + }else { + String cert_begin = "-----BEGIN CERTIFICATE-----\n"; + String end_cert = "\n-----END CERTIFICATE-----"; + pemCert = cert_begin + cert + end_cert; + } + X509Certificate certificate = null; + try { + certificate = CertUtil.convertToX509Cert(cert); + } catch (Exception e) { + throw new SydApiException( 0xC101, e ); + } + + SimpleDateFormat outputFormat = new SimpleDateFormat("yyyyMMdd"); + String afterDate = outputFormat.format(certificate.getNotAfter()); + String beforeDate = outputFormat.format(certificate.getNotBefore()); + + HashMap hashMap = new HashMap(); + hashMap.put("after",afterDate); + hashMap.put("before",beforeDate); + return hashMap; + } + + public String importCertAndGetDN(String cert){ + RetWrap retWrap = importCert(cert.getBytes(),null); + String dn = null; + int isImport= (Integer) retWrap.get("isImport"); + if(isImport == 0) { + X509Certificate certificate = null; + try { + certificate = CertUtil.convertToX509Cert(cert); + } catch (Exception e) { + throw new SydApiException( 0xC101, e ); + } + dn = certificate.getSubjectDN().toString(); + } + return dn; + } + public boolean attachedVerifyAll(int rFlag, String sign){ try { boolean sm2Cert = CertUtil.isSignedBySM2Cert(sign); @@ -1381,6 +1548,23 @@ public class SydApi4j implements SydApi { } + public String detachedSign(byte[] orgData, String sCertDN){ + try { + if (orgData.length<4096){ + return detachedSign(DATA_ORIGIN,orgData,sCertDN); + }else { + String pk = null; + pk = this.SYD_SM2_Get_Dn_PublicKey_HA(sCertDN.getBytes("GBK"), 0); + System.out.println(pk); + byte[] hash = this.SM3Hash(pk, orgData); + System.out.println("hash为："+Util.bytes2HexString(hash)); + return detachedSign(DATA_HASH,hash,sCertDN); + } + } catch (UnsupportedEncodingException e) { + throw new RuntimeException(e); + } + } + public String attachedSignAll(int rFlag,byte[] orgData, String sCertDN){ try { String cert = getCertByDn(sCertDN,0); @@ -1772,6 +1956,43 @@ public class SydApi4j implements SydApi { return importCert(certData, organizationId, CertUsage.encipherOnly); } + @Override + public String importCert(String certData) { + Proto8009 proto = new Proto8009(); + // 填充数据 + HashMap packet = new HashMap(); + HashMap data = new HashMap(); + packet.put("data", data); + PacketSN sn = PacketSN.gen(); + packet.put("header", sn.getSn().array()); + data.put("certData", certData.getBytes()); + // 渲染发送 + ByteBuffer bb = proto.rend(packet); + + synchronized (this) { + // 响应解析 + bb = syncRead(syncSend(bb)); + } + + Packet p = proto.parse(bb, packet); + Map ret = p.toMap(); + if ( + !Arrays.equals(sn.getSn().array(), ((PacketSection) ret.get("header")).getBytes()) + ) { + throw new SydApiException("包序号不匹配", -4); + } + ret = (Map) ret.get("data"); + PacketSection error = (PacketSection) ret.get("error"); + byte[] be = error.getBytes(); + + if ((0 != (be[0] ^ be[1]))) { + throw new SydApiException(error.getInfo(), error.autoInt()); + } + + return CertUtil.getDN(certData); + } + + @Override public boolean deleteCert(String dn) { Proto8011 proto = new Proto8011(); @@ -1866,10 +2087,12 @@ public class SydApi4j implements SydApi { // System.out.println(s1); RetWrap r = new RetWrap(); r.put("retCode", true); + r.put("isImport", 0); if ((0 != (be[0] ^ be[1]))) { r.put("retCode", false); + r.put("isImport", 1); r.put("msg", error.getInfo() == null || "".equals(error.getInfo()) ? RetWrap.transMsg(error.autoInt()) : error.getInfo()); throw new SydApiException(error.getInfo(), error.autoInt()); } @@ -3268,6 +3491,101 @@ public class SydApi4j implements SydApi { } } + + @Override + public RetWrap generateDEByDnICBC(String certSerial,String IV, byte[] oData,int roundmod ) { + + // roundmod 轮模式，密钥加密模式：1=ECB,2=CBC + + certSerial = verifyDn(certSerial); + + RetWrap ret = new RetWrap(); + byte[] dnBytes = null; + try { + dnBytes = certSerial.getBytes("gbk"); + } catch (UnsupportedEncodingException e) { + e.printStackTrace(); + } + + // 查询完整证书 + String cert = getCertByDn(dnBytes); + println("cert=" + cert); + + try { + X509Certificate x509 = getX509Certificate(new ByteArrayInputStream(cert.getBytes())); + X500Principal issuser = x509.getIssuerX500Principal(); + + String pk = ByteUtils.toHexString(x509.getPublicKey().getEncoded()); + if (!pk.startsWith("03420004")) { + int i = pk.indexOf("03420004"); + if (i >= 0) { + pk = pk.substring(i); + } else { + pk = "03420004" + pk; + } + } + + + // 生成会话密钥 + ret = SM2GenSessionKey(pk); + String ciperKey = ret.get(SydApi.RET_CIPHER_KEY).toString(); + String sessionKeyByLMK = (String) ret.get(SydApi.RET_SESSION_KEY); + ret.put(SydApi.RET_SESSION_KEY, sessionKeyByLMK.getBytes()); + +// println("ciperKey=" + ciperKey); +// println("sessionKeyByLMK=" + sessionKeyByLMK); + + // 加密数据 + byte[] iv; + if(IV == null || IV.isEmpty()){ + String random = GenerateRandom(16); + System.out.println("random:"+random); + iv = random.getBytes(); + // Arrays.fill(iv, (byte) 0x30); + }else{ +// if(32 != IV.getBytes().length){ +// throw new SydApiException("IV长度需为32位", 0x81); +// } + iv = IV.getBytes(); + } + /** + * E0 指令复合接口 + * @param isEn 指定加解密，true为加密，false为解密 + * @param nAlg 密钥模式，当isEn为true时，默认为SM4加密，0为DES加密，1为AES256 加密。当isEn为false时，默认为SM4解密，0为DES解密，1为AES256解密 + * @param seesionKey 密钥 + * @param roundmod 轮模式，密钥加密模式：1=ECB,2=CBC,3=CFB,4=OFB + * @param fullMode 填充模式：0为饥饿模式，1为贪婪模式 + * @param pInData 消息数据 + * @param iv IV + * @param block 消息块号 + * @return + * iv: IV 数据域 + * msg_all: 消息数据 + */ + + RetWrap retWrap = SYMEnDeData(true, 1, sessionKeyByLMK, roundmod, 1, oData, iv, 0); + byte[] enData = (byte[]) retWrap.get("msg_all"); + // System.out.println("加密结果："+Util.bytes2HexString(enData)); + + // 组织格式 + ContentInfo cms = genCMSEnvelopedData(Util.hexString2Bytes(ciperKey), enData, + x509.getSerialNumber().toString(16), + dnToMap(issuser.getName()),Util.hexString2Bytes(new String(iv)) + ); + // System.out.println("信封结果："+Util.bytes2HexString(cms.getEncoded(DL))); + + ret.put(SydApi.RET_CIPHER_KEY, Util.encodeBase64(cms.getEncoded(DL))); + + return ret; + + } catch (SydApiException syde) { + throw syde; + } catch (Exception e) { + e.printStackTrace(); + throw new SydApiException("生成数字信封错误", -5); + } + } + @Override public RetWrap generateDEByDnRSA(int alg, String certSerial, byte[] oData) { if (oData.length <= 4 * 1024) { @@ -3819,6 +4137,51 @@ public class SydApi4j implements SydApi { return info; } + + public static ContentInfo genCMSEnvelopedData(byte[] sessionKeyDer, byte[] enData, String sn, Map issuer,byte[] iv) throws UnsupportedEncodingException { + //String tmpl = "3082014D06092A864886F70D010703A082013E3082013A0201003181F73081F40201003065305C310B300906035504061302434E3130302E060355040A0C274368696E612046696E616E6369616C2043657274696669636174696F6E20417574686F72697479311B301906035504030C1243464341205445535420534D32204F43413102051004282452300B06092A811CCF5501822D03047B307902203C3AF535307DA548DA02C0AD171D2BC24D22472B42E5E175FCAF2C5CD30B5443022100ED53E7594F35FFACEB57F05898123F78E5B2D045CC47D894CD2E7BD34D66DA1D042014BD71F8CDA9729093A7CC391E2009C5D5F007586C2EBFB55BC175A6E8BDA33E04104AB82510BFDDD4FEE79C3F107D6F7F94303B060A2A811CCF550601040201301B06072A811CCF55016804100000000000000000000000000000000080109FD3D4338DB19E672CC162AF5B9B03E9"; + String tmpl = "3082014E060A2A811CCF550601040203A082013E3082013A0201003181F73081F40201003065305C310B300906035504061302434E3130302E060355040A0C274368696E612046696E616E6369616C2043657274696669636174696F6E20417574686F72697479311B301906035504030C1243464341205445535420534D32204F43413102051004282452300B06092A811CCF5501822D03047B307902203C3AF535307DA548DA02C0AD171D2BC24D22472B42E5E175FCAF2C5CD30B5443022100ED53E7594F35FFACEB57F05898123F78E5B2D045CC47D894CD2E7BD34D66DA1D042014BD71F8CDA9729093A7CC391E2009C5D5F007586C2EBFB55BC175A6E8BDA33E04104AB82510BFDDD4FEE79C3F107D6F7F94303B060A2A811CCF550601040201301B06072A811CCF55016804100000000000000000000000000000000080109FD3D4338DB19E672CC162AF5B9B03E9"; + ContentInfo info = SydCmsUtil.getContentInfo(Util.hexString2Bytes(tmpl)); + // 修改 + ASN1Sequence seq = (ASN1Sequence) info.getContent().toASN1Primitive(); + + ASN1Set set = ASN1Set.getInstance(seq.getObjectAt(1).toASN1Primitive()); + ASN1Sequence seq2 = (ASN1Sequence) set.getObjectAt(0).toASN1Primitive(); + + // 会话密钥 + DEROctetString key = (DEROctetString) seq2.getObjectAt(3); + BeanUtil.setFieldValue(key, "string", sessionKeyDer); + + // 签发信息段 + ASN1Sequence seq3 = (ASN1Sequence) seq2.getObjectAt(1).toASN1Primitive(); + ASN1Integer isn = (ASN1Integer) seq3.getObjectAt(1).toASN1Primitive(); + BeanUtil.setFieldValue(isn, "bytes", Util.hexString2Bytes(sn)); + + ASN1Sequence seq4 = (ASN1Sequence) seq3.getObjectAt(0).toASN1Primitive(); + ASN1Set setO = (ASN1Set) seq4.getObjectAt(1).toASN1Primitive(); + ASN1Sequence seqO = (ASN1Sequence) setO.getObjectAt(0).toASN1Primitive(); + DERUTF8String o = (DERUTF8String) seqO.getObjectAt(1).toASN1Primitive(); + BeanUtil.setFieldValue(o, "string", issuer.get("O").getBytes("UTF-8")); + + ASN1Set setCN = (ASN1Set) seq4.getObjectAt(2).toASN1Primitive(); + ASN1Sequence seqCn = (ASN1Sequence) setCN.getObjectAt(0).toASN1Primitive(); + DERUTF8String Cn = (DERUTF8String) seqCn.getObjectAt(1).toASN1Primitive(); + BeanUtil.setFieldValue(Cn, "string", issuer.get("CN").getBytes("UTF-8")); + + // 密文段 + ASN1Sequence seq5 = (ASN1Sequence) seq.getObjectAt(2).toASN1Primitive(); + ASN1TaggedObject tag = (ASN1TaggedObject) seq5.getObjectAt(2).toASN1Primitive(); + DEROctetString data = (DEROctetString) tag.getObject(); + BeanUtil.setFieldValue(data, "string", enData); + + //iv段 + ASN1Sequence seq6 = (ASN1Sequence)seq5.getObjectAt(1).toASN1Primitive(); + DEROctetString ivtag = (DEROctetString) seq6.getObjectAt(1).toASN1Primitive(); + BeanUtil.setFieldValue(ivtag, "string", iv); + + return info; + } + public static ContentInfo genCMSEnvelopedDataRSA(byte[] sessionKeyDer, byte[] enData, String sn, Map issuer) throws UnsupportedEncodingException { String tmpl = "308201d506092a864886f70d010703a08201c6308201c20201003182017c3082017802010030623059310b300906035504061302434e3130302e060355040a13274368696e612046696e616e6369616c2043657274696669636174696f6e20417574686f72697479311830160603550403130f434643412054455354204f4341313102052003470933300b06092a864886f70d01010104820100e0f8d8cf94321e7b41452845e98d5998d8c0af8aaf63a5c67a05c27c82eac3f7251d0374e59a53af39898de43a6ed9e8ca642cf3b9d19be7529be767491452b990938199384f5f7f244055ed6472e29fec18103f868109cde28f40641ddaa3c408d0629c05ec8f34b1d629975f03e05734c9931f4eae9fce912a0f8e7f726b02f3696b31c6155c191b245c8ebbb381da6f19a0b5e00e3006a3084f6519874c871ae054eae1f723aaf20982d78864b72153e47960e606cc448ece1f75a8a2f08aab2b8773af1569089253c46b7c4deab20d47a671a7f5bf06546087b98885507b69bd186c73a658efbcdd2edd5b55ea515c38729dd386425132cd5a95b5cd8e2d303d060a2a811ccf550601040201301d060960864801650304012a041000000000000000000000000000000000801043cfb263acadf7f0a5071fd7f94282ab"; ContentInfo info = SydCmsUtil.getContentInfo(Util.hexString2Bytes(tmpl)); @@ -3866,6 +4229,47 @@ public class SydApi4j implements SydApi { } } + public RetWrap decryptDEByDNICBC(String certSerial, String IV,String pCipherKey,int roundmod) { + + certSerial = verifyDn(certSerial); + + byte[] dnBytes = null; + try { + dnBytes = certSerial.getBytes("gbk"); + } catch (UnsupportedEncodingException e) { + e.printStackTrace(); + } + + RetWrap ret = null; + + try { + ret = deCMSEnvelopedData(Util.decodeBase64(pCipherKey)); + } catch (Exception e) { + throw new IllegalArgumentException("数字信封解封格式错误"); + } + + byte[] sessionKeyDer = (byte[]) ret.get("sessionKeyDer"); + byte[] enData = (byte[]) ret.get("enData"); + + // 解密原文 + byte[] iv = Util.bytes2HexString((byte[]) ret.get("iv")).getBytes(); //new byte[32]; + System.out.println("实际iv值hex："+Util.bytes2HexString((byte[]) ret.get("iv"))); + if(null != IV && !IV.isEmpty()){ + iv = IV.getBytes(); + } + // 解密会话密钥 + ret = decryptDE(false, 1, dnBytes, Util.encodeBase64(sessionKeyDer)); + String sessionKey = new String((byte[]) ret.get("SessionKey")); + + RetWrap retWrap = SYMEnDeData(false, 1, sessionKey, roundmod, 1, enData, iv, 0); + byte[] data = (byte[]) retWrap.get("msg_all"); + + ret.put("oData", data); + + return ret; + + } + public RetWrap decryptDEByDNRSA(int alg, String certSerial, byte[] pCipherKey) { if (pCipherKey.length <= 4 * 1024) { diff --git a/src/test/java/sample/EasyPDF.java b/src/test/java/sample/EasyPDF.java new file mode 100644 index 0000000..fdd4af8 --- /dev/null +++ b/src/test/java/sample/EasyPDF.java @@ -0,0 +1,134 @@ +package sample; + +import com.google.zxing.*; +import com.google.zxing.client.j2se.BufferedImageLuminanceSource; +import com.google.zxing.client.j2se.MatrixToImageWriter; +import com.google.zxing.common.BitMatrix; +import com.google.zxing.common.HybridBinarizer; +import com.google.zxing.qrcode.QRCodeReader; +import org.junit.Test; + + +import javax.imageio.ImageIO; +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import java.util.Hashtable; + +public class EasyPDF { + + + @Test + public void test2(){ + String qrCodeText = "12345678"; + + // 图片输出路径 + String filePath = "./QRCode.png"; + String filePath2 = "./Code.png"; + + // 图片的尺寸（宽度和高度） + int width = 300; + int height = 300; + + // 设置二维码的相关参数 + Hashtable hintMap = new Hashtable<>(); + hintMap.put(EncodeHintType.MARGIN, 1); // 设置二维码的空白边距 + + try { + // 创建二维码矩阵 + BitMatrix bitMatrix = new MultiFormatWriter().encode( + qrCodeText, + BarcodeFormat.QR_CODE, + width, + height, + hintMap + ); + + + //生成条形码 + + // 生成 Code 128 条形码 + BitMatrix bitMatrix2= new MultiFormatWriter().encode( + qrCodeText, + BarcodeFormat.CODE_128, + width, + height, + hintMap + ); + + // 将二维码矩阵转换为图片，并保存 + File outputFile = new File(filePath); + + File outputFile2 = new File(filePath2); + MatrixToImageWriter.writeToFile(bitMatrix, "PNG", outputFile); + MatrixToImageWriter.writeToFile(bitMatrix2, "PNG", outputFile2); + + System.out.println("QR Code has been generated successfully!"); + } catch (Exception e) { + System.err.println("Error occurred while generating QR code: " + e.getMessage()); + } + } + + + @Test + public void test3(){ + // 加载二维码图像 + File qrCodeImage = new File("./QRCode.png"); + + // 读取二维码图像 + BufferedImage bufferedImage = null; + try { + bufferedImage = ImageIO.read(qrCodeImage); + } catch (IOException e) { + throw new RuntimeException(e); + } + + // 使用 ZXing 的 QRCodeReader 进行解码 + QRCodeReader reader = new QRCodeReader(); + LuminanceSource source = new BufferedImageLuminanceSource(bufferedImage); + BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source)); + + try { + // 解码二维码 + Result result = reader.decode(bitmap); + + // 提取二维码中的数据 + String qrCodeData = result.getText(); + System.out.println("QR Code Data: " + qrCodeData); + } catch (NotFoundException e) { + System.out.println("QR Code could not be read."); + } catch (ChecksumException e) { + throw new RuntimeException(e); + } catch (FormatException e) { + throw new RuntimeException(e); + } + } + + + @Test + public void test4(){ + // 条形码图片文件路径 + File barcodeImage = new File("./Code.png"); + + try { + // 读取条形码图像 + BufferedImage bufferedImage = ImageIO.read(barcodeImage); + + // 使用 ZXing 的 MultiFormatReader 进行解码 + MultiFormatReader reader = new MultiFormatReader(); + LuminanceSource source = new BufferedImageLuminanceSource(bufferedImage); + BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source)); + + // 解码条形码 + Result result = reader.decode(bitmap); + + // 提取条形码中的数据 + String barcodeData = result.getText(); + System.out.println("Barcode Data: " + barcodeData); + } catch (NotFoundException e) { + System.out.println("Barcode could not be read."); + } catch (IOException e) { + e.printStackTrace(); + } + } +} diff --git a/src/test/java/sample/GetHash.java b/src/test/java/sample/GetHash.java new file mode 100644 index 0000000..9dd3eea --- /dev/null +++ b/src/test/java/sample/GetHash.java @@ -0,0 +1,91 @@ +package sample; + +import com.sunyard.RetWrap; +import com.sunyard.proto.Util; +import com.sunyard.util.ASN1Util; +import com.sunyard.util.CertUtil; +import org.bouncycastle.asn1.ASN1Sequence; +import org.junit.Test; + +import java.io.IOException; +import java.security.NoSuchProviderException; +import java.security.cert.CertificateException; +import java.security.cert.X509Certificate; + +import static org.bouncycastle.cms.SydCmsUtil.readContentInfo; + +public class GetHash { + public static void main(String[] args) throws IOException, CertificateException, NoSuchProviderException { + String sign = "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"; + RetWrap retWrap = ASN1Util.takeOutOriginDataFromPKCS7Sign(sign); + String cert =(String) retWrap.get("cert"); + System.out.println(cert); + + String pemCert = null; + if(cert.contains("-----BEGIN CERTIFICATE-----")){ + pemCert =cert; + }else { + String cert_begin = "-----BEGIN CERTIFICATE-----\n"; + String end_cert = "\n-----END CERTIFICATE-----"; + pemCert = cert_begin + cert + end_cert; + } + + System.out.println(pemCert); + + + X509Certificate certificate = CertUtil.convertToX509Cert(pemCert); + String sigAlgName = certificate.getSigAlgName(); + System.out.println(sigAlgName); + System.out.println(sigAlgName.toUpperCase().contains("SHA1")); + + + } + + @Test + public void getDn() throws CertificateException, NoSuchProviderException { + String cert = "-----BEGIN CERTIFICATE-----\n" + + "MIIFNzCCBB+gAwIBAgIQewelBvoQTWilE9UF5pwiBDANBgkqhkiG9w0BAQsFADAz\n" + + "MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxETAPBgNVBAMMCFNIRUNB\n" + + "IEcyMB4XDTIzMDkwNzA3NTQ1MloXDTI2MDkwNzE1NTk1OVowge8xQjBABgNVBAMM\n" + + "Oea1i+ivleS4reWbveWGnOS4mumTtuihjOiCoeS7veaciemZkOWFrOWPuOS4iua1\n" + + "t+W4guWIhuihjDE8MDoGA1UECwwz5Lit5Zu95Yac5Lia6ZO26KGM6IKh5Lu95pyJ\n" + + "6ZmQ5YWs5Y+45LiK5rW35biC5YiG6KGMMTwwOgYDVQQKDDPkuK3lm73lhpzkuJrp\n" + + "k7booYzogqHku73mnInpmZDlhazlj7jkuIrmtbfluILliIbooYwxDzANBgNVBAcM\n" + + "BuS4iua1tzEPMA0GA1UECAwG5LiK5rW3MQswCQYDVQQGEwJDTjCCASIwDQYJKoZI\n" + + "hvcNAQEBBQADggEPADCCAQoCggEBAL6d0aFiewo3RkYA0sb3kMaH6bvlUNCw+FFN\n" + + "ZMWwqFCt5K2FrwRkfZjtNWVuF6MXVBX605D/mML85+hbCrKs/Rj6rq3V3ur1mYja\n" + + "2duNTBlT9WzrKSCdPP1ae9kSM8Fwde2w0tAGqn41kjQgn3nw8twPSqnG/mqDlzkV\n" + + "OCwaZoxNqHouOCL3OYTATDOj48e9c4Q9In5NXbUFeu16JP8Y9SSlusfZof7v8umq\n" + + "XlMfzIyw5tpA9hQGrBtmFRY41gM1j1JwO2/BjFtDVHDe4QxG2cmzc9T3YT2bN2+h\n" + + "tSAEZKbOxY4G3AUlPhgkxEJuzdFEN1zpgctAUnrUmDTy4chk6W8CAwEAAaOCAYgw\n" + + "ggGEMBQGA1UdJQQNMAsGCSqGSIb3LwEBBTB9BggrBgEFBQcBAQRxMG8wOAYIKwYB\n" + + "BQUHMAGGLGh0dHA6Ly9vY3NwMy5zaGVjYS5jb20vb2NzcC9zaGVjYS9zaGVjYS5v\n" + + "Y3NwMDMGCCsGAQUFBzAChidodHRwOi8vbGRhcDIuc2hlY2EuY29tL3Jvb3Qvc2hl\n" + + "Y2FnMi5kZXIwHwYDVR0jBBgwFoAUVoje4xhDgrdypCbrRKli0IfErCYwHQYDVR0O\n" + + "BBYEFK6AF/JiY5AhOi04JSg6KltgUy69MA4GA1UdDwEB/wQEAwIGwDAhBgkqgRyG\n" + + "7zoLgVIEFBMSOTEzMTAwMDAxMzIyMDI1MjhMMAwGA1UdEwEB/wQCMAAwIgYDVR0g\n" + + "BBswGTAKBggqgRyG7zoBAzALBgkqgRyG7zoBAgQwSAYDVR0fBEEwPzA9oDugOYY3\n" + + "aHR0cDovL2xkYXAyLnNoZWNhLmNvbS9DQTIwMDExL1JBMTIwNTAxMDAvQ1JMMTAw\n" + + "MDc0LmNybDANBgkqhkiG9w0BAQsFAAOCAQEAaNG0Zl2W4RlCM934eaZFp30Sj3kx\n" + + "EHBtZ4x1FXrjS0Vq+Jzflcb+3lVhfmt/FiaPA+ShF1vxy0UOO9tszs3Wj8gWX6p8\n" + + "W2uNaOdq9PCk6Y0N4x8U0LEzWGBj0dXfEK8UZxMrorzsZWN8LO1imUFVbu+WV+9M\n" + + "eRP7RIF3Y9Ah8QCozMvzHk7z4JRMgRoe6GtE0ehevph93YFNdTamulLTjt5hZaFU\n" + + "SFZL028+RVa7k2DhQetZuUdD1/DBLTrlz8DqGHYHptifDtZapPALGr4nx94YChMT\n" + + "OsOvFugFTrtg0H3vWTRX4Al5mftx356VE8nt9A/6DYA7sGnFRKDPMoIPCg==\n" + + "-----END CERTIFICATE-----\n"; + X509Certificate certificate = CertUtil.convertToX509Cert(cert); + String sigAlgName = certificate.getSubjectDN().toString(); + System.out.println(sigAlgName); + System.out.println(certificate.getSubjectDN().toString()); + System.out.println(sigAlgName.toUpperCase().contains("SHA1")); + } + + + @Test + public void getOID(){ + String sign = "MIIBOwYJKoZIhvcNAQcDoIIBLDCCASgCAQAxgdUwgdICAQAwQzA5MQswCQYDVQQGEwJDTjEOMAwGA1UECgwFR01TU0wxGjAYBgNVBAMMEU1pZGRsZUNBIGZvciBUZXN0AgYBkZGPx4AwCwYJKoEcz1UBgi0DBHsweQIgfLZlDgJJ9201wsYsQ9S4KNvOlgrX0WtZGPQBXPKRTG0CIQD2PthXQ7hHnxN287jAbHqQXaeDuVC3ohQ06Pv+eMzruQQgG8iD0R2vtl//q1JkdWjIwibgL3ZdNWkrJEEiNw2NqEkEEHT7hJTar0bnrKlE5BxCIJIwSwYKKoEcz1UGAQQCATAbBgcqgRzPVQFoBBAT1Kuxlcocuacphn3Iadr6gCB26bmHVsH8aQrj7tTACj2PmdMxALYkI2eUKmiJTH/96Q=="; + Object pkContent = readContentInfo( Util.decodeBase64(sign) ); + ASN1Sequence pkSeq = ASN1Sequence.getInstance( pkContent ); + + } +} diff --git a/src/test/java/sample/Sample4GH.java b/src/test/java/sample/Sample4GH.java index 86a204d..7336ba2 100644 --- a/src/test/java/sample/Sample4GH.java +++ b/src/test/java/sample/Sample4GH.java @@ -1,39 +1,63 @@ package sample; import com.sunyard.proto.Util; +import org.junit.Test; import racal.sunyard.main.SydApi4j; import racal.sunyard.main.SydApiBuilder; public class Sample4GH { - private static final String SM2dn = "C=CN,O=CFCA OCA1,OU=YCCA,OU=Individual-2,CN=YCCA@黄金交易所@Zhuangj@1"; + private static final String SM2dn = "C=CN,OU=cfca,CN=20202055611728611409939"; private static final String SM2dn2 = "C=CN,O=SM2,OU=test,CN=1"; private static final String RSAdn = "C=cn,O=CFCA TEST CA,OU=NCS2,OU=Enterprises,CN=041@Z402451000010@ShanDong@00000001"; private static final byte[] orgData = new byte[ 1024]; public static void main(String[] args) { - + System.setProperty("com.sunyard.sydapi4j.debug", "true"); //设置连接 - SydApiBuilder builder = new SydApiBuilder().setIp("172.16.17.161"); - SydApi4j api = (SydApi4j) builder.build(); +// SydApiBuilder builder = new SydApiBuilder().setIp("172.16.17.134"); +// SydApi4j api = (SydApi4j) builder.build(); - byte[] nakedSign = api.SYD_NakedSign(SM2dn, orgData, (byte[]) null); - System.out.println("裸签"+nakedSign); - boolean nakedVerify = api.SYD_NakedVerify(SM2dn, nakedSign, orgData, (byte[]) null); - System.out.println("裸签验签"+nakedVerify); + SydApiBuilder builder2 = new SydApiBuilder().setIp("172.16.17.112"); + SydApi4j api2 = (SydApi4j) builder2.build(); - String detachedSign = api.detachedSign(1, orgData, SM2dn); +// byte[] nakedSign = api.SYD_NakedSign(SM2dn, orgData, (byte[]) null); +// System.out.println("裸签"+nakedSign); +// +// boolean nakedVerify = api.SYD_NakedVerify(SM2dn, nakedSign, orgData, (byte[]) null); +// System.out.println("裸签验签"+nakedVerify); + + String detachedSign = api2.detachedSign(1, orgData, SM2dn); System.out.println("det签名"+detachedSign); - boolean detachedVerify = api.detachedVerify(1, orgData, detachedSign); - System.out.println("det验签"+detachedVerify); +// boolean detachedVerify = api.detachedVerify(1, orgData, detachedSign); +// System.out.println("det验签"+detachedVerify); - String attachedSign = api.attachedSignHsm(orgData, SM2dn); - System.out.println("att签名"+attachedSign); - boolean attachedVerify = api.attachedVerify(attachedSign.getBytes()); - System.out.println("att验签"+attachedVerify); +// boolean detachedVerify = api.detachedVerify(1, orgData, detachedSign); +// System.out.println("det验签"+detachedVerify); + +// String attachedSign = api.attachedSignHsm(orgData, SM2dn); +// System.out.println("att签名"+attachedSign); +// +// boolean attachedVerify = api.attachedVerify(attachedSign.getBytes()); +// System.out.println("att验签"+attachedVerify); + + } + + @Test + public void test11(){ + System.setProperty("com.sunyard.sydapi4j.debug", "true"); + SydApiBuilder builder2 = new SydApiBuilder().setIp("172.16.17.112"); + SydApi4j api = (SydApi4j) builder2.build(); + + String data = "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"; + System.out.println(new String(Util.decodeBase64(data))); + + String sign = "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"; + boolean detachedVerify = api.detachedVerify(2, 0, Util.decodeBase64(data), sign); + System.out.println(detachedVerify); } } diff --git a/src/test/java/sample/Sample4P1.java b/src/test/java/sample/Sample4P1.java new file mode 100644 index 0000000..aaee03c --- /dev/null +++ b/src/test/java/sample/Sample4P1.java @@ -0,0 +1,149 @@ +package sample; + +import com.sunyard.RetWrap; +import com.sunyard.SydApi; +import com.sunyard.proto.Util; +import com.sunyard.util.CertUtil; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import racal.sunyard.main.SydApi4j; + +import java.security.NoSuchProviderException; +import java.security.Principal; +import java.security.cert.CertificateException; +import java.security.cert.X509Certificate; + +/** + * @Author：Cheney + * @Date：2023/8/19 16:24 + */ +public class Sample4P1 { + private SydApi4j api; + + final String SM2dn = "C=CN,O=CFCA TEST CA,OU=NCS2,OU=Enterprises,CN=041@Z402451000010@ShanDong@00000001"; + byte[] orgData = new byte[8000]; + @Before + public void before() { + // 通过设置debug的属性开启debug，如果不设置则默认不打开 + System.setProperty("com.sunyard.sydapi4j.debug", "true"); + api = (SydApi4j) new SydApi4j().connect("172.16.17.161", 8889, null, 1000); + } + + @After + public void after() { + try { + this.api.disconnect(); + } catch (Exception e) { + e.printStackTrace(); + } + } + + @Test + //sm2算法 + public void sm2sign(){ + /** + * 正常证书 SM2 P1 裸签签名 + * @param orgData 原始数据 + * @param sm2Dn 签名者证书 DN + * @return 裸签签名数据 + */ + byte[] nakedSign = api.SYD_NakedSign(orgData,SM2dn); + System.out.println("裸签名："+Util.encodeBase64(nakedSign)); + + + /** + * 使用指定的证书 DN，对指定的原始数据编制裸验签（遵循PKCS#1） + * @param orgData 待签名的原始数据 + * @param sign 签名数据 + * @param sCertDN 签名者证书 DN + * @return 验签是否通过 + */ + boolean ver = api.SYD_NakedVerify(orgData, nakedSign,SM2dn ); + System.out.println("验签："+ver); + + } + + @Test + public void getDn() throws CertificateException, NoSuchProviderException { + String cert ="-----BEGIN CERTIFICATE-----\n" + + "MIIFFzCCA/+gAwIBAgIQVZErQ4caem9EAi7zgWIlMzANBgkqhkiG9w0BAQsFADAz\n" + + "MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxETAPBgNVBAMMCFNIRUNB\n" + + "IEcyMB4XDTI0MDMyNzAzMTUyNVoXDTI1MDMyNzE1NTk1OVowgb8xCzAJBgNVBAYT\n" + + "AkNOMQ8wDQYDVQQIDAbkuIrmtbcxDzANBgNVBAcMBuS4iua1tzEqMCgGA1UECgwh\n" + + "5Lit5Zu95Lq65rCR6ZO26KGM5LiK5rW35biC5YiG6KGMMSowKAYDVQQLDCHkuK3l\n" + + "m73kurrmsJHpk7booYzkuIrmtbfluILliIbooYwxNjA0BgNVBAMMLea1i+ivleS4\n" + + "reWbveS6uuawkemTtuihjOS4iua1t+W4guWIhuihjOetvuWQjTCCASIwDQYJKoZI\n" + + "hvcNAQEBBQADggEPADCCAQoCggEBALqXQHI6GeefK4pu/KLVLZDvrjNjcAVKxr1m\n" + + "Czu+uwhrMIdelr+72Tj+8tsC8dRdRKEti9lNZ2eKCiI56gKjg6nJiByhVnCju5No\n" + + "jqiOyvhgIGl4TulDK9Oq1nTX3MuNfWJuwG9fsa749pBGvvdvXglkOeZTbZ9hrMJ7\n" + + "ga4ft9vZZYTc8syPxJNnoPDCbDqiPBg9+U6ECI/6UZ4p7nV8Q8BaopkhKqqrpUQR\n" + + "+sygk8V7QX7D3E1TDeoxwFHyNBKpBRonGI2DwfdpxG0aq916MGdoHSWcvu5XxpfO\n" + + "nMf8Ur8qK7XO3F5pla8sbXeOesL8aNMw/f5/uM+Xt6YQPfKKs88CAwEAAaOCAZgw\n" + + "ggGUMB8GA1UdIwQYMBaAFFaI3uMYQ4K3cqQm60SpYtCHxKwmMB0GA1UdDgQWBBSk\n" + + "pQSgIAR1k1zPq9A6//h/892n2TAOBgNVHQ8BAf8EBAMCBsAwFAYDVR0lBA0wCwYJ\n" + + "KoZIhvcvAQEFMCIGA1UdIAQbMBkwCgYIKoEchu86AQMwCwYJKoEchu86AQIEMAwG\n" + + "A1UdEwEB/wQCMAAwWAYDVR0fBFEwTzBNoEugSYZHaHR0cDovL2xkYXAyLnNoZWNh\n" + + "LmNvbS9hYzg4NDg2MC9kODQ4L2VjOGYvYjkzYTQ1ZTYvOTFjYTEzOTBhMmFlNWM3\n" + + "MC5jcmwwfQYIKwYBBQUHAQEEcTBvMDgGCCsGAQUFBzABhixodHRwOi8vb2NzcDMu\n" + + "c2hlY2EuY29tL29jc3Avc2hlY2Evc2hlY2Eub2NzcDAzBggrBgEFBQcwAoYnaHR0\n" + + "cDovL2xkYXAyLnNoZWNhLmNvbS9yb290L3NoZWNhZzIuZGVyMCEGCSqBHIbvOguB\n" + + "UgQUExIxMTMxMDAwMDAwMjQwNzIwWEowDQYJKoZIhvcNAQELBQADggEBALmYF/nZ\n" + + "jed5UiqBpb8mA9xIxJRi4QD5c6Mmww3Ks9cLq72RiLQV0QG+sjApPHTOosRka0l7\n" + + "oqUyQhMzATHFUW/cjFuYVLwjvSANNPVtxKJxHPe105DA+34CPxwd25DeMvhNsq5X\n" + + "sEMiLVZacA9RD1pGI8KlmnA9SK7ZzN3yf1exMbVYb3LqQH9kW2BfBX83reewiF1N\n" + + "1TlLDCsEd41pF20twpw6xWUKekXW7Tok0gR9c5+lpWH6gtZiQvFUp05VbbuVhmee\n" + + "zGYX8e9202S7YYEY+A9+4CIN+u7JYbI88Zr2HY5RErTeDcZGHKD/3c2aPwaE1lFb\n" + + "aEACH34c7sDBTTE=\n" + + "-----END CERTIFICATE-----"; + String pemCert = null; + if(cert.contains("-----BEGIN CERTIFICATE-----")){ + pemCert =cert; + }else { + String cert_begin = "-----BEGIN CERTIFICATE-----\n"; + String end_cert = "\n-----END CERTIFICATE-----"; + pemCert = cert_begin + cert + end_cert; + } + + System.out.println(pemCert); + + X509Certificate certificate = CertUtil.convertToX509Cert(pemCert); + String dn = certificate.getSubjectDN().toString(); + System.out.println(dn); + ; + } + + @Test + public void ver(){ + SydApi4j api = (SydApi4j) new SydApi4j().connect("172.16.17.134", 8889, null, 1000); + String data = "2024-10-11T17:22:18farms.107.001.01B00000110000234032069546MHkCIQCRl/FXCJP7TriAhT6SLrN1GUb4o7tujxHC9j/UGJftOwIgSK/nzCTmNSrA1jYO9G/PiToSTptTCexEJ2o7QYOfwWgEIPs+BFe8v7K0DoyXCBf4drsWPzifKaVwPeQFOaK9IKkiBBD6NkgVbBVCeXLc2pzjA8OG4067545618202410111721520429258551130010121B9999999999090C10202110000342024-10-11T17:21:52270103Wiwdanx6NtGjjUA+Qb5rbHddhfvAtT1fa8s6wgiqjamQCq3NWu5K4uYt/efuEXR7Alu6whWgMPjSQnn2/d0P1/I4N2F4m0kxy5HYSrQwpnB0x98zXvX/aDLvbcCY9zO5DyWUMpJhLv28NP0ikiXQEQChcp23C8MSWYZy1HaM/jaLWBuaLDvhiDaDvu9EC+T9GmOfbC2zgGaKZPnSMMXHvK1OVrTwKcvOe3xUsHkUY5FdPshrCIsyWH3PfH8Yc+CmPSf1b/iO5szOVmUgw6dXNqZ+3j3BJlitNvPTs4KeZtDgIT1MBa/yy6yPGw/h1NiWgqXBPvT6IwsxSMAqw4jQmFMfKJ7m9bXwi130lRVcI1/5KJtDf7CwuGnmnrKdVucJTAlqh8iUqs/zOgz0bnAbbayyqJsi/6ksTDrMjp/hFybiboSyG2L6+58yMwcI4zGZcZdbGwrftRxeq/ceTiF2mztDK4PtdXy9aqLrsazZyvvUiFDHOepZW1h4ccIA/NMOYK5WS5IgpXve4msLJlU5QVAqfntj1YsiITnwLoIsn6QjmrjmoMwOPLRg9kTGsxH/ScMpoTGE2wmXnYRR0PJxZ2Acm+LZlIneqaRQgv9wZ/l6Gf6A0Zb7nwdsjSjnvOIH13US8p3wbBBybHuzmgLhYJIVkvnA9TcP5PreN0+sLa3fLMkc1Xpxnkc5A/Zar0WfHb3MhXZeA1w8vzANBq5ocDygzqqSHzHlSgVZ6x85GbSPDMrCEsZb5NSODiyNWOfTAcV2cltlGsVlC+YF5mLySVojkwfhstMkoj7WoiG/ADf9vckBOLWmQvuh5289l/ih9hy+/uQ3SFBYVwi4m2CdYdSIUMc56llbWHhxwgD80w5YUNI59nZoVUGKwV+dBehsjwWHVVOoLGtLcJEbBpbDEdW9jL4I9oemSSXmEnoIjxhlnTMoKF22kYn8Q6ynmn5g/pJ+ziDqOcja8zRfM8vQk1SLvWmvnO8WiE/VR5B84xPVvYy+CPaHpkkl5hJ6CI8Y0ZAPQrsDF2A/udfY8pV+vLXpezGMoyLj/02lxtfTFpj11CjmHYjlrQAX8Vb1v4AN0PLwdz5ns3wTi+fj03B2p7y4Z5Cclp50sF4cInR4B7H6gq5CkUHFw3xLT6q1DjledSJ5EJNfSvl8WvU5MUEvwygNrWpYcvbqyOW70efoEYNrKpGy9T0RKDMuk5EsxLX++SibQ3+wsLhp5p6ynVbnCfOzW20qDzgYmqcSZ6Hq+1hSw/mTr3ZnncZuuqTY3TXKLcQOa7Q+iJQHayCwWs5R640GTv1ani1CBzywQXagLI/KPwecIfCCSJSIM//YNyttvxDm2Wk+TmJKU28CVOJXukiQyq0xnc8ac9LUZhkm+GDJQu0iJjkfwgeK3k6cfm30bGOhg0xAuvIcgWpmLVuKFiKKJuzMPpw6R5EpaYQMP7vsB5wjIpHr81iFHGAGRi8WkJWwQTxMBiSR303A1iRB1ncx76YhSDoZza851fEA80HizZy+fBanI5SQJx1K9kwaDYc+hfaWNqvERhE4sr9w1gzek5iyJsjiL2D1D/I/ahGAfJ5qvaEpr4yFp2TnS1yI1UDJLXBIX/clayNlMMHzIgiisfe5r2xcJYfWrNTJaXHywrBopfB8hA8MpXd8YnYxJDjnXBmo1fWgku9YegHmi0+V1pldLw7WA7BX3Ou2QoSIRsQiyclXPZylW6N1YavYxByGDxrXfzLIufJ8Od6lPFoPEbb9Nld2xfk7KUKUBX1dOLb77/ZiBlywTE21qvQy8sKwaKXwfIQPDKV3fGJ2MfrE711rH6xvO7lpfUXRMWGMfpCccB83/p5hclHeUIPzQx7BvXSDFxt1pq5AxKjmmd270zEz3ZYBxM/Hm/pxUrk=000202{\"fileInfoList\":[{\"fileName\":\"FC_B9999999999090_C1020211000034_2024101117215204292585511300101.zip.sec\",\"idcList\":\"30\"}]}010302{\"policeInnerId\":\"1111111111\",\"applicationId\":\"030100000FZ2024092409441727142255391\"}01"; + //计算整个报文的hash值 + byte[] hash = api.SM3Hash(data.getBytes()); + + System.out.println("报文hash值hex："+ Util.bytes2HexString(hash)); + //对hash值签名 + byte[] nakedSign = api.SYD_NakedSign(data.getBytes(),SM2dn); + + boolean ver = api.SYD_NakedVerify(SM2dn,nakedSign, data.getBytes(),hash); + + boolean ver2 = api.SYD_NakedVerify( data.getBytes(),nakedSign,SM2dn); + System.out.println("验签结果："+ver); + + System.out.println("验签结果："+ver2); + + + + + } + + + + + + + + + + +} + diff --git a/src/test/java/sample/SampleICBC.java b/src/test/java/sample/SampleICBC.java new file mode 100644 index 0000000..5bc0b76 --- /dev/null +++ b/src/test/java/sample/SampleICBC.java @@ -0,0 +1,119 @@ +package sample; + +import com.sunyard.RetWrap; +import com.sunyard.SydApi; +import com.sunyard.proto.Util; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import racal.sunyard.main.SydApi4j; + +import java.util.HashMap; + +/** + * @Author：Cheney + * @Date：2024/8/09 16:24 + */ +public class SampleICBC { + private SydApi4j api; + + final String SM2dn = "C=CN,O=CFCA OCA1,OU=YCCA,OU=Individual-2,CN=YCCA@黄金交易所@Zhuangj@1"; + byte[] orgData = "12345678123456".getBytes(); + @Before + public void before() { + // 通过设置debug的属性开启debug，如果不设置则默认不打开 + System.setProperty("com.sunyard.sydapi4j.debug", "true"); + + //通过设置不校验证书是否反序 + System.setProperty("com.sunyard.dnsort", "false"); + api = (SydApi4j) new SydApi4j().connect("172.16.17.232", 8889, null, 1000); + } + + @After + public void after() { + try { + this.api.disconnect(); + } catch (Exception e) { + e.printStackTrace(); + } + } + + @Test + //证书导入 + public void importCert(){ + String cert = "-----BEGIN CERTIFICATE-----\n" + + "MIICMjCCAdWgAwIBAgIGAYqHSuwHMAwGCCqBHM9VAYN1BQAwSzELMAkGA1UEBhMC\n" + + "Q04xDjAMBgNVBAoTBUdNU1NMMRAwDgYDVQQLEwdQS0kvU00yMRowGAYDVQQDExFN\n" + + "aWRkbGVDQSBmb3IgVGVzdDAiGA8yMDIzMDkxMTE2MDAwMFoYDzIwMjQwOTExMTYw\n" + + "MDAwWjBgMQswCQYDVQQGDAJDTjELMAkGA1UECAwCemoxCzAJBgNVBAcMAmh6MRAw\n" + + "DgYDVQQKDAdzdW55YXJkMRAwDgYDVQQLDAd6eWhUZXN0MRMwEQYDVQQDDAp6eWhU\n" + + "ZXN0U00yMFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEYB3P271TUdDKfUr0VbkL\n" + + "v+N6QlrYcfAqbqjgqHaa3Xt5/8n3rHXp5ILj8QdU1pCFOF6xaaCwg1L7oR90MHZe\n" + + "GKOBiTCBhjAbBgNVHSMEFDASgBD5f1W0J5QzYqZWym/MXRr/MBkGA1UdDgQSBBAK\n" + + "g03SZSfU07aY4XNDfVIOMDEGCCsGAQUFBwEBBCUwIzAhBggrBgEFBQcwAYYVaHR0\n" + + "cHM6Ly9vY3NwLmdtc3NsLmNuMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgDAMAwG\n" + + "CCqBHM9VAYN1BQADSQAwRgIhAK1lDGV1UtbYz5Hf8DCpq8UySCtu5dguh/eZsc4c\n" + + "V9PtAiEA5SO99BSunZMtrpHFJC1XbEQ5Xp0zIJQvzjRqZwfkyrw=\n" + + "-----END CERTIFICATE-----\n"; + String dn = api.importCert(cert); + System.out.println("返回证书主题："+dn); + } + + + @Test + //sm2算法 attach签名验签 + public void sm2signAtt(){ + String attachedSign = api.attachedSign(orgData, SM2dn); + System.out.println("attach签名："+attachedSign); + + boolean attachedVerify = api.attachedVerify(attachedSign); + System.out.println("attach验签："+attachedVerify); + } + + + @Test + //sm2数字信封加密解密 + public void sm2gen(){ + + String ivHex = "31323334353637383132333435363738"; + + /** + * SM2数字信封生成 + * @param sm2Dn 证书DN + * @param IV iv + * @param orgData 原始数据 + * @param roundmod 轮模式 0 ECB 1 CBC + * @return 加密后的数据 + */ + RetWrap genByDn = api.generateDEByDnICBC(SM2dn, ivHex,orgData,1); + String cipherKey = (String) genByDn.get(SydApi.RET_CIPHER_KEY); + System.out.println("SM2数字信封: " +cipherKey); + + /** + * SM2数字信封解密 + * @param sm2Dn 证书DN + * @param IV iv + * @param cipherKey 数字信封 + * @param roundmod 轮模式 0 ECB 1 CBC + * @return 加密后的数据 + */ + RetWrap denSM2 = api.decryptDEByDNICBC( SM2dn,ivHex, cipherKey,1); + byte[] oData = (byte[]) denSM2.get("oData"); + System.out.println("SM2信封解密："+ new String(oData)); + + } + + @Test + public void getTIme(){ + + HashMap certTime = api.getCertTime(SM2dn); + System.out.println(certTime.get("after")); + System.out.println(certTime.get("before")); + + Util.bytes2HexString("aa".getBytes()); + } + + + +} + diff --git a/src/test/java/sample/Shangqing.java b/src/test/java/sample/Shangqing.java index bd7aa5f..3c3896b 100644 --- a/src/test/java/sample/Shangqing.java +++ b/src/test/java/sample/Shangqing.java @@ -16,7 +16,7 @@ public class Shangqing { // 测试数据 private String uid = "8012"; private String dn = "C=CN,ST=ZJ,L=HZ,O=sunyard,OU=test1,CN=test1"; - private String SM2dn = "C=CN,ST=zj,L=hz,O=sunyard,OU=sm2Test,CN=sm2Test"; + private String SM2dn = "C=CN,O=CFCA OCA1,OU=YCCA,OU=Individual-2,CN=YCCA@黄金交易所@Zhuangj@1"; private String RSA ="C=cn,O=CFCA TEST CA,OU=NCS2,OU=Enterprises,CN=041@Z402451000010@ShanDong@00000001"; @@ -26,8 +26,8 @@ public class Shangqing { public void before() { // 通过设置debug的属性开启debug，如果不设置则默认不打开 System.setProperty("com.sunyard.sydapi4j.debug", "true"); - // api = (SydApi4j) new SydApi4j().connect("172.16.17.161", 8889, null, 1000); - api = (SydApi4j) new SydApi4j().connect("192.168.0.100", 8889, null, 1000); + api = (SydApi4j) new SydApi4j().connect("172.16.17.161", 8889, null, 1000); + //api = (SydApi4j) new SydApi4j().connect("192.168.0.100", 8889, null, 1000); } diff --git a/src/test/java/sample/Test4Nongxin.java b/src/test/java/sample/Test4Nongxin.java index 81845f9..3d2a7dd 100644 --- a/src/test/java/sample/Test4Nongxin.java +++ b/src/test/java/sample/Test4Nongxin.java @@ -209,7 +209,7 @@ public class Test4Nongxin { System.setProperty("com.sunyard.sydapi4j.debug", "true"); //设置连接 - SydApiBuilder builder = new SydApiBuilder().setIp("192.168.0.156"); + SydApiBuilder builder = new SydApiBuilder().setIp("172.16.17.64"); SydApi4j api = (SydApi4j) builder.build(); String cert = "-----BEGIN CERTIFICATE-----\n" + diff --git a/src/test/java/sample/Test4NongxinCW.java b/src/test/java/sample/Test4NongxinCW.java new file mode 100644 index 0000000..aa97cf5 --- /dev/null +++ b/src/test/java/sample/Test4NongxinCW.java @@ -0,0 +1,166 @@ +package sample; + +import com.sunyard.SydApiException; +import com.sunyard.proto.Util; +import com.sunyard.util.CertUtil; +import com.sunyard.util.SYMUtil; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import racal.sunyard.main.SydApi4j; +import racal.sunyard.main.SydApiBuilder; + +import java.io.UnsupportedEncodingException; +import java.security.cert.X509Certificate; +import java.util.List; +import java.util.concurrent.ThreadFactory; + +import static com.sunyard.util.CertUtil.convertToX509Cert; + +public class Test4NongxinCW { + + private SydApi4j api; + + final String SM2dn = "C=CN,O=Sunyard,OU=8001,CN=8001"; + + byte[] orgData = new byte[100]; + + @Before + public void before() { + // 通过设置debug的属性开启debug，如果不设置则默认不打开 + api = (SydApi4j) new SydApi4j().connect("172.16.17.34", 8889, null, 1000); + + } + + @After + public void after() { + try { + this.api.disconnect(); + } catch (Exception e) { + e.printStackTrace(); + } + } + + @Test + public void nakeSign(){ + //裸签 + byte[] nakedSign = api.SYD_NakedSign(orgData,SM2dn ); + System.out.println("SM2签名："+ Util.bytes2HexString(nakedSign)); + + //裸签验签 + boolean ver = api.SYD_NakedVerify(orgData,nakedSign, SM2dn); + System.out.println("SM2验签："+ ver); + } + + @Test + public void detSign(){ + //detach签名 + String detachedSign = api.detachedSign(orgData, SM2dn); + System.out.println("detach签名："+ detachedSign); + + //detach验签 + boolean ver = api.detachedVerify(orgData, detachedSign); + System.out.println("detach验签："+ ver); + } + + + @Test + public void folw(){ + String detSign = "MIICpQYKKoEcz1UGAQQCAqCCApUwggKRAgEBMQ4wDAYIKoEcz1UBgxEFADAMBgoqgRzPVQYBBAIBoIIByTCCAcUwggFooAMCAQICCDyTAAAAAAAlMAwGCCqBHM9VAYN1BQAwJjELMAkGA1UEBhMCQ04xFzAVBgNVBAMMDlN1bnlhcmRTTTJSb290MB4XDTE3MDUxNzAyNTI0NFoXDTIyMDcyNTAyNTI0NFowPTELMAkGA1UEBhMCQ04xEDAOBgNVBAoMB1N1bnlhcmQxDTALBgNVBAsMBDgwMDExDTALBgNVBAMMBDgwMDEwWTATBgcqhkjOPQIBBggqgRzPVQGCLQNCAAQ+2joQe3zDXMAFx/vwu05rQ6B+4U42BgPSLsoqYAstD6AwVdQA0SQDAPVGSLhJ0T9QszD/FDUbVkWxNoaCCmW7o2cwZTAOBgNVHQ8BAf8EBAMCAMAwEwYDVR0lBAwwCgYIKwYBBQUHAwEwHwYDVR0jBBgwFoAU93/arv8hxtk6eq2g+6z+AqVO1cEwHQYDVR0OBBYEFAMWZaY2AwaQTNiFLpsa0dyCzBZ6MAwGCCqBHM9VAYN1BQADSQAwRgIhAIl2ZHGfln5hedcousARzZ2yeUjUbxSFMmhMmr5t6Q6nAiEAvqYX/KpIcvnPyB/Yiil+oq6DFdVM6P3vDxBhU/8taXExgaAwgZ0CAQEwMjAmMQswCQYDVQQGEwJDTjEXMBUGA1UEAwwOU3VueWFyZFNNMlJvb3QCCDyTAAAAAAAlMAwGCCqBHM9VAYMRBQAwDQYJKoEcz1UBgi0BBQAERzBFAiEArdbDSpZUSvPTGjzPOhyJhR7BK8owUpQjcq8eKSH8Xa8CIFmGgCdsd5V8qzeOOB7QtKnjH9KoyoGe8bASpgquX2p6"; + String netSignHex = "304402202EC53E985C09575A64A7B96C8A23713165FB0733C800145F07B9D5F990F546070220046F854CA62DF93AF8F0D541CA8B8697957423182EE70BB03B678A920985004F"; + +// //从detach签名中获取证书 +// String certBySign = api.getCertBySign(detSign); +// //System.out.println("获取证书内容为："+certBySign); +// System.out.println(certBySign); + + String certBySign = "-----BEGIN CERTIFICATE-----\n" + + "MIIC2TCCAn2gAwIBAgIFIGhhlgkwDAYIKoEcz1UBg3UFADBdMQswCQYDVQQGEwJDTjEwMC4GA1UE\n" + + "CgwnQ2hpbmEgRmluYW5jaWFsIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MRwwGgYDVQQDDBNDRkNB\n" + + "IFRFU1QgU00yIE9DQTExMB4XDTIzMTAzMDAyMzQzNVoXDTI1MDkyOTAyMzQzNVowgY4xCzAJBgNV\n" + + "BAYTAmNuMR8wHQYDVQQKDBZDRkNBIENTIFRFU1QgU00yIE9DQTExMQ0wCwYDVQQLDARHRklYMRkw\n" + + "FwYDVQQLDBBPcmdhbml6YXRpb25hbC0xMTQwMgYDVQQDDCswNTFAWjQwMjM2MTAxODg4NkA0MDIz\n" + + "NjEwMTg4ODZHRklYQDAwMDAwMDAzMFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAECyoVBYoJB4gA\n" + + "KsQJCOXv4mRpK6+9r3ygeuHfVlfM/Ry05TVEmTnYAx1EvPnpgzDsgufEQU7oCjLTeznV0Ytc9qOB\n" + + "9TCB8jAfBgNVHSMEGDAWgBS+pn5NPXyPoFXmwS8JLiwgQ7NCfzBIBgNVHSAEQTA/MD0GCGCBHIbv\n" + + "KgECMDEwLwYIKwYBBQUHAgEWI2h0dHA6Ly93d3cuY2ZjYS5jb20uY24vdXMvdXMtMTUuaHRtMDoG\n" + + "A1UdHwQzMDEwL6AtoCuGKWh0dHA6Ly8yMTAuNzQuNDIuMy9PQ0ExMS9TTTIvY3JsMjkyMzYuY3Js\n" + + "MAsGA1UdDwQEAwID6DAdBgNVHQ4EFgQUEXk8fc+VwuPgF2uLzPJwLunm1mswHQYDVR0lBBYwFAYI\n" + + "KwYBBQUHAwIGCCsGAQUFBwMEMAwGCCqBHM9VAYN1BQADSAAwRQIhANBoYhm7RwzcWi0QJa4IeBW3\n" + + "jY4S64AdH/IWiO+aUyfPAiAu+9MrvCfd27KGZQKurf/djfbe5xBQg2CG6ae+Tax9lQ==\n" + + "-----END CERTIFICATE-----"; + + + //将证书导入设备，获取证书主题 + String dn = api.importCertAndGetDN(certBySign); + System.out.println("导入证书主题为："+dn); + + + //裸签名格式转换 + byte[] netSign = Util.hexString2Bytes(netSignHex); + //使用导入证书对裸签名验签 + boolean verify = api.SYD_NakedVerify(orgData, netSign, dn); + System.out.println("验证裸签名："+verify); + + + } + + + @Test + public void test(){ + String cert = "-----BEGIN CERTIFICATE-----\n" + + "MIIDNTCCAh2gAwIBAgIFE2lVIzcwDQYJKoZIhvcNAQEFBQAwITELMAkGA1UEBhMC\n" + + "Q04xEjAQBgNVBAoTCUNGQ0EgT0NBMTAeFw0yMjA0MjIwODIyMTVaFw0yNzA0MjIw\n" + + "ODIyMTVaMGQxCzAJBgNVBAYTAkNOMRIwEAYDVQQKEwlDRkNBIE9DQTExDzANBgNV\n" + + "BAsTBlRQQy1TMzEVMBMGA1UECxMMSW5kaXZpZHVhbC0xMRkwFwYDVQQDExBBUkNV\n" + + "NTIwMDAyNTI3MDg1MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC74cciiBbs\n" + + "UcfmBxVlMWtsILsc85erRngknMaMW6wFyBsfJGrcL0TC7EO5XIsJXRrJN32vWdoo\n" + + "6Qm8WUGour+hrSNDzJ7cVtNA1ragPIjlkmMgbDLD0UsEbjHmA902079Fktv35L4l\n" + + "Hqe/vBygXcUoWJsGY5+8ykmI8W0LYPRkVwIDAQABo4G0MIGxMB8GA1UdIwQYMBaA\n" + + "FNHb6YiC5d0aj0yqAIy+fPKrG/bZMDgGA1UdHwQxMC8wLaAroCmGJ2h0dHA6Ly9j\n" + + "cmwuY2ZjYS5jb20uY24vUlNBL2NybDMwMDgyLmNybDALBgNVHQ8EBAMCA+gwHQYD\n" + + "VR0OBBYEFMM/joQIWvRFdLOx0HarTXAtZk7RMCgGA1UdJQQhMB8GCCsGAQUFBwMC\n" + + "BggrBgEFBQcDBAYJKoZIhvcvAQEFMA0GCSqGSIb3DQEBBQUAA4IBAQANEhHR34gg\n" + + "iivRj9VTO2lS0StsHQy4A4seq9YmaQa6QZDUEndFwcxr5DN6CAf6xA1YiHG5FoYd\n" + + "yH4sLORUhdfzQUWle7ZTPn4TfFjddPh3RDHXMXOh+pHNgrSjXpdACwadHedJO5e4\n" + + "HqXI8wEoNovDA8HT4ucMmsZHbIyQMhxW9k+DgTHx8nvltqv3reoDou3ekQ1tSWvW\n" + + "nUteKp64vop1ktgiIKjLshKRaUmZO4/fo9EcJHCH51J6f/2TAM7S+IaFzXR/VWf3\n" + + "JaiaGbT8kAJI854SmKWqRE8HVzMo/NYNdP0M7xZ2kt68PVE/UIl20xWii9P2/7Oh\n" + + "KYAnLX1nKjbg\n" + + "-----END CERTIFICATE-----"; + + + String pemCert; + if(cert.contains("-----BEGIN CERTIFICATE-----")){ + pemCert =cert; + }else { + String cert_begin = "-----BEGIN CERTIFICATE-----\n"; + String end_cert = "\n-----END CERTIFICATE-----"; + pemCert = cert_begin + cert + end_cert; + } + X509Certificate certificate = null; + try { + certificate = convertToX509Cert(pemCert); + } catch (Exception e) { + throw new SydApiException( 0xC101, e ); + } + String dn = certificate.getSubjectDN().toString(); + System.out.println(dn); + String name = certificate.getSubjectDN().getName(); + System.out.println(name); + + String hex = "6D32F5C0151C8E25686E5016A1A3EE2118063C2FB83F941F01ED8C418563FCB5248BE6C50E504D19AC0CFA4573564F11878CBA3E2F2E40D8DAFD6CBD2929570223964D7C479639999C4CA3A84AFA3F791E296A3058F704DEB9BE5B96EEF5904A72DF5EA7CB88C1176B52292D9629784576D33F11D4DD721A585BAE359130DD5F"; + System.out.println(Util.encodeBase64(Util.hexString2Bytes(hex))); + + + } + + @Test + public void test2(){ + String index = "000000000000000000A00000000"; + String data = "12345678"; + String s = api.SYMEncrytByKeyIndex(index, data); + System.out.println(s); + } + +} diff --git a/src/test/java/sample/Test4WL.java b/src/test/java/sample/Test4WL.java index 95a172c..685b33a 100644 --- a/src/test/java/sample/Test4WL.java +++ b/src/test/java/sample/Test4WL.java @@ -15,14 +15,14 @@ import racal.sunyard.main.SydApi4j; public class Test4WL { private SydApi4j api; - final String SM2dn = "C=CN,O=1,OU=1,CN=1"; + final String SM2dn = "C=CN,ST=1,L=1,O=1,OU=1,OU=1,CN=1"; final String RSAdn = "C=CN,O=2,OU=2,CN=2"; byte[] orgData = new byte[100]; @Before public void before() { // 通过设置debug的属性开启debug，如果不设置则默认不打开 //System.setProperty("com.sunyard.sydapi4j.debug", "true"); - api = (SydApi4j) new SydApi4j().connect("172.16.18.91", 8889, null, 1000); + api = (SydApi4j) new SydApi4j().connect("172.16.17.82", 8889, null, 1000); } @After diff --git a/src/test/java/sample/TestQR.java b/src/test/java/sample/TestQR.java new file mode 100644 index 0000000..9ed5980 --- /dev/null +++ b/src/test/java/sample/TestQR.java @@ -0,0 +1,50 @@ +package sample; + +import com.sunyard.proto.Util; +import org.junit.Before; +import org.junit.Test; +import racal.sunyard.main.SydApi4j; + +public class TestQR { + SydApi4j api; + + String Sm2Dn = "C=CN,O=CFCA OCA1,OU=YCCA,OU=Individual-2,CN=YCCA@黄金交易所@Zhuangj@1"; + String RsaDn = "C=cn,O=CFCA TEST CA,OU=NCS2,OU=Enterprises,CN=041@Z402451000010@ShanDong@00000001"; + String odata = "123456787654321"; + @Before + public void before() { + // 通过设置debug的属性开启debug，如果不设置则默认不打开 + System.setProperty("com.sunyard.sydapi4j.debug", "true"); + + + api = (SydApi4j) new SydApi4j().connect("172.16.17.232", 8889, null, 1000); + + } + + + @Test + public void test1(){ + api.QRCodeSign(odata,Sm2Dn,"./QRcode.png"); + boolean b = api.QRCodeVer(Sm2Dn, "./QRcode.png"); + System.out.println(b); + } + @Test + public void test2(){ + api.BarCodeSign(odata,Sm2Dn,"./Barcode.png"); + boolean b = api.BarCodeVer(Sm2Dn, "./Barcode.png"); + System.out.println(b); + } + @Test + public void test3(){ + api.QRCodeSignRSA(2,odata,RsaDn,"./QRcodeRSA.png"); + boolean b = api.QRCodeVerRSA(2,RsaDn, "./QRcodeRSA.png"); + System.out.println(b); + } + @Test + public void test4(){ + api.BarCodeSignRSA(2,odata,RsaDn,"./BarcodeRSA.png"); + boolean b = api.BarCodeVerRSA(2,RsaDn, "./BarcodeRSA.png"); + System.out.println(b); + } + +}