對稱加密：

對稱加密是指，加密方和解密方使用同樣的祕鑰來進行加密和解密。

常用對稱加密：

1. DES演算法

DES演算法的入口引數有三個：Key、Data、Mode。其中Key為8個位元組共64位，是DES演算法的工作金鑰；Data也為8個位元組64位，是要被加密或被解密的資料；Mode為DES的工作方式，有兩種：加密或解密。DES演算法是這樣工作的：如Mode為加密，則用Key 去把資料Data進行加密， 生成Data的密碼形式（64位）作為DES的輸出結果；如Mode為解密，則用Key去把密碼形式的資料Data解密，還原為Data的明碼形式（64位）作為DES的輸出結果。DES演算法具有極高安全性，到目前為止，除了用窮舉搜尋法對DES演算法進行攻擊外，還沒有發現更有效的辦法。

java實現：

package com.xxx.controller.api;


import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class Test {

    /**
     * 入口函式
     * @param args
     */
    public static void main(String[] args) throws Exception{
        String test = desEncrypt("helloworld", "123456asdsadad");
        System.out.println("加密後：" + test);
        String data = desDecrypt(test, "123456asdsadad");
        System.out.println("解密後：" + data);
    }

    /**
     * DES加密演算法-加密
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static String desEncrypt(String data, String key) throws Exception {
        SecureRandom sr = new SecureRandom(); //強隨機數
        DESKeySpec dks = new DESKeySpec(key.getBytes("UTF-8"));
        //金鑰工廠用來將金鑰（型別 Key 的不透明加密金鑰）轉換為金鑰規範（底層金鑰材料的透明表示形式）
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey securekey = keyFactory.generateSecret(dks);
        //DES加密
        Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding"); //DES演算法
        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
        byte[] bt =  cipher.doFinal(data.getBytes());
        return new BASE64Encoder().encode(bt); //base64處理     
    }
    
    /**
     * DES加密演算法-解密
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static String desDecrypt(String data, String key) throws Exception {
        byte[] buf = new BASE64Decoder().decodeBuffer(data); //base64處理     
        
        //強隨機數
        SecureRandom sr = new SecureRandom(); 
        
        //金鑰工廠用來將金鑰（型別 Key 的不透明加密金鑰）轉換為金鑰規範（底層金鑰材料的透明表示形式）
        DESKeySpec dks = new DESKeySpec(key.getBytes("UTF-8"));
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey securekey = keyFactory.generateSecret(dks);
        
        //DES解密
        Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding"); //DES演算法
        cipher.init(Cipher.DECRYPT_MODE, securekey, sr);
        byte[] bt =  cipher.doFinal(buf);
        return new String(bt); 
    }

}
 

2. AES演算法

AES 是一個迭代的、對稱金鑰分組的密碼，它可以使用128、192 和 256 位金鑰，並且用 128 位（16位元組）分組加密和解密資料。與公共金鑰密碼使用金鑰對不同，對稱金鑰密碼使用相同的金鑰加密和解密資料。通過分組密碼返回的加密資料的位數與輸入資料相同。迭代加密使用一個迴圈結構，在該迴圈中重複置換和替換輸入資料。

java實現：

package com.xxx.controller;


import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class test {

    /**
     * 入口函式
     * @param args
     */
    public static void main(String[] args) throws Exception {
        String test = aesEncrypt("helloworld", "123456asdsadad");
        System.out.println("加密後：" + test);
        String data = aesDecrypt(test, "123456asdsadad");
        System.out.println("解密後：" + data);
    }

    /**
     * AES加密演算法-加密
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static String aesEncrypt(String data, String key) throws Exception {
        //構造祕鑰生成器
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        kgen.init(128, new SecureRandom(key.getBytes()));
        //產生原始對稱金鑰
        SecretKey secretKey = kgen.generateKey();
        byte[] enCodeFormat = secretKey.getEncoded();
        //生成金鑰
        SecretKeySpec keySpec = new SecretKeySpec(enCodeFormat, "AES");
        //AES加密演算法
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        byte[] byteContent = data.getBytes("utf-8");
        cipher.init(Cipher.ENCRYPT_MODE, keySpec);
        byte[] result = cipher.doFinal(byteContent);
        //base64處理
        return new BASE64Encoder().encode(result);
    }

    /**
     * AES加密演算法-解密
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public static String aesDecrypt(String data, String key) throws Exception {
        byte[] buf = new BASE64Decoder().decodeBuffer(data); //base64處理     

        //構造祕鑰生成器
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        kgen.init(128, new SecureRandom(key.getBytes()));
        //產生原始對稱金鑰
        SecretKey secretKey = kgen.generateKey();
        byte[] enCodeFormat = secretKey.getEncoded();
        //生成金鑰
        SecretKeySpec keySpec = new SecretKeySpec(enCodeFormat, "AES");
        //AES加密演算法
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, keySpec);
        byte[] result = cipher.doFinal(buf);
        //base64處理
        return new String(result);
    }

}
 

常用非對稱加密：

非對稱加密演算法實現機密資訊交換的基本過程是：甲方生成一對金鑰並將其中的一把作為公用金鑰向其它方公開；得到該公用金鑰的乙方使用該金鑰對機密資訊進行加密後再發送給甲方；甲方再用自己儲存的另一把專用金鑰對加密後的資訊進行解密。甲方只能用其專用金鑰解密由其公用金鑰加密後的任何資訊。

1. RSA演算法

import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

/**
 * RSA安全編碼元件
 * 
 * @author 樑棟
 * @version 1.0
 * @since 1.0
 */
public abstract class RSACoder extends Coder {
	public static final String KEY_ALGORITHM = "RSA";
	public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

	private static final String PUBLIC_KEY = "RSAPublicKey";
	private static final String PRIVATE_KEY = "RSAPrivateKey";

	/**
	 * 用私鑰對資訊生成數字簽名
	 * 
	 * @param data
	 *            加密資料
	 * @param privateKey
	 *            私鑰
	 * 
	 * @return
	 * @throws Exception
	 */
	public static String sign(byte[] data, String privateKey) throws Exception {
		// 解密由base64編碼的私鑰
		byte[] keyBytes = decryptBASE64(privateKey);

		// 構造PKCS8EncodedKeySpec物件
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

		// KEY_ALGORITHM 指定的加密演算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

		// 取私鑰匙物件
		PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);

		// 用私鑰對資訊生成數字簽名
		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		signature.initSign(priKey);
		signature.update(data);

		return encryptBASE64(signature.sign());
	}

	/**
	 * 校驗數字簽名
	 * 
	 * @param data
	 *            加密資料
	 * @param publicKey
	 *            公鑰
	 * @param sign
	 *            數字簽名
	 * 
	 * @return 校驗成功返回true 失敗返回false
	 * @throws Exception
	 * 
	 */
	public static boolean verify(byte[] data, String publicKey, String sign)
			throws Exception {

		// 解密由base64編碼的公鑰
		byte[] keyBytes = decryptBASE64(publicKey);

		// 構造X509EncodedKeySpec物件
		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

		// KEY_ALGORITHM 指定的加密演算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

		// 取公鑰匙物件
		PublicKey pubKey = keyFactory.generatePublic(keySpec);

		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		signature.initVerify(pubKey);
		signature.update(data);

		// 驗證簽名是否正常
		return signature.verify(decryptBASE64(sign));
	}

	/**
	 * 解密<br>
	 * 用私鑰解密
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPrivateKey(byte[] data, String key)
			throws Exception {
		// 對金鑰解密
		byte[] keyBytes = decryptBASE64(key);

		// 取得私鑰
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

		// 對資料解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, privateKey);

		return cipher.doFinal(data);
	}

	/**
	 * 解密<br>
	 * 用公鑰解密
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPublicKey(byte[] data, String key)
			throws Exception {
		// 對金鑰解密
		byte[] keyBytes = decryptBASE64(key);

		// 取得公鑰
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key publicKey = keyFactory.generatePublic(x509KeySpec);

		// 對資料解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, publicKey);

		return cipher.doFinal(data);
	}

	/**
	 * 加密<br>
	 * 用公鑰加密
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptByPublicKey(byte[] data, String key)
			throws Exception {
		// 對公鑰解密
		byte[] keyBytes = decryptBASE64(key);

		// 取得公鑰
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key publicKey = keyFactory.generatePublic(x509KeySpec);

		// 對資料加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, publicKey);

		return cipher.doFinal(data);
	}

	/**
	 * 加密<br>
	 * 用私鑰加密
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptByPrivateKey(byte[] data, String key)
			throws Exception {
		// 對金鑰解密
		byte[] keyBytes = decryptBASE64(key);

		// 取得私鑰
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

		// 對資料加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, privateKey);

		return cipher.doFinal(data);
	}

	/**
	 * 取得私鑰
	 * 
	 * @param keyMap
	 * @return
	 * @throws Exception
	 */
	public static String getPrivateKey(Map<String, Object> keyMap)
			throws Exception {
		Key key = (Key) keyMap.get(PRIVATE_KEY);

		return encryptBASE64(key.getEncoded());
	}

	/**
	 * 取得公鑰
	 * 
	 * @param keyMap
	 * @return
	 * @throws Exception
	 */
	public static String getPublicKey(Map<String, Object> keyMap)
			throws Exception {
		Key key = (Key) keyMap.get(PUBLIC_KEY);

		return encryptBASE64(key.getEncoded());
	}

	/**
	 * 初始化金鑰
	 * 
	 * @return
	 * @throws Exception
	 */
	public static Map<String, Object> initKey() throws Exception {
		KeyPairGenerator keyPairGen = KeyPairGenerator
				.getInstance(KEY_ALGORITHM);
		keyPairGen.initialize(1024);

		KeyPair keyPair = keyPairGen.generateKeyPair();

		// 公鑰
		RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

		// 私鑰
		RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

		Map<String, Object> keyMap = new HashMap<String, Object>(2);

		keyMap.put(PUBLIC_KEY, publicKey);
		keyMap.put(PRIVATE_KEY, privateKey);
		return keyMap;
	}
}

簽名方法：

在開發後端服務的過程中，為了確保介面資料的準確性和不被修改，我們一般會對傳遞的引數進行一個簽名。

假如請求資料：appKey=test&a=xxxx&b=ssss&e=sss&d=sss&time=xxxxx&sign=sapodpasdpa

這個請求引數中，appKey為api請求方的key（請求方和服務端還儲存一份secret祕鑰），sign為資料的簽名，其餘為傳遞的引數。

sign的簽名演算法是對傳遞的引數進行鍵值升序排序，例如排序成這樣：

a=xxxx&appKey=test&b=ssss&d=sss&e=sss&time=xxxxx

請求方對這個引數進行簽名：sign = MD5（a=xxxx&appKey=test&b=ssss&d=sss&e=sss&time=xxxxx + 祕鑰）

然後服務端拿到請求的sign，同時也會拿到appKey，就可以找到對應的secret祕鑰，同樣對請求的引數進行升序排序後進行md5的簽名，再比較sign值是否相同，如果相同則表示資料未被修改。

同時為了介面的安全性，我們可以看到請求引數中有time欄位，我們還可以根據time時間來做請求的失效性處理，例如time和當前伺服器時間比較 大小返回在5分鐘之內還是有效，超出了說明這個請求的資料過期，可以拒絕請求。

PHP方法：

	/**
	 * 方法庫-sign簽名方法
	 * @param $array 需要加密的引數 
	 * @param $secret 祕鑰
	 * @param $signName sign的名稱，sign不會進行加密
	 */
	public function sign($array, $secret, $signName = "sign") {
		if (count($array) == 0) {
			return "";
		}
		ksort($array); //按照升序排序
		$str = "";
		foreach ($array as $key => $value) {
			if ($signName == $key) continue;
			$str .= $key . "=" . $value . "&";
		}
		$str = rtrim($str, "&");
		return md5($str . $secret);
	}