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

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

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

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

因此，以下介绍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";


    
    public static String decrypt(String src) {
        try {
            return new String(decrypt(hex2byte(src.getBytes()), PASSWORD_CRYPT_KEY.getBytes()));
        } catch (Exception e) {
        }
        return null;
    }

    
    public static String encrypt(String src) {
        try {
            return byte2hex(encrypt(src.getBytes(), PASSWORD_CRYPT_KEY.getBytes()));
        } catch (Exception e) {
        }
        return null;
    }

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

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

    
    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;
    }

    
    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 {

    
    public static String md5(String src) {
        return encrypt(src, "md5");
    }

    
    public static String sha(String src) {
        return encrypt(src, "sha-1");
    }

    
    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;
    }

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

详情可参考下面的链接。

参考：https://blog.csdn.net/u012611878/article/details/54000607