对接海关总署电子口岸时遇到清单加密问题的总结

最新推荐文章于 2024-05-04 13:19:23 发布
最新推荐文章于 2024-05-04 13:19:23 发布
阅读量7.7k 收藏 11
点赞数 4
分类专栏： JAVA 文章标签： 海关总署 电子口岸 报文加密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zl453061296/article/details/54381490
版权

问题描述：

由于海关各个关区的申报都对接了总署，以前向各个关区申报的业务现在全部通过向总署申报，在向总署申报清单时遇到了报文加密问题，怎么加密也加不对。总署给的规则也不清晰，目前是第一家在做这个，所以也没人请教，特发此文用来记录下。

报文格式加密处理代码

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.Map;
import *.CertificateInfo;
import *.init.CustSwxaJm;
import *.XmlElement;
/**
 * <p>标题： 调用三未信安加密机加密</p>
 * <p>功能： 提供对海关总署报文加密的加密服务 </p>
 */
public class CustSwxaJmService
{
	private final CustSwxaJm		swxaJm;
	private final CertificateInfo	certificateInfo;

	public CustSwxaJmService(Map<String,Object> envParams)
	{
		this.swxaJm = new CustSwxaJm(envParams);
		this.certificateInfo = new CertificateInfo(envParams);
	}

	/**
	 * @param envParams
	 * @param index 密钥索引位置  (1:南沙,2:黄埔)
	 */
	public CustSwxaJmService(Map<String,Object> envParams, int index)
	{
		this.swxaJm = new CustSwxaJm(envParams, index);
		this.certificateInfo = new CertificateInfo(envParams, index);
	}

	/**
	 * 对加密节点进行预处理
	 * @param envParams
	 * @param ceb621Message
	 * @param encodeStr
	 */
	public void setSignatureXmlElement(XmlElement ceb621Message, String encodeStr)
	{
		String digestValueZY = swxaJm.getHash_SHAl(toHashText(ceb621Message));
		//增加  Signature
		XmlElement signature = new XmlElement("Signature");//1层
		signature.setAttribute("xmlns", "http://www.w3.org/2000/09/xmldsig#");
		ceb621Message.addSubElement(signature);
		//增加  Signature-SignedInfo
		XmlElement signedInfo = new XmlElement("SignedInfo");//2层
		signature.addSubElement(signedInfo);
		//增加  Signature-SignedInfo-CanonicalizationMethod
		XmlElement canonicalizationMethod = new XmlElement("CanonicalizationMethod");//3层
		canonicalizationMethod.setAttribute("Algorithm", "http://www.w3.org/TR/2001/REC-xml-c14n-20010315");
		signedInfo.addSubElement(canonicalizationMethod);
		//增加  Signature-SignedInfo-SignatureMethod
		XmlElement signatureMethod = new XmlElement("SignatureMethod");//3层
		signatureMethod.setAttribute("Algorithm", "http://www.w3.org/2000/09/xmldsig#rsa-sha1");
		signedInfo.addSubElement(signatureMethod);
		//增加  Signature-SignedInfo-Reference
		XmlElement seference = new XmlElement("Reference");//3层
		seference.setAttribute("URI", "");
		signedInfo.addSubElement(seference);
		//增加  Signature-SignedInfo-Reference-Transforms
		XmlElement transforms = new XmlElement("Transforms");//4层
		seference.addSubElement(transforms);
		//增加  Signature-SignedInfo-Reference-Transforms-Transform
		XmlElement transform = new XmlElement(signedInfo, "Transform");//5层
		transform.setAttribute("Algorithm", "http://www.w3.org/2000/09/xmldsig#enveloped-signature");
		transforms.addSubElement(transform);
		//增加  Signature-SignedInfo-Reference-DigestMethod
		XmlElement digestMethod = new XmlElement("DigestMethod");//4层
		digestMethod.setAttribute("Algorithm", "http://www.w3.org/2000/09/xmldsig#sha1");
		seference.addSubElement(digestMethod);
		//增加  Signature-SignedInfo-Reference-DigestValue
		XmlElement digestValue = new XmlElement("DigestValue");//4层
		//String digestValueJQ = "digestValue加签值";
		digestValue.setValue(digestValueZY);
		seference.addSubElement(digestValue);
		//增加  Signature-SignatureValue
		XmlElement signatureValue = new XmlElement("SignatureValue");//2层
		signature.addSubElement(signatureValue);
		String signatureValueJQ = swxaJm.getPrivateSign(toXmlText(ceb621Message, encodeStr));//getXMLStr(signedInfo, 2)
		//signatureValueJQ.replace("
", "\n");
		signatureValue.setValue(signatureValueJQ);
		//增加  Signature-KeyInfo
		XmlElement keyInfo = new XmlElement("KeyInfo");//2层
		signature.addSubElement(keyInfo);
		//增加  Signature-KeyInfo-KeyName
		XmlElement keyName = new XmlElement("KeyName");//3层
		String keyNameJQ = certificateInfo.getSerialNumber();
		keyName.setValue(keyNameJQ);
		keyInfo.addSubElement(keyName);
		//增加  Signature-KeyInfo-X509Data
		XmlElement x509Data = new XmlElement("X509Data");//3层
		keyInfo.addSubElement(x509Data);
		//增加  Signature-KeyInfo-X509Data-X509Certificate
		XmlElement x509Certificate = new XmlElement("X509Certificate");//4层
		String x509CertificateJQ = certificateInfo.getX509InfoBase64();
		//x509CertificateJQ.replace("
", "\n");
		x509Certificate.setValue(x509CertificateJQ);
		x509Data.addSubElement(x509Certificate);
	}

	/**
	 * 海关格式化XML内容
	 * @param xmlElement
	 * @param encodeStr
	 * @return
	 */
	public String toXmlText(XmlElement xmlElement, String encodeStr)
	{
		ByteArrayOutputStream os = new ByteArrayOutputStream();
		PrintStream out = new PrintStream(os);
		String nodeName = "Signature";
		//添加头结点 
		out.print(encodeStr);
		out.print('\n');
		list(xmlElement, out, 0, nodeName);
		return new String(os.toByteArray());
	}

	private String toHashText(XmlElement xmlElement)
	{
		ByteArrayOutputStream os = new ByteArrayOutputStream();
		PrintStream out = new PrintStream(os);
		list(xmlElement, out, 0, "Signature");
		String xmlTest = new String(os.toByteArray());
		return xmlTest;
	}

	private void list(XmlElement xmlElement, PrintStream out, int baseIndent, String nodeName)
	{
		if (!existParentElement(xmlElement, nodeName))
		{
			for (int i = 0; i < baseIndent; i++)
			{
				out.print('\t');
			}
		}
		out.print("<" + xmlElement.qName);
		if (xmlElement.localName != null && xmlElement.localName.length() > 0)
		{
			out.print(" name=\"" + xmlElement.localName + "\"");
		}
		for (final String name : xmlElement.getAttributes().keySet())
		{
			out.print(" " + name + "=\"" + XmlElement.xmlEscape(xmlElement.getAttributes().get(name), 0xffff) + "\"");
		}
		int nSub = xmlElement.subElements.size();
		if (nSub == 0)
		{
			if (xmlElement.value != null && xmlElement.value.length() > 0)
			{
				out.print(">" + XmlElement.xmlEscape(xmlElement.value, 31) + "</" + xmlElement.qName + ">");
				if (!existParentElement(xmlElement, nodeName))
				{
					out.print('\n');
				}
			} else
			{
				out.print("/>");
				if (!existParentElement(xmlElement, nodeName))
				{
					out.print('\n');
				}
			}
		} else
		{
			out.print(">");
			if (!existParentElement(xmlElement, nodeName))
			{
				out.print('\n');
			}
			if (xmlElement.value != null && xmlElement.value.length() > 0)
			{
				if (!existParentElement(xmlElement, nodeName))
				{
					for (int i = 0; i < baseIndent + 1; i++)
					{
						out.print('\t');
					}
				}
				out.print(xmlElement.value);
				if (!existParentElement(xmlElement, nodeName))
				{
					out.print('\n');
				}
			}
			for (int i = 0; i < nSub; i++)
			{
				list(xmlElement.subElements.get(i), out, baseIndent + 1, nodeName);
			}
			for (int i = 0; i < baseIndent; i++)
			{
				if (!existParentElement(xmlElement, nodeName))
				{
					out.print('\t');
				}
			}
			out.print("</" + xmlElement.qName + ">");
			if (!existParentElement(xmlElement, nodeName))
			{
				out.print('\n');
			}
		}
	}

	/**
	 * 判断父节点中是否存在nodeName节点
	 * @param xmlElement 节点
	 * @param nodeName	比较节点
	 * @return
	 */
	private boolean existParentElement(XmlElement xmlElement, String nodeName)
	{
		boolean flag = false;
		String name = xmlElement.qName;
		if (nodeName.equals(name))
		{
			flag = true;
		} else
		{
			XmlElement pNode = xmlElement.getParentNode();
			if (pNode != null)
			{
				String pname = pNode.qName;
				if (nodeName.equals(pname))
				{
					flag = true;
				} else
				{
					flag = existParentElement(pNode, nodeName);
				}
			}
		}
		return flag;
	}
}
获取证书的代码 

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.security.cert.CertificateEncodingException;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.util.Map;
import org.apache.xml.security.utils.Base64;
/**
 * <p>标题： 证书信息</p>
 * <p>功能： 获取证书信息</p>
 */
public class CertificateInfo
{
	/**系统环境变量*/
	private final Map<String,Object>	envParams;
	/**证书地址*/
	private String						x509CertFilePath;
	/**证书*/
	private X509Certificate				x509Certificate;
	/**证书编号*/
	private String						SerialNumber;
	/**证书信息Base64编码*/
	private String						x509InfoBase64;

	public CertificateInfo(Map<String,Object> envParams)
	{
		this.envParams = envParams;
		init(1);
	}

	public CertificateInfo(Map<String,Object> envParams, int index)
	{
		this.envParams = envParams;
		init(index);
	}

	
	private void init(int index)
	{
		setX509CertFilePath(initX509CertFilePath(index));
		setX509Certificate(initX509Certificate());
		setSerialNumber(initSerialNumber());
		setX509InfoBase64(initX509InfoBase64());
	}

	/**
	* 证书地址
	* @return
	*/
	public String initX509CertFilePath(int index)
	{
		switch (index)
		{
		case 1:
			return CustSysOptions.getCertificateAddress(this.envParams);
		case 3:
			return CustSysOptions.getCertificateAddress_A(this.envParams);
		}
		return null;
	}

	/**
	 * 获取证书
	 * @return
	 */
	private X509Certificate initX509Certificate()
	{
		X509Certificate x509Cert = null;
		FileInputStream in = null;
		try
		{
			in = new FileInputStream(getX509CertFilePath());
			CertificateFactory cf = CertificateFactory.getInstance("X.509");
			x509Cert = (X509Certificate) cf.generateCertificate(in);
		} catch (FileNotFoundException e)
		{
			throw new RuntimeException("证书文件不存在，文件路径:" + getX509CertFilePath(), e);
		} catch (CertificateException e)
		{
			throw new RuntimeException("获取证书内容失败!", e);
		} finally
		{
			try
			{
				if (in != null)
				{
					in.close();
				}
			} catch (IOException e)
			{
				throw new RuntimeException("关闭读取证书的文件流失败！", e);
			}
		}
		return x509Cert;
	}

	/**
	 * 获取证书编号
	 * @return
	 * 赵力
	 */
	private String initSerialNumber()
	{
		String numberStr = getX509Certificate().getSerialNumber().toString(16);
		if (StrUtil.isNotNull(numberStr) && numberStr.length() < 16)
		{
			StringBuilder buf = new StringBuilder();
			int num = 16 - numberStr.length();
			for (int i = 0; i < num; i++)
			{
				buf.append("0");
			}
			numberStr = buf.toString() + numberStr;
		}
		return numberStr;
	}

	/**
	 * 获取证书信息BASE64编码
	 * @return
	 * 赵力
	 */
	private String initX509InfoBase64()
	{
		try
		{
			return Base64.encode(x509Certificate.getEncoded());
		} catch (CertificateEncodingException e)
		{
			throw new RuntimeException("获取证书信息BASE64编码失败", e);
		}
	}

	public String getX509CertFilePath()
	{
		return x509CertFilePath;
	}

	private void setX509CertFilePath(String x509CertFilePath)
	{
		this.x509CertFilePath = x509CertFilePath;
	}

	public X509Certificate getX509Certificate()
	{
		return x509Certificate;
	}

	private void setX509Certificate(X509Certificate x509Certificate)
	{
		this.x509Certificate = x509Certificate;
	}

	public String getSerialNumber()
	{
		return SerialNumber;
	}

	private void setSerialNumber(String serialNumber)
	{
		SerialNumber = serialNumber;
	}

	public String getX509InfoBase64()
	{
		return x509InfoBase64;
	}

	private void setX509InfoBase64(String x509InfoBase64)
	{
		this.x509InfoBase64 = x509InfoBase64;
	}
}
三未信安加密对象代码 

import java.io.IOException;
import java.io.StringReader;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.PrivateKey;
import java.security.Security;
import java.security.Signature;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.apache.xml.security.Init;
import org.apache.xml.security.c14n.CanonicalizationException;
import org.apache.xml.security.c14n.Canonicalizer;
import org.apache.xml.security.c14n.InvalidCanonicalizerException;
import org.apache.xml.security.utils.Base64;
import org.apache.xml.security.utils.IgnoreAllErrorHandler;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import com.sansec.jce.provider.SwxaProvider;
/**
 * <p>标题：三未信安加密对象 </p>
 * <p>功能：对发送总署的报文进行加密 </p>
 */
public class CustSwxaJm
{
	/**配置文件地址*/
	private String	swxaConfigFilePath;
	/**内部密钥位置*/
	private int		keyIndex;
	/**内部密钥*/
	private KeyPair	inKeyPair;
	/**外部密钥*/
	private KeyPair	outKeyPair;

	public CustSwxaJm(Map<String,Object> envParams)
	{
		init(envParams, 1);
	}

	public CustSwxaJm(Map<String,Object> envParams, int keyIndex)
	{
		init(envParams, keyIndex);
	}

	/**
	* 初始化加密对象
	*/
	private void init(Map<String,Object> envParams, int keyIndex)
	{
		setSwxaConfigFilePath(StrUtil.obj2str(DataConfig.getDataConfig(envParams, "swxaConfigFilePath")));
		initProvider();
		setKeyIndex(keyIndex);
		setInKeyPair(initInKeyPair());
		setOutKeyPair(initOutKeyPair());
	}

	/**
	 * 初始化配置文件
	 * 功能：加载配置文件并进行初始化
	 */
	private void initProvider()
	{
		SwxaProvider provider = new SwxaProvider(getSwxaConfigFilePath());
		Security.addProvider(provider);
	}

	/**
	* 生成内部密钥
	*/
	private KeyPair initInKeyPair()
	{
		KeyPair kp = null;
		try
		{
			KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "SwxaJCE");
			kpg.initialize(keyIndex << 16);
			kp = kpg.genKeyPair();
			if (kp == null)
			{
				throw new RuntimeException();
			}
		} catch (Exception e)
		{
			throw new RuntimeException("获取内部密钥失败");
		}
		return kp;
	}

	/**
	 * 生成外部密钥
	 */
	private static KeyPair initOutKeyPair()
	{
		KeyPair kp = null;
		try
		{
			int keylength = 1024;
			KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "SwxaJCE");
			kpg.initialize(keylength);
			kp = kpg.genKeyPair();
			if (kp == null)
			{
				throw new RuntimeException();
			}
		} catch (Exception e)
		{
			throw new RuntimeException("生成外部密钥失败");
		}
		return kp;
	}

	/**
	 * 生成HASH摘要
	 */
	public String getHash_SHAl(String xmlInfo)
	{
		byte[] plain_bytes;
		try
		{
			Init.init();
			Canonicalizer canonicalizer = Canonicalizer.getInstance(Canonicalizer.ALGO_ID_C14N_OMIT_COMMENTS);
			plain_bytes = canonicalizer.canonicalize(xmlInfo.getBytes());
		} catch (RuntimeException e)
		{
			throw new RuntimeException("报错内容", e);
		} catch (CanonicalizationException e)
		{
			throw new RuntimeException("报错内容", e);
		} catch (ParserConfigurationException e)
		{
			throw new RuntimeException("报错内容", e);
		} catch (IOException e)
		{
			throw new RuntimeException("报错内容", e);
		} catch (SAXException e)
		{
			throw new RuntimeException("报错内容", e);
		} catch (InvalidCanonicalizerException e)
		{
			throw new RuntimeException("报错内容", e);
		}
		String hashShal;
		MessageDigest md;
		try
		{
			md = MessageDigest.getInstance("SHA1", "SwxaJCE");
			md.update(plain_bytes);
			byte[] data = md.digest();
			hashShal = Base64.encode(data);
		} catch (Exception e)
		{
			throw new RuntimeException("加密机生成hash摘要失败");
		}
		return hashShal;
	}

	/**
	 * 进行加签
	 * @param strSignedInfo XML报文不包含头的文本
	 */
	public String getPrivateSign(String xmlText)
	{
		String privateSignatue;
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		factory.setNamespaceAware(true);
		factory.setValidating(true);
		byte[] bytes = null;
		try
		{
			DocumentBuilder builder = factory.newDocumentBuilder();
			builder.setErrorHandler(new IgnoreAllErrorHandler());
			//signedInfo
			Document doc = builder.parse(new InputSource(new StringReader(xmlText)));
			NodeList nodeList = doc.getElementsByTagName("SignedInfo");
			Node node = nodeList.item(0);
			Init.init();
			Canonicalizer canon = Canonicalizer.getInstance(Canonicalizer.ALGO_ID_C14N_OMIT_COMMENTS);
			//格式化
			bytes = canon.canonicalizeSubtree(node);
			PrivateKey privateKey = getInKeyPair().getPrivate();
			Signature signatue = null;
			signatue = Signature.getInstance("SHA1WithRSA", "SwxaJCE");
			signatue.initSign(privateKey);
			signatue.update(bytes);
			privateSignatue = Base64.encode(signatue.sign());
		} catch (Exception e)
		{
			throw new RuntimeException("加密机进行内部签名失败");
		}
		return privateSignatue;
	}

	private String getSwxaConfigFilePath()
	{
		return swxaConfigFilePath;
	}

	private void setSwxaConfigFilePath(String swxaConfigFilePath)
	{
		this.swxaConfigFilePath = swxaConfigFilePath;
	}

	public KeyPair getInKeyPair()
	{
		return inKeyPair;
	}

	private void setInKeyPair(KeyPair inKeyPair)
	{
		this.inKeyPair = inKeyPair;
	}

	public int getKeyIndex()
	{
		return keyIndex;
	}

	private void setKeyIndex(int keyIndex)
	{
		this.keyIndex = keyIndex;
	}

	public KeyPair getOutKeyPair()
	{
		return outKeyPair;
	}

	private void setOutKeyPair(KeyPair outKeyPair)
	{
		this.outKeyPair = outKeyPair;
	}
}

实际调用

package snsoft.customs.custentryelist.serv;

import java.math.BigDecimal;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * <p>标题： 海关总署进境清单导出监听</p>
 */
public class CustentryelistZSXmlListener
{
	protected final String			DATATYPE1	= "YYYYMMDDhhmmss";
	protected final String			DATATYPE2	= "YYYYMMDD";
	private static final String		MTABLE		= "custentryelist";
	private final CustSwxaJmService	swxaJmService;

	/**
	 * @param envParams
	 * @param parameter
	 * @param xmlObj
	 */
	public CustentryelistZSXmlListener(Map<String,Object> envParams, Map<String,Object> parameter, XmlExObject xmlObj)
	{
		super(envParams, parameter, xmlObj);
		this.swxaJmService = new CustSwxaJmService(envParams);
	}

	/**
	 * 加密对节点进行预处理
	 */
	@Override
	public void onXmlElementCreated(XmlElement xmlElement)
	{
		super.onXmlElementCreated(xmlElement);
		XmlElement ceb621Message = xmlElement.getSubElement("ceb:CEB621Message");
		String encodeStr = xmlObj.getXmlencoding();
		swxaJmService.setSignatureXmlElement(ceb621Message, encodeStr);
	}

	/**
	 * 海关格式化xml内容
	 */
	@Override
	public String toXml(XmlElement xmlElement)
	{
		XmlElement ceb621Message = xmlElement.getSubElement("ceb:CEB621Message");
		String encodeStr = xmlObj.getXmlencoding();
		return swxaJmService.toXmlText(ceb621Message, encodeStr);
	}

	
}






zl453061296
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 21
    评论
专栏目录
海关179加签原理及加签步骤介绍
alexyu01的博客
12-15 5712
海关179号公告对接,其中要用到一个usbkey加签数据上报,很多人多这个了解不够深入,导致对接困难,下面就加签原理进行阐述 1.为什么要用usbkey 法律责任,认定 2.加签原理 Sha1WithRsa 非对称加签 3.私钥加签公钥验证签名 4.实现 海关空间会起一个websocket服务器 wss: 61231 ws: 61232 5.加签方式 js,php,java,go,.net,python均可 ...
三未信安jec文档，加密机服务器配置说明文件
12-15
国密加密服务器密码机jce文档和加密机安装文档，包含putty.exe,swxajce使用指南，web挂你用户指南等
maven引入本地jar包的方法
little_spice的博客
04-16 1317
maven作为包管理工具，好处不必多说 但是有些情况，比如需要引入第三方包，如快递鸟，支付宝，微信等jar包（当然有可能直接提供maven依赖） 如果直接下载到本地之后，怎么整合到自己的maven工程呢？ 方式挺多的，下面列举四种方式 1. 上传到maven中心仓库 https://oss.sonatype.org/ 愿意折腾可也搞搞，可以参考如何发布Jar包到Maven中央仓库（确...
NoSuchProviderException的解决方案
最新发布
2301_79779756的博客
05-04 1046
NoSuchProviderException 是 Java 加密框架中的一个异常，它通常表示 Java 虚拟机（JVM）在尝试使用某个特定的安全提供者（Provider）时，无法找到或加载该提供者。安全提供者是 Java 加密框架中的一部分，它们提供了加密算法、密钥生成、签名等安全服务的具体实现。
SM4多线程流式加解密
IZZDJ的博客
03-20 245
【代码】SM4多线程流式加解密。
文件加密机（对文件加密）
08-28
对文件加密，支持3DES、blowfish、MD5、SHA等加密算法，自由软件
X509证书详解
热门推荐
weixin_43408952的博客
05-11 2万+
X509证书全面解读
跨境电商与海关对接开发资料文档
03-14
跨境电商，全称跨境电子商务，是国际贸易的一种新型模式，它通过电子平台进行交易，跨越国界，涉及商品和服务的购买、销售以及物流等多个环节。在这一过程中，与海关的对接至关重要，因为海关是国家对外贸易的主要...
电子发票对接文档.zip
04-13
9. **售后服务与技术支持**：在对接过程中遇到的问题，航信通常会提供相应的技术支持和服务，帮助企业解决问题，确保系统的正常运行。 10. **税务政策变化**：由于税务政策可能随时间调整，企业在使用电子发票系统...
【美团团购】第三方优惠码电子凭证平台对接文档V2版
04-24
【美团团购】第三方优惠码电子凭证平台对接文档V2版主要介绍了如何使商家在美团上售卖项目时，能够使用自己平台的券码进行验证。这一过程涉及到四个关键接口的对接，包括发券通知接口、查券接口、废券通知接口和验证...
179海关公告php接入 php最新版 海关报关申报清单申报
09-29
179海关公告php接入 php最新版
加密机操作指南
06-08
详细的加密机操作指南，是您快速掌握加密机的使用。
sunjce_provider.jar
02-05
Could not find class 'com.sun.crypto.provider.SunJCE', referenced from method ...不能加载到类的情况
海关对接订单申报php xml加签
02-06
还有一种是KJ开头的这种是公共平台的报文，这两种报文都能实现申报电子订单的申报，建议还是选择CEB格式的报文，这个是新版的报文，KJ好像是老版的，对接群里有用KJ报文对接三单对碰有问题转CEB的，所以最好还是用...
java xml 签名_Java SE 6中 XML 数字签名的标准 Java 接口
weixin_29879257的博客
02-12 727
Java SE 6中 XML 数字签名的标准 Java 接口孙 瑛霖2007 年 4 月 16 日发布1.技术背景1.1数字签名简介数字签名是非对称密钥技术的一种应用模式，用于保证报文的完整性，不可否认性，以及提供身份认证信息。数字签名的原理如图 1 所示。图 1：数字签名的原理发送者在发送报文之前，先选用某种摘要算法为报文生成一个摘要值，并使用自己的私钥对摘要值加密，然后将加密后的摘要附在报文后...
Linux下使用shell解压打包jar包
a13069730106的专栏
12-22 1万+
Linux 使用shell 解压打包jar
java调用公钥_java 使用byte生成公钥报错
weixin_35955928的博客
02-26 1198
我在使用java生成公钥的时候报了如下错误java.security.spec.InvalidKeySpecException: java.lang.IllegalStateException: DEF length 26 object truncated by 8at com.sansec.jce.provider.JDKKeyFactory.engineGeneratePublic(JDKKe...
海关179对接
mgq_1991的博客
12-17 6025
1.背景 http://www.customs.gov.cn/customs/302249/302266/302267/2155884/index.html 跨境电子商务平台企业支付相关原始数据必须对接179，否则会清关失败。 例：清单[电商企业编码：xxxx,订单编号：xxxxxxxx]报文校验失败:电商平台[xxx]未对接海关总署179号公告数据实时抓取业务，无法正常申报。 2.准备 第一步去海关注册备案拿到法人卡（用于服务注册管理）和操作员卡（或者ukey）（用于上传支付信息加签） 如果操

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值