AS2协议JAVA版

陈超娜

于 2024-07-24 04:30:28 发布

阅读量52

点赞数

文章标签：网络

在沃尔玛要求其供应商使用该协议之后，AS2（或Applicability Statement 2）快速流行起来。许多其他大型零售商也纷纷效仿，这意味着AS2迅速成为许多行业点对点连接的最流行EDI传输协议。

但是在国内，该协议使用的很少，资料也很稀缺，今天我把所学的知识整理一下，同时提供一个JAVA的实现版本，方便大家集成AS2。

数字摘要，加密，解密

在学习AS2协议之前，大家需要对基本的加密知识有所了解。

数字摘要

首先需要了解的是数字摘要，也叫数字指纹,数字签名，顾名思义，每段信息都有特定的指纹信息，就像人的指纹一样，通过指纹你就能确定人的身份。同理，通过数字指纹就能确定是哪一段信息。那这个有什么用呢？我们知道，网络传输是不安全的，比如你女朋友给你发消息，你怎么知道这段消息就是你女朋友发的？说不定是哪个骗子发的诈骗信息。或者你如何确定这段信息没被篡改过？说不定你的情敌在偷偷的篡改你们之间的通信来破坏你们间的感情。这时如果你女朋友通过某种算法根据这段信息生成一段数字摘要，然后随着这段信息发送给你，你通过比较原始信息和摘要是否能对应上，就能验证信息是否伪造，是否篡改了。

常见的摘要算法有MD5,SHA1,SHA256(也叫SHA2)。这几种算法安全性是递进的，耗时也是递进的。

MD5输出128bit,SHA1输出160bit,SHA256bit。

数字摘要的应用有签名,加密密码，校验文件是否损坏是否相同等。

数字摘要的缺点有两个，一个是会发生HASH碰撞，就是两段不同的信息会生成相同的指纹，虽然概率很低，MD5发生碰撞的概率为2的128次方之1,还有一个是会被暴力破解，比如使用字典记录所有信息和指纹的对应关系，就能通过指纹倒推原始信息，成本很高，但一些简单的信息都能查到。

对称加密

对称加密很容易理解，通过算法和秘钥对原文进行加密，得到密文，接受者拿到密文后再通过算法和秘钥进行解密，得到原文，这就是对称加密，对称加密的优点是简单，运算速度快，缺点是无法保证秘钥在传输过程中不被窃取，安全性不高。

常见的对称加密算法有DES,3DES,AES

DES是比较老的加密算法，已经不推荐使用了，3DES是DES的改进型，现在最常用的是AES

非对称加密

非对称加密的加密和解密用的不是同一个秘钥，它分为公钥和私钥，公钥加密私钥解密，或者私钥加密公钥解密，所以在使用非对称加密的时候需要和你的通信对象交换公钥，私钥自己保留，不对外开放，当你发送信息时使用自己的私钥加密后发送给对方，对方通过你的公钥解密，反之亦然。

常用的非对称加密算法是RSA。

非对称加密+对称加密

非对称加密的优点是安全性高，缺点是速度慢，对称加密的优点是速度快，缺点是安全性不高，有没有办法结合两方面的优缺点呢？答案当然是有的

比如使用RAS+3DES,首先随机生成3DES的秘钥,然后使用3DES加密你的内容，也就是长内容，再使用对方的公钥加密3DES的秘钥，也就是短内容,一起传输给对方，对方通过自己的私钥解密出3DES的秘钥，再通过3DES的秘钥解密长内容，是不是很巧妙。

生成证书库

要使用非对称加密，首先我们需要有证书，可以通过java的keytool工具来生成证书。

keytool -genkeypair -alias mykeystore -keyalg RSA -keysize 2048 -keypass mypassword -sigalg SHA256withRSA -dname "cn=www.justinqin.com,ou=justinqin,o=qjg,l=Shenzhen,st=Guangdong,c=CN" -validity 1095 -keystore D:/keys/mykeystore.keystore -storetype JKS -storepass mypassword

-genkeypair非对称密钥（密钥对，私钥签名、公钥验签），对称密钥为-gendeskey（单个密钥）

-alias mykeystore证书库别名为mykeystore

-keyalg RSA加密算法为RSA，加密算法可以分为对称加密、不对称加密和不可逆加密算法对称加密算法：加解密都用的同一把密钥，如DES、AES不对称加密算法：使用密钥对即公钥、私钥进行加解密，如RSA SHS不可逆加密算法：加密过程中不需要密钥，明文加密成密文后不可逆，如MD5MD5、SHS的加密都是用了哈希加密算法

-keysize 2048密钥长度，位数越大越安全，但同时加解密时间成正比增长

-keypass mypassword私钥密码为mypassword

-sigalg SHA256withRSA签名算法为SHA256withRSAkeyalg=RSA时，sigalg可选MD5withRSA、SHA1withRSA、SHA256withRSA、SHA384withRSA、SHA512withRSAkeyalg=DSA时，sigalg可选SHA1withDSA、SHA256withDSA

-dname "cn=www.justinqin.com,ou=justinqin,o=qjg,l=Shenzhen,st=Guangdong,c=CN"证书相关信息CN=名字与姓氏/域名OU=组织单位名称O=组织名称L=城市或区域名称ST=州或省份名称C=单位的两字母国家代码

-keystore D:/keys/mykeystore.keystore生成的证书库文件为mykeystore.keystore，存储位置D:/keys/

-validity 1095证书有效天数为3年=1095

-storetype JKS证书库类型为JKS，JDK1.9以前默认JKS，JDK1.9及以后默认PKCS12

-storepass mypassword证书库密码为mypassword

这个就是生成证书库的命令，既然是是库，说明可以包含多个证书，通过别名来区分，当从证书库中取证书时，需要知道别名，证书库的密码，当取私钥时还需要私钥的密码

导出公钥

keytool -export -alias mykeystore -keystore D:/keys/mykeystore.keystore -storepass mypassword -file D:/keys/publickey.cer

这个公钥需要给通信对象，这样对方就能解密你发送的密文了。

上一篇中主要讲解了加密的理论知识，这篇来上代码。

签名和验签

通过信息摘要算法和非对称加密，可以实现信息的防伪造，防篡改，通过我们的私钥来签名消息，接收方就能通过我们的公钥来校验该消息是否是我们发送的。

/**

* 获取证书库

*/public static KeyStore getKeyStore(InputStream keyStoreInputStream, String keyStorePassword, String keyStoreType) throws Exception {

return getKeyStore(keyStoreInputStream, keyStorePassword, keyStoreType);

}

public static KeyStore getKeyStore(InputStream keyStoreInputStream, String keyStorePassword, String keyStoreType, String provider) throws Exception {

KeyStore keyStore;

if (StringUtils.isNotBlank(provider)) {

keyStore = KeyStore.getInstance(keyStoreType, provider);

} else {

keyStore = KeyStore.getInstance(keyStoreType);

}

keyStore.load(keyStoreInputStream, keyStorePassword.toCharArray());

IoUtil.close(keyStoreInputStream);

return keyStore;

}

/**

* 从证书库中获取公钥

*/public static PublicKey getPublicKeyFromKeyStore(KeyStore keyStore, String alias) throws Exception {

Certificate certificate = keyStore.getCertificate(alias);

return certificate.getPublicKey();

}

/**

* 从证书库获取私钥

*/public static PrivateKey getPrivateKeyFromKeyStore(KeyStore keyStore, String alias, String password) throws Exception {

return (PrivateKey) keyStore.getKey(alias, password.toCharArray());

}

/**

* 签名

*/public static byte[] sign(byte[] message, PrivateKey privateKey, String algorithm) throws Exception {

Signature signature;

signature = Signature.getInstance(algorithm);

signature.initSign(privateKey);

signature.update(message);

return signature.sign();

}

/**

* 验签

*/public static boolean verify(byte[] message, byte[] signMessage, PublicKey publicKey, String algorithm) throws Exception {

Signature signature;

boolean verifyResult;

signature = Signature.getInstance(algorithm);

signature.initVerify(publicKey);

signature.update(message);

verifyResult = signature.verify(signMessage);

return verifyResult;

}

然后写个单元测试来验证下

@Testpublic void testVerify() throws Exception {

FileInputStream fis = new FileInputStream(new File("d:/keys/testkeystore.keystore"));

//获取证书库

KeyStore keyStore = getKeyStore(fis, "mypassword", "JKS");

//获取私钥

PrivateKey privateKey = getPrivateKeyFromKeyStore(keyStore, "mykeystore", "mypassword");

//摘要算法用SHA1,非对称加密算法用RSA进行签名

byte[] signMessage = sign(CONTENT.getBytes(), privateKey, "SHA1withRSA");

//获取公钥

PublicKey publicKey = getPublicKeyFromKeyStore(keyStore, "mykeystore");

//进行验签

boolean verify = verify(CONTENT.getBytes(), signMessage, publicKey, "SHA1withRSA");

System.out.println(verify);

}

加密和解密

/**

* 使用私钥加密

*/public static byte[] encodeByPrivateKey(byte[] data, PrivateKey privateKey) throws Exception {

// 对数据加密,加密算法由创建秘钥时指定，也可以自己指定,一般用RSA

Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());

cipher.init(Cipher.ENCRYPT_MODE, privateKey);

return cipher.doFinal(data);

}

/**

* 使用公钥解密

*/public static byte[] decodeByPublicKey(byte[] data, PublicKey publicKey)

throws Exception {

// 对数据加密

Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());

cipher.init(Cipher.DECRYPT_MODE, publicKey);

return cipher.doFinal(data);

}

/**

* 公钥加密

*/public static byte[] encodeByPublicKey(byte[] data, PublicKey publicKey)

throws Exception {

// 对数据加密

Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());

cipher.init(Cipher.ENCRYPT_MODE, publicKey);

return cipher.doFinal(data);

}

/**

* 私钥解密

*/public static byte[] decodeByPrivateKey(byte[] data, PrivateKey privateKey) throws Exception {

// 对数据加密

Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());

cipher.init(Cipher.DECRYPT_MODE, privateKey);

return cipher.doFinal(data);

}

单元测试

public static String CONTENT = "寥落古行宫，宫花寂寞红。白头宫女在，闲坐说玄宗";@Testpublic void testDecode() throws Exception {

FileInputStream fis = new FileInputStream(new File("d:/keys/testkeystore.keystore"));

KeyStore keyStore = getKeyStore(fis, "mypassword", "JKS");

PrivateKey privateKey = getPrivateKeyFromKeyStore(keyStore, "mykeystore", "mypassword");

PublicKey publicKey = getPublicKeyFromKeyStore(keyStore, "mykeystore");

//加密

byte[] encode = encodeByPrivateKey(CONTENT.getBytes(), privateKey);

//解密

byte[] message = decodeByPublicKey(encode, publicKey);

System.out.println(new String(message));

}

AS2协议本身比较复杂，我们不需要了解其中太多细节，只需要知道一些重要概念就行了。

AS2是基于HTTP/HTTPS的，消息的格式使用MIME,就是邮件的格式，使用SHA1或SHA2加RSA进行签名，使用S/MIME进行加密。S/MIME加密本质就是3DES或者AES加RSA加密，有了之前的基础应该就很清楚了。

AS2的通信双方称为partner,每个partner有个partnerId,通信双方需要交互彼此的公钥。

自己实现S/MIME加密比较复杂，我们引入以下包来加密，jdk15on支持jdk1.5-jdk1.8,其他jdk版可去maven上搜索对应的版本

<groupId>org.bouncycastle</groupId>

<artifactId>bcmail-jdk15on</artifactId>

</dependency>

接下来是实现AS2发送文件的JAVA版本

@Testpublic void testAS2() throws Exception {

//注册证书提供者BC

Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());

String password = "testas2";

//生成mime消息体，放入待发送文件

MimeBodyPart finalMessage = new MimeBodyPart();

File file = new File("D:\\workspace\\data\\a.xml");

finalMessage.setDataHandler(new DataHandler(new FileDataSource(file)));

finalMessage.setHeader("Content-Type", "application/xml");

finalMessage.setHeader("Content-Transfer-Encoding", "base64");

finalMessage.setFileName(file.getName());

//加载证书

FileInputStream fis = new FileInputStream(new File("D:\\workspace\\OpenAs2App\\Server\\src\\config\\as2_certs.p12"));

KeyStore keyStore = getKeyStore(fis, password, "PKCS12", "BC");

PrivateKey privateKey = getPrivateKeyFromKeyStore(keyStore, "mycompany", "password");

//签名

X509Certificate signCert = getCertificate(keyStore, "mycompany");

List certList = new ArrayList();

certList.add(signCert);

Store certs = new JcaCertStore(certList);

SMIMESignedGenerator signer = new SMIMESignedGenerator();

signer.setContentTransferEncoding("base64");

//使用SHA1进行签名

signer.addSignerInfoGenerator(new JcaSimpleSignerInfoGeneratorBuilder().setProvider("BC")

.build("SHA1WITHRSA", privateKey, signCert));

signer.addCertificates(certs);

MimeMultipart signedMimeMultipart = signer.generate(finalMessage);

finalMessage = new MimeBodyPart();

finalMessage.setContent(signedMimeMultipart);

finalMessage.setHeader("Content-Type", signedMimeMultipart.getContentType());

//加密

// 加载partner的数字证书

X509Certificate cert = getCertificate(keyStore, "partnera");

// 创建加密器

SMIMEEnvelopedGenerator encryptor = new SMIMEEnvelopedGenerator();

encryptor.addRecipientInfoGenerator(new JceKeyTransRecipientInfoGenerator(cert).setProvider("BC"));

encryptor.setContentTransferEncoding("base64");

//3DES加密

JceCMSContentEncryptorBuilder jceCMSContentEncryptorBuilder =

new JceCMSContentEncryptorBuilder(new ASN1ObjectIdentifier(SMIMEEnvelopedGenerator.DES_EDE3_CBC)).setProvider("BC");

jceCMSContentEncryptorBuilder.setSecureRandom(new SecureRandom());

// 进行加密

MimeBodyPart encryptedPart = encryptor.generate(finalMessage, jceCMSContentEncryptorBuilder.build());

//准备头字段

InternetHeaders ih = new InternetHeaders();

ih.addHeader("Connection", "close, TE");

ih.addHeader("Message-ID", UUID.randomUUID().toString());

ih.addHeader("Mime-Version", "1.0");

ih.addHeader("Content-Type", encryptedPart.getContentType());

ih.addHeader("AS2-To", "PartnerA_OID");

ih.addHeader("AS2-From", "MyCompany_OID");

ih.addHeader("Subject", "Subject: File a.xml sent from MyCompany to PartnerA");

ih.addHeader("Disposition-Notification-To", "edi@myCompany.com");

ih.addHeader("Content-Disposition", "attachment");

String url = "http://localhost:10080";

execRequest("POST", url, ih.getAllHeaders(), null, encryptedPart.getInputStream());

}

private static X509Certificate getCertificate(KeyStore keyStore,

String alias) throws Exception {

Certificate certificate = keyStore.getCertificate(alias);

return (X509Certificate) certificate;

}

发送http请求的代码

public static void execRequest(String method, String url, Enumeration<Header> headers, NameValuePair[] params, InputStream inputStream) throws Exception {

HttpClientBuilder httpBuilder = HttpClientBuilder.create();

URL urlObj = new URL(url);

* httpClient is used for this request only,

* set a connection manager that manages just one connection.

if (urlObj.getProtocol().equalsIgnoreCase("https")) {

* Note: registration of a custom SSLSocketFactory via httpBuilder.setSSLSocketFactory is ignored when a connection manager is set.

* The custom SSLSocketFactory needs to be registered together with the connection manager.

SSLConnectionSocketFactory sslCsf = buildSslFactory();

httpBuilder.setConnectionManager(new BasicHttpClientConnectionManager(RegistryBuilder.<ConnectionSocketFactory>create().register("http", PlainConnectionSocketFactory.getSocketFactory()).register("https", sslCsf).build()));

} else {

httpBuilder.setConnectionManager(new BasicHttpClientConnectionManager());

}

RequestBuilder rb = getRequestBuilder(method, urlObj, params, headers);

if (inputStream != null) {

InputStreamEntity ise = new InputStreamEntity(inputStream);

rb.setEntity(ise);

}

final HttpUriRequest request = rb.build();

try (CloseableHttpClient httpClient = httpBuilder.build()) {

try (CloseableHttpResponse response = httpClient.execute(request)) {

HttpEntity entity = response.getEntity();

String result = EntityUtils.toString(entity);

System.out.println(result);

}

private static SSLConnectionSocketFactory buildSslFactory() throws Exception {

boolean overrideSslChecks = true;

SSLContext sslcontext;

sslcontext = SSLContexts.createSystemDefault();

// String [] protocols = Properties.getProperty(HTTP_PROP_SSL_PROTOCOLS,

// "TLSv1").split("\\s*,\\s*");

HostnameVerifier hnv = SSLConnectionSocketFactory.getDefaultHostnameVerifier();

if (overrideSslChecks) {

hnv = new HostnameVerifier() {

@Override

public boolean verify(String hostname, SSLSession session) {

return true;

}

};

}

SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, null, null, hnv);

return sslsf;

}

private static RequestBuilder getRequestBuilder(String method, URL urlObj, NameValuePair[] params, Enumeration<Header> headers) throws URISyntaxException {

RequestBuilder req = null;

if (method == null || method.equalsIgnoreCase(Method.GET)) {

//default get

req = RequestBuilder.get();

} else if (method.equalsIgnoreCase(Method.POST)) {

req = RequestBuilder.post();

} else if (method.equalsIgnoreCase(Method.HEAD)) {

req = RequestBuilder.head();

} else if (method.equalsIgnoreCase(Method.PUT)) {

req = RequestBuilder.put();

} else if (method.equalsIgnoreCase(Method.DELETE)) {

req = RequestBuilder.delete();