java加密算法–MD5加密和哈希散列带秘钥加密算法源码

下面我来详细讲解Java加密算法——MD5加密和哈希散列带秘钥加密算法源码的完整攻略。

MD5加密算法

概述

MD5(Message Digest Algorithm)是一种单向的哈希算法，可以将任意长度的数据加密成一个128位的二进制串。MD5算法将数据经过多次非线性函数变换和数据干扰后，生成一个唯一的128位散列码，具有很高的安全性，被广泛应用于数据的完整性校验和密码保护等领域。

MD5加密实现

Java中MD5加密的实现可以通过java.security.MessageDigest类来完成。实现代码如下：

import java.security.*;

public class MD5Util {
    /**
     * 对字符串进行MD5加密
     * @param src 源字符串
     * @return 加密后的字符串
     */
    public static String MD5(String src) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] bytes = md.digest(src.getBytes());
            StringBuilder sb = new StringBuilder();
            for (byte b : bytes) {
                String str = Integer.toHexString(b & 0xff);
                if (str.length() == 1) {
                    sb.append("0");
                }
                sb.append(str);
            }
            return sb.toString();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return null;
    }
}

上面的MD5Util类提供了一个静态方法MD5，参数为源字符串src，返回值为加密后的字符串。该方法通过MessageDigest.getInstance("MD5")获取MD5加密实例，然后通过md.digest(src.getBytes())方法对传入的源字符串进行加密，并返回加密后的字节数组。再通过字节数组转换为十六进制字符串的方式，得到最终的加密结果。

MD5加密示例

下面通过一个简单的示例来演示MD5加密的使用：

public class Test {
    public static void main(String[] args) {
        String src = "123456";
        String result = MD5Util.MD5(src);
        System.out.println("MD5加密后的字符串为：" + result);
    }
}

以上代码输出的结果为：

MD5加密后的字符串为：e10adc3949ba59abbe56e057f20f883e

哈希散列带秘钥加密算法

概述

哈希散列带秘钥加密算法主要用于对数据进行加密和解密，加密时使用秘钥对数据进行哈希计算，生成一个指定长度的哈希值，并用此哈希值异或原始数据作为加密结果。解密时对加密结果进行异或运算，再使用相同的秘钥进行哈希计算，如果生成的哈希值与加密结果中的哈希值相等，则表示解密成功。

哈希散列带秘钥加密实现

Java中哈希散列带秘钥加密的实现可以通过javax.crypto.KeyGenerator类和javax.crypto.Cipher类来完成。实现代码如下：

import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.security.*;

public class HashEncryptUtil {
    /**
     * 对字符串进行哈希散列带秘钥加密
     * @param src 源字符串
     * @param secretKey 秘钥
     * @param algorithm 加密算法
     * @return 加密后的字符串
     */
    public static String hashEncrypt(String src, String secretKey, String algorithm) {
        try {
            KeyGenerator keyGen = KeyGenerator.getInstance(algorithm);
            SecureRandom random = new SecureRandom(secretKey.getBytes());
            keyGen.init(random);
            SecretKey key = keyGen.generateKey();
            Cipher cipher = Cipher.getInstance(algorithm);
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] bytes = src.getBytes();
            bytes = cipher.doFinal(bytes);
            StringBuilder sb = new StringBuilder();
            for (byte b : bytes) {
                String str = Integer.toHexString(b & 0xff);
                if (str.length() == 1) {
                    sb.append("0");
                }
                sb.append(str);
            }
            return sb.toString();
        } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | BadPaddingException | IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 对字符串进行哈希散列带秘钥解密
     * @param encryptedStr 加密后的字符串
     * @param secretKey 秘钥
     * @param algorithm 加密算法
     * @return 解密后的字符串
     */
    public static String hashDecrypt(String encryptedStr, String secretKey, String algorithm) {
        try {
            KeyGenerator keyGen = KeyGenerator.getInstance(algorithm);
            SecureRandom random = new SecureRandom(secretKey.getBytes());
            keyGen.init(random);
            SecretKey key = keyGen.generateKey();
            Cipher cipher = Cipher.getInstance(algorithm);
            cipher.init(Cipher.DECRYPT_MODE, key);
            byte[] bytes = hex2Bytes(encryptedStr);
            bytes = cipher.doFinal(bytes);
            return new String(bytes);
        } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | BadPaddingException | IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 将十六进制字符串转换为字节数组
     * @param hexString 十六进制字符串
     * @return 字节数组
     */
    private static byte[] hex2Bytes(String hexString) {
        if (hexString == null || hexString.equals("")) {
            return null;
        }
        hexString = hexString.toUpperCase();
        int length = hexString.length() / 2;
        char[] hexChars = hexString.toCharArray();
        byte[] bytes = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            bytes[i] = (byte) (char2Byte(hexChars[pos]) << 4 | char2Byte(hexChars[pos + 1]));
        }
        return bytes;
    }

    /**
     * 将字符转换为字节
     * @param c 字符
     * @return 字节
     */
    private static byte char2Byte(char c) {
        return (byte) "0123456789ABCDEF".indexOf(c);
    }
}

上面的HashEncryptUtil类提供了两个静态方法hashEncrypt和hashDecrypt，分别用于对字符串进行加密和解密，参数为源字符串src、秘钥secretKey、加密算法algorithm，返回值为加密或解密后的字符串。加密方法中使用KeyGenerator.generateKey()方法生成一个秘钥；使用Cipher.getInstance(algorithm)方法获取Cipher实例；通过cipher.init(Cipher.ENCRYPT_MODE, key)初始化Cipher实例为加密模式，然后对源字符串进行加密，并将结果转换为十六进制字符串。解密方法中仍然使用KeyGenerator.generateKey()方法生成一个秘钥；使用Cipher.getInstance(algorithm)方法获取Cipher实例；通过cipher.init(Cipher.DECRYPT_MODE, key)初始化Cipher实例为解密模式，然后对加密后的字符串进行解密，并将结果还原为原始字符串。

哈希散列带秘钥加密示例

下面通过一个简单的示例来演示哈希散列带秘钥加密的使用：

public class Test {
    public static void main(String[] args) {
        String src = "123456";
        String secretKey = "abcd1234";
        String algorithm = "AES";
        String encryptedStr = HashEncryptUtil.hashEncrypt(src, secretKey, algorithm);
        System.out.println("加密后的字符串为：" + encryptedStr);
        String decryptedStr = HashEncryptUtil.hashDecrypt(encryptedStr, secretKey, algorithm);
        System.out.println("解密后的字符串为：" + decryptedStr);
    }
}

以上代码输出的结果为：

加密后的字符串为：1d452be8beed39a1f1f4d08723b21ea9
解密后的字符串为：123456

以上就是Java加密算法——MD5加密和哈希散列带秘钥加密算法源码的完整攻略。