Java加密解密介绍

柔情只为你懂 2022-10-02 12:46 55阅读 0赞

# 加密解密介绍 #

常用的加密算法总体可以分为两类：单项加密和双向加密，双向加密又分为对称加密和非对称加密，因此主要分析下面三种加密算法：

对称加密算法、非对称加密算法和单项加密算法（Hash算法）。

*  1、对称加密算法（AES、DES、3DES）  
    对称加密算法是指加密和解密采用相同的密钥，是可逆的（即可解密）。  
    AES加密算法是密码学中的高级加密标准，采用的是对称分组密码体制，密钥长度的最少支持为128。AES加密算法是美国联邦政府采用的区块加密标准，这个标准用来替代原先的DES，已经被多方分析且广为全世界使用。  
    优点：加密速度快  
    缺点：密钥的传递和保存是一个问题，参与加密和解密的双方使用的密钥是一样的，这样密钥就很容易泄露。
 *  2、非对称加密算法（RSA、DSA）  
    非对称加密算法是指加密和解密采用不同的密钥（公钥和私钥），因此非对称加密也叫公钥加密，是可逆的（即可解密）。  
    RSA加密算法是基于一个十分简单的数论事实：将两个大素数相乘十分容易，但是想要对其乘积进行因式分解极其困难，因此可以将乘积公开作为加密密钥。虽然RSA的安全性一直未能得到理论上的证明，但它经历了各种攻击至今未被完全攻破。  
    优点：加密和解密的密钥不一致，公钥是可以公开的，只需保证私钥不被泄露即可，这样就密钥的传递变的简单很多，从而降低了被破解的几率。  
    缺点：加密速度慢  
    RSA加密算法既可以用来做数据加密，也可以用来数字签名。

1.  数据加密过程：发送者用公钥加密，接收者用私钥解密（只有拥有私钥的接收者才能解读加密的内容）
2.  数字签名过程：甲方用私钥加密，乙方用公钥解密（乙方解密成功说明就是甲方加的密，甲方就不可以抵赖）

*  3、Hash加密算法（MD5）  
    MD5全称是Message-Digest Algorithm 5（信息摘要算法5），单向的算法不可逆（被MD5加密的数据不能被解密）。MD5加密后的数据长度要比加密数据小的多，且长度固定，且加密后的串是唯一的。  
    适用场景：常用在不可还原的密码存储、信息完整性校验等。  
    信息完整性校验：典型的应用是对一段信息产生信息摘要，以防止被篡改。如果再有一个第三方的认证机构，用MD5还可以防止文件作者的“抵赖”，这就是所谓的数字签名应用。
 *  4、混合加密  
    由于以上加密算法都有各自的缺点（RSA加密速度慢、AES密钥存储问题、MD5加密不可逆），因此实际应用时常将几种加密算法混合使用。  
    例如：RSA+AES：  
    采用RSA加密AES的密钥，采用AES对数据进行加密，这样集成了两种加密算法的优点，既保证了数据加密的速度，又实现了安全方便的密钥管理。  
    那么，采用多少位的密钥合适呢？一般来讲密钥长度越长，安全性越高，但是加密速度越慢。所以密钥长度也要合理的选择，一般RSA建议采用1024位的数字，AES建议采用128位即可。
 *  5、Base64  
    严格意义讲，Base64并不能算是一种加密算法，而是一种编码格式，是网络上最常见的用于传输8bid字节代码的编码方式之一。  
    Base64编码可用于在HTTP环境下传递较长的标识信息，Base编码不仅不仅比较简单，同时也据有不可读性（编码的数据不会被肉眼直接看到）。

# 部分代码实现 #

package com.util;
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.Mac;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    
    import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
    
    import java.security.MessageDigest;
    import java.security.SecureRandom;
    
    public class EncryptUtil {
        public static final String MD5 = "MD5";
        public static final String SHA1 = "SHA1";
        public static final String HmacMD5 = "HmacMD5";
        public static final String HmacSHA1 = "HmacSHA1";
        public static final String DES = "DES";
        public static final String AES = "AES";
    
        /**编码格式；默认使用uft-8*/
        public String charset = "utf-8";
        /**DES*/
        public int keysizeDES = 0;
        /**AES*/
        public int keysizeAES = 128;
    
        public static EncryptUtil me;
    
        private EncryptUtil(){
            //单例
        }
        //双重锁
        public static EncryptUtil getInstance(){
            if (me==null) {
               synchronized (EncryptUtil.class) {
                   if(me == null){
                       me = new EncryptUtil();
                   }
               }
            }
            return me;
        }
    
        /**
         * 使用MessageDigest进行单向加密（无密码）
         * @param res 被加密的文本
         * @param algorithm 加密算法名称
         * @return
         */
        private String messageDigest(String res,String algorithm){
            try {
                MessageDigest md = MessageDigest.getInstance(algorithm);
                byte[] resBytes = charset==null?res.getBytes():res.getBytes(charset);
                return base64(md.digest(resBytes));
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 使用KeyGenerator进行单向/双向加密（可设密码）
         * @param res 被加密的原文
         * @param algorithm  加密使用的算法名称
         * @param key 加密使用的秘钥
         * @return
         */
        private String keyGeneratorMac(String res,String algorithm,String key){
            try {
                SecretKey sk = null;
                if (key==null) {
                    KeyGenerator kg = KeyGenerator.getInstance(algorithm);
                    sk = kg.generateKey();
                }else {
                    byte[] keyBytes = charset==null?key.getBytes():key.getBytes(charset);
                    sk = new SecretKeySpec(keyBytes, algorithm);
                }
                Mac mac = Mac.getInstance(algorithm);
                mac.init(sk);
                byte[] result = mac.doFinal(res.getBytes());
                return base64(result);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 使用KeyGenerator双向加密，DES/AES，注意这里转化为字符串的时候是将2进制转为16进制格式的字符串，不是直接转，因为会出错
         * @param res 加密的原文
         * @param algorithm 加密使用的算法名称
         * @param key  加密的秘钥
         * @param keysize
         * @param isEncode
         * @return
         */
        private String keyGeneratorES(String res,String algorithm,String key,int keysize,boolean isEncode){
            try {
                KeyGenerator kg = KeyGenerator.getInstance(algorithm);
                if (keysize == 0) {
                    byte[] keyBytes = charset==null?key.getBytes():key.getBytes(charset);
                    kg.init(new SecureRandom(keyBytes));
                }else if (key==null) {
                    kg.init(keysize);
                }else {
                    byte[] keyBytes = charset==null?key.getBytes():key.getBytes(charset);
                    kg.init(keysize, new SecureRandom(keyBytes));
                }
                SecretKey sk = kg.generateKey();
                SecretKeySpec sks = new SecretKeySpec(sk.getEncoded(), algorithm);
                Cipher cipher = Cipher.getInstance(algorithm);
                if (isEncode) {
                    cipher.init(Cipher.ENCRYPT_MODE, sks);
                    byte[] resBytes = charset==null?res.getBytes():res.getBytes(charset);
                    return parseByte2HexStr(cipher.doFinal(resBytes));
                }else {
                    cipher.init(Cipher.DECRYPT_MODE, sks);
                    return new String(cipher.doFinal(parseHexStr2Byte(res)));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        private String base64(byte[] res){
            return Base64.encode(res);
        }
    
        /**将二进制转换成16进制 */
        public static String parseByte2HexStr(byte buf[]) {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < buf.length; i++) {
                String hex = Integer.toHexString(buf[i] & 0xFF);
                if (hex.length() == 1) {
                    hex = '0' + hex;
                }
                sb.append(hex.toUpperCase());
            }
            return sb.toString();
        }
        /**将16进制转换为二进制*/
        public static byte[] parseHexStr2Byte(String hexStr) {
            if (hexStr.length() < 1)
                return null;
            byte[] result = new byte[hexStr.length()/2];
            for (int i = 0;i< hexStr.length()/2; i++) {
                int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);
                int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);
                result[i] = (byte) (high * 16 + low);
            }
            return result;
        }
    
        /**
         * md5加密算法进行加密（不可逆）
         * @param res 需要加密的原文
         * @return
         */
        public String MD5(String res) {
            return messageDigest(res, MD5);
        }
    
        /**
         * md5加密算法进行加密（不可逆）
         * @param res  需要加密的原文
         * @param key  秘钥
         * @return
         */
        public String MD5(String res, String key) {
            return keyGeneratorMac(res, HmacMD5, key);
        }
    
        /**
         * 使用SHA1加密算法进行加密（不可逆）
         * @param res 需要加密的原文
         * @return
         */
        public String SHA1(String res) {
            return messageDigest(res, SHA1);
        }
    
        /**
         * 使用SHA1加密算法进行加密（不可逆）
         * @param res 需要加密的原文
         * @param key 秘钥
         * @return
         */
        public String SHA1(String res, String key) {
            return keyGeneratorMac(res, HmacSHA1, key);
        }
    
        /**
         * 使用DES加密算法进行加密（可逆）
         * @param res 需要加密的原文
         * @param key 秘钥
         * @return
         */
        public String DESencode(String res, String key) {
            return keyGeneratorES(res, DES, key, keysizeDES, true);
        }
    
        /**
         * 对使用DES加密算法的密文进行解密（可逆）
         * @param res 需要解密的密文
         * @param key 秘钥
         * @return
         */
        public String DESdecode(String res, String key) {
            return keyGeneratorES(res, DES, key, keysizeDES, false);
        }
    
        /**
         * 使用AES加密算法经行加密（可逆）
         * @param res 需要加密的密文
         * @param key 秘钥
         * @return
         */
        public String AESencode(String res, String key) {
            return keyGeneratorES(res, AES, key, keysizeAES, true);
        }
    
        /**
         * 对使用AES加密算法的密文进行解密
         * @param res 需要解密的密文
         * @param key 秘钥
         * @return
         */
        public String AESdecode(String res, String key) {
            return keyGeneratorES(res, AES, key, keysizeAES, false);
        }
    
        /**
         * 使用异或进行加密
         * @param res 需要加密的密文
         * @param key 秘钥
         * @return
         */
        public String XORencode(String res, String key) {
            byte[] bs = res.getBytes();
            for (int i = 0; i < bs.length; i++) {
                bs[i] = (byte) ((bs[i]) ^ key.hashCode());
            }
            return parseByte2HexStr(bs);
        }
    
        /**
         * 使用异或进行解密
         * @param res 需要解密的密文
         * @param key 秘钥
         * @return
         */
        public String XORdecode(String res, String key) {
            byte[] bs = parseHexStr2Byte(res);
            for (int i = 0; i < bs.length; i++) {
                bs[i] = (byte) ((bs[i]) ^ key.hashCode());
            }
            return new String(bs);
        }
    
        /**
         * 直接使用异或（第一调用加密，第二次调用解密）
         * @param res 密文
         * @param key 秘钥
         * @return
         */
        public int XOR(int res, String key) {
            return res ^ key.hashCode();
        }
    
        /**
         * 使用Base64进行加密
         * @param res 密文
         * @return
         */
        public String Base64Encode(String res) {
            return Base64.encode(res.getBytes());
        }
    
        /**
         * 使用Base64进行解密
         * @param res
         * @return
         */
        public String Base64Decode(String res) {
            return new String(Base64.decode(res));
        }
    }

# JS的MD5加密 #

[Md5插件下载地址][Md5]

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
    <html xmlns="http://www.w3.org/1999/xhtml"> 
      <head> 
       <title>liehuo.net</title> 
      <script type="text/javascript" src="/uploads/Common/jquery-1.3.2.min.js"></script> 
      <script type="text/javascript" src="/uploads/Common/js/jquery.md5.js"></script> 
      <script type="text/javascript"> alert($.md5("Hello,Liehuo.Net")); </script> 
      </head> 
     <body> 
    </body> 
    </html>

[Md5]: http://www.veryhuo.com/uploads/Common/js/jQuery.md5.js