基於HTTP在互聯網傳輸敏感數據的消息摘要、簽名與加密方案

時間  2019-11-18
標籤 基於 http 互聯網 傳輸 敏感 數據 消息 摘要 簽名 加密 方案 欄目 HTTP/TCP 简体版
原文   原文鏈接

基於HTTP在互聯網傳輸敏感數據的消息摘要、簽名與加密方案

博客分類：
簽名 加密 AES MD5 HTTPS 

1、關鍵詞java

HTTP，HTTPS，AES，SHA-1，MD5，消息摘要，數字簽名，數字加密，Java，Servlet，Bouncy Castlegit

 

2、名詞解釋算法

   數字摘要：是將任意長度的消息變成固定長度的短消息，它相似於一個自變量是消息的函數，也就是Hash函數。數字摘要就是採用單項Hash函數將須要加密的明文「摘要」成一串固定長度（128位）的密文這一串密文又稱爲數字指紋，它有固定的長度，並且不一樣的明文摘要成密文，其結果老是不一樣的，而一樣的明文其摘要一定一致。spring

   AES：密碼學中的高級加密標準（Advanced Encryption Standard，AES），又稱Rijndael加密法，是美國聯邦政府採用的一種區塊加密標準。這個標準用來替代原先的DES，已經被多方分析且廣爲全世界所使用。是一種對稱加密算法。apache

   SHA-1：安全哈希算法（Secure Hash Algorithm）主要適用於數字簽名標準 （Digital Signature Standard DSS）裏面定義的數字簽名算法（Digital Signature Algorithm DSA）。 SHA1有以下特性：不能夠從消息摘要中復原信息；兩個不一樣的消息不會產生一樣的消息摘要。安全

   MD5：Message Digest Algorithm MD5（中文名爲消息摘要算法第五版）爲計算機安全領域普遍使用的一種散列函數，用以提供消息的完整性保護。服務器

 

3、項目背景微信

   某合做公司須要經過互聯網向我司傳遞一些用戶數據，可是我所在項目組的外網服務器上並沒有部署https，只能基於http進行數據傳輸。爲了保護雙方共同的用戶數據，必須對在互聯網上傳輸的信息進行加密處理。app

 

4、方案設計微信公衆平臺

   這裏涉及到兩個問題，一是採用什麼樣的遠程消息傳遞框架，二是如何對傳輸的數據進行加密。

   本人平時開發所用的語言主要是Java，對於Jsp/Servlet還比較熟悉，結合去年參加過所在公司的微信公衆號開發的經驗，設計出了以下方案：

   1.在客戶端採用構造http post請求，把用戶數據加密後放入request body中，並在http參數中放入調用方的簽名；

   2.服務端接收到請求，提取參數進行簽名校驗，經過後從request body中提取密文進行解密，而後進行後續處理，最終生成響應返回給客戶端。

   如下是具體處理的流程圖：

 

   在數據加密階段，基於性能以及效率考慮，採用了Bouncy Castle提供的AES算法，而生成簽名則採用了jdk提供的SHA-1，值得注意的是，基於安全考慮，消息密文的消息摘要也被列入到參與數字簽名的參數之一。

 

5、代碼實現

1.AES加密工具類：

Java代碼   收藏代碼
  1. import org.apache.commons.lang.StringUtils;  
  2. import org.apache.log4j.Logger;  
  3. import org.bouncycastle.crypto.CipherParameters;  
  4. import org.bouncycastle.crypto.engines.AESFastEngine;  
  5. import org.bouncycastle.crypto.modes.CBCBlockCipher;  
  6. import org.bouncycastle.crypto.paddings.PaddedBufferedBlockCipher;  
  7. import org.bouncycastle.crypto.params.KeyParameter;  
  8. import org.bouncycastle.crypto.params.ParametersWithIV;  
  9. import org.bouncycastle.util.encoders.Hex;  
  10.   
  11. /** 
  12.  * AES encryption and decryption tool. 
  13.  *  
  14.  * @author ben 
  15.  * @creation 2014年3月20日 
  16.  */  
  17. public class AESTool {  
  18.     protected static final Logger log = Logger.getLogger(AESTool.class);  
  19.   
  20.     private byte[] initVector = { 0x32, 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31,  
  21.             0x38, 0x27, 0x36, 0x35, 0x33, 0x23, 0x32, 0x31 };  
  22.   
  23.     /** 
  24.      * FIXME For demo only, should rewrite this method in your product environment! 
  25.      *  
  26.      * @param appid 
  27.      * @return 
  28.      */  
  29.     public String findKeyById(String appid) {  
  30.         // Fake key.  
  31.         String key = "123456789012345678901234567890~!";  
  32.         return key;  
  33.     }  
  34.   
  35.     /** 
  36.      * Encrypt the content with a given key using aes algorithm. 
  37.      *  
  38.      * @param content 
  39.      * @param key 
  40.      *          must contain exactly 32 characters 
  41.      * @return 
  42.      * @throws Exception  
  43.      */  
  44.     public String encrypt(String content, String key) throws Exception {  
  45.         if (key == null) {  
  46.             throw new IllegalArgumentException("Key cannot be null!");  
  47.         }  
  48.         String encrypted = null;  
  49.         byte[] keyBytes = key.getBytes();  
  50.         if (keyBytes.length != 32 && keyBytes.length != 24  
  51.                 && keyBytes.length != 16) {  
  52.             throw new IllegalArgumentException(  
  53.                     "Key length must be 128/192/256 bits!");  
  54.         }  
  55.         byte[] encryptedBytes = null;  
  56.         encryptedBytes = encrypt(content.getBytes(), keyBytes, initVector);  
  57.         encrypted = new String(Hex.encode(encryptedBytes));  
  58.         return encrypted;  
  59.     }  
  60.   
  61.     /** 
  62.      * Decrypt the content with a given key using aes algorithm. 
  63.      *  
  64.      * @param content 
  65.      * @param key 
  66.      *          must contain exactly 32 characters 
  67.      * @return 
  68.      * @throws Exception  
  69.      */  
  70.     public String decrypt(String content, String key) throws Exception {  
  71.         if (key == null) {  
  72.             throw new IllegalArgumentException("Key cannot be null!");  
  73.         }  
  74.         String decrypted = null;  
  75.         byte[] encryptedContent = Hex.decode(content);  
  76.         byte[] keyBytes = key.getBytes();  
  77.         byte[] decryptedBytes = null;  
  78.         if (keyBytes.length != 32 && keyBytes.length != 24  
  79.                 && keyBytes.length != 16) {  
  80.             throw new IllegalArgumentException(  
  81.                     "Key length must be 128/192/256 bits!");  
  82.         }  
  83.         decryptedBytes = decrypt(encryptedContent, keyBytes, initVector);  
  84.         decrypted = new String(decryptedBytes);  
  85.         return decrypted;  
  86.     }  
  87.   
  88.     /** 
  89.      * Encrypt data. 
  90.      *  
  91.      * @param plain 
  92.      * @param key 
  93.      * @param iv 
  94.      * @return 
  95.      * @throws Exception 
  96.      */  
  97.     public byte[] encrypt(byte[] plain, byte[] key, byte[] iv) throws Exception {  
  98.         PaddedBufferedBlockCipher aes = new PaddedBufferedBlockCipher(  
  99.                 new CBCBlockCipher(new AESFastEngine()));  
  100.         CipherParameters ivAndKey = new ParametersWithIV(new KeyParameter(key),  
  101.                 iv);  
  102.         aes.init(true, ivAndKey);  
  103.         return cipherData(aes, plain);  
  104.     }  
  105.   
  106.     /** 
  107.      * Decrypt data. 
  108.      *  
  109.      * @param cipher 
  110.      * @param key 
  111.      * @param iv 
  112.      * @return 
  113.      * @throws Exception 
  114.      */  
  115.     public byte[] decrypt(byte[] cipher, byte[] key, byte[] iv)  
  116.             throws Exception {  
  117.         PaddedBufferedBlockCipher aes = new PaddedBufferedBlockCipher(  
  118.                 new CBCBlockCipher(new AESFastEngine()));  
  119.         CipherParameters ivAndKey = new ParametersWithIV(new KeyParameter(key),  
  120.                 iv);  
  121.         aes.init(false, ivAndKey);  
  122.         return cipherData(aes, cipher);  
  123.     }  
  124.   
  125.     /** 
  126.      * Encrypt or decrypt data. 
  127.      *  
  128.      * @param cipher 
  129.      * @param data 
  130.      * @return 
  131.      * @throws Exception 
  132.      */  
  133.     private byte[] cipherData(PaddedBufferedBlockCipher cipher, byte[] data)  
  134.             throws Exception {  
  135.         int minSize = cipher.getOutputSize(data.length);  
  136.         byte[] outBuf = new byte[minSize];  
  137.         int length1 = cipher.processBytes(data, 0, data.length, outBuf, 0);  
  138.         int length2 = cipher.doFinal(outBuf, length1);  
  139.         int actualLength = length1 + length2;  
  140.         byte[] result = new byte[actualLength];  
  141.         System.arraycopy(outBuf, 0, result, 0, result.length);  
  142.         return result;  
  143.     }  
  144.   
  145.     public static void main(String[] args) throws Exception {  
  146.         AESTool aesTool = new AESTool();  
  147.         String appid = "canairport001";  
  148.         String key = aesTool.findKeyById(appid);  
  149.         String xml = "<root><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name></root>";  
  150.         String encrypted = aesTool.encrypt(xml, key);  
  151.         System.out.println("encrypted: \n" + encrypted);  
  152.         System.out.println("encrypted length: \n" + encrypted.length());  
  153.         String decrypted = aesTool.decrypt(encrypted, key);  
  154.         System.out.println("decrypted: \n" + decrypted);  
  155.         System.out.println("decrypted length: \n" + decrypted.length());  
  156.         boolean isSuccessful = StringUtils.equals(decrypted, xml);  
  157.         System.out.println(isSuccessful);  
  158.     }  
  159. }  

 

2.數字簽名工具類： 

Java代碼   收藏代碼
  1. import java.security.MessageDigest;  
  2. import java.security.NoSuchAlgorithmException;  
  3. import java.util.ArrayList;  
  4. import java.util.Collections;  
  5. import java.util.List;  
  6.   
  7. import org.apache.commons.lang.StringUtils;  
  8. import org.apache.log4j.Logger;  
  9.   
  10. /** 
  11.  * @author lixuanbin 
  12.  * @creation 2013-1-30 
  13.  */  
  14. public class SignatureUtil {  
  15.     protected static Logger log = Logger.getLogger(SignatureUtil.class);  
  16.   
  17.     private static final char[] hexArray = "0123456789ABCDEF".toCharArray();  
  18.   
  19.     private String encryptionAlgorithm = "SHA-1";  
  20.   
  21.     public String bytesToHexString(byte[] bytes) {  
  22.         char[] hexChars = new char[bytes.length * 2];  
  23.         for (int j = 0; j < bytes.length; j++) {  
  24.             int v = bytes[j] & 0xFF;  
  25.             hexChars[j * 2] = hexArray[v >>> 4];  
  26.             hexChars[j * 2 + 1] = hexArray[v & 0x0F];  
  27.         }  
  28.         return new String(hexChars);  
  29.     }  
  30.   
  31.     public byte[] hexStringToBytes(String s) {  
  32.         int len = s.length();  
  33.         byte[] data = new byte[len / 2];  
  34.         for (int i = 0; i < len; i += 2) {  
  35.             data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character  
  36.                     .digit(s.charAt(i + 1), 16));  
  37.         }  
  38.         return data;  
  39.     }  
  40.   
  41.     /** 
  42.      * 使用指定算法生成消息摘要，默認是md5 
  43.      *  
  44.      * @param strSrc 
  45.      *            , a string will be encrypted; <br/> 
  46.      * @param encName 
  47.      *            , the algorithm name will be used, dafault to "MD5"; <br/> 
  48.      * @return 
  49.      */  
  50.     public String digest(String strSrc, String encName) {  
  51.         MessageDigest md = null;  
  52.         String strDes = null;  
  53.         byte[] bt = strSrc.getBytes();  
  54.         try {  
  55.             if (encName == null || encName.equals("")) {  
  56.                 encName = "MD5";  
  57.             }  
  58.             md = MessageDigest.getInstance(encName);  
  59.             md.update(bt);  
  60.             strDes = bytesToHexString(md.digest()); // to HexString  
  61.         } catch (NoSuchAlgorithmException e) {  
  62.             log.error("Invalid algorithm: " + encName);  
  63.             return null;  
  64.         }  
  65.         return strDes;  
  66.     }  
  67.   
  68.     /** 
  69.      * 根據appid、token、lol以及時間戳來生成簽名 
  70.      *  
  71.      * @param appid 
  72.      * @param token 
  73.      * @param lol 
  74.      * @param millis 
  75.      * @return 
  76.      */  
  77.     public String generateSignature(String appid, String token, String lol,  
  78.             long millis) {  
  79.         String timestamp = String.valueOf(millis);  
  80.         String signature = null;  
  81.         if (StringUtils.isNotBlank(token) && StringUtils.isNotBlank(timestamp)  
  82.                 && StringUtils.isNotBlank(appid)) {  
  83.             List<String> srcList = new ArrayList<String>();  
  84.             srcList.add(timestamp);  
  85.             srcList.add(appid);  
  86.             srcList.add(token);  
  87.             srcList.add(lol);  
  88.             // 按照字典序逆序拼接參數  
  89.             Collections.sort(srcList);  
  90.             Collections.reverse(srcList);  
  91.             StringBuilder sb = new StringBuilder();  
  92.             for (int i = 0; i < srcList.size(); i++) {  
  93.                 sb.append(srcList.get(i));  
  94.             }  
  95.             signature = digest(sb.toString(), encryptionAlgorithm);  
  96.             srcList.clear();  
  97.             srcList = null;  
  98.         }  
  99.         return signature;  
  100.     }  
  101.   
  102.     /** 
  103.      * 驗證簽名: <br/> 
  104.      * 1.根據appid獲取該渠道的token;<br/> 
  105.      * 2.根據appid、token、lol以及時間戳計算一次簽名;<br/> 
  106.      * 3.比較傳過來的簽名以及計算出的簽名是否一致; 
  107.      * @param signature 
  108.      * @param appid 
  109.      * @param lol 
  110.      * @param millis 
  111.      * @return 
  112.      */  
  113.     public boolean isValid(String signature, String appid, String lol,  
  114.             long millis) {  
  115.         String token = findTokenById(appid);  
  116.         String calculatedSignature = generateSignature(appid, token, lol,  
  117.                 millis);  
  118.         log.info("calculated signature: \n" + calculatedSignature);  
  119.         if (StringUtils.equals(calculatedSignature, signature)) {  
  120.             return true;  
  121.         } else {  
  122.             return false;  
  123.         }  
  124.     }  
  125.   
  126.     /** 
  127.      * FIXME For demo only, should be a different string in production. 
  128.      * @param appid 
  129.      * @return 
  130.      */  
  131.     public String findTokenById(String appid) {  
  132.         String token = "#@!1234567890!@#";  
  133.         return token;  
  134.     }  
  135.   
  136.     public static void main(String[] args) {  
  137.         SignatureUtil generator = new SignatureUtil();  
  138.         String xmlString = "<root><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name><name>test</name></root>";  
  139.         System.out.println(xmlString.getBytes().length);  
  140.         String digest = generator.digest(xmlString, "MD5");  
  141.         System.out.println(digest);  
  142.         System.out.println(digest.getBytes().length);  
  143.         String appid = "canairport001";  
  144.         String token = generator.findTokenById(appid);  
  145.         long millis = System.currentTimeMillis();  
  146.         String signature = generator.generateSignature(appid, token, digest,  
  147.                 millis);  
  148.         System.out.println(signature);  
  149.         boolean isValid = generator.isValid(signature, appid, digest, millis);  
  150.         System.out.println(isValid);  
  151.     }  
  152. }  
 

 3.發送方代碼：

Java代碼   收藏代碼
  1. import java.io.IOException;  
  2. import java.util.HashMap;  
  3. import java.util.Iterator;  
  4. import java.util.Map;  
  5. import java.util.Map.Entry;  
  6.   
  7. import org.apache.commons.lang.StringUtils;  
  8. import org.apache.http.HttpEntity;  
  9. import org.apache.http.HttpHost;  
  10. import org.apache.http.HttpResponse;  
  11. import org.apache.http.HttpStatus;  
  12. import org.apache.http.auth.AuthScope;  
  13. import org.apache.http.auth.UsernamePasswordCredentials;  
  14. import org.apache.http.client.ClientProtocolException;  
  15. import org.apache.http.client.methods.HttpPost;  
  16. import org.apache.http.conn.params.ConnRoutePNames;  
  17. import org.apache.http.entity.StringEntity;  
  18. import org.apache.http.impl.client.DefaultHttpClient;  
  19. import org.apache.http.message.BasicHeader;  
  20. import org.apache.http.protocol.HTTP;  
  21. import org.apache.http.util.EntityUtils;  
  22. import org.apache.log4j.Logger;  
  23.   
  24. /** 
  25.  * @author ben 
  26.  * @creation 2014年6月9日 
  27.  */  
  28. public class HttpclientUtil {  
  29.     protected static final Logger log = Logger.getLogger(HttpclientUtil.class);  
  30.   
  31.     /** 
  32.      * 根據傳入的uri和參數map拼接成實際uri 
  33.      *  
  34.      * @param uri 
  35.      * @param paraMap 
  36.      * @return 
  37.      */  
  38.     public String buildUri(String uri, Map<String, String> paraMap) {  
  39.         StringBuilder sb = new StringBuilder();  
  40.         uri = StringUtils.trim(uri);  
  41.         uri = StringUtils.removeEnd(uri, "/");  
  42.         uri = StringUtils.removeEnd(uri, "?");  
  43.         sb.append(uri);  
  44.         if (paraMap != null && !paraMap.isEmpty()) {  
  45.             sb.append("?");  
  46.             Iterator<Entry<String, String>> iterator = paraMap.entrySet()  
  47.                     .iterator();  
  48.             while (iterator.hasNext()) {  
  49.                 Map.Entry<String, String> pair = iterator.next();  
  50.                 try {  
  51.                     String keyString = pair.getKey();  
  52.                     String valueString = pair.getValue();  
  53.                     sb.append(keyString);  
  54.                     sb.append("=");  
  55.                     sb.append(valueString);  
  56.                     sb.append("&");  
  57.                 } catch (Exception e) {  
  58.                     log.error(e, e);  
  59.                 }  
  60.             }  
  61.         }  
  62.         return StringUtils.removeEnd(sb.toString(), "&");  
  63.     }  
  64.   
  65.     /** 
  66.      * Post an xml string to a specific host. 
  67.      *  
  68.      * @param targetHost 
  69.      * @param targetPort 
  70.      * @param protocol 
  71.      * @param proxyHost 
  72.      * @param proxyPort 
  73.      * @param proxyUser 
  74.      * @param proxyPassword 
  75.      * @param uri 
  76.      * @param paraMap 
  77.      * @param xml 
  78.      * @param charset 
  79.      * @return 
  80.      * @throws ClientProtocolException 
  81.      * @throws IOException 
  82.      */  
  83.     public String postXmlString(String targetHost, int targetPort,  
  84.             String protocol, String proxyHost, int proxyPort, String proxyUser,  
  85.             String proxyPassword, String uri, Map<String, String> paraMap,  
  86.             String xml, String charset) throws ClientProtocolException,  
  87.             IOException {  
  88.         String result = null;  
  89.         DefaultHttpClient httpclient = new DefaultHttpClient();  
  90.         if (StringUtils.isNotBlank(proxyHost) && proxyPort > 0) {  
  91.             // 設置上網代理  
  92.             AuthScope authScope = new AuthScope(proxyHost, proxyPort);  
  93.             if (StringUtils.isNotBlank(proxyUser)  
  94.                     && StringUtils.isNotBlank(proxyPassword)) {  
  95.                 // 設置上網代理的用戶名和密碼  
  96.                 UsernamePasswordCredentials upc = new UsernamePasswordCredentials(  
  97.                         proxyUser, proxyPassword);  
  98.                 httpclient.getCredentialsProvider().setCredentials(authScope,  
  99.                         upc);  
  100.             }  
  101.             HttpHost proxy = new HttpHost(proxyHost, proxyPort);  
  102.             httpclient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY,  
  103.                     proxy);  
  104.         }  
  105.         HttpHost host = new HttpHost(targetHost, targetPort, protocol);  
  106.         uri = buildUri(uri, paraMap);  
  107.         log.info("post uri: " + uri);  
  108.         log.info("post content: " + xml);  
  109.         HttpPost post = new HttpPost(uri);  
  110.         StringEntity se = new StringEntity(xml,  
  111.                 StringUtils.isNotBlank(charset) ? charset : "utf-8");  
  112.         se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE,  
  113.                 "application/xml"));  
  114.         post.setEntity(se);  
  115.         HttpResponse response = httpclient.execute(host, post);  
  116.         if (HttpStatus.SC_OK == response.getStatusLine().getStatusCode()) {  
  117.             HttpEntity entity = response.getEntity();  
  118.             if (entity != null) {  
  119.                 result = EntityUtils.toString(entity);  
  120.                 log.info("post result: " + result);  
  121.             }  
  122.         } else {  
  123.             log.error("post failed, status code: "  
  124.                     + response.getStatusLine().getStatusCode());  
  125.         }  
  126.         return result;  
  127.     }  
  128.   
  129.     public static void main(String[] args) throws Exception {  
  130.         AESTool aes = new AESTool();  
  131.         SignatureUtil signatureUtil = new SignatureUtil();  
  132.         String appid = "canairport001";  
  133.         String token = signatureUtil.findTokenById(appid);  
  134.         String key = aes.findKeyById(appid);  
  135.         long millis = System.currentTimeMillis();  
  136.         String xml = "<dependency><groupId>commons-lang</groupId><artifactId>commons-lang</artifactId><version>2.5</version></dependency>";  
  137.         xml = aes.encrypt(xml, key);  
  138.         String lol = signatureUtil.digest(xml, "MD5");  
  139.         String signature = signatureUtil.generateSignature(appid, token, lol,  
  140.                 millis);  
  141.         log.info("lol: \n" + lol);  
  142.         log.info("signature: \n" + signature);  
  143.         String uri = "http://127.0.0.1:8080/demo/psginfo.do";  
  144.         Map<String, String> paraMap = new HashMap<String, String>();  
  145.         paraMap.put("s", signature);  
  146.         paraMap.put("a", appid);  
  147.         paraMap.put("t", String.valueOf(millis));  
  148.         paraMap.put("l", lol);  
  149.         paraMap.put("o", "test");  
  150.         HttpclientUtil util = new HttpclientUtil();  
  151.         try {  
  152.             String result = util.postXmlString("127.0.0.1", 8080, "http", null,  
  153.                     0, null, null, uri, paraMap, xml, "utf-8");  
  154.             result = aes.decrypt(result, key);  
  155.             System.out.println(result);  
  156.         } catch (ClientProtocolException e) {  
  157.             e.printStackTrace();  
  158.         } catch (IOException e) {  
  159.             e.printStackTrace();  
  160.         }  
  161.     }  
  162. }  

 

4.服務端代碼：

Java代碼   收藏代碼
  1. import java.io.BufferedReader;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4. import java.io.InputStreamReader;  
  5. import java.io.PrintWriter;  
  6. import java.io.UnsupportedEncodingException;  
  7.   
  8. import javax.servlet.ServletException;  
  9. import javax.servlet.annotation.WebServlet;  
  10. import javax.servlet.http.HttpServlet;  
  11. import javax.servlet.http.HttpServletRequest;  
  12. import javax.servlet.http.HttpServletResponse;  
  13.   
  14. import org.apache.commons.lang.StringUtils;  
  15. import org.apache.log4j.Logger;  
  16.   
  17. import co.speedar.wechat.util.AESTool;  
  18. import co.speedar.wechat.util.SignatureUtil;  
  19.   
  20. /** 
  21.  * Servlet implementation class PsginfoServlet 
  22.  */  
  23. @WebServlet(urlPatterns = { "/psginfo.do" }, loadOnStartup = 1)  
  24. public class PsginfoServlet extends HttpServlet {  
  25.     protected static final Logger log = Logger.getLogger(PsginfoServlet.class);  
  26.     private static final long serialVersionUID = 6536688299231165548L;  
  27.   
  28.     private SignatureUtil signatureUtil = new SignatureUtil();  
  29.   
  30.     private AESTool aes = new AESTool();  
  31.   
  32.     /** 
  33.      * @see HttpServlet#HttpServlet() 
  34.      */  
  35.     public PsginfoServlet() {  
  36.         super();  
  37.     }  
  38.   
  39.     /** 
  40.      * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse 
  41.      *      response) 
  42.      */  
  43.     protected void doGet(HttpServletRequest request,  
  44.             HttpServletResponse response) throws ServletException, IOException {  
  45.         String echostr = request.getParameter("e");  
  46.         log.info("echostr before echo: " + echostr);  
  47.         String signature = request.getParameter("s");  
  48.         String appid = request.getParameter("a");  
  49.         String timestamp = request.getParameter("t");  
  50.         String lol = request.getParameter("l");  
  51.         long millis = Long.valueOf(timestamp);  
  52.         // Need to check signature in product mode.  
  53.         if (signatureUtil.isValid(signature, appid, lol, millis)) {  
  54.             PrintWriter writer = response.getWriter();  
  55.             log.info("echostr after echo: " + echostr);  
  56.             writer.print(echostr);  
  57.             writer.flush();  
  58.             writer.close();  
  59.         }  
  60.     }  
  61.   
  62.     /** 
  63.      * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse 
  64.      *      response) 
  65.      */  
  66.     protected void doPost(HttpServletRequest request,  
  67.             HttpServletResponse response) throws ServletException, IOException {  
  68.         // Get request parameters.  
  69.         String signature = request.getParameter("s");  
  70.         String appid = request.getParameter("a");  
  71.         String timestamp = request.getParameter("t");  
  72.         String lol = request.getParameter("l");  
  73.         String operation = request.getParameter("o");  
  74.         long millis = Long.valueOf(timestamp);  
  75.   
  76.         // Get xml data.  
  77.         String encoding = StringUtils  
  78.                 .isNotBlank(request.getCharacterEncoding()) ? request  
  79.                 .getCharacterEncoding() : "utf-8";  
  80.         String requestXmlString = getXmlStringFromHttpRequest(request);  
  81.         String digest = signatureUtil.digest(requestXmlString, "MD5");  
  82.   
  83.         // Check signature and digest.  
  84.         if (StringUtils.equals(digest, lol)) {  
  85.             if (signatureUtil.isValid(signature, appid, lol, millis)) {  
  86.                 try {  
  87.                     String key = aes.findKeyById(appid);  
  88.                     requestXmlString = aes.decrypt(requestXmlString, key);  
  89.                     log.info("received xml data:\n" + requestXmlString);  
  90.                     // 校驗xml合法性並執行相應動做  
  91.                     String responseXmlString = doSomeThing(requestXmlString,  
  92.                             operation);  
  93.                     responseXmlString = aes.encrypt(responseXmlString, key);  
  94.                     log.info("responsed xml data:\n" + responseXmlString);  
  95.                     response.setCharacterEncoding(encoding);  
  96.                     PrintWriter writer = response.getWriter();  
  97.                     writer.print(responseXmlString);  
  98.                     writer.flush();  
  99.                     writer.close();  
  100.                 } catch (Exception e) {  
  101.                     log.error(e, e);  
  102.                 }  
  103.             } else {  
  104.                 log.error("invalid signature");  
  105.             }  
  106.         } else {  
  107.             log.error("invalid digest.");  
  108.         }  
  109.     }  
  110.   
  111.     /** 
  112.      * TODO Write your own business here. 
  113.      *  
  114.      * @param xml 
  115.      * @param operation 
  116.      * @return 
  117.      */  
  118.     private String doSomeThing(String xml, String operation) {  
  119.         return "done";  
  120.     }  
  121.   
  122.     /** 
  123.      * Extract xml string form http request. 
  124.      *  
  125.      * @param request 
  126.      * @return 
  127.      * @throws IOException 
  128.      */  
  129.     private String getXmlStringFromHttpRequest(HttpServletRequest request) {  
  130.         String requestXmlString = "";  
  131.         try {  
  132.             InputStream inputStream = request.getInputStream();  
  133.             String encoding = StringUtils.isNotBlank(request  
  134.                     .getCharacterEncoding()) ? request.getCharacterEncoding()  
  135.                     : "utf-8";  
  136.             requestXmlString = getXmlStringFromInputStream(inputStream,  
  137.                     encoding);  
  138.             encoding = null;  
  139.             inputStream.close();  
  140.             inputStream = null;  
  141.         } catch (IOException e) {  
  142.             log.error(e, e);  
  143.         }  
  144.   
  145.         return requestXmlString;  
  146.     }  
  147.   
  148.     /** 
  149.      * Extract xml string from the inputStream. 
  150.      *  
  151.      * @param inputStream 
  152.      * @param charsetName 
  153.      * @return 
  154.      */  
  155.     private String getXmlStringFromInputStream(InputStream inputStream,  
  156.             String charsetName) {  
  157.         String resultXmlString = "";  
  158.         String tempString = null;  
  159.         BufferedReader bufferedReader;  
  160.         try {  
  161.             bufferedReader = new BufferedReader(new InputStreamReader(  
  162.                     inputStream, charsetName));  
  163.             tempString = bufferedReader.readLine();  
  164.             while (tempString != null) {  
  165.                 resultXmlString += tempString;  
  166.                 tempString = bufferedReader.readLine();  
  167.             }  
  168.             tempString = null;  
  169.             bufferedReader.close();  
  170.             bufferedReader = null;  
  171.         } catch (UnsupportedEncodingException e) {  
  172.             log.error(e, e);  
  173.         } catch (IOException e) {  
  174.             log.error(e, e);  
  175.         }  
  176.         return StringUtils.trim(resultXmlString);  
  177.     }  
  178.   
  179. }  

 

5.maven配置：

Xml代碼   收藏代碼
  1. <dependency>   
  2.     <groupId>org.bouncycastle</groupId>   
  3.     <artifactId>bcprov-jdk16</artifactId>   
  4.     <version>1.46</version>   
  5. </dependency>  
  6. <dependency>  
  7.     <groupId>commons-lang</groupId>  
  8.     <artifactId>commons-lang</artifactId>  
  9.     <version>2.5</version>  
  10. </dependency>  
  11. <dependency>  
  12.     <groupId>org.apache.httpcomponents</groupId>  
  13.     <artifactId>httpclient</artifactId>  
  14.     <version>4.2.5</version>  
  15. </dependency>  
  16. <dependency>  
  17.     <groupId>org.apache.httpcomponents</groupId>  
  18.     <artifactId>httpmime</artifactId>  
  19.     <version>4.2.5</version>  
  20. </dependency>  

 

6、結語

   在本方案設計實現過程當中，消息傳遞的框架採用的是Java開發者所熟悉的Servlet技術，摘要、簽名、加密所採用的算法，以及所依賴的第三方jar也是比較有口碑又大衆化的貨，對於有相似須要的開發者來講，本方案具備必定的參考意義。遠程傳遞消息框架以及生成簽名的環節，主要是模仿了微信公衆平臺的消息交互方式以及生成簽名的思路，而有所創新的一小點是，把消息密文的MD5值也參與到了簽名運算中，增長了被仿冒的難度，同時也便於服務方校驗消息在傳遞過程當中是否有被第三方所篡改。

   基於簡化工程配置的考慮，本示例項目中沒有使用spring，您能夠在您的生產項目中把本示例中的代碼改形成春哥的單例業務bean。密鑰、token建議別直接寫到春哥的context配置文件中，而是寫在您的生產容器的環境變量中，防止被竊取。

   另外，在本方案中生成簽名的參數您能夠酌情增減並調換順序，替換籤名所採用的算法，或者根據您的實際須要「個性化」一下您的加密算法，以期達到更好的安全效果。

   Last but not the least，在密鑰以及token交換的階段，請採起您所承認的安全有效的方式進行，譬如面對面，微信，qq，微薄私信，電話，短信，郵件（能夠參考本人以前寫過的一篇文章：http://lixuanbin.iteye.com/blog/1544344）

 

7、參考資料

【Java加密與解密的藝術】——做者：樑棟，出版日期：2010年12月，ISBN：978-7-111-29762-8

http://stackoverflow.com/questions/4243650/aes-encryption-decryption-with-bouncycastle-example-in-j2me

http://stackoverflow.com/questions/6729834/need-solution-for-wrong-iv-length-in-aes

http://baike.baidu.com/view/941329.htm?fr=aladdin

http://baike.baidu.com/subview/133041/5358738.htm?fr=aladdin

http://baike.baidu.com/view/1228622.htm?fr=aladdin

http://baike.baidu.com/view/7636.htm?fr=aladdin

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程