Java中常用的加密方法(JDK)

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

雙向加密大體意思就是明文加密後形成密文，可以通過算法還原成明文。而單向加密只是對信息進行了摘要計算，不能通過算法生成明文，單向加密從嚴格意思上說不能算是加密的一種，應該算是摘要算法吧。具體區分可以參考： 
(本人解釋不清呢 …… ) 
http://security.group.iteye.com/group/wiki/1710-one-way-encryption-algorithm 
一、雙向加密 
(一)、對稱加密 
採用單鑰密碼系統的加密方法，同一個密鑰可以同時用作信息的加密和解密，這種加密方法稱爲對稱加密，也稱爲單密鑰加密。 
需要對加密和解密使用相同密鑰的加密算法。由於其速度，對稱性加密通常在消息發送方需要加密大量數據時使用。對稱性加密也稱爲密鑰加密。 
所謂對稱，就是採用這種加密方法的雙方使用方式用同樣的密鑰進行加密和解密。密鑰是控制加密及解密過程的指令。 

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

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

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

在構造函數中初始化 

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位的密鑰按位替代或交換的方法形成密文組的加密方法。 

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))) 

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());
        // 實例化支持DES算法的密鑰生成器(算法名稱命名需按規定，否則拋出異常)
        keygen = KeyGenerator.getInstance("DESede");
        // 生成密鑰
        deskey = keygen.generateKey();
        // 生成Cipher對象,指定其支持的DES算法
        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"。） 

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());
        //實例化支持DES算法的密鑰生成器(算法名稱命名需按規定，否則拋出異常)
        keygen = KeyGenerator.getInstance("AES");
        //生成密鑰
        deskey = keygen.generateKey();
        //生成Cipher對象,指定其支持的DES算法
        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算法基於一個十分簡單的數論事實：將兩個大素數相乘十分容易，但那時想要對其乘積進行因式分解卻極其困難，因此可以將乘積公開作爲加密密鑰。 

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){
            //Cipher負責完成加密或解密工作，基於RSA
            Cipher cipher = Cipher.getInstance("RSA");
            //根據公鑰，對Cipher對象進行初始化
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            byte[] resultBytes = cipher.doFinal(srcBytes);
            return resultBytes;
        }
        return null;
    }

    /**
     * 解密
     * @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){
            //Cipher負責完成加密或解密工作，基於RSA
            Cipher cipher = Cipher.getInstance("RSA");
            //根據公鑰，對Cipher對象進行初始化
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[] resultBytes = cipher.doFinal(srcBytes);
            return resultBytes;
        }
        return null;
    }

    /**
     * @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()。 
下面是一個簡單的實例： 

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（）函數會爲您的數據創建一個“指紋”並將它保存起來，供驗證測試使用。下面就是如何使用它的一個簡單例子： 

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

Query OK， 1 row affected （0.00 sec）

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

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

Query OK， 1 row affected （0.00 sec）

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

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

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

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

public class EncrypSHA {

    public byte[] eccrypt(String info) throws NoSuchAlgorithmException{
        MessageDigest md5 = MessageDigest.getInstance("SHA");
        byte[] srcBytes = info.getBytes();
        //使用srcBytes更新摘要
        md5.update(srcBytes);
        //完成哈希計算，得到result
        byte[] resultBytes = md5.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));

    }

}

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

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

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<MessageDigest>();
        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();
    }

}

運行說明 

"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" 完全不相關的另外一個文件

運行結果： 

需要獲取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文庫、騰訊的羣共享上傳時，先會判斷是否有相同文件，從某種可能上來說也採用了對文件的哈希算法，畢竟從本地運算一個哈希算法後獲得的數值要比把整個文件傳過去比較實惠得多。而且字符串的比較也是很方便的。 

對於某一種哈希算法，存在一種可能：就是兩個不同的文件，計算出來的哈希值可能是一樣的。當然爲了保險，可以用兩種甚至更多的哈希算法，只有在每種算法獲得的哈希值都相同時，才能判斷是同一個文件。 

如果我們也對用戶上傳的文件進行哈希計算的話，就可以節省資源，同樣的文件按理說可以減少上傳次數……

轉自：http://www.iteye.com/topic/1122076