1.對稱加密演算法概述

對稱加密演算法是應用較早的加密演算法，技術成熟。在對稱加密演算法中，資料發信方將明文和加密金鑰一起經過特殊加密演算法處理後，使其變成複雜的加密密文傳送出去。收信方收到密文後，若想解讀原文，則需要使用加密用過的金鑰及相同演算法的逆演算法對密文進行解密，才能使其恢復成可讀明文。

在對稱加密演算法中，使用的金鑰只有一個，發收信雙方都使用這個金鑰對資料進行加密和解密，這就要求解密方事先必須知道加密金鑰。

對稱加密演算法的特點是演算法公開、計算量小、加密速度快、加密效率高。

不足之處是，交易雙方都使用同樣鑰匙，安全性得不到保證。

在計算機系統中廣泛使用的對稱加密演算法有DES和IDEA等。因為DES近年來屢屢被破解，所以，美國國家標準局倡導的AES即將作為新標準取代DES。

2.對稱加密演算法-DES

DES演算法為密碼體制中的對稱密碼體制，又被稱為美國資料加密標準，是1972年美國IBM公司研製的對稱密碼體制加密演算法。

明文按64位進行分組，金鑰長64位，金鑰事實上是56位參與DES運算（第8、16、24、32、40、48、56、64位是校驗位， 使得每個金鑰都有奇數個1）分組後的明文組和56位的金鑰按位替代或交換的方法形成密文組的加密方法。

金鑰長度	預設	工作模式	填充方式	實現方
56	56	ECB、CBC、PCBC、CTR、CTS、CFB、CFB8到128、OFB、OFB8到128	NoPadding、PKCS5Padding、ISO10126Padding	JDK
64	56	同上	PKCS7Padding、ISO10126d2Padding、X932Padding、ISO7816d4Padding、ZeroBytePadding	BC

引入Bouncy Castle依賴：

<dependency>
   <groupId>org.bouncycastle</groupId>
   <artifactId>bcprov-jdk15</artifactId>
   <version>1.46</version>
</dependency>

引入Commons Codec依賴：

<dependency>
   <groupId>commons-codec</groupId>
   <artifactId>commons-codec</artifactId>
   <version>1.10</version>
</dependency>

Java程式碼實現：

import java.security.Key;
import java.security.Security;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import org.apache.commons.codec.binary.Hex;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

public class DES {

  public static final String src = "des test";

  public static void main(String[] args) {
    jdkDES();
    bcDES();
  }

  // 用jdk實現:
  public static void jdkDES() {
    try {
      // 生成KEY
      KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");
      keyGenerator.init(56);
      // 產生金鑰
      SecretKey secretKey = keyGenerator.generateKey();
      // 獲取金鑰
      byte[] bytesKey = secretKey.getEncoded();

      // KEY轉換
      DESKeySpec desKeySpec = new DESKeySpec(bytesKey);
      SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
      Key convertSecretKey = factory.generateSecret(desKeySpec);

      // 加密
      Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
      cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
      byte[] result = cipher.doFinal(src.getBytes());
      System.out.println("jdk des encrypt:" + Hex.encodeHexString(result));

      // 解密
      cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
      result = cipher.doFinal(result);
      System.out.println("jdk des decrypt:" + new String(result));
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  // 用bouncy castle實現:
  public static void bcDES() {
    try {
      Security.addProvider(new BouncyCastleProvider());

      // 生成KEY
      KeyGenerator keyGenerator = KeyGenerator.getInstance("DES", "BC");
      keyGenerator.getProvider();
      keyGenerator.init(56);
      // 產生金鑰
      SecretKey secretKey = keyGenerator.generateKey();
      // 獲取金鑰
      byte[] bytesKey = secretKey.getEncoded();

      // KEY轉換
      DESKeySpec desKeySpec = new DESKeySpec(bytesKey);
      SecretKeyFactory factory = SecretKeyFactory.getInstance("DES");
      Key convertSecretKey = factory.generateSecret(desKeySpec);

      // 加密
      Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
      cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
      byte[] result = cipher.doFinal(src.getBytes());
      System.out.println("bc des encrypt:" + Hex.encodeHexString(result));

      // 解密
      cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
      result = cipher.doFinal(result);
      System.out.println("bc des decrypt:" + new String(result));
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

3.對稱加密演算法-3DES

密碼學中，三重資料加密演算法（英語：Triple Data Encryption Algorithm，縮寫為TDEA，Triple DEA），或稱3DES（Triple DES），是一種對稱金鑰加密塊密碼，相當於是對每個資料塊應用三次資料加密標準（DES）演算法。由於計算機運算能力的增強，原版DES密碼的金鑰長度變得容易被暴力破解；3DES即是設計用來提供一種相對簡單的方法，即通過增加DES的金鑰長度來避免類似的攻擊，而不是設計一種全新的塊密碼演算法。

Java程式碼實現：

import java.security.Key;
import java.security.SecureRandom;
import java.security.Security;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import org.apache.commons.codec.binary.Hex;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

public class DES3 {

  public static final String src = "3des test";

  public static void main(String[] args) {
    jdk3DES();
    bc3DES();
  }

  // 用jdk實現:
  public static void jdk3DES() {
    try {
      // 生成KEY
      KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");
      // 必須長度是：112或168
//          keyGenerator.init(168);
      keyGenerator.init(new SecureRandom());
      // 產生金鑰
      SecretKey secretKey = keyGenerator.generateKey();
      // 獲取金鑰
      byte[] bytesKey = secretKey.getEncoded();

      // KEY轉換
      DESedeKeySpec desKeySpec = new DESedeKeySpec(bytesKey);
      SecretKeyFactory factory = SecretKeyFactory.getInstance("DESede");
      Key convertSecretKey = factory.generateSecret(desKeySpec);

      // 加密
      Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
      cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
      byte[] result = cipher.doFinal(src.getBytes());
      System.out.println("jdk 3des encrypt:" + Hex.encodeHexString(result));

      // 解密
      cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
      result = cipher.doFinal(result);
      System.out.println("jdk 3des decrypt:" + new String(result));

    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  // 用bouncy castle實現:
  public static void bc3DES() {
    try {
      Security.addProvider(new BouncyCastleProvider());

      // 生成KEY
      KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede", "BC");
      keyGenerator.getProvider();
      keyGenerator.init(168);
      // 產生金鑰
      SecretKey secretKey = keyGenerator.generateKey();
      // 獲取金鑰
      byte[] bytesKey = secretKey.getEncoded();

      // KEY轉換
      DESedeKeySpec desKeySpec = new DESedeKeySpec(bytesKey);
      SecretKeyFactory factory = SecretKeyFactory.getInstance("DESede");
      Key convertSecretKey = factory.generateSecret(desKeySpec);

      // 加密
      Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
      cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey);
      byte[] result = cipher.doFinal(src.getBytes());
      System.out.println("bc 3des encrypt:" + Hex.encodeHexString(result));

      // 解密
      cipher.init(Cipher.DECRYPT_MODE, convertSecretKey);
      result = cipher.doFinal(result);
      System.out.println("bc 3des decrypt:" + new String(result));

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

4.對稱加密演算法-AES

高階加密標準（英語：Advanced Encryption Standard，縮寫：AES），在密碼學中又稱Rijndael加密法，是美國聯邦政府採用的一種區塊加密標準。這個標準用來替代原先的DES，已經被多方分析且廣為全世界所使用。經過五年的甄選流程，高階加密標準由美國國家標準與技術研究院（NIST）於2001年11月26日釋出於FIPS PUB 197，並在2002年5月26日成為有效的標準。2006年，高階加密標準已然成為對稱金鑰加密中最流行的演算法之一。

該演算法為比利時密碼學家Joan Daemen和Vincent Rijmen所設計，結合兩位作者的名字，以Rijndael為名投稿高階加密標準的甄選流程。（Rijndael的發音近於"Rhine doll"）

金鑰長度	預設	工作模式	填充方式	實現方
128、192、256	128	ECB、CBC、PCBC、CTR、CTS、CFB、CFB8到128、OFB、OFB8到128	NoPadding、PKCS5Padding、ISO10126Padding	JDK（256位金鑰需要獲得無政策限制許可權檔案）
同上	同上	同上	PKCS7Padding、ZeroBytePadding	BC

Java程式碼實現：

import java.security.Key;
import java.security.Security;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Hex;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

public class AES {

  public static final String src = "aes test";

  public static void main(String[] args) {
    jdkAES();
    bcAES();
  }

  // 用jdk實現:
  public static void jdkAES() {
    try {
      // 生成KEY
      KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
      keyGenerator.init(128);
      // 產生金鑰
      SecretKey secretKey = keyGenerator.generateKey();
      // 獲取金鑰
      byte[] keyBytes = secretKey.getEncoded();

      // KEY轉換
      Key key = new SecretKeySpec(keyBytes, "AES");

      // 加密
      Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
      cipher.init(Cipher.ENCRYPT_MODE, key);
      byte[] result = cipher.doFinal(src.getBytes());
      System.out.println("jdk aes encrypt:" + Hex.encodeHexString(result));

      // 解密
      cipher.init(Cipher.DECRYPT_MODE, key);
      result = cipher.doFinal(result);
      System.out.println("jdk aes decrypt:" + new String(result));
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  // 用bouncy castle實現:
  public static void bcAES() {
    try {
      Security.addProvider(new BouncyCastleProvider());

      // 生成KEY
      KeyGenerator keyGenerator = KeyGenerator.getInstance("AES", "BC");
      keyGenerator.getProvider();
      keyGenerator.init(128);
      // 產生金鑰
      SecretKey secretKey = keyGenerator.generateKey();
      // 獲取金鑰
      byte[] keyBytes = secretKey.getEncoded();

      // KEY轉換
      Key key = new SecretKeySpec(keyBytes, "AES");

      // 加密
      Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
      cipher.init(Cipher.ENCRYPT_MODE, key);
      byte[] result = cipher.doFinal(src.getBytes());
      System.out.println("bc aes encrypt:" + Hex.encodeHexString(result));

      // 解密
      cipher.init(Cipher.DECRYPT_MODE, key);
      result = cipher.doFinal(result);
      System.out.println("bc aes decrypt:" + new String(result));
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

應用舉例：

5.對稱加密演算法-PBE

PBE演算法（Password Based Encryption，基於口令加密）是一種基於口令的加密演算法，其特點是使用口令代替了金鑰，而口令由使用者自己掌管，採用隨機數雜湊多重加密等方法保證資料的安全性。

PBE演算法在加密過程中並不是直接使用口令來加密，而是加密的金鑰由口令生成，這個功能由PBE演算法中的KDF函式完成。KDF函式的實現過程為：將使用者輸入的口令首先通過“鹽”（salt）的擾亂產生準金鑰，再將準金鑰經過雜湊函式多次迭代後生成最終加密金鑰，金鑰生成後，PBE演算法再選用對稱加密演算法對資料進行加密，可以選擇DES、3DES、RC5等對稱加密演算法。

具體實現如下：

Java程式碼實現：

import java.security.Key;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;
import org.apache.commons.codec.binary.Hex;

public class PBE {

  public static final String src = "pbe test";

  public static void main(String[] args) {
    jdkPBE();
  }

  // 用jdk實現:
  public static void jdkPBE() {
    try {
      // 初始化鹽
      SecureRandom random = new SecureRandom();
      byte[] salt = random.generateSeed(8);

      // 口令與金鑰
      String password = "timliu";
      PBEKeySpec pbeKeySpec = new PBEKeySpec(password.toCharArray());
      SecretKeyFactory factory = SecretKeyFactory.getInstance("PBEWITHMD5andDES");
      Key key = factory.generateSecret(pbeKeySpec);

      // 加密
      PBEParameterSpec pbeParameterSpac = new PBEParameterSpec(salt, 100);
      Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
      cipher.init(Cipher.ENCRYPT_MODE, key, pbeParameterSpac);
      byte[] result = cipher.doFinal(src.getBytes());
      System.out.println("jdk pbe encrypt:" + Hex.encodeHexString(result));

      // 解密
      cipher.init(Cipher.DECRYPT_MODE, key, pbeParameterSpac);
      result = cipher.doFinal(result);
      System.out.println("jdk pbe decrypt:" + new String(result));
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

應用舉例：

相關推薦