Java 加解密技術系列之 DES

標籤：加密   解密   技術   des   

序
前幾篇文章講的都是單向密碼編譯演算法，其中涉及到了 BASE64、MD5、SHA、HMAC 等幾個比較常見的加解密演算法。這篇文章，以及後面幾篇，打算介紹幾個對稱式加密演算法，比如：DES、3DES（TripleDES）、AES 等。那麼，這篇文章主要是對 DES 大概講一下。

背景
在討論 DES 之前，首先瞭解一下什麼是對稱式加密演算法吧。對於對稱式加密演算法，他應用的時間比較早，技術相對來說比較成熟，在對稱式加密演算法中，資料發信方將明文（未經處理資料）和加密金鑰一起經過特殊密碼編譯演算法處理後，使其變成複雜的加密密文發送出去。收信方收到密文後，若想解讀原文，則需要使用加密用過的密鑰及相同演算法的逆演算法對密文進行解密，才能使其恢複成可讀明文。


在對稱式加密演算法中，使用的密鑰只有一個，發收信雙方都使用這個金鑰組資料進行加密和解密，這就要求解密方事先必須知道加密金鑰。對稱式加密演算法的特點是演算法公開、計算量小。不足之處是，交易雙方都使用同樣鑰匙，安全性得不到保證。

概念
那麼，什麼是 DES？他是怎麼來的？相信很多人都高度興趣，因為以前在開發的時候，對進度的要求比較嚴，很多時候根本就沒有時間來瞭解這些東西。因此，今天專門來研究研究這個東西。
DES，全稱為“Data Encryption Standard”，中文名為“資料加密標準”，是一種使用祕密金鑰加密的塊演算法。DES 演算法為密碼體制中的對稱密碼體制，又被稱為美國資料加密標準，是 1972 年美國 IBM 公司研製的對稱密碼體制密碼編譯演算法。 明文按 64 位元進行分組，密鑰長 64 位元，密鑰事實上是 56 位參與 DES 運算（第8、16、24、32、40、48、56、64 位元是校正位， 使得每個密鑰都有奇數個 1）分組後的明文組和 56 位的密鑰按位替代或交換的方法形成密文組的加密方法。

基本原理
入口參數有三個：key、data、mode。key 為加密解密使用的密鑰，data 為加密 解密的資料，mode 為其工作模式。當模式為加密模式時，明文按照 64 位元進行分組，形成明文組，key 用於對資料加密，當模式為解密模式時，key 用於對資料解密。實際運用中，密鑰只用到了 64 位元中的 56 位，這樣才具有高的安全性。



主要流程
DES 演算法把 64 位元的明文輸入塊變為 64 位元的密文輸出塊，它所使用的密鑰也是 64 位元，其演算法主要分為兩步：

• 初始置換

其功能是把輸入的 64 位元資料區塊按位重新組合,並把輸出分為 L0、R0 兩部分，每部分各長 32 位，其置換規則為將輸入的第 58 位換到第一位，第 50 位換到第 2 位 …… 依此類推,最後一位是原來的第 7 位。L0、R0 則是換位輸出後的兩部分，L0 是輸出的左 32 位，R0 是右  32 位，例：設定換前的輸入值為 D1 D2 D3 …… D64，則經過初始置換後的結果為：L0 = D58 D50 …… D8；R0 = D57 D49 …… D7。

• 逆置換

經過 16 次迭代運算後，得到 L16、R16，將此作為輸入，進行逆置換，逆置換正好是初始置換的逆運算，由此即得到密文輸出。
整個演算法 的主流程圖如下：



分組模式

• ECB模式

ECB，中文名“電子密碼本模式”，是最古老、最簡單的模式，將加密的資料分成若干組，每組的大小跟加密金鑰長度相同。然後每組都用相同的祕密金鑰加密，比如 DES 演算法，如果最後一個分組長度不夠 64 位元，要補齊 64 位元。：

• CBC模式

CBC，中文名“加密塊鏈模式”，與 ECB 模式最大的不同是加入了初始向量。他的特點是，每次加密的密文長度為 64位 ( 8 個位元組)，當相同的明文使用相同的密鑰和初始向量的時候 CBC 模式總是產生相同的密文。

• CFB模式

CFB，中文名“加密反饋模式”，加密反饋模式克服了需要等待 8 個位元組才能加密的缺點，它採用了分組密碼作為流密碼的密鑰流產生器。他的特點是，每次加密的 Pi 和 Ci 不大於 64 位元；密碼編譯演算法和解密演算法相同，不能適用於公開金鑰演算法；使用相同的密鑰和初始向量的時候，相同明文使用 CFB 模式加密輸出相同的密文；可以使用不同的初始設定變數使相同的明文產生不同的密文，防止字典攻擊；加密強度依賴於密鑰長度；加密塊長度過小時,會增加迴圈的數量,導致開銷增加；加密塊長度應時 8 位的整數倍（即位元組為單位）；一旦某位元據出錯,會影響目前和其後 8 個塊的資料。

• OFB模式

OFB，中文名“輸出反饋模式”，與 CFB 模式不同之處在於, 加密位移寄存器與密文無關了,僅與加密 key 和密碼編譯演算法有關，做法是不再把密文輸入到加密移位寄存器，而是把輸出的分組密文（Oi）輸入到一位寄存器。因為密文沒有參與鏈操作，所以使得 OFB 模式更容易受到攻擊；不會進行錯誤傳播，某位密文發生錯誤，只會影響該位對應的明文，而不會影響別的位；不是自同步的，如果加密和解密兩個操作失去同步，那麼系統需要重新初始化；每次重新同步時，應使用不同的初始向量。可以避免產生相同的位元流，避免“已知明文”攻擊。

• CTR模式

CTR，中文名“計數模式”，是對一系列輸入資料區塊(稱為計數)進行加密，產生一系列的輸出塊，輸出塊與明文異或得到密文。對於最後的資料區塊，可能是長 u 位的局部資料區塊，這 u 位就將用於異或操作，而剩下的 b-u 位將被丟棄（b表示塊的長度）。



代碼實現

<span style="font-family:Comic Sans MS;"><span style="font-size:12px;">package com.sica.des;import com.google.common.base.Strings;import sun.misc.BASE64Decoder;import sun.misc.BASE64Encoder;import javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;import java.security.InvalidKeyException;import java.security.Key;import java.security.NoSuchAlgorithmException;import java.security.SecureRandom;import java.security.spec.InvalidKeySpecException;/** * Created by xiang.li on 2015/2/28. * DES 加解密工具類 * * <pre> * 支援 DES、DESede(TripleDES,就是3DES)、AES、Blowfish、RC2、RC4(ARCFOUR) * DES                  key size must be equal to 56 * DESede(TripleDES)    key size must be equal to 112 or 168 * AES                  key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available * Blowfish             key size must be multiple of 8, and can only range from 32 to 448 (inclusive) * RC2                  key size must be between 40 and 1024 bits * RC4(ARCFOUR)         key size must be between 40 and 1024 bits * 具體內容 需要關注 JDK Document http://.../docs/technotes/guides/security/SunProviders.html * </pre> */public class DES {    /**     * 定義加密方式     */    private final static String KEY_DES = "DES";    private final static String KEY_AES = "AES";    // 測試    /**     * 全域數組     */    private final static String[] hexDigits = { "0", "1", "2", "3", "4", "5",            "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };    /**     * 初始化密鑰     * @return     */    public static String init() {        return init(null);    }    /**     * 初始化密鑰     * @param seed 初始化參數     * @return     */    public static String init(String seed) {        SecureRandom secure = null;        String str = "";        try {            if (null != secure) {                // 帶參數的初始化                secure = new SecureRandom(decryptBase64(seed));            } else {                // 不帶參數的初始化                secure = new SecureRandom();            }            KeyGenerator generator = KeyGenerator.getInstance(KEY_DES);            generator.init(secure);            SecretKey key = generator.generateKey();            str = encryptBase64(key.getEncoded());        } catch (Exception e) {            e.printStackTrace();        }        return str;    }    /**     * 轉換密鑰     * @param key 密鑰的位元組數組     * @return     */    private static Key byteToKey(byte[] key) {        SecretKey secretKey = null;        try {            DESKeySpec dks = new DESKeySpec(key);            SecretKeyFactory factory = SecretKeyFactory.getInstance(KEY_DES);            secretKey = factory.generateSecret(dks);            // 當使用其他對稱式加密演算法時，如AES、Blowfish等演算法時，用下述代碼替換上述三行代碼//            secretKey = new SecretKeySpec(key, KEY_DES);        } catch (InvalidKeyException e) {            e.printStackTrace();        } catch (NoSuchAlgorithmException e) {            e.printStackTrace();        } catch (InvalidKeySpecException e) {            e.printStackTrace();        }        return secretKey;    }    /**     * DES 解密     * @param data 需要解密的字串     * @param key 密鑰     * @return     */    public static String decryptDES(String data, String key) {        // 驗證傳入的字串        if (Strings.isNullOrEmpty(data)) {            return "";        }        // 調用解密方法完成解密        byte[] bytes = decryptDES(hexString2Bytes(data), key);        // 將得到的位元組數組變成字串返回        return new String(bytes);    }    /**     * DES 解密     * @param data 需要解密的位元組數組     * @param key 密鑰     * @return     */    public static byte[] decryptDES(byte[] data, String key) {        byte[] bytes = null;        try {            Key k = byteToKey(decryptBase64(key));            Cipher cipher = Cipher.getInstance(KEY_DES);            cipher.init(Cipher.DECRYPT_MODE, k);            bytes = cipher.doFinal(data);        } catch (Exception e) {            e.printStackTrace();        }        return bytes;    }    /**     * DES 加密     * @param data 需要加密的字串     * @param key 密鑰     * @return     */    public static String encryptDES(String data, String key) {        // 驗證傳入的字串        if (Strings.isNullOrEmpty(data)) {            return "";        }        // 調用加密方法完成加密        byte[] bytes = encryptDES(data.getBytes(), key);        // 將得到的位元組數組變成字串返回        return byteArrayToHexString(bytes);    }    /**     * DES 加密     * @param data 需要加密的位元組數組     * @param key 密鑰     * @return     */    public static byte[] encryptDES(byte[] data, String key) {        byte[] bytes = null;        try {            Key k = byteToKey(decryptBase64(key));            Cipher cipher = Cipher.getInstance(KEY_DES);            cipher.init(Cipher.ENCRYPT_MODE, k);            bytes = cipher.doFinal(data);        } catch (Exception e) {            e.printStackTrace();        }        return bytes;    }    /**     * BASE64 解密     * @param key 需要解密的字串     * @return 位元組數組     * @throws Exception     */    public static byte[] decryptBase64(String key) throws Exception {        return (new BASE64Decoder()).decodeBuffer(key);    }    /**     * BASE64 加密     * @param key 需要加密的位元組數組     * @return 字串     * @throws Exception     */    public static String encryptBase64(byte[] key) throws Exception {        return (new BASE64Encoder()).encodeBuffer(key);    }    /**     * 將一個位元組轉化成十六進位形式的字串     * @param b 位元組數組     * @return 字串     */    private static String byteToHexString(byte b) {        int ret = b;        //System.out.println("ret = " + ret);        if (ret < 0) {            ret += 256;        }        int m = ret / 16;        int n = ret % 16;        return hexDigits[m] + hexDigits[n];    }    /**     * 轉換位元組數組為十六進位字串     * @param bytes 位元組數組     * @return 十六進位字串     */    private static String byteArrayToHexString(byte[] bytes) {        StringBuffer sb = new StringBuffer();        for (int i = 0; i < bytes.length; i++) {            sb.append(byteToHexString(bytes[i]));        }        return sb.toString();    }    /**     * 轉換十六進位字串為位元組數組     * @param hexstr 十六進位字串     * @return     */    public static byte[] hexString2Bytes(String hexstr) {        byte[] b = new byte[hexstr.length() / 2];        int j = 0;        for (int i = 0; i < b.length; i++) {            char c0 = hexstr.charAt(j++);            char c1 = hexstr.charAt(j++);            b[i] = (byte) ((parse(c0) << 4) | parse(c1));        }        return b;    }    /**     * 轉換字元類型資料為整型資料     * @param c 字元     * @return     */    private static int parse(char c) {        if (c >= 'a')            return (c - 'a' + 10) & 0x0f;        if (c >= 'A')            return (c - 'A' + 10) & 0x0f;        return (c - '0') & 0x0f;    }    /**     * 測試方法     * @param args     */    public static void main(String[] args) {        String key = DES.init();        System.out.println("DES密鑰:\n" + key);        String word = "123";                String encWord = encryptDES(word, key);        System.out.println(word + "\n加密後：\n" + encWord);        System.out.println(word + "\n解密後：\n" + decryptDES(encWord, key));    }}</span><span style="font-size: 14px;"></span></span>

結束語
到這裡，這篇文章也就差不多要結束了，希望以上的內容對各位看官有稍許的協助，哪怕一點也好。其實，在日常的開發中，如果不是進度控制的特別嚴格，對於這些原理性的東西，我們還是需要知道的，對於那些細節的東西，可以不用死記硬背，有網的話，隨用隨查就可以了。但這個前提是，原理性的東西必須要懂，知道了原理，就會有解決思路，有了思路，解決問題是遲早的事，細節嘛，不用那麼糾結，做的時候考慮到就行了，畢竟時間是有限的。

Java 加解密技術系列之 DES