[轉載] Java中常用的加密方法

轉載自：Java中常用的加密方法(JDK) - Java - language - ITeye论坛

加密，是以某種特殊的演算法改變原有的信息數據，使得未授權的用戶即使獲得了已加密的信息，但因不知解密的方法，仍然無法了解信息的內容。大體上分為雙向加密和單向加密，而雙向加密又分為對稱加密和非對稱加密(有些資料將加密直接分為對稱加密和非對稱加密)。

雙向加密大體意思就是明文加密後形成密文，可以通過演算法還原成明文。而單向加密只是對信息進行了摘要計算，不能通過演算法生成明文，單向加密從嚴格意思上說不能算是加密的一種，應該算是摘要演算法吧。具體區分可以參考：
(本人解釋不清呢 …… )
http://security.group.iteye.com/group/wiki/1710-one-way-encryption-algorithm

一、雙向加密

(一)、對稱加密

采用單鑰密碼系統的加密方法，同一個密鑰可以同時用作信息的加密和解密，這種加密方法稱為對稱加密，也稱為單密鑰加密。
需要對加密和解密使用相同密鑰的加密演算法。由於其速度，對稱性加密通常在消息發送方需要加密大量數據時使用。對稱性加密也稱為密鑰加密。
所謂對稱，就是采用這種加密方法的雙方使用方式用同樣的密鑰進行加密和解密。密鑰是控制加密及解密過程的指令。

演算法是一組規則，規定如何進行加密和解密。因此對稱式加密本身不是安全的。 　　
常用的對稱加密有：DES、IDEA、RC2、RC4、SKIPJACK、RC5、AES 演算法等

對稱加密一般 Java 類中中定義成員

1. // KeyGenerator 提供對稱密鑰生成器的功能，支持各種演算法 
2. private KeyGenerator keygen; 
3. // SecretKey 負責保存對稱密鑰 
4. private SecretKey deskey; 
5. // Cipher負責完成加密或解密工作 
6. private Cipher c; 
7. // 該字節數組負責保存加密的結果 
8. private byte[] cipherByte; 

// KeyGenerator 提供對稱密鑰生成器的功能，支持各種演算法
private KeyGenerator keygen;
// SecretKey 負責保存對稱密鑰
private SecretKey deskey;
// Cipher負責完成加密或解密工作
private Cipher c;
// 該字節數組負責保存加密的結果
private byte[] cipherByte;

在構造函數中初始化

1. Security.addProvider(new com.sun.crypto.provider.SunJCE()); 
2. // 實例化支持 DES 演算法的密鑰生成器(演算法名稱命名需按規定，否則拋出異常) 
3. keygen = KeyGenerator.getInstance("DES");// 
4. // 生成密鑰 
5. deskey = keygen.generateKey(); 
6. // 生成 Cipher 物件,指定其支持的 DES 演算法 
7. c = Cipher.getInstance("DES"); 

Security.addProvider(new com.sun.crypto.provider.SunJCE());
// 實例化支持 DES 演算法的密鑰生成器(演算法名稱命名需按規定，否則拋出異常)
keygen = KeyGenerator.getInstance("DES");//
// 生成密鑰
deskey = keygen.generateKey();
// 生成 Cipher 物件,指定其支持的 DES 演算法
c = Cipher.getInstance("DES");

1. DES
演算法為密碼體制中的對稱密碼體制，又被成為美國數據加密標准，是 1972 年美國 IBM 公司研制的對稱密碼體制加密演算法。 明文按 64 位進行分組, 密鑰長 64 位，密鑰事實上是 56 位參與 DES 運算（第 8、16、24、32、40、48、56、64 位是校驗位， 使得每個密鑰都有奇數個 1）分組後的明文組和 56 位的密鑰按位替代或交換的方法形成密文組的加密方法。

原始碼

1. import java.security.InvalidKeyException; 
2. import java.security.NoSuchAlgorithmException; 
3. import java.security.Security; 
4.  
5. import javax.crypto.BadPaddingException; 
6. import javax.crypto.Cipher; 
7. import javax.crypto.IllegalBlockSizeException; 
8. import javax.crypto.KeyGenerator; 
9. import javax.crypto.NoSuchPaddingException; 
10. import javax.crypto.SecretKey; 
11.  
12. public class EncrypDES { 
13.  
14.    // KeyGenerator 提供對稱密鑰生成器的功能，支持各種演算法 
15.    private KeyGenerator keygen; 
16.    // SecretKey 負責保存對稱密鑰 
17.    private SecretKey deskey; 
18.    // Cipher 負責完成加密或解密工作 
19.    private Cipher c; 
20.    // 該字節數組負責保存加密的結果 
21.    private byte[] cipherByte; 
22.  
23.    public EncrypDES() 
24.        throws NoSuchAlgorithmException, NoSuchPaddingException 
25.    { 
26.        Security.addProvider(new com.sun.crypto.provider.SunJCE()); 
27.        // 實例化支持 DES 演算法的密鑰生成器(演算法名稱命名需按規定，否則拋出異常) 
28.        keygen = KeyGenerator.getInstance("DES"); 
29.        // 生成密鑰 
30.        deskey = keygen.generateKey(); 
31.        // 生成 Cipher 物件,指定其支持的 DES 演算法 
32.        c = Cipher.getInstance("DES"); 
33.    } 
34.  
35.    /** 
36.     * 對字符串加密 
37.     * 
38.     * @param str 
39.     * @return 
40.     * @throws InvalidKeyException 
41.     * @throws IllegalBlockSizeException 
42.     * @throws BadPaddingException 
43.     */ 
44.    public byte[] Encrytor(String str) 
45.        throws InvalidKeyException, IllegalBlockSizeException, 
46.               BadPaddingException 
47.    { 
48.        // 根據密鑰，對 Cipher 物件進行初始化，ENCRYPT_MODE 表示加密模式 
49.        c.init(Cipher.ENCRYPT_MODE, deskey); 
50.        byte[] src = str.getBytes(); 
51.        // 加密，結果保存進 cipherByte 
52.        cipherByte = c.doFinal(src); 
53.        return cipherByte; 
54.    } 
55.  
56.    /** 
57.     * 對字符串解密 
58.     * 
59.     * @param buff 
60.     * @return 
61.     * @throws InvalidKeyException 
62.     * @throws IllegalBlockSizeException 
63.     * @throws BadPaddingException 
64.     */ 
65.    public byte[] Decryptor(byte[] buff) 
66.        throws InvalidKeyException, IllegalBlockSizeException, 
67.               BadPaddingException 
68.    { 
69.        // 根據密鑰，對 Cipher 物件進行初始化，DECRYPT_MODE 表示加密模式 
70.        c.init(Cipher.DECRYPT_MODE, deskey); 
71.        cipherByte = c.doFinal(buff); 
72.        return cipherByte; 
73.    } 
74.  
75.    /** 
76.     * @param args 
77.     * @throws NoSuchPaddingException 
78.     * @throws NoSuchAlgorithmException 
79.     * @throws BadPaddingException 
80.     * @throws IllegalBlockSizeException 
81.     * @throws InvalidKeyException 
82.     */ 
83.    public static void main(String[] args) throws Exception { 
84.        EncrypDES de1 = new EncrypDES(); 
85.        String msg ="郭XX-搞笑相聲全集"; 
86.        byte[] encontent = de1.Encrytor(msg); 
87.        byte[] decontent = de1.Decryptor(encontent); 
88.        System.out.println("明文是:" + msg); 
89.        System.out.println("加密後:" + new String(encontent)); 
90.        System.out.println("解密後:" + new String(decontent)); 
91.    } 
92. } 

import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.Security;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;

public class EncrypDES {

    // KeyGenerator 提供對稱密鑰生成器的功能，支持各種演算法
    private KeyGenerator keygen;
    // SecretKey 負責保存對稱密鑰
    private SecretKey deskey;
    // Cipher 負責完成加密或解密工作
    private Cipher c;
    // 該字節數組負責保存加密的結果
    private byte[] cipherByte;

    public EncrypDES()
        throws NoSuchAlgorithmException, NoSuchPaddingException
    {
        Security.addProvider(new com.sun.crypto.provider.SunJCE());
        // 實例化支持 DES 演算法的密鑰生成器(演算法名稱命名需按規定，否則拋出異常)
        keygen = KeyGenerator.getInstance("DES");
        // 生成密鑰
        deskey = keygen.generateKey();
        // 生成 Cipher 物件,指定其支持的 DES 演算法
        c = Cipher.getInstance("DES");
    }

    /**
     * 對字符串加密
     *
     * @param str
     * @return
     * @throws InvalidKeyException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     */
    public byte[] Encrytor(String str)
        throws InvalidKeyException, IllegalBlockSizeException,
               BadPaddingException
    {
        // 根據密鑰，對 Cipher 物件進行初始化，ENCRYPT_MODE 表示加密模式
        c.init(Cipher.ENCRYPT_MODE, deskey);
        byte[] src = str.getBytes();
        // 加密，結果保存進 cipherByte
        cipherByte = c.doFinal(src);
        return cipherByte;
    }

    /**
     * 對字符串解密
     *
     * @param buff
     * @return
     * @throws InvalidKeyException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     */
    public byte[] Decryptor(byte[] buff)
        throws InvalidKeyException, IllegalBlockSizeException,
               BadPaddingException
    {
        // 根據密鑰，對 Cipher 物件進行初始化，DECRYPT_MODE 表示加密模式
        c.init(Cipher.DECRYPT_MODE, deskey);
        cipherByte = c.doFinal(buff);
        return cipherByte;
    }

    /**
     * @param args
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     * @throws InvalidKeyException
     */
    public static void main(String[] args) throws Exception {
        EncrypDES de1 = new EncrypDES();
        String msg ="郭XX-搞笑相聲全集";
        byte[] encontent = de1.Encrytor(msg);
        byte[] decontent = de1.Decryptor(encontent);
        System.out.println("明文是:" + msg);
        System.out.println("加密後:" + new String(encontent));
        System.out.println("解密後:" + new String(decontent));
    }
}

2. 3DES
又稱 Triple DES，是 DES 加密演算法的一種模式，它使用 3 條 56 位的密鑰對 3DES
數據進行三次加密。數據加密標准（DES）是美國的一種由來已久的加密標准，它使用對稱密鑰加密法，並於 1981 年被 ANSI 組織規範為 ANSI X.3.92。DES 使用 56 位密鑰和密碼塊的方法，而在密碼塊的方法中，文本被分成 64 位大小的文本塊然後再進行加密。比起最初的 DES，3DES 更為安全。 　　
3DES（即Triple DES）是 DES 向 AES 過渡的加密演算法（1999年，NIST 將 3-DES 指定為過渡的加密標准），是 DES 的一個更安全的變形。它以 DES 為基本模塊，通過組合分組方法設計出分組加密演算法，其具體實現如下：
設 Ek() 和 Dk() 代表 DES 演算法的加密和解密過程，K 代表 DES 演算法使用的密鑰，P 代表明文，C 代表密文，

3DES 加密過程為：C=Ek3(Dk2(Ek1(P)))
3DES 解密過程為：P=Dk1((EK2(Dk3(C)))

原始碼

1. import java.security.InvalidKeyException; 
2. import java.security.NoSuchAlgorithmException; 
3. import java.security.Security; 
4.  
5. import javax.crypto.BadPaddingException; 
6. import javax.crypto.Cipher; 
7. import javax.crypto.IllegalBlockSizeException; 
8. import javax.crypto.KeyGenerator; 
9. import javax.crypto.NoSuchPaddingException; 
10. import javax.crypto.SecretKey; 
11.  
12. public class EncrypDES3 { 
13.  
14.    // KeyGenerator 提供對稱密鑰生成器的功能，支持各種演算法 
15.    private KeyGenerator keygen; 
16.    // SecretKey 負責保存對稱密鑰 
17.    private SecretKey deskey; 
18.    // Cipher 負責完成加密或解密工作 
19.    private Cipher c; 
20.    // 該字節數組負責保存加密的結果 
21.    private byte[] cipherByte; 
22.  
23.    public EncrypDES3() 
24.        throws NoSuchAlgorithmException, NoSuchPaddingException 
25.    { 
26.        Security.addProvider(new com.sun.crypto.provider.SunJCE()); 
27.        // 實例化支持 DESede 演算法的密鑰生成器(演算法名稱命名需按規定，否則拋出異常) 
28.        keygen = KeyGenerator.getInstance("DESede"); 
29.        // 生成密鑰 
30.        deskey = keygen.generateKey(); 
31.        // 生成 Cipher 物件,指定其支持的 DESede 演算法 
32.        c = Cipher.getInstance("DESede"); 
33.    } 
34.  
35.    /** 
36.     * 對字符串加密 
37.     * 
38.     * @param str 
39.     * @return 
40.     * @throws InvalidKeyException 
41.     * @throws IllegalBlockSizeException 
42.     * @throws BadPaddingException 
43.     */ 
44.    public byte[] Encrytor(String str) 
45.        throws InvalidKeyException, IllegalBlockSizeException, 
46.               BadPaddingException 
47.    { 
48.        // 根據密鑰，對 Cipher 物件進行初始化，ENCRYPT_MODE 表示加密模式 
49.        c.init(Cipher.ENCRYPT_MODE, deskey); 
50.        byte[] src = str.getBytes(); 
51.        // 加密，結果保存進 cipherByte 
52.        cipherByte = c.doFinal(src); 
53.        return cipherByte; 
54.    } 
55.  
56.    /** 
57.     * 對字符串解密 
58.     * 
59.     * @param buff 
60.     * @return 
61.     * @throws InvalidKeyException 
62.     * @throws IllegalBlockSizeException 
63.     * @throws BadPaddingException 
64.     */ 
65.    public byte[] Decryptor(byte[] buff) 
66.        throws InvalidKeyException, IllegalBlockSizeException, 
67.               BadPaddingException 
68.    { 
69.        // 根據密鑰，對 Cipher 物件進行初始化，DECRYPT_MODE 表示加密模式 
70.        c.init(Cipher.DECRYPT_MODE, deskey); 
71.        cipherByte = c.doFinal(buff); 
72.        return cipherByte; 
73.    } 
74.  
75.    /** 
76.     * @param args 
77.     * @throws NoSuchPaddingException 
78.     * @throws NoSuchAlgorithmException 
79.     * @throws BadPaddingException 
80.     * @throws IllegalBlockSizeException 
81.     * @throws InvalidKeyException 
82.     */ 
83.    public static void main(String[] args) throws Exception { 
84.        EncrypDES3 des = new EncrypDES3(); 
85.        String msg ="郭XX-搞笑相聲全集"; 
86.        byte[] encontent = des.Encrytor(msg); 
87.        byte[] decontent = des.Decryptor(encontent); 
88.        System.out.println("明文是:" + msg); 
89.        System.out.println("加密後:" + new String(encontent)); 
90.        System.out.println("解密後:" + new String(decontent)); 
91.    } 
92. } 

import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.Security;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;

public class EncrypDES3 {

    // KeyGenerator 提供對稱密鑰生成器的功能，支持各種演算法
    private KeyGenerator keygen;
    // SecretKey 負責保存對稱密鑰
    private SecretKey deskey;
    // Cipher 負責完成加密或解密工作
    private Cipher c;
    // 該字節數組負責保存加密的結果
    private byte[] cipherByte;

    public EncrypDES3()
        throws NoSuchAlgorithmException, NoSuchPaddingException
    {
        Security.addProvider(new com.sun.crypto.provider.SunJCE());
        // 實例化支持 DESede 演算法的密鑰生成器(演算法名稱命名需按規定，否則拋出異常)
        keygen = KeyGenerator.getInstance("DESede");
        // 生成密鑰
        deskey = keygen.generateKey();
        // 生成 Cipher 物件,指定其支持的 DESede 演算法
        c = Cipher.getInstance("DESede");
    }

    /**
     * 對字符串加密
     *
     * @param str
     * @return
     * @throws InvalidKeyException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     */
    public byte[] Encrytor(String str)
        throws InvalidKeyException, IllegalBlockSizeException,
               BadPaddingException
    {
        // 根據密鑰，對 Cipher 物件進行初始化，ENCRYPT_MODE 表示加密模式
        c.init(Cipher.ENCRYPT_MODE, deskey);
        byte[] src = str.getBytes();
        // 加密，結果保存進 cipherByte
        cipherByte = c.doFinal(src);
        return cipherByte;
    }

    /**
     * 對字符串解密
     *
     * @param buff
     * @return
     * @throws InvalidKeyException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     */
    public byte[] Decryptor(byte[] buff)
        throws InvalidKeyException, IllegalBlockSizeException,
               BadPaddingException
    {
        // 根據密鑰，對 Cipher 物件進行初始化，DECRYPT_MODE 表示加密模式
        c.init(Cipher.DECRYPT_MODE, deskey);
        cipherByte = c.doFinal(buff);
        return cipherByte;
    }

    /**
     * @param args
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     * @throws InvalidKeyException
     */
    public static void main(String[] args) throws Exception {
        EncrypDES3 des = new EncrypDES3();
        String msg ="郭XX-搞笑相聲全集";
        byte[] encontent = des.Encrytor(msg);
        byte[] decontent = des.Decryptor(encontent);
        System.out.println("明文是:" + msg);
        System.out.println("加密後:" + new String(encontent));
        System.out.println("解密後:" + new String(decontent));
    }
}

3. AES
密碼學中的高級加密標准（Advanced Encryption Standard，AES），又稱 高級加密標准
Rijndael 加密法，是美國聯邦政府采用的一種區塊加密標准。這個標准用來替代原先的 DES，已經被多方分析且廣為全世界所使用。經過五年的甄選流程，高級加密標准由美國國家標准與技術研究院（NIST）於 2001 年 11 月 26 日發布於 FIPS PUB 197，並在 2002 年 5 月 26 日成為有效的標准。2006 年高級加密標准已然成為對稱密鑰加密中最流行的演算法之一。
該演算法為比利時密碼學家 Joan Daemen 和 Vincent Rijmen 所設計，結合兩位作者的名字，以 Rijndael 之命名之，投稿高級加密標准的甄選流程。（Rijdael 的發音近於 "Rhinedoll"）

原始碼

1. import java.security.InvalidKeyException; 
2. import java.security.NoSuchAlgorithmException; 
3. import java.security.Security; 
4.  
5. import javax.crypto.BadPaddingException; 
6. import javax.crypto.Cipher; 
7. import javax.crypto.IllegalBlockSizeException; 
8. import javax.crypto.KeyGenerator; 
9. import javax.crypto.NoSuchPaddingException; 
10. import javax.crypto.SecretKey; 
11.  
12. public class EncrypAES { 
13.  
14.    // KeyGenerator 提供對稱密鑰生成器的功能，支持各種演算法 
15.    private KeyGenerator keygen; 
16.    // SecretKey 負責保存對稱密鑰 
17.    private SecretKey deskey; 
18.    // Cipher 負責完成加密或解密工作 
19.    private Cipher c; 
20.    //該字節數組負責保存加密的結果 
21.    private byte[] cipherByte; 
22.  
23.    public EncrypAES() 
24.        throws NoSuchAlgorithmException, NoSuchPaddingException 
25.    { 
26.        Security.addProvider(new com.sun.crypto.provider.SunJCE()); 
27.        // 實例化支持 AES 演算法的密鑰生成器(演算法名稱命名需按規定，否則拋出異常) 
28.        keygen = KeyGenerator.getInstance("AES"); 
29.        //生成密鑰 
30.        deskey = keygen.generateKey(); 
31.        //生成 Cipher 物件,指定其支持的 AES 演算法 
32.        c = Cipher.getInstance("AES"); 
33.    } 
34.  
35.    /** 
36.     * 對字符串加密 
37.     * 
38.     * @param str 
39.     * @return 
40.     * @throws InvalidKeyException 
41.     * @throws IllegalBlockSizeException 
42.     * @throws BadPaddingException 
43.     */ 
44.    public byte[] Encrytor(String str) 
45.        throws InvalidKeyException, IllegalBlockSizeException, 
46.               BadPaddingException 
47.    { 
48.        // 根據密鑰，對 Cipher 物件進行初始化，ENCRYPT_MODE 表示加密模式 
49.        c.init(Cipher.ENCRYPT_MODE, deskey); 
50.        byte[] src = str.getBytes(); 
51.        // 加密，結果保存進 cipherByte 
52.        cipherByte = c.doFinal(src); 
53.        return cipherByte; 
54.    } 
55.  
56.    /** 
57.     * 對字符串解密 
58.     * 
59.     * @param buff 
60.     * @return 
61.     * @throws InvalidKeyException 
62.     * @throws IllegalBlockSizeException 
63.     * @throws BadPaddingException 
64.     */ 
65.    public byte[] Decryptor(byte[] buff) 
66.        throws InvalidKeyException, IllegalBlockSizeException, 
67.               BadPaddingException 
68.    { 
69.        // 根據密鑰，對 Cipher 物件進行初始化，DECRYPT_MODE 表示加密模式 
70.        c.init(Cipher.DECRYPT_MODE, deskey); 
71.        cipherByte = c.doFinal(buff); 
72.        return cipherByte; 
73.    } 
74.  
75.    /** 
76.     * @param args 
77.     * @throws NoSuchPaddingException 
78.     * @throws NoSuchAlgorithmException 
79.     * @throws BadPaddingException 
80.     * @throws IllegalBlockSizeException 
81.     * @throws InvalidKeyException 
82.     */ 
83.    public static void main(String[] args) throws Exception { 
84.        EncrypAES de1 = new EncrypAES(); 
85.        String msg ="郭XX-搞笑相聲全集"; 
86.        byte[] encontent = de1.Encrytor(msg); 
87.        byte[] decontent = de1.Decryptor(encontent); 
88.        System.out.println("明文是:" + msg); 
89.        System.out.println("加密後:" + new String(encontent)); 
90.        System.out.println("解密後:" + new String(decontent)); 
91.    } 
92. } 

import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.Security;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;

public class EncrypAES {

    // KeyGenerator 提供對稱密鑰生成器的功能，支持各種演算法
    private KeyGenerator keygen;
    // SecretKey 負責保存對稱密鑰
    private SecretKey deskey;
    // Cipher 負責完成加密或解密工作
    private Cipher c;
    //該字節數組負責保存加密的結果
    private byte[] cipherByte;

    public EncrypAES()
        throws NoSuchAlgorithmException, NoSuchPaddingException
    {
        Security.addProvider(new com.sun.crypto.provider.SunJCE());
        // 實例化支持 AES 演算法的密鑰生成器(演算法名稱命名需按規定，否則拋出異常)
        keygen = KeyGenerator.getInstance("AES");
        //生成密鑰
        deskey = keygen.generateKey();
        //生成 Cipher 物件,指定其支持的 AES 演算法
        c = Cipher.getInstance("AES");
    }

    /**
     * 對字符串加密
     *
     * @param str
     * @return
     * @throws InvalidKeyException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     */
    public byte[] Encrytor(String str)
        throws InvalidKeyException, IllegalBlockSizeException,
               BadPaddingException
    {
        // 根據密鑰，對 Cipher 物件進行初始化，ENCRYPT_MODE 表示加密模式
        c.init(Cipher.ENCRYPT_MODE, deskey);
        byte[] src = str.getBytes();
        // 加密，結果保存進 cipherByte
        cipherByte = c.doFinal(src);
        return cipherByte;
    }

    /**
     * 對字符串解密
     *
     * @param buff
     * @return
     * @throws InvalidKeyException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     */
    public byte[] Decryptor(byte[] buff)
        throws InvalidKeyException, IllegalBlockSizeException,
               BadPaddingException
    {
        // 根據密鑰，對 Cipher 物件進行初始化，DECRYPT_MODE 表示加密模式
        c.init(Cipher.DECRYPT_MODE, deskey);
        cipherByte = c.doFinal(buff);
        return cipherByte;
    }

    /**
     * @param args
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     * @throws InvalidKeyException
     */
    public static void main(String[] args) throws Exception {
        EncrypAES de1 = new EncrypAES();
        String msg ="郭XX-搞笑相聲全集";
        byte[] encontent = de1.Encrytor(msg);
        byte[] decontent = de1.Decryptor(encontent);
        System.out.println("明文是:" + msg);
        System.out.println("加密後:" + new String(encontent));
        System.out.println("解密後:" + new String(decontent));
    }
}

(二)、非對稱加密

1976 年，美國學者 Dime 和 Henman 為解決信息公開傳送和密鑰管理問題，提出一種新的密鑰交換協議，允許在不安全的媒體上的通訊雙方交換信息，安全地達成一致的密鑰，這就是“公開密鑰系統”。相對於“對稱加密演算法”這種方法也叫做“非對稱加密演算法”。 與對稱加密演算法不同，非對稱加密演算法需要兩個密鑰：公開密鑰（publickey）和私有密鑰（privatekey）。公開密鑰與私有密鑰是一對，如果用公開密鑰對數據進行加密，只有用對應的私有密鑰才能解密；如果用私有密鑰對數據進行加密，那麼只有用對應的公開密鑰才能解密。因為加密和解密使用的是兩個不同的密鑰，所以這種演算法叫作非對稱加密演算法。

1. RSA
公鑰加密演算法是 1977 年由 Ron Rivest、Adi Shamirh 和 LenAdleman 在（美國麻省理工學院）開發的。RSA 取名來自開發他們三者的名字。RSA 是目前最有影響力的公鑰加密演算法，它能夠抵抗到目前為止已知的所有密碼攻擊，已被 ISO 推薦為公鑰數據加密標准。RSA 演算法基於一個十分簡單的數論事實：將兩個大素數相乘十分容易，但那時想要對其乘積進行因式分解卻極其困難，因此可以將乘積公開作為加密密鑰。

原始碼

1. import java.security.InvalidKeyException; 
2. import java.security.KeyPair; 
3. import java.security.KeyPairGenerator; 
4. import java.security.NoSuchAlgorithmException; 
5. import java.security.interfaces.RSAPrivateKey; 
6. import java.security.interfaces.RSAPublicKey; 
7.  
8. import javax.crypto.BadPaddingException; 
9. import javax.crypto.Cipher; 
10. import javax.crypto.IllegalBlockSizeException; 
11. import javax.crypto.NoSuchPaddingException; 
12.  
13. public class EncrypRSA { 
14.  
15.    /** 
16.     * 加密 
17.     * @param publicKey 
18.     * @param srcBytes 
19.     * @return 
20.     * @throws NoSuchAlgorithmException 
21.     * @throws NoSuchPaddingException 
22.     * @throws InvalidKeyException 
23.     * @throws IllegalBlockSizeException 
24.     * @throws BadPaddingException 
25.     */ 
26.    protected byte[] encrypt(RSAPublicKey publicKey,byte[] srcBytes) 
27.        throws NoSuchAlgorithmException, NoSuchPaddingException, 
28.               InvalidKeyException, IllegalBlockSizeException, 
29.               BadPaddingException 
30.    { 
31.        if(publicKey == null){ return null; } 
32.  
33.        // Cipher 負責完成加密或解密工作，基於 RSA 
34.        Cipher cipher = Cipher.getInstance("RSA"); 
35.        // 根據公鑰，對 Cipher 物件進行初始化 
36.        cipher.init(Cipher.ENCRYPT_MODE, publicKey); 
37.        byte[] resultBytes = cipher.doFinal(srcBytes); 
38.        return resultBytes; 
39.    } 
40.  
41.    /** 
42.     * 解密 
43.     * @param privateKey 
44.     * @param srcBytes 
45.     * @return 
46.     * @throws NoSuchAlgorithmException 
47.     * @throws NoSuchPaddingException 
48.     * @throws InvalidKeyException 
49.     * @throws IllegalBlockSizeException 
50.     * @throws BadPaddingException 
51.     */ 
52.    protected byte[] decrypt(RSAPrivateKey privateKey,byte[] srcBytes) 
53.        throws NoSuchAlgorithmException, NoSuchPaddingException, 
54.               InvalidKeyException, IllegalBlockSizeException, 
55.               BadPaddingException 
56.    { 
57.        if(privateKey == null){ return null; } 
58.  
59.        // Cipher負責完成加密或解密工作，基於RSA 
60.        Cipher cipher = Cipher.getInstance("RSA"); 
61.        // 根據公鑰，對 Cipher 物件進行初始化 
62.        cipher.init(Cipher.DECRYPT_MODE, privateKey); 
63.        byte[] resultBytes = cipher.doFinal(srcBytes); 
64.        return resultBytes; 
65.    } 
66.  
67.    /** 
68.     * @param args 
69.     * @throws NoSuchAlgorithmException 
70.     * @throws BadPaddingException 
71.     * @throws IllegalBlockSizeException 
72.     * @throws NoSuchPaddingException 
73.     * @throws InvalidKeyException 
74.     */ 
75.    public static void main(String[] args) 
76.        throws NoSuchAlgorithmException, InvalidKeyException, 
77.               NoSuchPaddingException, IllegalBlockSizeException, 
78.               BadPaddingException 
79.    { 
80.        EncrypRSA rsa = new EncrypRSA(); 
81.        String msg = "郭XX-精品相聲"; 
82.  
83.        // KeyPairGenerator 類用於生成公鑰和私鑰對，基於 RSA 演算法生成物件 
84.        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA"); 
85.        // 初始化密鑰對生成器，密鑰大小為 1024 位 
86.        keyPairGen.initialize(1024); 
87.        // 生成一個密鑰對，保存在 keyPair 中 
88.        KeyPair keyPair = keyPairGen.generateKeyPair(); 
89.        // 得到私鑰 
90.        RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate(); 
91.        // 得到公鑰 
92.        RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic(); 
93.  
94.        // 用公鑰加密 
95.        byte[] srcBytes = msg.getBytes(); 
96.        byte[] resultBytes = rsa.encrypt(publicKey, srcBytes); 
97.  
98.        // 用私鑰解密 
99.        byte[] decBytes = rsa.decrypt(privateKey, resultBytes); 
100.  
101.        System.out.println("明文是:" + msg); 
102.        System.out.println("加密後是:" + new String(resultBytes)); 
103.        System.out.println("解密後是:" + new String(decBytes)); 
104.    } 
105.  
106. } 

import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

public class EncrypRSA {

    /**
     * 加密
     * @param publicKey
     * @param srcBytes
     * @return
     * @throws NoSuchAlgorithmException
     * @throws NoSuchPaddingException
     * @throws InvalidKeyException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     */
    protected byte[] encrypt(RSAPublicKey publicKey,byte[] srcBytes)
        throws NoSuchAlgorithmException, NoSuchPaddingException,
               InvalidKeyException, IllegalBlockSizeException,
               BadPaddingException
    {
        if(publicKey == null){ return null; }

        // Cipher 負責完成加密或解密工作，基於 RSA
        Cipher cipher = Cipher.getInstance("RSA");
        // 根據公鑰，對 Cipher 物件進行初始化
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] resultBytes = cipher.doFinal(srcBytes);
        return resultBytes;
    }

    /**
     * 解密
     * @param privateKey
     * @param srcBytes
     * @return
     * @throws NoSuchAlgorithmException
     * @throws NoSuchPaddingException
     * @throws InvalidKeyException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     */
    protected byte[] decrypt(RSAPrivateKey privateKey,byte[] srcBytes)
        throws NoSuchAlgorithmException, NoSuchPaddingException,
               InvalidKeyException, IllegalBlockSizeException,
               BadPaddingException
    {
        if(privateKey == null){ return null; }

        // Cipher負責完成加密或解密工作，基於RSA
        Cipher cipher = Cipher.getInstance("RSA");
        // 根據公鑰，對 Cipher 物件進行初始化
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] resultBytes = cipher.doFinal(srcBytes);
        return resultBytes;
    }

    /**
     * @param args
     * @throws NoSuchAlgorithmException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     * @throws NoSuchPaddingException
     * @throws InvalidKeyException
     */
    public static void main(String[] args)
        throws NoSuchAlgorithmException, InvalidKeyException,
               NoSuchPaddingException, IllegalBlockSizeException,
               BadPaddingException
    {
        EncrypRSA rsa = new EncrypRSA();
        String msg = "郭XX-精品相聲";

        // KeyPairGenerator 類用於生成公鑰和私鑰對，基於 RSA 演算法生成物件
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
        // 初始化密鑰對生成器，密鑰大小為 1024 位
        keyPairGen.initialize(1024);
        // 生成一個密鑰對，保存在 keyPair 中
        KeyPair keyPair = keyPairGen.generateKeyPair();
        // 得到私鑰
        RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();
        // 得到公鑰
        RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();

        // 用公鑰加密
        byte[] srcBytes = msg.getBytes();
        byte[] resultBytes = rsa.encrypt(publicKey, srcBytes);

        // 用私鑰解密
        byte[] decBytes = rsa.decrypt(privateKey, resultBytes);

        System.out.println("明文是:" + msg);
        System.out.println("加密後是:" + new String(resultBytes));
        System.out.println("解密後是:" + new String(decBytes));
    }

}

2. DSA
Digital Signature Algorithm (DSA)是 Schnorr 和 ElGamal 簽名演算法的變種，被美國 NIST 作為 DSS(DigitalSignature Standard)。(感覺有點復雜，沒有附代碼)
詳見http://63938525.iteye.com/blog/1051565

(三)、題外話 MySQL加密解密函數

MySQL有兩個函數來支持這種類型的加密，分別叫做 ENCODE() 和 DECODE()。
下面是一個簡單的實例：

1. mysql> INSERT INTO users (username,password) VALUES ('joe',ENCODE('guessme','abr')); 
2.  
3. Query OK， 1 row affected (0.14 sec) 

mysql> INSERT INTO users (username,password) VALUES ('joe',ENCODE('guessme','abr'));

Query OK， 1 row affected (0.14 sec)

其中，Joe 的密碼是 guessme，它通過密鑰 abracadabra 被加密。要注意的是，加密完的結果是一個二進制字符串，如下所示：

提示：雖然 ENCODE() 和DECODE() 這兩個函數能夠滿足大多數的要求，但是有的時候您希望使用強度更高的加密手段。在這種情況下，您可以使用 AES_ENCRYPT() 和 AES_DECRYPT() 函數，它們的工作方式是相同的，但是加密強度更高。

單向加密與雙向加密不同，一旦數據被加密就沒有辦法顛倒這一過程。因此密碼的驗證包括對用戶輸入內容的重新加密，並將它與保存的密文進行比對，看是否匹配。一種簡單的單向加密方式是MD5校驗碼。MySQL 的 MD5() 函數會為您的數據創建一個“指紋”並將它保存起來，供驗證測試使用。下面就是如何使用它的一個簡單例子：

1. mysql> INSERT INTO users (username,password) VALUES ('joe',MD5('guessme')); 
2.  
3. Query OK， 1 row affected (0.00 sec) 

mysql> INSERT INTO users (username,password) VALUES ('joe',MD5('guessme'));

Query OK， 1 row affected (0.00 sec)

或者，您考慮一下使用 ENCRYPT() 函數，它使用系統底層的 crypt() 系統調用來完成加密。這個函數有兩個參數：一個是要被加密的字符串，另一個是雙（或者多）字符的“salt”。它然後會用 salt 加密字符串；這個 salt 然後可以被用來再次加密用戶輸入的內容，並將它與先前加密的字符串進行比對。下面一個例子說明了如何使用它：

1. mysql> INSERT INTO users (username,password) VALUES('joe'， ENCRYPT('guessme','ab')); 
2.  
3. Query OK， 1 row affected (0.00 sec) 

mysql> INSERT INTO users (username,password) VALUES('joe'， ENCRYPT('guessme','ab'));

Query OK， 1 row affected (0.00 sec)

PS：ENCRYPT() 只能用在 UNIX、LINIX 系統上，因為它需要用到底層的 crypt() 庫。

---

二、單向加密(信息摘要)

Java 一般需要獲取物件 MessageDigest 來實現單項加密(信息摘要)。

1. MD5
即 Message-Digest Algorithm 5（信息-摘要演算法 5），用於確保信息傳輸完整一致。是計算機廣泛使用的雜湊演算法之一（又譯摘要演算法、哈希演算法），主流編程語言普遍已有MD5實現。將數據（如漢字）運算為另一固定長度值，是雜湊演算法的基礎原理，MD5 的前身有 MD2、MD3 和 MD4。MD5 的作用是讓大容量信息在用數字簽名軟件簽署私人密鑰前被"壓縮"成一種保密的格式（就是把一個任意長度的字節串變換成一定長的十六進制數字串）。
除了 MD5 以外，其中比較有名的還有 sha-1、RIPEMD 以及 Haval 等

原始碼

1. import java.security.MessageDigest; 
2. import java.security.NoSuchAlgorithmException; 
3.  
4. public class EncrypMD5 { 
5.  
6.    public byte[] eccrypt(String info) throws 
7.        NoSuchAlgorithmException 
8.    { 
9.        // 根據 MD5 演算法生成 MessageDigest 物件 
10.        MessageDigest md5 = MessageDigest.getInstance("MD5"); 
11.        byte[] srcBytes = info.getBytes(); 
12.        // 使用 srcBytes 更新摘要 
13.        md5.update(srcBytes); 
14.        // 完成哈希計算，得到 result 
15.        byte[] resultBytes = md5.digest(); 
16.        return resultBytes; 
17.    } 
18.  
19.    public static void main(String args[]) throws 
20.        NoSuchAlgorithmException 
21.    { 
22.        String msg = "郭XX-精品相聲技術"; 
23.        EncrypMD5 md5 = new EncrypMD5(); 
24.        byte[] resultBytes = md5.eccrypt(msg); 
25.  
26.        System.out.println("密文是：" + new String(resultBytes)); 
27.        System.out.println("明文是：" + msg); 
28.    } 
29. } 

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class EncrypMD5 {

    public byte[] eccrypt(String info) throws
        NoSuchAlgorithmException
    {
        // 根據 MD5 演算法生成 MessageDigest 物件
        MessageDigest md5 = MessageDigest.getInstance("MD5");
        byte[] srcBytes = info.getBytes();
        // 使用 srcBytes 更新摘要
        md5.update(srcBytes);
        // 完成哈希計算，得到 result
        byte[] resultBytes = md5.digest();
        return resultBytes;
    }

    public static void main(String args[]) throws
        NoSuchAlgorithmException
    {
        String msg = "郭XX-精品相聲技術";
        EncrypMD5 md5 = new EncrypMD5();
        byte[] resultBytes = md5.eccrypt(msg);

        System.out.println("密文是：" + new String(resultBytes));
        System.out.println("明文是：" + msg);
    }
}

2. SHA
是一種數據加密演算法，該演算法經過加密專家多年來的發展和改進已日益完善，現在已成為公認的最安全的散列演算法之一，並被廣泛使用。該演算法的思想是接收一段明文，然後以一種不可逆的方式將它轉換成一段（通常更小）密文，也可以簡單的理解為取一串輸入碼（稱為預映射或信息），並把它們轉化為長度較短、位數固定的輸出序列即散列值（也稱為信息摘要或信息認證代碼）的過程。散列函數值可以說時對明文的一種“指紋”或是“摘要”所以對散列值的數字簽名就可以視為對此明文的數字簽名。

原始碼

1. import java.security.MessageDigest; 
2. import java.security.NoSuchAlgorithmException; 
3.  
4. public class EncrypSHA { 
5.  
6.    public byte[] eccrypt(String info) throws 
7.        NoSuchAlgorithmException 
8.    { 
9.        MessageDigest sha = MessageDigest.getInstance("SHA"); 
10.        byte[] srcBytes = info.getBytes(); 
11.        // 使用 srcBytes 更新摘要 
12.        sha.update(srcBytes); 
13.        // 完成哈希計算，得到 result 
14.        byte[] resultBytes = sha.digest(); 
15.        return resultBytes; 
16.    } 
17.  
18.    /** 
19.     * @param args 
20.     * @throws NoSuchAlgorithmException 
21.     */ 
22.    public static void main(String[] args) throws 
23.        NoSuchAlgorithmException 
24.    { 
25.        String msg = "郭XX-精品相聲技術"; 
26.        EncrypSHA sha = new EncrypSHA(); 
27.        byte[] resultBytes = sha.eccrypt(msg); 
28.        System.out.println("明文是：" + msg); 
29.        System.out.println("密文是：" + new String(resultBytes)); 
30.  
31.    } 
32. } 

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class EncrypSHA {

    public byte[] eccrypt(String info) throws
        NoSuchAlgorithmException
    {
        MessageDigest sha = MessageDigest.getInstance("SHA");
        byte[] srcBytes = info.getBytes();
        // 使用 srcBytes 更新摘要
        sha.update(srcBytes);
        // 完成哈希計算，得到 result
        byte[] resultBytes = sha.digest();
        return resultBytes;
    }

    /**
     * @param args
     * @throws NoSuchAlgorithmException
     */
    public static void main(String[] args) throws
        NoSuchAlgorithmException
    {
        String msg = "郭XX-精品相聲技術";
        EncrypSHA sha = new EncrypSHA();
        byte[] resultBytes = sha.eccrypt(msg);
        System.out.println("明文是：" + msg);
        System.out.println("密文是：" + new String(resultBytes));

    }
}

附件中是以上幾種的源代碼，附帶額外的兩種使用方式。

增加一種關於文件的哈希演算法源代碼：

原始碼

1. import java.io.FileInputStream; 
2. import java.io.InputStream; 
3. import java.security.MessageDigest; 
4.  
5. public class FileHashUtil { 
6.  
7.    public static final char[] hexChar = { 
8.        '0', '1', '2', '3', '4', '5', '6', '7', 
9.        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' 
10.    }; 
11.    public static final String[] hashTypes = new String[] { 
12.        "MD2", "MD5", "SHA1", "SHA-256", "SHA-384", "SHA-512" 
13.    }; 
14.  
15.    public void MD5File(String fileName) throws Exception{ 
16.        //String fileName = args[0]; 
17.        System.out.println("需要獲取 hash 的文件為：　" + fileName); 
18.  
19.        java.util.List<MessageDigest> mds = new java.util.ArrayList<>(); 
20.        for (String hashType : hashTypes) { 
21.            MessageDigest md = MessageDigest.getInstance(hashType); 
22.            mds.add(md); 
23.        } 
24.  
25.        InputStream fis = null; 
26.        try { 
27.            fis = new FileInputStream(fileName); 
28.            byte[] buffer = new byte[1024]; 
29.            int numRead = 0; 
30.            while ((numRead = fis.read(buffer)) > 0) { 
31.                for (MessageDigest md : mds) { 
32.                    md.update(buffer, 0, numRead); 
33.                } 
34.            } 
35.        } catch (Exception ex) { 
36.            ex.printStackTrace(); 
37.        } finally { 
38.            if (fis != null) { fis.close(); } 
39.        } 
40.  
41.        for (MessageDigest md : mds) { 
42.            System.out.println( 
43.                md.getAlgorithm() + 
44.                " == " + 
45.                toHexString(md.digest()) 
46.            ); 
47.        } 
48.    } 
49.  
50.  
51.    public static void main(String[] args) throws Exception { 
52.        String[] fileName = new String[] { 
53.            "D:/hapfish/ShellFolder.java", 
54.            "D:/hapfish/ShellFolder - 副本.java", 
55.            "E:/ShellFolder - 副本.java", 
56.            "E:/ShellFolder.txt", 
57.            "D:/hapfish/ShellFolder.jpg", 
58.            "E:/ShellFolder增加字符.txt", 
59.            "D:/hapfish/birosoft.jar" 
60.        }; 
61.  
62.        FileHashUtil files  = new FileHashUtil(); 
63.        for(int i=0;i<fileName.length;i++){ 
64.            files.MD5File(fileName[i]); 
65.        } 
66.    } 
67.  
68.    public static String toHexString(byte[] b) { 
69.        StringBuilder sb = new StringBuilder(b.length * 2); 
70.        for (int i = 0; i < b.length; i++) { 
71.            sb.append(hexChar[(b[i] & 0xf0) >>> 4]); 
72.            sb.append(hexChar[b[i] & 0x0f]); 
73.        } 
74.        return sb.toString(); 
75.    } 
76. } 

import java.io.FileInputStream;
import java.io.InputStream;
import java.security.MessageDigest;

public class FileHashUtil {

    public static final char[] hexChar = {
        '0', '1', '2', '3', '4', '5', '6', '7',
        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
    };
    public static final String[] hashTypes = new String[] {
        "MD2", "MD5", "SHA1", "SHA-256", "SHA-384", "SHA-512"
    };

    public void MD5File(String fileName) throws Exception{
        //String fileName = args[0];
        System.out.println("需要獲取 hash 的文件為：　" + fileName);

        java.util.List<MessageDigest> mds = new java.util.ArrayList<>();
        for (String hashType : hashTypes) {
            MessageDigest md = MessageDigest.getInstance(hashType);
            mds.add(md);
        }

        InputStream fis = null;
        try {
            fis = new FileInputStream(fileName);
            byte[] buffer = new byte[1024];
            int numRead = 0;
            while ((numRead = fis.read(buffer)) > 0) {
                for (MessageDigest md : mds) {
                    md.update(buffer, 0, numRead);
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (fis != null) { fis.close(); }
        }

        for (MessageDigest md : mds) {
            System.out.println(
                md.getAlgorithm() +
                " == " +
                toHexString(md.digest())
            );
        }
    }


    public static void main(String[] args) throws Exception {
        String[] fileName = new String[] {
            "D:/hapfish/ShellFolder.java",
            "D:/hapfish/ShellFolder - 副本.java",
            "E:/ShellFolder - 副本.java",
            "E:/ShellFolder.txt",
            "D:/hapfish/ShellFolder.jpg",
            "E:/ShellFolder增加字符.txt",
            "D:/hapfish/birosoft.jar"
        };

        FileHashUtil files  = new FileHashUtil();
        for(int i=0;i<fileName.length;i++){
            files.MD5File(fileName[i]);
        }
    }

    public static String toHexString(byte[] b) {
        StringBuilder sb = new StringBuilder(b.length * 2);
        for (int i = 0; i < b.length; i++) {
            sb.append(hexChar[(b[i] & 0xf0) >>> 4]);
            sb.append(hexChar[b[i] & 0x0f]);
        }
        return sb.toString();
    }
}

運行說明

原始碼

1. "D:/hapfish/ShellFolder.java", 
2. "D:/hapfish/ShellFolder - 副本.java", 
3. "E:/ShellFolder - 副本.java", 
4. "E:/ShellFolder.txt", 
5. "D:/hapfish/ShellFolder.jpg", 
6. 以上五個文件是同一文件經過復制、改擴展名的，最後計算哈希結果是一致的。 
7.  
8. "E:/ShellFolder增加字符.txt" 增加了幾個字符串，就不一樣了 
9.  
10. "D:/hapfish/birosoft.jar" 完全不相關的另外一個文件 

"D:/hapfish/ShellFolder.java",
"D:/hapfish/ShellFolder - 副本.java",
"E:/ShellFolder - 副本.java",
"E:/ShellFolder.txt",
"D:/hapfish/ShellFolder.jpg",
以上五個文件是同一文件經過復制、改擴展名的，最後計算哈希結果是一致的。

"E:/ShellFolder增加字符.txt" 增加了幾個字符串，就不一樣了

"D:/hapfish/birosoft.jar" 完全不相關的另外一個文件

運行結果：

原始碼

1. 需要獲取 hash 的文件為：　D:/hapfish/ShellFolder.java 
2.  MD2 == 3a755a99c5e407005cd45ebd856b4649 
3.  MD5 == 5d08d440fa911d1e418c69a90b83cd86 
4.  SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63 
5.  SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99 
6.  SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6 
7.  SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458 
8. 需要獲取 hash 的文件為：　D:/hapfish/ShellFolder - 副本.java 
9.  MD2 == 3a755a99c5e407005cd45ebd856b4649 
10.  MD5 == 5d08d440fa911d1e418c69a90b83cd86 
11.  SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63 
12.  SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99 
13.  SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6 
14.  SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458 
15. 需要獲取 hash 的文件為：　E:/ShellFolder - 副本.java 
16.  MD2 == 3a755a99c5e407005cd45ebd856b4649 
17.  MD5 == 5d08d440fa911d1e418c69a90b83cd86 
18.  SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63 
19.  SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99 
20.  SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6 
21.  SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458 
22. 需要獲取 hash 的文件為：　E:/ShellFolder.txt 
23.  MD2 == 3a755a99c5e407005cd45ebd856b4649 
24.  MD5 == 5d08d440fa911d1e418c69a90b83cd86 
25.  SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63 
26.  SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99 
27.  SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6 
28.  SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458 
29. 需要獲取 hash 的文件為：　D:/hapfish/ShellFolder.jpg 
30.  MD2 == 3a755a99c5e407005cd45ebd856b4649 
31.  MD5 == 5d08d440fa911d1e418c69a90b83cd86 
32.  SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63 
33.  SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99 
34.  SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6 
35.  SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458 
36. 需要獲取 hash 的文件為：　E:/ShellFolder增加字符.txt 
37.  MD2 == f2717c24c6c0e110457bd17221c9ca6c 
38.  MD5 == c49e353a7c4c26bd7ccb5e90917c230f 
39.  SHA1 == 477c8a9e465bfaa4be42d35c032a17f7e6b42b97 
40.  SHA-256 == 9fa18adaf242ebcdc6563922d84c2a163c82e1a24db2eb2b73978ed1f354a8a3 
41.  SHA-384 == 4eee8f8e6d64d21c15dc01fa049f4d12a3b8e1d94d87763fe0bea75ab5ea8432fa8251289ece45ee39fe3d36b3c3020c 
42.  SHA-512 == e852ec0ff77250be497389d2f5a1818c18bb66106b9905c4ee26fe0d256eb3b77e0ce9a28a84e4b67e4332ba37ec3aa7518148e3a682318c0fc34c391f45c201 
43. 需要獲取 hash 的文件為：　D:/hapfish/birosoft.jar 
44.  MD2 == 38c5e1404718916dec59c33cafc909b3 
45.  MD5 == dc3e2cc4fb3949cf3660e0f5f8c3fba3 
46.  SHA1 == cde3dc25498afc5a563af0bb0eb54dc45f71bb28 
47.  SHA-256 == adf6a961c70c6ea677dff066fc5d896fb0beb4dd442ca0eb619ae1d1b04291e5 
48.  SHA-384 == fe7c6b754893c53ebd82bb53703fb5cc32115c9a38f98072f73def90729b271ee3c5c78e258bd9ff5ee5476193c2178b 
49.  SHA-512 == a15376f327256a6e049dfbdc5c2ad3a98bffccc6fa92ee01ff53db6b04471ca0f45ca28f76ff4a6911b57825afa046671299141f2499d71f1dac618c92385491 

需要獲取 hash 的文件為：　D:/hapfish/ShellFolder.java
  MD2 == 3a755a99c5e407005cd45ebd856b4649
  MD5 == 5d08d440fa911d1e418c69a90b83cd86
  SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63
  SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99
  SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6
  SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458
需要獲取 hash 的文件為：　D:/hapfish/ShellFolder - 副本.java
  MD2 == 3a755a99c5e407005cd45ebd856b4649
  MD5 == 5d08d440fa911d1e418c69a90b83cd86
  SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63
  SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99
  SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6
  SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458
需要獲取 hash 的文件為：　E:/ShellFolder - 副本.java
  MD2 == 3a755a99c5e407005cd45ebd856b4649
  MD5 == 5d08d440fa911d1e418c69a90b83cd86
  SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63
  SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99
  SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6
  SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458
需要獲取 hash 的文件為：　E:/ShellFolder.txt
  MD2 == 3a755a99c5e407005cd45ebd856b4649
  MD5 == 5d08d440fa911d1e418c69a90b83cd86
  SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63
  SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99
  SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6
  SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458
需要獲取 hash 的文件為：　D:/hapfish/ShellFolder.jpg
  MD2 == 3a755a99c5e407005cd45ebd856b4649
  MD5 == 5d08d440fa911d1e418c69a90b83cd86
  SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63
  SHA-256 == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99
  SHA-384 == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6
  SHA-512 == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458
需要獲取 hash 的文件為：　E:/ShellFolder增加字符.txt
  MD2 == f2717c24c6c0e110457bd17221c9ca6c
  MD5 == c49e353a7c4c26bd7ccb5e90917c230f
  SHA1 == 477c8a9e465bfaa4be42d35c032a17f7e6b42b97
  SHA-256 == 9fa18adaf242ebcdc6563922d84c2a163c82e1a24db2eb2b73978ed1f354a8a3
  SHA-384 == 4eee8f8e6d64d21c15dc01fa049f4d12a3b8e1d94d87763fe0bea75ab5ea8432fa8251289ece45ee39fe3d36b3c3020c
  SHA-512 == e852ec0ff77250be497389d2f5a1818c18bb66106b9905c4ee26fe0d256eb3b77e0ce9a28a84e4b67e4332ba37ec3aa7518148e3a682318c0fc34c391f45c201
需要獲取 hash 的文件為：　D:/hapfish/birosoft.jar
  MD2 == 38c5e1404718916dec59c33cafc909b3
  MD5 == dc3e2cc4fb3949cf3660e0f5f8c3fba3
  SHA1 == cde3dc25498afc5a563af0bb0eb54dc45f71bb28
  SHA-256 == adf6a961c70c6ea677dff066fc5d896fb0beb4dd442ca0eb619ae1d1b04291e5
  SHA-384 == fe7c6b754893c53ebd82bb53703fb5cc32115c9a38f98072f73def90729b271ee3c5c78e258bd9ff5ee5476193c2178b
  SHA-512 == a15376f327256a6e049dfbdc5c2ad3a98bffccc6fa92ee01ff53db6b04471ca0f45ca28f76ff4a6911b57825afa046671299141f2499d71f1dac618c92385491

最後，把運行結果貼出來有點占空間，主要為了說明表述自己的猜想。一般來說同一哈希演算法對同一文件(鏡像、擴展名被修改)所產生的結果應該是一致的。

因此有個猜想，在 baidu 文庫、騰訊的群共享上傳時，先會判斷是否有相同文件，從某種可能上來說也采用了對文件的哈希演算法，畢竟從本地運算一個哈希演算法後獲得的數值要比把整個文件傳過去比較實惠得多。而且字符串的比較也是很方便的。

對於某一種哈希演算法，存在一種可能：就是兩個不同的文件，計算出來的哈希值可能是一樣的。當然為了保險，可以用兩種甚至更多的哈希演算法，只有在每種演算法獲得的哈希值都相同時，才能判斷是同一個文件。
如果我們也對用戶上傳的文件進行哈希計算的話，就可以節省資源，同樣的文件按理說可以減少上傳次數……