Java's built in encryption class MessageDigest class code example

MessageDigest class

The MessageDigest class provides the functionality of an information summary algorithm for an application, such as the MD5 or SHA algorithm. An information digest is a secure one-way hash function that receives arbitrary data sizes and outputs a fixed length hash value.

The MessageDigest object begins to be initialized. This object processes the data by using the update () method. The reset () method can be called at any time to reset the summary. Once all the data that needs to be updated has been updated, the digest() method 1 should be called to complete the hash.

The digest method can only be called once for a given amount of updated data. After calling digest, the MessageDigest object is reset to its original state.

Description:

On the site, in order to protect the members of the privacy information such as the user name and password, so we can directly when user registration MD5 encrypted way or the other way, even the database administrator can't view the member's information such as password, check the password in the database effect such as: 8 e830882f03b2cb84d1a657f346dd41a effect.

Because the MD5 algorithm is irreversible, it is widely used by many websites.

Three commonly used encryption methods

Option 1: Convert the encrypted data to hexadecimal using the bit operator
Method 2: Convert the encrypted data into hexadecimal using formatting (recommended)
Method 3: Convert the encrypted data into hexadecimal using an algorithm

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
/** 
 *  use Java built-in MessageDigest class  
 * @author xiaokui 
 */
public class EncryptionUtil {
	/** 
  *  Due to the MD5  with SHA-1 Both from MD4  Developed, they have a lot in common in such properties as structure and strength  
  * SHA-1 with MD5  The biggest difference lies in its summary ratio MD5  In the long  32  Bits ( 1byte=8bit , equivalent to the length of 4byte , the transformation 16 Than after into the system MD5 more 8 Three characters).  
  *  For forcible attack, : MD5  is 2128  An order of magnitude operation, SHA-1  is 2160 An operation of orders of magnitude.  
  *  Difficulty for two messages with the same abstract: MD5 is  264  It's an order of magnitude operation, SHA-1  is 280  An operation of orders of magnitude.  
  *  As a result, SHA-1  The intensity of a forced attack is greater.   But as a result of SHA-1  The cyclic step ratio MD5  More than ( 80:64 ) and the cache to be processed is large ( 160  The bit :128  Bits), SHA-1  Running speed ratio MD5  Slow.  
  * 
  * @param source  String that needs to be encrypted  
  * @param hashType  Encryption type   ( MD5  and  SHA )  
  * @return 
  */
	public static String getHash(String source, String hashType) {
		//  Used to convert bytes to  16  The character represented in base  
		char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
		try {
			MessageDigest md = MessageDigest.getInstance(hashType);
			md.update(source.getBytes());
			//  Through the use of  update  Methods To process data , Make the specified  byte Array update summary  
			byte[] encryptStr = md.digest();
			//  Obtain ciphertext to complete the hash calculation , produce 128  Long integer of bits  
			char str[] = new char[16 * 2];
			//  Per byte  16  In base case, use two characters  
			int k = 0;
			//  Represents the corresponding character position in the conversion result  
			for (int i = 0; i < 16; i++) {
				//  From the first 1 Start with 2 bytes, for each 1 bytes , Converted to  16  Conversion of base characters  
				byte byte0 = encryptStr[i];
				//  Take the first  i  bytes  
				str[k++] = hexDigits[byte0 >>> 4 & 0xf];
				//  Takes the height of a byte  4  Digit conversion of bits , >>>  Move the symbol bit to the right of the logic 1 The moves to the right  
				str[k++] = hexDigits[byte0 & 0xf];
				//  Take the low in the byte  4  Digit conversion of bits 
			}
			return new String(str);
			//  The result is converted to a string 
		}
		catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return null;
	}
	/** @param source  String that needs to be encrypted  
  * @param hashType  Encryption type   ( MD5  and  SHA )  
  * @return 
  */
	public static String getHash2(String source, String hashType) {
		StringBuilder sb = new StringBuilder();
		MessageDigest md5;
		try {
			md5 = MessageDigest.getInstance(hashType);
			md5.update(source.getBytes());
			for (byte b : md5.digest()) {
				sb.append(String.format("%02X", b));
				// 10 Turn into the system 16 Into the system, X  Said to 106 Output in base form, 02  Indicates insufficient two front fill 0 The output 
			}
			return sb.toString();
		}
		catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return null;
	}
	/** @param source  String that needs to be encrypted  
  * @param hashType  Encryption type   ( MD5  and  SHA )  
  * @return 
  */
	public static String getHash3(String source, String hashType) {
		//  Used to convert bytes to  16  The character represented in base  
		char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
		StringBuilder sb = new StringBuilder();
		MessageDigest md5;
		try {
			md5 = MessageDigest.getInstance(hashType);
			md5.update(source.getBytes());
			byte[] encryptStr = md5.digest();
			for (int i = 0; i < encryptStr.length; i++) {
				int iRet = encryptStr[i];
				if (iRet < 0) {
					iRet += 256;
				}
				int iD1 = iRet / 16;
				int iD2 = iRet % 16;
				sb.append(hexDigits[iD1] + "" + hexDigits[iD2]);
			}
			return sb.toString();
		}
		catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return null;
	}
	public static void main(String[] args) {
		System.out.println(getHash(" Small, carlos ", "MD5"));
		System.out.println(getHash(" Small, carlos ", "SHA") + "\n");
		System.out.println(getHash2(" Small, carlos ", "MD5"));
		System.out.println(getHash2(" Small, carlos ", "SHA") + "\n");
		System.out.println(getHash3(" Small, carlos ", "MD5"));
		System.out.println(getHash3(" Small, carlos ", "SHA") + "\n");
	}
}

The output

 8e830882f03b2cb84d1a657f346dd41a 
 0ba5512371d00c86e91712f44aab7138 
 
 8E830882F03B2CB84D1A657F346DD41A 
 0BA5512371D00C86E91712F44AAB713898745F91 
 
 8e830882f03b2cb84d1a657f346dd41a 
 0ba5512371d00c86e91712f44aab713898745f91 

We found that all three methods performed the same, with SHA 8 more characters (32 bits) than MD5

conclusion

That's the end of this article on Java's built-in encryption class MessageDigest class code examples, I hope to help you. If there is any deficiency, please let me know.