数据加密的一些理解

青旅半醒 2022-07-15 10:08 193阅读 0赞

**（一）加密算法分为：**  
**（1）对称加密算法：**

*  DES算法，3DES算法，TDEA算法，Blowfish算法，RC5算法，IDEA算法，AES算法。

**（2）非对称加密算法 :**

*  RSA、Elgamal、背包算法、Rabin、D-H、ECC。

**（3）哈希算法 :**

*  MD2、MD4、MD5 和 SHA-1

**(二) 区别及特点：**  
**对称加密算法：**

*  秘钥只有一个，通过该秘钥可以对加密过后的数据进行解密。加密解密速度相对快，安全性低一点。解密加密都用同一个秘钥所以叫对称加密算法。

**非对称加密算法 ：**

*  一般分为两个秘钥 一个加密秘钥一个解密秘钥， 称为公钥和秘钥。  
    公钥进行加密，可以公开。秘钥进行解密不公开。加密解密速度较慢一点。安全性高。两个秘钥不一样所以叫非对称加密算法 。

**哈希算法 ：**

*  目的是将任意长输入通过算法变为固定长输出，且保证输入变化一点输出都不同，且不能反向解密。

(三) 举例

**对称加密算法 （AES）：**

/**
     * Created by linving on 2016/11/10.
     */
    
    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    
    import javax.crypto.*;
    import javax.crypto.spec.SecretKeySpec;
    import java.math.BigInteger;
    import java.security.InvalidKeyException;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    
    
    /**
     * 编码工具类
     * 1.将byte[]转为各种进制的字符串
     * 2.base 64 encode
     * 3.base 64 decode
     * 4.获取byte[]的md5值
     * 5.获取字符串md5值
     * 6.结合base64实现md5加密
     * 7.AES加密
     * 8.AES加密为base 64 code
     * 9.AES解密
     * 10.将base 64 code AES解密
     *
     * @author uikoo9
     * @version 0.0.7.20140601
     */
    public class AESUtil {
        
    
    
        /**
         * 将byte[]转为各种进制的字符串
         *
         * @param bytes byte[]
         * @param radix 可以转换进制的范围，从Character.MIN_RADIX到Character.MAX_RADIX，超出范围后变为10进制
         * @return 转换后的字符串
         */
        public static String binary(byte[] bytes, int radix) {
            return new BigInteger(1, bytes).toString(radix);// 这里的1代表正数
        }
    
        /**
         * base 64 encode
         *
         * @param bytes 待编码的byte[]
         * @return 编码后的base 64 code
         */
        public static String base64Encode(byte[] bytes) {
            return new BASE64Encoder().encode(bytes);
        }
    
        /**
         * base 64 decode
         *
         * @param base64Code 待解码的base 64 code
         * @return 解码后的byte[]
         * @throws Exception
         */
        public static byte[] base64Decode(String base64Code) throws Exception {
            return new BASE64Decoder().decodeBuffer(base64Code);
        }
    
        /**
         * 获取byte[]的md5值
         *
         * @param bytes byte[]
         * @return md5
         * @throws Exception
         */
        public static byte[] md5(byte[] bytes) throws Exception {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(bytes);
    
            return md.digest();
        }
    
        /**
         * 获取字符串md5值
         *
         * @param msg
         * @return md5
         * @throws Exception
         */
        public static byte[] md5(String msg) throws Exception {
            return md5(msg.getBytes());
        }
    
        /**
         * 结合base64实现md5加密
         *
         * @param msg 待加密字符串
         * @return 获取md5后转为base64
         * @throws Exception
         */
        public static String md5Encrypt(String msg) throws Exception {
            return base64Encode(md5(msg));
        }
    
        /**
         * AES加密
         *
         * @param content    待加密的内容
         * @param encryptKey 加密密钥
         * @return 加密后的byte[]
         * @throws Exception
         */
        public static byte[] aesEncryptToBytes(String content, String encryptKey) throws Exception {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            kgen.init(128, new SecureRandom(encryptKey.getBytes()));
    
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));
    
            return cipher.doFinal(content.getBytes("utf-8"));
        }
    
        /**
         * AES加密为base 64 code
         *
         * @param content    待加密的内容
         * @param encryptKey 加密密钥
         * @return 加密后的base 64 code
         * @throws Exception
         */
        public static String aesEncrypt(String content, String encryptKey) {
            try {
                return base64Encode(aesEncryptToBytes(content, encryptKey));
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * AES解密
         *
         * @param encryptBytes 待解密的byte[]
         * @param decryptKey   解密密钥
         * @return 解密后的String
         * @throws Exception
         */
        public static String aesDecryptByBytes(byte[] encryptBytes, String decryptKey) {
    
            try {
                KeyGenerator kgen = KeyGenerator.getInstance("AES");
                kgen.init(128, new SecureRandom(decryptKey.getBytes()));
                Cipher cipher = Cipher.getInstance("AES");
                cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));
                byte[] decryptBytes = cipher.doFinal(encryptBytes);
                return new String(decryptBytes);
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 将base 64 code AES解密
         *
         * @param encryptStr 待解密的base 64 code
         * @param decryptKey 解密密钥
         * @return 解密后的string
         * @throws Exception
         */
        public static String aesDecrypt(String encryptStr, String decryptKey)  {
            try {
                return aesDecryptByBytes(base64Decode(encryptStr), decryptKey);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
    }

**非对称加密算法（RSA）**

/**
     * Created by linving on 2016/11/10.
     */
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.security.InvalidKeyException;
    import java.security.Key;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.HashMap;
    import java.util.Map;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;
    
    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    
    /**
     * RSA算法，实现数据的加密解密。
     * @author ShaoJiang
     *
     */
    public class RSAUtil {
        
    
        private static Cipher cipher;
    
        static{
            try {
                cipher = Cipher.getInstance("RSA");
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 生成密钥对
         * @return
         */
        public static Map<String,String> generateKeyPair(){
            try {
                KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
                // 密钥位数
                keyPairGen.initialize(1024);
                // 密钥对
                KeyPair keyPair = keyPairGen.generateKeyPair();
                // 公钥
                PublicKey publicKey = keyPair.getPublic();
                // 私钥
                PrivateKey privateKey = keyPair.getPrivate();
                //得到公钥字符串
                String publicKeyString = getKeyString(publicKey);
                //得到私钥字符串
                String privateKeyString = getKeyString(privateKey);
                //将生成的密钥对返回
                Map<String,String> map = new HashMap<>();
                map.put("publicKey",publicKeyString);
                map.put("privateKey",privateKeyString);
                return map;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 得到公钥
         *
         * @param key
         *            密钥字符串（经过base64编码）
         * @throws Exception
         */
        public static PublicKey getPublicKey(String key) throws Exception {
            byte[] keyBytes;
            keyBytes = (new BASE64Decoder()).decodeBuffer(key);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PublicKey publicKey = keyFactory.generatePublic(keySpec);
            return publicKey;
        }
    
        /**
         * 得到私钥
         *
         * @param key
         *            密钥字符串（经过base64编码）
         * @throws Exception
         */
        public static PrivateKey getPrivateKey(String key) throws Exception {
            byte[] keyBytes;
            keyBytes = (new BASE64Decoder()).decodeBuffer(key);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
            return privateKey;
        }
    
        /**
         * 得到密钥字符串（经过base64编码）
         *
         * @return
         */
        public static String getKeyString(Key key) throws Exception {
            byte[] keyBytes = key.getEncoded();
            String s = (new BASE64Encoder()).encode(keyBytes);
            return s;
        }
    
        /**
         * 使用公钥对明文进行加密，返回BASE64编码的字符串
         * @param publicKey
         * @param plainText
         * @return
         */
        public static String encrypt(PublicKey publicKey,String plainText){
            try {
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                byte[] enBytes = cipher.doFinal(plainText.getBytes());
                return (new BASE64Encoder()).encode(enBytes);
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 使用keystore对明文进行加密
         * @param
         * @param plainText      明文
         * @return
         */
        public static String encrypt(String publicKey,String plainText){
            try {
                cipher.init(Cipher.ENCRYPT_MODE,getPublicKey(publicKey));
                byte[] enBytes = cipher.doFinal(plainText.getBytes());
                return (new BASE64Encoder()).encode(enBytes);
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 使用私钥对明文密文进行 解密
         * @param privateKey
         * @param enStr
         * @return
         */
        public static String decrypt(PrivateKey privateKey,String enStr){
            try {
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                byte[] deBytes = cipher.doFinal((new BASE64Decoder()).decodeBuffer(enStr));
                return new String(deBytes);
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 使用keystore对密文进行解密
         * @param enStr   密文
         * @return
         */
        public static String decrypt(String privateKey,String enStr){
            try {
                cipher.init(Cipher.DECRYPT_MODE, getPrivateKey(privateKey));
                byte[] deBytes = cipher.doFinal((new BASE64Decoder()).decodeBuffer(enStr));
                return new String(deBytes);
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    }

**散列算法 /哈希算法(MD5 )**

import java.io.IOException;
    import java.io.StringReader;
    
    public class HexDump {
        
        class HexTablifier {
            private int m_row = 8;
    
            private String m_pre = "";
    
            private String m_post = "\n";
    
            public HexTablifier() {
            }
    
            public HexTablifier(int row) {
                this(row, "", "\n");
            }
    
            public HexTablifier(int row, String pre) {
                this(row, pre, "\n");
            }
    
            public HexTablifier(int row, String pre, String post) {
                m_row = row;
                m_pre = pre;
                m_post = post;
            }
    
            public String format(String hex) {
                StringReader reader = new StringReader(hex);
                StringBuilder builder = new StringBuilder(hex.length() * 2);
    
                try {
                    while (getHexLine(builder, reader)) {
                    }
                } catch (IOException e) {
                    // 不应该有异常出现。
                }
    
                return builder.toString();
            }
    
            private boolean getHexLine(StringBuilder builder, StringReader reader)
                    throws IOException {
                StringBuilder lineBuilder = new StringBuilder();
                boolean result = true;
    
                for (int i = 0; i < m_row; i++) {
                    result = getHexByte(lineBuilder, reader);
    
                    if (result == false)
                        break;
                }
    
                if (lineBuilder.length() > 0) {
                    builder.append(m_pre);
                    builder.append(lineBuilder);
                    builder.append(m_post);
                }
    
                return result;
            }
    
            private boolean getHexByte(StringBuilder builder, StringReader reader)
                    throws IOException {
                char[] hexByte = new char[4];
                int bytesRead = reader.read(hexByte);
    
                if (bytesRead == -1)
                    return false;
    
                builder.append(hexByte, 0, bytesRead);
                builder.append(" ");
    
                return bytesRead == 4;
            }
        }
    
        private static final char m_hexCodes[] = { '0', '1', '2', '3', '4', '5',
                '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
    
        private static final int m_shifts[] = { 60, 56, 52, 48, 44, 40, 36, 32, 28,
                24, 20, 16, 12, 8, 4, 0 };
    
        public static String tablify(byte[] bytes) {
            return (new HexDump()).new HexTablifier().format(HexDump.toHex(bytes));
        }
    
        public static String tablify(byte[] bytes, int row) {
            return (new HexDump()).new HexTablifier(row).format(HexDump
                    .toHex(bytes));
        }
    
        public static String tablify(byte[] bytes, int row, String pre) {
            return (new HexDump()).new HexTablifier(row, pre).format(HexDump
                    .toHex(bytes));
        }
    
        public static String tablify(String hex, int row, String pre, String post) {
            return (new HexDump()).new HexTablifier(row, pre, post).format(hex);
        }
    
        private static String toHex(final long value, final int digitNum) {
            StringBuilder result = new StringBuilder(digitNum);
    
            for (int j = 0; j < digitNum; j++) {
                int index = (int) ((value >> m_shifts[j + (16 - digitNum)]) & 15);
                result.append(m_hexCodes[index]);
            }
    
            return result.toString();
        }
    
        public static String toHex(final byte value) {
            return toHex(value, 2);
        }
    
        public static String toHex(final short value) {
            return toHex(value, 4);
        }
    
        public static String toHex(final int value) {
            return toHex(value, 8);
        }
    
        public static String toHex(final long value) {
            return toHex(value, 16);
        }
    
        public static String toHex(final byte[] value) {
            return toHex(value, 0, value.length);
        }
    
        public static String toHex(final byte[] value, final int offset,
                final int length) {
            StringBuilder retVal = new StringBuilder();
    
            int end = offset + length;
            for (int x = offset; x < end; x++)
                retVal.append(toHex(value[x]));
    
            return retVal.toString();
        }
    
        public static byte[] restoreBytes(String hex) {
            byte[] bytes = new byte[hex.length() / 2];
            for (int i = 0; i < bytes.length; ++i) {
                int c1 = charToNumber(hex.charAt(2 * i));
                int c2 = charToNumber(hex.charAt(2 * i + 1));
                if (c1 == -1 || c2 == -1) {
                    return null;
                }
                bytes[i] = (byte) ((c1 << 4) + c2);
            }
    
            return bytes;
        }
    
        private static int charToNumber(char c) {
            if (c >= '0' && c <= '9') {
                return c - '0';
            } else if (c >= 'a' && c <= 'f') {
                return c - 'a' + 0xa;
            } else if (c >= 'A' && c <= 'F') {
                return c - 'A' + 0xA;
            } else {
                return -1;
            }
        }
    }

import java.io.UnsupportedEncodingException;
    import java.security.MessageDigest;
    
    /**
     * Created by linving on 2016/11/12.
     */
    public class MD5Util {
        
    
        public static String getStringMD5(String value) {
            if (value == null || value.trim().length() < 1) {
                return null;
            }
            try {
                return getMD5(value.getBytes("UTF-8"));
            } catch (UnsupportedEncodingException e) {
                throw new RuntimeException(e.getMessage(), e);
            }
        }
    
        public static String getMD5(byte[] source) {
            try {
                MessageDigest md5 = MessageDigest.getInstance("MD5");
                return HexDump.toHex(md5.digest(source));
            } catch (Exception e) {
                throw new RuntimeException(e.getMessage(), e);
            }
        }
    
    }

**Test :**

import java.util.Map;
    
    /**
     * Created by linving on 2016/11/10.
     */
    public class Test {
        public static void main(String[] args) {
            testRSA();
            testAES();
            tetsMD5();
        }
    
        private static void testAES() {
    
    
            String data = "adcb";
            System.out.println("AES加密前：" + data);
    
            String key = "123456";
            System.out.println("AES加密密钥和解密密钥：" + key);
    
            String encrypt = AESUtil.aesEncrypt(data, key);
            System.out.println("AES加密后：" + encrypt);
    
            String decrypt = AESUtil.aesDecrypt(encrypt, key);
            System.out.println("AES解密后：" + decrypt);
    
        }
    
    
        private static void testRSA() {
    
            String data = "adsbc";
            String publicKey = "";
            String privateKey = "";
            System.out.println("RSA原始数据: " + data);
    
            Map<String, String> keyPair = RSAUtil.generateKeyPair();
            publicKey = keyPair.get("publicKey");
            privateKey = keyPair.get("privateKey");
            System.out.println("RSA公钥: " + publicKey);
            System.out.println("RSA私钥: " + privateKey);
    
            String encryptData = RSAUtil.encrypt(publicKey, data);
            System.out.println("RSA加密数据: " + encryptData);
            String decryptData = RSAUtil.decrypt(privateKey, encryptData);
            System.out.println("RSA解密数据: " + decryptData);
        }
    
        private static void tetsMD5() {
            String data = "adsbc";
            System.out.println("MD5原始数据: " + data);
            String encryptData = MD5Util.getStringMD5(data);
            System.out.println("MD5 加密数据: " + encryptData);
    
    
        }
    
    }
    
    
    结果：

RSA原始数据: adsbc  
RSA公钥: MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCwUnEo/9+NI8GJbQtwl6X7MuALqe7YzuDNEeGn  
3zEuiktxbXj53duJoYtGqO+rY+Vae7Ypt7UwolgnFtfJbfSmoBJc7wuBPOdTFkpsb7nYZXTvNoFI  
fYdjT2mQgcOnZGSoz7alApPQ1sxXkkZ2tx+H+hsSaHxTBHW1Pq6Eyqi8LQIDAQAB  
RSA私钥: MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBALBScSj/340jwYltC3CXpfsy4Aup  
7tjO4M0R4affMS6KS3FtePnd24mhi0ao76tj5Vp7tim3tTCiWCcW18lt9KagElzvC4E851MWSmxv  
udhldO82gUh9h2NPaZCBw6dkZKjPtqUCk9DWzFeSRna3H4f6GxJofFMEdbU+roTKqLwtAgMBAAEC  
gYEAjAquvfWcRKllihUFxQNtXTpnIFxzy9dkTPwq0f4/PcuxaAGe2DYRrBqWWCTNVr8c5uTjJfc2  
/c2zXjiSYvXmHS8EGFglwsJ8Dos+FiPtWTJl0Xo3Qhnbs2+F2z9Idgg0ddzrLK5r2o6l8VWuv/43  
vdrjnvc4ArF/Kas/RHKyzzECQQDlVI2aiAqkOjs44sxr2rrRZRcRp5qxz8k/M31yRJnHWEVL6DXx  
9IxGtkZNYdaD6fHgfbxd/5Xano7iyxvoJGmjAkEAxNPEh1ZW8SFQaE9mt/AMU6OMDM6F399uunOs  
7yzz6vCUxLOIko6oyFj0WiilQEr9Y1wr1EZGkcMHYeJFK1k/7wJANJqtlKnqDvvQg976Vy8oNUoD  
/ae9g1YParDr8J8tyx1DYAMXBLY8yyeafruXklDCi+UrpUAwZqKCUiGW+CwKEwJBAMHiTMx3+0qp  
41ftJyT3fF0DVJjk8zD1GlDmU6qCoH+EnzcoFtcvWgmIvqL1ONsdQ38Vs0L2OtuovuPoDPTHhNcC  
QBkOkrgFhJYnmDDTMUj4TCEO64RIdOyzzpFeQ0TgpjMJ99QOv8Q2kEFpylCw9bYMk1uioCStYSR8  
ZOhE+H2N+yg=  
RSA加密数据: Olsmy/qEigtaXIhlY8g41ktk1pXo/Kr098hA0keGM718yc6vnS2Mzc0YFXCQUMnpYS3ZEa7mm0Lg  
CBIQNaPC8LPRmVS+giXui5Us9vbtYmejSRC0aDqnFqlONaoQidxHGSow65vpvgPTTfm3Hec/xOnC  
6iEaslW4bsaEQcTHm6k=  
RSA解密数据: adsbc  
AES加密前：adcb  
AES加密密钥和解密密钥：123456  
AES加密后：F0QsZk5pFhDME01ZT7sQ0Q==  
AES解密后：adcb  
MD5原始数据: adsbc  
MD5 加密数据: 51d84a98aeb971d801a9e1bed8803bd1

Process finished with exit code 0

这就是常用的加密算法了， 通常如果数据比较隐私的话，会采用多重加密算法。比如先经过 RSA 再经过 AＥＳ　算法进行加密。

用ＲＳＡ算法将ＡＥＳ的秘钥和数据绑定在一起，解密后拿到ＡＥＳ的秘钥再解密。

更多精彩内容：  
[http://jblog.top/][http_jblog.top]

[http_jblog.top]: http://jblog.top/