Java对于数据加密与解密的实现EncryptUtil、MD5与sha-1

Cz范特西

已于 2022-01-21 16:25:40 修改

阅读量6.8k

点赞数 2

文章标签： java 安全 md5 sha1 加密解密

于 2022-01-21 16:25:00 首次发布

本文链接：https://blog.csdn.net/weixin_45866737/article/details/122623649

版权

前言

假设用户在创建账户的时候，会输入账户名和密码，此时，密码会存储到数据库中。如果我们的数据库被黑客黑了，数据泄露，那么黑客就得到了数据库中所有用户的账户密码，这不安全。

如果我们对于用户的密码进行加密，再存储到数据库中，那么，即使数据库被黑客黑掉拿到用户密码了，也是加了密的密码，没有解密算法的话，黑客也无法登录，相对来说比较安全。

因此，以下介绍Java如何对数据进行加密解密。

EncryptUtil加密工具类

import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

/**
 * 加密工具类
 */
public final class EncryptUtil {

    // 原始密匙,自己设置，必须为8位，使得你加密的密码是通过这8位加密的
    // 如果别人使用的加密工具类和你一样，只要这8位不同，加密完的密码就不同
    private static final String PASSWORD_CRYPT_KEY = "88444487";
    private final static String DES = "DES";


    /**
     * 密码解密
     * @return
     * @throws Exception
     */
    public static String decrypt(String src) {
        try {
            return new String(decrypt(hex2byte(src.getBytes()), PASSWORD_CRYPT_KEY.getBytes()));
        } catch (Exception e) {
        }
        return null;
    }

    /**
     * 密码加密
     * @return
     * @throws Exception
     */
    public static String encrypt(String src) {
        try {
            return byte2hex(encrypt(src.getBytes(), PASSWORD_CRYPT_KEY.getBytes()));
        } catch (Exception e) {
        }
        return null;
    }

    /**
     * 加密
     *
     * @param src 数据源
     * @param key 密钥，长度必须是8的倍数
     * @return 返回加密后的数据
     * @throws Exception
     */
    private static byte[] encrypt(byte[] src, byte[] key) throws Exception {
        // DES算法要求有一个可信任的随机数源
        SecureRandom sr = new SecureRandom();
        // 从原始密匙数据创建DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(key);
        // 创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
        SecretKey securekey = keyFactory.generateSecret(dks);
        // Cipher对象实际完成加密操作
        Cipher cipher = Cipher.getInstance(DES);
        // 用密匙初始化Cipher对象
        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
        // 现在，获取数据并加密正式执行加密操作
        return cipher.doFinal(src);
    }

    /**
     * 解密
     * 
     * @param src 数据源
     * @param key 密钥，长度必须是8的倍数
     * @return 返回解密后的原始数据
     * @throws Exception
     */
    private static byte[] decrypt(byte[] src, byte[] key) throws Exception {
        // DES算法要求有一个可信任的随机数源
        SecureRandom sr = new SecureRandom();
        // 从原始密匙数据创建一个DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(key);
        // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成一个SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
        SecretKey securekey = keyFactory.generateSecret(dks);
        // Cipher对象实际完成解密操作
        Cipher cipher = Cipher.getInstance(DES);
        // 用密匙初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, securekey, sr);
        // 现在，获取数据并解密正式执行解密操作
        return cipher.doFinal(src);
    }

    /**
     * 字符串转二进制
     * @param b
     * @return
     */
    private static byte[] hex2byte(byte[] b) {
        if ((b.length % 2) != 0)
            throw new IllegalArgumentException("长度不是偶数");
        byte[] b2 = new byte[b.length / 2];
        for (int n = 0; n < b.length; n += 2) {
            String item = new String(b, n, 2);
            b2[n / 2] = (byte) Integer.parseInt(item, 16);
        }
        return b2;
    }

    /**
     * 二行制转字符串
     * @param b
     * @return
     */
    private static String byte2hex(byte[] b) {
        String hs = "";
        String stmp = "";
        for (int n = 0; n < b.length; n++) {
            stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
            if (stmp.length() == 1)
                hs = hs + "0" + stmp;
            else
                hs = hs + stmp;
        }
        return hs.toUpperCase();
    }
}

使用测试：

public class EncryTest {
    public static void main(String[] args) {
        String str = "1234567";
        String encrypt = EncryptUtil.encrypt(str);
        System.out.println(encrypt);    //输出：14C749ACC3821362
        String decrypt = EncryptUtil.decrypt(encrypt);
        System.out.println(decrypt);    //输出：1234567
    }
}

MD5与sha-1

MD5与sha-1是不可逆的算法，密码加密之后不能解密。

因此，如果用户密码通过MD5或sha-1加密存储到数据库后，用户下次登录，就对用户输入的密码进行加密，然后将加密后的密码与数据库中的密码进行对比，对比相同后才登录成功。

public class Encryption {

    /**
     * md5加密
     *
     * @param src
     * @return
     */
    public static String md5(String src) {
        return encrypt(src, "md5");
    }

    /**
     * sha-1加密
     *
     * @param src
     * @return
     */
    public static String sha(String src) {
        return encrypt(src, "sha-1");
    }

    /**
     * md5或者sha-1加密
     *
     * @param src
     *            要加密的内容
     * @param algorithmName
     *            加密算法名称：md5或者sha-1，不区分大小写
     * @return
     */
    private static String encrypt(String src, String algorithmName) {
        if (src == null || "".equals(src.trim())) {
            throw new IllegalArgumentException("请输入要加密的内容");
        }
        if (algorithmName == null || "".equals(algorithmName.trim())) {
            algorithmName = "md5";
        }
        String encryptText = null;
        try {
            MessageDigest m = MessageDigest.getInstance(algorithmName);
            m.update(src.getBytes("UTF8"));
            byte s[] = m.digest();
            // m.digest(src.getBytes("UTF8"));
            return hex(s);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return encryptText;
    }

    /**
     * 返回十六进制字符串
     *
     * @param arr
     * @return
     */
    private static String hex(byte[] arr) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < arr.length; ++i) {
            sb.append(Integer.toHexString((arr[i] & 0xFF) | 0x100).substring(1, 3));
        }
        return sb.toString();
    }
}

测试：

public class MD5Test {
    public static void main(String[] args) {
        String md5 = Encryption.md5("123456");
        String db_password = md5;  //数据库中的密码

        String pwd = "123456";  //用户输入的密码

        if (Encryption.md5(pwd).equals(db_password)){
            System.out.println("登录成功");
        }else {
            System.out.println("密码错误");
        }
    }
}

MD5与sha-1并不建议当作数据加密工具

普遍认为MD5是很安全，因为暴力破解的时间是一般人无法接受的。实际上如果把用户的密码MD5处理后再存储到数据库，其实是很不安全的。因为用户的密码是比较短的，而且很多用户的密码都使用生日，手机号码，身份证号码，电话号码等等。或者使用常用的一些吉利的数字，或者某个英文单词。如果我把常用的密码先MD5处理，把数据存储起来，然后再跟你的MD5结果匹配，这时我就有可能得到明文。比如某个MD5破解网站http://www.cmd5.com/default.aspx，所以现在大多数网站密码的策略是强制要求用户使用数字大小写字母的组合的方式提高用户密码的安全度。

详情可参考下面的链接。