数据加密的一些理解

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

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

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

（2）非对称加密算法 :

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

（3）哈希算法 :

  • MD2、MD4、MD5 和 SHA-1

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

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

非对称加密算法 ：

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

哈希算法 ：

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

(三) 举例

对称加密算法 （AES）：

  1. /**
  2.  * Created by linving on 2016/11/10.
  3.  */
  5. import sun.misc.BASE64Decoder;
  6. import sun.misc.BASE64Encoder;
  8. import javax.crypto.*;
  9. import javax.crypto.spec.SecretKeySpec;
  10. import java.math.BigInteger;
  11. import java.security.InvalidKeyException;
  12. import java.security.MessageDigest;
  13. import java.security.NoSuchAlgorithmException;
  14. import java.security.SecureRandom;
  17. /**
  18.  * 编码工具类
  19.  * 1.将byte[]转为各种进制的字符串
  20.  * 2.base 64 encode
  21.  * 3.base 64 decode
  22.  * 4.获取byte[]的md5值
  23.  * 5.获取字符串md5值
  24.  * 6.结合base64实现md5加密
  25.  * 7.AES加密
  26.  * 8.AES加密为base 64 code
  27.  * 9.AES解密
  28.  * 10.将base 64 code AES解密
  29.  *
  30.  * @author uikoo9
  31.  * @version 0.0.7.20140601
  32.  */
  33. public class AESUtil {
  37.     /**
  38.      * 将byte[]转为各种进制的字符串
  39.      *
  40.      * @param bytes byte[]
  41.      * @param radix 可以转换进制的范围，从Character.MIN_RADIX到Character.MAX_RADIX，超出范围后变为10进制
  42.      * @return 转换后的字符串
  43.      */
  44.     public static String binary(byte[] bytes, int radix) {
  45.         return new BigInteger(1, bytes).toString(radix);// 这里的1代表正数
  46.     }
  48.     /**
  49.      * base 64 encode
  50.      *
  51.      * @param bytes 待编码的byte[]
  52.      * @return 编码后的base 64 code
  53.      */
  54.     public static String base64Encode(byte[] bytes) {
  55.         return new BASE64Encoder().encode(bytes);
  56.     }
  58.     /**
  59.      * base 64 decode
  60.      *
  61.      * @param base64Code 待解码的base 64 code
  62.      * @return 解码后的byte[]
  63.      * @throws Exception
  64.      */
  65.     public static byte[] base64Decode(String base64Code) throws Exception {
  66.         return new BASE64Decoder().decodeBuffer(base64Code);
  67.     }
  69.     /**
  70.      * 获取byte[]的md5值
  71.      *
  72.      * @param bytes byte[]
  73.      * @return md5
  74.      * @throws Exception
  75.      */
  76.     public static byte[] md5(byte[] bytes) throws Exception {
  77.         MessageDigest md = MessageDigest.getInstance("MD5");
  78.         md.update(bytes);
  80.         return md.digest();
  81.     }
  83.     /**
  84.      * 获取字符串md5值
  85.      *
  86.      * @param msg
  87.      * @return md5
  88.      * @throws Exception
  89.      */
  90.     public static byte[] md5(String msg) throws Exception {
  91.         return md5(msg.getBytes());
  92.     }
  94.     /**
  95.      * 结合base64实现md5加密
  96.      *
  97.      * @param msg 待加密字符串
  98.      * @return 获取md5后转为base64
  99.      * @throws Exception
  100.      */
  101.     public static String md5Encrypt(String msg) throws Exception {
  102.         return base64Encode(md5(msg));
  103.     }
  105.     /**
  106.      * AES加密
  107.      *
  108.      * @param content    待加密的内容
  109.      * @param encryptKey 加密密钥
  110.      * @return 加密后的byte[]
  111.      * @throws Exception
  112.      */
  113.     public static byte[] aesEncryptToBytes(String content, String encryptKey) throws Exception {
  114.         KeyGenerator kgen = KeyGenerator.getInstance("AES");
  115.         kgen.init(128, new SecureRandom(encryptKey.getBytes()));
  117.         Cipher cipher = Cipher.getInstance("AES");
  118.         cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));
  120.         return cipher.doFinal(content.getBytes("utf-8"));
  121.     }
  123.     /**
  124.      * AES加密为base 64 code
  125.      *
  126.      * @param content    待加密的内容
  127.      * @param encryptKey 加密密钥
  128.      * @return 加密后的base 64 code
  129.      * @throws Exception
  130.      */
  131.     public static String aesEncrypt(String content, String encryptKey) {
  132.         try {
  133.             return base64Encode(aesEncryptToBytes(content, encryptKey));
  134.         } catch (Exception e) {
  135.             e.printStackTrace();
  136.         }
  137.         return null;
  138.     }
  140.     /**
  141.      * AES解密
  142.      *
  143.      * @param encryptBytes 待解密的byte[]
  144.      * @param decryptKey   解密密钥
  145.      * @return 解密后的String
  146.      * @throws Exception
  147.      */
  148.     public static String aesDecryptByBytes(byte[] encryptBytes, String decryptKey) {
  150.         try {
  151.             KeyGenerator kgen = KeyGenerator.getInstance("AES");
  152.             kgen.init(128, new SecureRandom(decryptKey.getBytes()));
  153.             Cipher cipher = Cipher.getInstance("AES");
  154.             cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"));
  155.             byte[] decryptBytes = cipher.doFinal(encryptBytes);
  156.             return new String(decryptBytes);
  157.         } catch (NoSuchAlgorithmException e) {
  158.             e.printStackTrace();
  159.         } catch (BadPaddingException e) {
  160.             e.printStackTrace();
  161.         } catch (IllegalBlockSizeException e) {
  162.             e.printStackTrace();
  163.         } catch (NoSuchPaddingException e) {
  164.             e.printStackTrace();
  165.         } catch (InvalidKeyException e) {
  166.             e.printStackTrace();
  167.         }
  168.         return null;
  169.     }
  171.     /**
  172.      * 将base 64 code AES解密
  173.      *
  174.      * @param encryptStr 待解密的base 64 code
  175.      * @param decryptKey 解密密钥
  176.      * @return 解密后的string
  177.      * @throws Exception
  178.      */
  179.     public static String aesDecrypt(String encryptStr, String decryptKey)  {
  180.         try {
  181.             return aesDecryptByBytes(base64Decode(encryptStr), decryptKey);
  182.         } catch (Exception e) {
  183.             e.printStackTrace();
  184.         }
  185.         return null;
  186.     }
  188. }

非对称加密算法（RSA）

  1. /**
  2.  * Created by linving on 2016/11/10.
  3.  */
  5. import java.io.BufferedReader;
  6. import java.io.BufferedWriter;
  7. import java.io.FileReader;
  8. import java.io.FileWriter;
  9. import java.io.IOException;
  10. import java.security.InvalidKeyException;
  11. import java.security.Key;
  12. import java.security.KeyFactory;
  13. import java.security.KeyPair;
  14. import java.security.KeyPairGenerator;
  15. import java.security.NoSuchAlgorithmException;
  16. import java.security.PrivateKey;
  17. import java.security.PublicKey;
  18. import java.security.interfaces.RSAPrivateKey;
  19. import java.security.interfaces.RSAPublicKey;
  20. import java.security.spec.PKCS8EncodedKeySpec;
  21. import java.security.spec.X509EncodedKeySpec;
  22. import java.util.HashMap;
  23. import java.util.Map;
  25. import javax.crypto.BadPaddingException;
  26. import javax.crypto.Cipher;
  27. import javax.crypto.IllegalBlockSizeException;
  28. import javax.crypto.NoSuchPaddingException;
  30. import sun.misc.BASE64Decoder;
  31. import sun.misc.BASE64Encoder;
  33. /**
  34.  * RSA算法，实现数据的加密解密。
  35.  * @author ShaoJiang
  36.  *
  37.  */
  38. public class RSAUtil {
  41.     private static Cipher cipher;
  43.     static{
  44.         try {
  45.             cipher = Cipher.getInstance("RSA");
  46.         } catch (NoSuchAlgorithmException e) {
  47.             e.printStackTrace();
  48.         } catch (NoSuchPaddingException e) {
  49.             e.printStackTrace();
  50.         }
  51.     }
  53.     /**
  54.      * 生成密钥对
  55.      * @return
  56.      */
  57.     public static Map<String,String> generateKeyPair(){
  58.         try {
  59.             KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
  60.             // 密钥位数
  61.             keyPairGen.initialize(1024);
  62.             // 密钥对
  63.             KeyPair keyPair = keyPairGen.generateKeyPair();
  64.             // 公钥
  65.             PublicKey publicKey = keyPair.getPublic();
  66.             // 私钥
  67.             PrivateKey privateKey = keyPair.getPrivate();
  68.             //得到公钥字符串
  69.             String publicKeyString = getKeyString(publicKey);
  70.             //得到私钥字符串
  71.             String privateKeyString = getKeyString(privateKey);
  72.             //将生成的密钥对返回
  73.             Map<String,String> map = new HashMap<>();
  74.             map.put("publicKey",publicKeyString);
  75.             map.put("privateKey",privateKeyString);
  76.             return map;
  77.         } catch (Exception e) {
  78.             e.printStackTrace();
  79.         }
  80.         return null;
  81.     }
  83.     /**
  84.      * 得到公钥
  85.      *
  86.      * @param key
  87.      *            密钥字符串（经过base64编码）
  88.      * @throws Exception
  89.      */
  90.     public static PublicKey getPublicKey(String key) throws Exception {
  91.         byte[] keyBytes;
  92.         keyBytes = (new BASE64Decoder()).decodeBuffer(key);
  93.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
  94.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  95.         PublicKey publicKey = keyFactory.generatePublic(keySpec);
  96.         return publicKey;
  97.     }
  99.     /**
  100.      * 得到私钥
  101.      *
  102.      * @param key
  103.      *            密钥字符串（经过base64编码）
  104.      * @throws Exception
  105.      */
  106.     public static PrivateKey getPrivateKey(String key) throws Exception {
  107.         byte[] keyBytes;
  108.         keyBytes = (new BASE64Decoder()).decodeBuffer(key);
  109.         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
  110.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
  111.         PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
  112.         return privateKey;
  113.     }
  115.     /**
  116.      * 得到密钥字符串（经过base64编码）
  117.      *
  118.      * @return
  119.      */
  120.     public static String getKeyString(Key key) throws Exception {
  121.         byte[] keyBytes = key.getEncoded();
  122.         String s = (new BASE64Encoder()).encode(keyBytes);
  123.         return s;
  124.     }
  126.     /**
  127.      * 使用公钥对明文进行加密，返回BASE64编码的字符串
  128.      * @param publicKey
  129.      * @param plainText
  130.      * @return
  131.      */
  132.     public static String encrypt(PublicKey publicKey,String plainText){
  133.         try {
  134.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);
  135.             byte[] enBytes = cipher.doFinal(plainText.getBytes());
  136.             return (new BASE64Encoder()).encode(enBytes);
  137.         } catch (InvalidKeyException e) {
  138.             e.printStackTrace();
  139.         } catch (IllegalBlockSizeException e) {
  140.             e.printStackTrace();
  141.         } catch (BadPaddingException e) {
  142.             e.printStackTrace();
  143.         }
  144.         return null;
  145.     }
  147.     /**
  148.      * 使用keystore对明文进行加密
  149.      * @param
  150.      * @param plainText      明文
  151.      * @return
  152.      */
  153.     public static String encrypt(String publicKey,String plainText){
  154.         try {
  155.             cipher.init(Cipher.ENCRYPT_MODE,getPublicKey(publicKey));
  156.             byte[] enBytes = cipher.doFinal(plainText.getBytes());
  157.             return (new BASE64Encoder()).encode(enBytes);
  158.         } catch (InvalidKeyException e) {
  159.             e.printStackTrace();
  160.         } catch (IllegalBlockSizeException e) {
  161.             e.printStackTrace();
  162.         } catch (BadPaddingException e) {
  163.             e.printStackTrace();
  164.         } catch (Exception e) {
  165.             e.printStackTrace();
  166.         }
  167.         return null;
  168.     }
  170.     /**
  171.      * 使用私钥对明文密文进行 解密
  172.      * @param privateKey
  173.      * @param enStr
  174.      * @return
  175.      */
  176.     public static String decrypt(PrivateKey privateKey,String enStr){
  177.         try {
  178.             cipher.init(Cipher.DECRYPT_MODE, privateKey);
  179.             byte[] deBytes = cipher.doFinal((new BASE64Decoder()).decodeBuffer(enStr));
  180.             return new String(deBytes);
  181.         } catch (InvalidKeyException e) {
  182.             e.printStackTrace();
  183.         } catch (IllegalBlockSizeException e) {
  184.             e.printStackTrace();
  185.         } catch (BadPaddingException e) {
  186.             e.printStackTrace();
  187.         } catch (IOException e) {
  188.             e.printStackTrace();
  189.         }
  190.         return null;
  191.     }
  193.     /**
  194.      * 使用keystore对密文进行解密
  195.      * @param enStr   密文
  196.      * @return
  197.      */
  198.     public static String decrypt(String privateKey,String enStr){
  199.         try {
  200.             cipher.init(Cipher.DECRYPT_MODE, getPrivateKey(privateKey));
  201.             byte[] deBytes = cipher.doFinal((new BASE64Decoder()).decodeBuffer(enStr));
  202.             return new String(deBytes);
  203.         } catch (InvalidKeyException e) {
  204.             e.printStackTrace();
  205.         } catch (IllegalBlockSizeException e) {
  206.             e.printStackTrace();
  207.         } catch (BadPaddingException e) {
  208.             e.printStackTrace();
  209.         } catch (IOException e) {
  210.             e.printStackTrace();
  211.         } catch (Exception e) {
  212.             e.printStackTrace();
  213.         }
  214.         return null;
  215.     }
  216. }

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

  1. import java.io.IOException;
  2. import java.io.StringReader;
  4. public class HexDump {
  6.     class HexTablifier {
  7.         private int m_row = 8;
  9.         private String m_pre = "";
  11.         private String m_post = "\n";
  13.         public HexTablifier() {
  14.         }
  16.         public HexTablifier(int row) {
  17.             this(row, "", "\n");
  18.         }
  20.         public HexTablifier(int row, String pre) {
  21.             this(row, pre, "\n");
  22.         }
  24.         public HexTablifier(int row, String pre, String post) {
  25.             m_row = row;
  26.             m_pre = pre;
  27.             m_post = post;
  28.         }
  30.         public String format(String hex) {
  31.             StringReader reader = new StringReader(hex);
  32.             StringBuilder builder = new StringBuilder(hex.length() * 2);
  34.             try {
  35.                 while (getHexLine(builder, reader)) {
  36.                 }
  37.             } catch (IOException e) {
  38.                 // 不应该有异常出现。
  39.             }
  41.             return builder.toString();
  42.         }
  44.         private boolean getHexLine(StringBuilder builder, StringReader reader)
  45.                 throws IOException {
  46.             StringBuilder lineBuilder = new StringBuilder();
  47.             boolean result = true;
  49.             for (int i = 0; i < m_row; i++) {
  50.                 result = getHexByte(lineBuilder, reader);
  52.                 if (result == false)
  53.                     break;
  54.             }
  56.             if (lineBuilder.length() > 0) {
  57.                 builder.append(m_pre);
  58.                 builder.append(lineBuilder);
  59.                 builder.append(m_post);
  60.             }
  62.             return result;
  63.         }
  65.         private boolean getHexByte(StringBuilder builder, StringReader reader)
  66.                 throws IOException {
  67.             char[] hexByte = new char[4];
  68.             int bytesRead = reader.read(hexByte);
  70.             if (bytesRead == -1)
  71.                 return false;
  73.             builder.append(hexByte, 0, bytesRead);
  74.             builder.append(" ");
  76.             return bytesRead == 4;
  77.         }
  78.     }
  80.     private static final char m_hexCodes[] = { '0', '1', '2', '3', '4', '5',
  81.             '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
  83.     private static final int m_shifts[] = { 60, 56, 52, 48, 44, 40, 36, 32, 28,
  84.             24, 20, 16, 12, 8, 4, 0 };
  86.     public static String tablify(byte[] bytes) {
  87.         return (new HexDump()).new HexTablifier().format(HexDump.toHex(bytes));
  88.     }
  90.     public static String tablify(byte[] bytes, int row) {
  91.         return (new HexDump()).new HexTablifier(row).format(HexDump
  92.                 .toHex(bytes));
  93.     }
  95.     public static String tablify(byte[] bytes, int row, String pre) {
  96.         return (new HexDump()).new HexTablifier(row, pre).format(HexDump
  97.                 .toHex(bytes));
  98.     }
  100.     public static String tablify(String hex, int row, String pre, String post) {
  101.         return (new HexDump()).new HexTablifier(row, pre, post).format(hex);
  102.     }
  104.     private static String toHex(final long value, final int digitNum) {
  105.         StringBuilder result = new StringBuilder(digitNum);
  107.         for (int j = 0; j < digitNum; j++) {
  108.             int index = (int) ((value >> m_shifts[j + (16 - digitNum)]) & 15);
  109.             result.append(m_hexCodes[index]);
  110.         }
  112.         return result.toString();
  113.     }
  115.     public static String toHex(final byte value) {
  116.         return toHex(value, 2);
  117.     }
  119.     public static String toHex(final short value) {
  120.         return toHex(value, 4);
  121.     }
  123.     public static String toHex(final int value) {
  124.         return toHex(value, 8);
  125.     }
  127.     public static String toHex(final long value) {
  128.         return toHex(value, 16);
  129.     }
  131.     public static String toHex(final byte[] value) {
  132.         return toHex(value, 0, value.length);
  133.     }
  135.     public static String toHex(final byte[] value, final int offset,
  136.             final int length) {
  137.         StringBuilder retVal = new StringBuilder();
  139.         int end = offset + length;
  140.         for (int x = offset; x < end; x++)
  141.             retVal.append(toHex(value[x]));
  143.         return retVal.toString();
  144.     }
  146.     public static byte[] restoreBytes(String hex) {
  147.         byte[] bytes = new byte[hex.length() / 2];
  148.         for (int i = 0; i < bytes.length; ++i) {
  149.             int c1 = charToNumber(hex.charAt(2 * i));
  150.             int c2 = charToNumber(hex.charAt(2 * i + 1));
  151.             if (c1 == -1 || c2 == -1) {
  152.                 return null;
  153.             }
  154.             bytes[i] = (byte) ((c1 << 4) + c2);
  155.         }
  157.         return bytes;
  158.     }
  160.     private static int charToNumber(char c) {
  161.         if (c >= '0' && c <= '9') {
  162.             return c - '0';
  163.         } else if (c >= 'a' && c <= 'f') {
  164.             return c - 'a' + 0xa;
  165.         } else if (c >= 'A' && c <= 'F') {
  166.             return c - 'A' + 0xA;
  167.         } else {
  168.             return -1;
  169.         }
  170.     }
  171. }
  173. import java.io.UnsupportedEncodingException;
  174. import java.security.MessageDigest;
  176. /**
  177.  * Created by linving on 2016/11/12.
  178.  */
  179. public class MD5Util {
  182.     public static String getStringMD5(String value) {
  183.         if (value == null || value.trim().length() < 1) {
  184.             return null;
  185.         }
  186.         try {
  187.             return getMD5(value.getBytes("UTF-8"));
  188.         } catch (UnsupportedEncodingException e) {
  189.             throw new RuntimeException(e.getMessage(), e);
  190.         }
  191.     }
  193.     public static String getMD5(byte[] source) {
  194.         try {
  195.             MessageDigest md5 = MessageDigest.getInstance("MD5");
  196.             return HexDump.toHex(md5.digest(source));
  197.         } catch (Exception e) {
  198.             throw new RuntimeException(e.getMessage(), e);
  199.         }
  200.     }
  202. }

Test :

  1. import java.util.Map;
  3. /**
  4.  * Created by linving on 2016/11/10.
  5.  */
  6. public class Test {
  7.     public static void main(String[] args) {
  8.         testRSA();
  9.         testAES();
  10.         tetsMD5();
  11.     }
  13.     private static void testAES() {
  16.         String data = "adcb";
  17.         System.out.println("AES加密前：" + data);
  19.         String key = "123456";
  20.         System.out.println("AES加密密钥和解密密钥：" + key);
  22.         String encrypt = AESUtil.aesEncrypt(data, key);
  23.         System.out.println("AES加密后：" + encrypt);
  25.         String decrypt = AESUtil.aesDecrypt(encrypt, key);
  26.         System.out.println("AES解密后：" + decrypt);
  28.     }
  31.     private static void testRSA() {
  33.         String data = "adsbc";
  34.         String publicKey = "";
  35.         String privateKey = "";
  36.         System.out.println("RSA原始数据: " + data);
  38.         Map<String, String> keyPair = RSAUtil.generateKeyPair();
  39.         publicKey = keyPair.get("publicKey");
  40.         privateKey = keyPair.get("privateKey");
  41.         System.out.println("RSA公钥: " + publicKey);
  42.         System.out.println("RSA私钥: " + privateKey);
  44.         String encryptData = RSAUtil.encrypt(publicKey, data);
  45.         System.out.println("RSA加密数据: " + encryptData);
  46.         String decryptData = RSAUtil.decrypt(privateKey, encryptData);
  47.         System.out.println("RSA解密数据: " + decryptData);
  48.     }
  50.     private static void tetsMD5() {
  51.         String data = "adsbc";
  52.         System.out.println("MD5原始数据: " + data);
  53.         String encryptData = MD5Util.getStringMD5(data);
  54.         System.out.println("MD5 加密数据: " + encryptData);
  57.     }
  59. }
  62. 结果：

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/

发表评论

表情：
评论列表 （有 0 条评论，223人围观）

还没有评论，来说两句吧...

相关阅读

    相关 加密的病历单

    题目： 小英是药学专业大三的学生，暑假期间获得了去医院药房实习的机会。在药房实习期间，小英扎实的专业基础获得了医生的一致好评，得知小英在计算概论中取得过好成绩后，主任又额外交

    布满荆棘的人生布满荆棘的人生/ 0 赞/ 48 阅读

    相关 HTTPS加密的简单理解

    一、对共钥私钥、数字签名、证书的理解 1.公钥私钥（一般用于确保信息的安全性） 非对称加密：加密解密用的不是同一个东西。 公钥就像是锁，可以对信息进行加密，加密以

    素颜马尾好姑娘i素颜马尾好姑娘i/ 0 赞/ 245 阅读

    相关 Java 加盐加密的简单理解

    背景 对于同一密码，同一加密算法会产生相同的hash值。这样，当用户进行身份验证时，对用户输入的明文密码应用相同的hash加密算法，得出一个hash值，然后使用该hash...

    电玩女神电玩女神/ 0 赞/ 1452 阅读