对称加密与非对称加密

Posted Linyb极客之路

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了对称加密与非对称加密相关的知识，希望对你有一定的参考价值。

安全的交流方式需要同时满足下面三个条件

1.完整性，即消息没有中途篡改过。 2.保密性，第三方无法解密。 3.可认证性，消息的接收方可以确定消息是谁发送的。

对称加密

双方使用的同一个密钥，既可以加密又可以解密，这种加密方法称为对称加密，也称为单密钥加密。

优点：速度快，对称性加密通常在消息发送方需要加密大量数据时使用，算法公开、计算量小、加密速度快、加密效率高。

缺点：在数据传送前，发送方和接收方必须商定好秘钥，然后 使双方都能保存好秘钥。其次如果一方的秘钥被泄露，那么加密信息也就不安全了。另外，每对用户每次使用对称加密算法时，都需要使用其他人不知道的唯一秘 钥，这会使得收、发双方所拥有的钥匙数量巨大，密钥管理成为双方的负担。

在对称加密算法中常用的算法有：DES、AES等。

AES：密钥的长度可以为128、192和256位，也就是16个字节、24个字节和32个字节

DES：密钥的长度64位，8个字节。

java中使用des加密解密：

 
   
   
 
    
  
    
    
  
  1. import java.security.SecureRandom;
    2. 
  
    
    
  
    3. 
  
    
    
  
  3. import javax.crypto.Cipher;
    4. 
  
    
    
  
  4. import javax.crypto.KeyGenerator;
    5. 
  
    
    
  
  5. import javax.crypto.SecretKey;
    6. 
  
    
    
  
  6. import javax.crypto.spec.SecretKeySpec;
    7. 
  
    
    
  
    8. 
  
    
    
  
  8. public class DESUtil {
    9. 
  
    
    
  
  9.     public static final String DES = "DES";
    10. 
  
    
    
  
  10.     public static final String charset = null; // 编码格式；默认null为GBK
    11. 
  
    
    
  
  11.     public static final int keysizeDES = 0;
    12. 
  
    
    
  
    13. 
  
    
    
  
  13.     private static DESUtil instance;
    14. 
  
    
    
  
    15. 
  
    
    
  
  15.     private DESUtil() {
    16. 
  
    
    
  
  16.     }
    17. 
  
    
    
  
    18. 
  
    
    
  
  18.     // 单例
    19. 
  
    
    
  
  19.     public static DESUtil getInstance() {
    20. 
  
    
    
  
  20.         if (instance == null) {
    21. 
  
    
    
  
  21.             synchronized (MD5Util.class) {
    22. 
  
    
    
  
  22.                 if (instance == null) {
    23. 
  
    
    
  
  23.                     instance = new DESUtil();
    24. 
  
    
    
  
  24.                 }
    25. 
  
    
    
  
  25.             }
    26. 
  
    
    
  
  26.         }
    27. 
  
    
    
  
  27.         return instance;
    28. 
  
    
    
  
  28.     }
    29. 
  
    
    
  
    30. 
  
    
    
  
  30.     /**
    31. 
  
    
    
  
  31.      * 使用 DES 进行加密
    32. 
  
    
    
  
  32.      */
    33. 
  
    
    
  
  33.     public String encode(String res, String key) {
    34. 
  
    
    
  
  34.         return keyGeneratorES(res, DES, key, keysizeDES, true);
    35. 
  
    
    
  
  35.     }
    36. 
  
    
    
  
    37. 
  
    
    
  
  37.     /**
    38. 
  
    
    
  
  38.      * 使用 DES 进行解密
    39. 
  
    
    
  
  39.      */
    40. 
  
    
    
  
  40.     public String decode(String res, String key) {
    41. 
  
    
    
  
  41.         return keyGeneratorES(res, DES, key, keysizeDES, false);
    42. 
  
    
    
  
  42.     }
    43. 
  
    
    
  
    44. 
  
    
    
  
  44.     // 使用KeyGenerator双向加密，DES/AES，注意这里转化为字符串的时候是将2进制转为16进制格式的字符串，不是直接转，因为会出错
    45. 
  
    
    
  
  45.     private String keyGeneratorES(String res, String algorithm, String key, int keysize, boolean isEncode) {
    46. 
  
    
    
  
  46.         try {
    47. 
  
    
    
  
  47.             KeyGenerator kg = KeyGenerator.getInstance(algorithm);
    48. 
  
    
    
  
  48.             if (keysize == 0) {
    49. 
  
    
    
  
  49.                 byte[] keyBytes = charset == null ? key.getBytes() : key.getBytes(charset);
    50. 
  
    
    
  
  50.                 kg.init(new SecureRandom(keyBytes));
    51. 
  
    
    
  
  51.             } else if (key == null) {
    52. 
  
    
    
  
  52.                 kg.init(keysize);
    53. 
  
    
    
  
  53.             } else {
    54. 
  
    
    
  
  54.                 byte[] keyBytes = charset == null ? key.getBytes() : key.getBytes(charset);
    55. 
  
    
    
  
  55.                 kg.init(keysize, new SecureRandom(keyBytes));
    56. 
  
    
    
  
  56.             }
    57. 
  
    
    
  
  57.             SecretKey sk = kg.generateKey();
    58. 
  
    
    
  
  58.             SecretKeySpec sks = new SecretKeySpec(sk.getEncoded(), algorithm);
    59. 
  
    
    
  
  59.             Cipher cipher = Cipher.getInstance(algorithm);
    60. 
  
    
    
  
  60.             if (isEncode) {
    61. 
  
    
    
  
  61.                 cipher.init(Cipher.ENCRYPT_MODE, sks);
    62. 
  
    
    
  
  62.                 byte[] resBytes = charset == null ? res.getBytes() : res.getBytes(charset);
    63. 
  
    
    
  
  63.                 return parseByte2HexStr(cipher.doFinal(resBytes));
    64. 
  
    
    
  
  64.             } else {
    65. 
  
    
    
  
  65.                 cipher.init(Cipher.DECRYPT_MODE, sks);
    66. 
  
    
    
  
  66.                 return new String(cipher.doFinal(parseHexStr2Byte(res)));
    67. 
  
    
    
  
  67.             }
    68. 
  
    
    
  
  68.         } catch (Exception e) {
    69. 
  
    
    
  
  69.             e.printStackTrace();
    70. 
  
    
    
  
  70.         }
    71. 
  
    
    
  
  71.         return null;
    72. 
  
    
    
  
  72.     }
    73. 
  
    
    
  
    74. 
  
    
    
  
  74.     // 将二进制转换成16进制
    75. 
  
    
    
  
  75.     private String parseByte2HexStr(byte buf[]) {
    76. 
  
    
    
  
  76.         StringBuffer sb = new StringBuffer();
    77. 
  
    
    
  
  77.         for (int i = 0; i < buf.length; i++) {
    78. 
  
    
    
  
  78.             String hex = Integer.toHexString(buf[i] & 0xFF);
    79. 
  
    
    
  
  79.             if (hex.length() == 1) {
    80. 
  
    
    
  
  80.                 hex = '0' + hex;
    81. 
  
    
    
  
  81.             }
    82. 
  
    
    
  
  82.             sb.append(hex.toUpperCase());
    83. 
  
    
    
  
  83.         }
    84. 
  
    
    
  
  84.         return sb.toString();
    85. 
  
    
    
  
  85.     }
    86. 
  
    
    
  
    87. 
  
    
    
  
  87.     // 将16进制转换为二进制
    88. 
  
    
    
  
  88.     private byte[] parseHexStr2Byte(String hexStr) {
    89. 
  
    
    
  
  89.         if (hexStr.length() < 1)
    90. 
  
    
    
  
  90.             return null;
    91. 
  
    
    
  
  91.         byte[] result = new byte[hexStr.length() / 2];
    92. 
  
    
    
  
  92.         for (int i = 0; i < hexStr.length() / 2; i++) {
    93. 
  
    
    
  
  93.             int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
    94. 
  
    
    
  
  94.             int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
    95. 
  
    
    
  
  95.             result[i] = (byte) (high * 16 + low);
    96. 
  
    
    
  
  96.         }
    97. 
  
    
    
  
  97.         return result;
    98. 
  
    
    
  
  98.     }
    99. 
  
    
    
  
  99. }
    100.

java中使用AES加密解密：

 
   
   
 
    
  
    
    
  
  1. import java.security.SecureRandom;
    2. 
  
    
    
  
    3. 
  
    
    
  
  3. import javax.crypto.Cipher;
    4. 
  
    
    
  
  4. import javax.crypto.KeyGenerator;
    5. 
  
    
    
  
  5. import javax.crypto.SecretKey;
    6. 
  
    
    
  
  6. import javax.crypto.spec.SecretKeySpec;
    7. 
  
    
    
  
    8. 
  
    
    
  
  8. public class AESUtil {
    9. 
  
    
    
  
  9.     public static final String AES = "AES";
    10. 
  
    
    
  
  10.     public static final String charset = null; // 编码格式；默认null为GBK
    11. 
  
    
    
  
  11.     public static final int keysizeAES = 128;
    12. 
  
    
    
  
    13. 
  
    
    
  
  13.     private static AESUtil instance;
    14. 
  
    
    
  
    15. 
  
    
    
  
  15.     private AESUtil() {
    16. 
  
    
    
  
  16.     }
    17. 
  
    
    
  
    18. 
  
    
    
  
  18.     // 单例
    19. 
  
    
    
  
  19.     public static AESUtil getInstance() {
    20. 
  
    
    
  
  20.         if (instance == null) {
    21. 
  
    
    
  
  21.             synchronized (MD5Util.class) {
    22. 
  
    
    
  
  22.                 if (instance == null) {
    23. 
  
    
    
  
  23.                     instance = new AESUtil();
    24. 
  
    
    
  
  24.                 }
    25. 
  
    
    
  
  25.             }
    26. 
  
    
    
  
  26.         }
    27. 
  
    
    
  
  27.         return instance;
    28. 
  
    
    
  
  28.     }
    29. 
  
    
    
  
    30. 
  
    
    
  
  30.     /**
    31. 
  
    
    
  
  31.      * 使用 AES 进行加密
    32. 
  
    
    
  
  32.      */
    33. 
  
    
    
  
  33.     public String encode(String res, String key) {
    34. 
  
    
    
  
  34.         return keyGeneratorES(res, AES, key, keysizeAES, true);
    35. 
  
    
    
  
  35.     }
    36. 
  
    
    
  
    37. 
  
    
    
  
  37.     /**
    38. 
  
    
    
  
  38.      * 使用 AES 进行解密
    39. 
  
    
    
  
  39.      */
    40. 
  
    
    
  
  40.     public String decode(String res, String key) {
    41. 
  
    
    
  
  41.         return keyGeneratorES(res, AES, key, keysizeAES, false);
    42. 
  
    
    
  
  42.     }
    43. 
  
    
    
  
    44. 
  
    
    
  
  44.     // 使用KeyGenerator双向加密，DES/AES，注意这里转化为字符串的时候是将2进制转为16进制格式的字符串，不是直接转，因为会出错
    45. 
  
    
    
  
  45.     private String keyGeneratorES(String res, String algorithm, String key, int keysize, boolean isEncode) {
    46. 
  
    
    
  
  46.         try {
    47. 
  
    
    
  
  47.             KeyGenerator kg = KeyGenerator.getInstance(algorithm);
    48. 
  
    
    
  
  48.             if (keysize == 0) {
    49. 
  
    
    
  
  49.                 byte[] keyBytes = charset == null ? key.getBytes() : key.getBytes(charset);
    50. 
  
    
    
  
  50.                 kg.init(new SecureRandom(keyBytes));
    51. 
  
    
    
  
  51.             } else if (key == null) {
    52. 
  
    
    
  
  52.                 kg.init(keysize);
    53. 
  
    
    
  
  53.             } else {
    54. 
  
    
    
  
  54.                 byte[] keyBytes = charset == null ? key.getBytes() : key.getBytes(charset);
    55. 
  
    
    
  
  55.                 kg.init(keysize, new SecureRandom(keyBytes));
    56. 
  
    
    
  
  56.             }
    57. 
  
    
    
  
  57.             SecretKey sk = kg.generateKey();
    58. 
  
    
    
  
  58.             SecretKeySpec sks = new SecretKeySpec(sk.getEncoded(), algorithm);
    59. 
  
    
    
  
  59.             Cipher cipher = Cipher.getInstance(algorithm);
    60. 
  
    
    
  
  60.             if (isEncode) {
    61. 
  
    
    
  
  61.                 cipher.init(Cipher.ENCRYPT_MODE, sks);
    62. 
  
    
    
  
  62.                 byte[] resBytes = charset == null ? res.getBytes() : res.getBytes(charset);
    63. 
  
    
    
  
  63.                 return parseByte2HexStr(cipher.doFinal(resBytes));
    64. 
  
    
    
  
  64.             } else {
    65. 
  
    
    
  
  65.                 cipher.init(Cipher.DECRYPT_MODE, sks);
    66. 
  
    
    
  
  66.                 return new String(cipher.doFinal(parseHexStr2Byte(res)));
    67. 
  
    
    
  
  67.             }
    68. 
  
    
    
  
  68.         } catch (Exception e) {
    69. 
  
    
    
  
  69.             e.printStackTrace();
    70. 
  
    
    
  
  70.         }
    71. 
  
    
    
  
  71.         return null;
    72. 
  
    
    
  
  72.     }
    73. 
  
    
    
  
    74. 
  
    
    
  
  74.     // 将二进制转换成16进制
    75. 
  
    
    
  
  75.     private String parseByte2HexStr(byte buf[]) {
    76. 
  
    
    
  
  76.         StringBuffer sb = new StringBuffer();
    77. 
  
    
    
  
  77.         for (int i = 0; i < buf.length; i++) {
    78. 
  
    
    
  
  78.             String hex = Integer.toHexString(buf[i] & 0xFF);
    79. 
  
    
    
  
  79.             if (hex.length() == 1) {
    80. 
  
    
    
  
  80.                 hex = '0' + hex;
    81. 
  
    
    
  
  81.             }
    82. 
  
    
    
  
  82.             sb.append(hex.toUpperCase());
    83. 
  
    
    
  
  83.         }
    84. 
  
    
    
  
  84.         return sb.toString();
    85. 
  
    
    
  
  85.     }
    86. 
  
    
    
  
    87. 
  
    
    
  
  87.     // 将16进制转换为二进制
    88. 
  
    
    
  
  88.     private byte[] parseHexStr2Byte(String hexStr) {
    89. 
  
    
    
  
  89.         if (hexStr.length() < 1)
    90. 
  
    
    
  
  90.             return null;
    91. 
  
    
    
  
  91.         byte[] result = new byte[hexStr.length() / 2];
    92. 
  
    
    
  
  92.         for (int i = 0; i < hexStr.length() / 2; i++) {
    93. 
  
    
    
  
  93.             int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
    94. 
  
    
    
  
  94.             int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
    95. 
  
    
    
  
  95.             result[i] = (byte) (high * 16 + low);
    96. 
  
    
    
  
  96.         }
    97. 
  
    
    
  
  97.         return result;
    98. 
  
    
    
  
  98.     }
    99. 
  
    
    
  
  99. }
    100.

非对称加密

一对密钥由公钥和私钥组成（可以使用很多对密钥）。私钥解密公钥加密数据，公钥解密私钥加密数据（私钥公钥可以互相加密解密）。 私钥只能由一方保管，不能外泄。公钥可以交给任何请求方。

在非对称加密算法中常用的算法有： RSA等

缺点：速度较慢

优点：安全

java中使用rsa加密解密：

 
   
   
 
    
  
    
    
  
  1. import java.io.FileInputStream;
    2. 
  
    
    
  
  2. import java.io.FileOutputStream;
    3. 
  
    
    
  
  3. import java.io.ObjectInputStream;
    4. 
  
    
    
  
  4. import java.io.ObjectOutputStream;
    5. 
  
    
    
  
  5. import java.security.Key;
    6. 
  
    
    
  
  6. import java.security.KeyPair;
    7. 
  
    
    
  
  7. import java.security.KeyPairGenerator;
    8. 
  
    
    
  
  8. import java.security.SecureRandom;
    9. 
  
    
    
  
    10. 
  
    
    
  
  10. import javax.crypto.Cipher;
    11. 
  
    
    
  
    12. 
  
    
    
  
  12. import sun.misc.BASE64Decoder;
    13. 
  
    
    
  
  13. import sun.misc.BASE64Encoder;
    14. 
  
    
    
  
    15. 
  
    
    
  
  15. public class RSA_Encrypt {
    16. 
  
    
    
  
  16.     /** 指定加密算法为DESede */
    17. 
  
    
    
  
  17.     private static String ALGORITHM = "RSA";
    18. 
  
    
    
  
  18.     /** 指定key的大小 */
    19. 
  
    
    
  
  19.     private static int KEYSIZE = 1024;
    20. 
  
    
    
  
  20.     /** 指定公钥存放文件 */
    21. 
  
    
    
  
  21.     private static String PUBLIC_KEY_FILE = "PublicKey";
    22. 
  
    
    
  
  22.     /** 指定私钥存放文件 */
    23. 
  
    
    
  
  23.     private static String PRIVATE_KEY_FILE = "PrivateKey";
    24. 
  
    
    
  
    25. 
  
    
    
  
  25.     /**
    26. 
  
    
    
  
  26.      * 生成密钥对
    27. 
  
    
    
  
  27.      */
    28. 
  
    
    
  
  28.     private static void generateKeyPair() throws Exception {
    29. 
  
    
    
  
  29.         /** RSA算法要求有一个可信任的随机数源 */
    30. 
  
    
    
  
  30.         SecureRandom sr = new SecureRandom();
    31. 
  
    
    
  
  31.         /** 为RSA算法创建一个KeyPairGenerator对象 */
    32. 
  
    
    
  
  32.         KeyPairGenerator kpg = KeyPairGenerator.getInstance(ALGORITHM);
    33. 
  
    
    
  
  33.         /** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */
    34. 
  
    
    
  
  34.         kpg.initialize(KEYSIZE, sr);
    35. 
  
    
    
  
  35.         /** 生成密匙对 */
    36. 
  
    
    
  
  36.         KeyPair kp = kpg.generateKeyPair();
    37. 
  
    
    
  
  37.         /** 得到公钥 */
    38. 
  
    
    
  
  38.         Key publicKey = kp.getPublic();
    39. 
  
    
    
  
  39.         /** 得到私钥 */
    40. 
  
    
    
  
  40.         Key privateKey = kp.getPrivate();
    41. 
  
    
    
  
  41.         /** 用对象流将生成的密钥写入文件 */
    42. 
  
    
    
  
  42.         ObjectOutputStream oos1 = new ObjectOutputStream(new FileOutputStream(
    43. 
  
    
    
  
  43.                 PUBLIC_KEY_FILE));
    44. 
  
    
    
  
  44.         ObjectOutputStream oos2 = new ObjectOutputStream(new FileOutputStream(
    45. 
  
    
    
  
  45.                 PRIVATE_KEY_FILE));
    46. 
  
    
    
  
  46.         oos1.writeObject(publicKey);
    47. 
  
    
    
  
  47.         oos2.writeObject(privateKey);
    48. 
  
    
    
  
  48.         /** 清空缓存，关闭文件输出流 */
    49. 
  
    
    
  
  49.         oos1.close();
    50. 
  
    
    
  
  50.         oos2.close();
    51. 
  
    
    
  
  51.     }
    52. 
  
    
    
  
    53. 
  
    
    
  
  53.     /**
    54. 
  
    
    
  
  54.      * 加密方法 source： 源数据
    55. 
  
    
    
  
  55.      */
    56. 
  
    
    
  
  56.     public static String encrypt(String source) throws Exception {
    57. 
  
    
    
  
  57.         generateKeyPair();
    58. 
  
    
    
  
  58.         /** 将文件中的公钥对象读出 */
    59. 
  
    
    
  
  59.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
    60. 
  
    
    
  
  60.                 PUBLIC_KEY_FILE));
    61. 
  
    
    
  
  61.         Key key = (Key) ois.readObject();
    62. 
  
    
    
  
  62.         ois.close();
    63. 
  
    
    
  
  63.         /** 得到Cipher对象来实现对源数据的RSA加密 */
    64. 
  
    
    
  
  64.         Cipher cipher = Cipher.getInstance(ALGORITHM);
    65. 
  
    
    
  
  65.         cipher.init(Cipher.ENCRYPT_MODE, key);
    66. 
  
    
    
  
  66.         byte[] b = source.getBytes();
    67. 
  
    
    
  
  67.         /** 执行加密操作 */
    68. 
  
    
    
  
  68.         byte[] b1 = cipher.doFinal(b);
    69. 
  
    
    
  
  69.         BASE64Encoder encoder = new BASE64Encoder();
    70. 
  
    
    
  
  70.         return encoder.encode(b1);
    71. 
  
    
    
  
  71.     }
    72. 
  
    
    
  
    73. 
  
    
    
  
  73.     /**
    74. 
  
    
    
  
  74.      * 解密算法 cryptograph:密文
    75. 
  
    
    
  
  75.      */
    76. 
  
    
    
  
  76.     public static String decrypt(String cryptograph) throws Exception {
    77. 
  
    
    
  
  77.         /** 将文件中的私钥对象读出 */
    78. 
  
    
    
  
  78.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
    79. 
  
    
    
  
  79.                 PRIVATE_KEY_FILE));
    80. 
  
    
    
  
  80.         Key key = (Key) ois.readObject();
    81. 
  
    
    
  
  81.         /** 得到Cipher对象对已用公钥加密的数据进行RSA解密 */
    82. 
  
    
    
  
  82.         Cipher cipher = Cipher.getInstance(ALGORITHM);
    83. 
  
    
    
  
  83.         cipher.init(Cipher.DECRYPT_MODE, key);
    84. 
  
    
    
  
  84.         BASE64Decoder decoder = new BASE64Decoder();
    85. 
  
    
    
  
  85.         byte[] b1 = decoder.decodeBuffer(cryptograph);
    86. 
  
    
    
  
  86.         /** 执行解密操作 */
    87. 
  
    
    
  
  87.         byte[] b = cipher.doFinal(b1);
    88. 
  
    
    
  
  88.         return new String(b);
    89. 
  
    
    
  
  89.     }
    90. 
  
    
    
  
    91. 
  
    
    
  
  91.     public static void main(String[] args) throws Exception {
    92. 
  
    
    
  
  92.         String source = "Hello World!";// 要加密的字符串
    93. 
  
    
    
  
  93.         String cryptograph = encrypt(source);// 生成的密文
    94. 
  
    
    
  
  94.         System.out.println(cryptograph);
    95. 
  
    
    
  
  95.         System.out.println("=====================");
    96. 
  
    
    
  
  96.         String target = decrypt(cryptograph);// 解密密文
    97. 
  
    
    
  
  97.         System.out.println(target);
    98. 
  
    
    
  
  98.     }
    99. 
  
    
    
  
  99. }
    100.


消息摘要（散列运算，哈希运算）

对一段信息（Message）产生信息摘要（加密 Message-Digest），以防止被篡改。多次对同一个字符串加密结果一样，不可逆。

常用算法：md5,sha1

java中使用md5加密解密：

 
   
   
 
    
  
    
    
  
  1. import java.security.MessageDigest;
    2. 
  
    
    
  
    3. 
  
    
    
  
  3. import javax.crypto.KeyGenerator;
    4. 
  
    
    
  
  4. import javax.crypto.Mac;
    5. 
  
    
    
  
  5. import javax.crypto.SecretKey;
    6. 
  
    
    
  
  6. import javax.crypto.spec.SecretKeySpec;
    7. 
  
    
    
  
    8. 
  
    
    
  
  8. public class MD5Util {
    9. 
  
    
    
  
  9.     public static final String MD5 = "MD5";
    10. 
  
    
    
  
  10.     public static final String HmacMD5 = "HmacMD5";
    11. 
  
    
    
  
  11.     public static final String charset = null; // 编码格式；默认null为GBK
    12. 
  
    
    
  
    13. 
  
    
    
  
  13.     private static MD5Util instance;
    14. 
  
    
    
  
    15. 
  
    
    
  
  15.     private MD5Util() {
    16. 
  
    
    
  
  16.     }
    17. 
  
    
    
  
    18. 
  
    
    
  
  18.     // 单例
    19. 
  
    
    
  
  19.     public static MD5Util getInstance() {
    20. 
  
    
    
  
  20.         if (instance == null) {
    21. 
  
    
    
  
  21.             synchronized (MD5Util.class) {
    22. 
  
    
    
  
  22.                 if (instance == null) {
    23. 
  
    
    
  
  23.                     instance = new MD5Util();
    24. 
  
    
    
  
  24.                 }
    25. 
  
    
    
  
  25.             }
    26. 
  
    
    
  
  26.         }
    27. 
  
    
    
  
  27.         return instance;
    28. 
  
    
    
  
  28.     }
    29. 
  
    
    
  
    30. 
  
    
    
  
  30.     /**
    31. 
  
    
    
  
  31.      * 使用 MD5 方法加密（无密码）
    32. 
  
    
    
  
  32.      */
    33. 
  
    
    
  
  33.     public String encode(String res) {
    34. 
  
    
    
  
  34.         try {
    35. 
  
    
    
  
  35.             MessageDigest md = MessageDigest.getInstance(MD5);
    36. 
  
    
    
  
  36.             byte[] resBytes = charset == null ? res.getBytes() : res.getBytes(charset);
    37. 
  
    
    
  
  37.             return BASE64Util.getInstance().encode(md.digest(resBytes).toString());
    38. 
  
    
    
  
  38.         } catch (Exception e) {
    39. 
  
    
    
  
  39.             e.printStackTrace();
    40. 
  
    
    
  
  40.         }
    41. 
  
    
    
  
  41.         return null;
    42. 
  
    
    
  
  42.     }
    43. 
  
    
    
  
    44. 
  
    
    
  
  44.     /**
    45. 
  
    
    
  
  45.      * 使用 MD5 方法加密（可以设密码）
    46. 
  
    
    
  
  46.      */
    47. 
  
    
    
  
  47.     public String encode(String res, String key) {
    48. 
  
    
    
  
  48.         try {
    49. 
  
    
    
  
  49.             SecretKey sk = null;
    50. 
  
    
    
  
  50.             if (key == null) {
    51. 
  
    
    
  
  51.                 KeyGenerator kg = KeyGenerator.getInstance(HmacMD5);
    52. 
  
    
    
  
  52.                 sk = kg.generateKey();
    53. 
  
    
    
  
  53.             } else {
    54. 
  
    
    
  
  54.                 byte[] keyBytes = charset == null ? key.getBytes() : key.getBytes(charset);
    55. 
  
    
    
  
  55.                 sk = new SecretKeySpec(keyBytes, HmacMD5);
    56. 
  
    
    
  
  56.             }
    57. 
  
    
    
  
  57.             Mac mac = Mac.getInstance(HmacMD5);
    58. 
  
    
    
  
  58.             mac.init(sk);
    59. 
  
    
    
  
  59.             byte[] result = mac.doFinal(res.getBytes());
    60. 
  
    
    
  
  60.             return BASE64Util.getInstance().encode(result.toString());
    61. 
  
    
    
  
  61.         } catch (Exception e) {
    62. 
  
    
    
  
  62.             e.printStackTrace();
    63. 
  
    
    
  
  63.         }
    64. 
  
    
    
  
  64.         return null;
    65. 
  
    
    
  
  65.     }
    66. 
  
    
    
  
  66. }
    67.


java中使用sha1加密解密：

 
   
   
 
    
  
    
    
  
  1. import java.security.MessageDigest;
    2. 
  
    
    
  
    3. 
  
    
    
  
  3. import javax.crypto.KeyGenerator;
    4. 
  
    
    
  
  4. import javax.crypto.Mac;
    5. 
  
    
    
  
  5. import javax.crypto.SecretKey;
    6. 
  
    
    
  
  6. import javax.crypto.spec.SecretKeySpec;
    7. 
  
    
    
  
    8. 
  
    
    
  
  8. /**
    9. 
  
    
    
  
  9.  * 使用 SHA1 方法进行加密<br/>
    10. 
  
    
    
  
  10.  * SHA1方法加密是不可逆的，不能解密，要想解密就必须使用暴力解密<br/>
    11. 
  
    
    
  
  11.  * <p/>
    12. 
  
    
    
  
  12.  * 方法中的 res 参数：原始的数据<br/>
    13. 
  
    
    
  
  13.  * 方法中的 key 参数：密钥，可以随便写<br/>
    14. 
  
    
    
  
  14.  */
    15. 
  
    
    
  
  15. public class SHA1Util {
    16. 
  
    
    
  
  16.     public static final String SHA1 = "SHA1";
    17. 
  
    
    
  
  17.     public static final String HmacSHA1 = "HmacSHA1";
    18. 
  
    
    
  
  18.     public static final String charset = null; // 编码格式；默认null为GBK
    19. 
  
    
    
  
    20. 
  
    
    
  
  20.     private static SHA1Util instance;
    21. 
  
    
    
  
    22. 
  
    
    
  
  22.     private SHA1Util() {
    23. 
  
    
    
  
  23.     }
    24. 
  
    
    
  
    25. 
  
    
    
  
  25.     // 单例
    26. 
  
    
    
  
  26.     public static SHA1Util getInstance() {
    27. 
  
    
    
  
  27.         if (instance == null) {
    28. 
  
    
    
  
  28.             synchronized (SHA1Util.class) {
    29. 
  
    
    
  
  29.                 if (instance == null) {
    30. 
  
    
    
  
  30.                     instance = new SHA1Util();
    31. 
  
    
    
  
  31.                 }
    32. 
  
    
    
  
  32.             }
    33. 
  
    
    
  
  33.         }
    34. 
  
    
    
  
  34.         return instance;
    35. 
  
    
    
  
  35.     }
    36. 
  
    
    
  
    37. 
  
    
    
  
  37.     /**
    38. 
  
    
    
  
  38.      * 使用 SHA1 方法加密（无密码）
    39. 
  
    
    
  
  39.      */
    40. 
  
    
    
  
  40.     public String encode(String res) {
    41. 
  
    
    
  
  41.         try {
    42. 
  
    
    
  
  42.             MessageDigest md = MessageDigest.getInstance(SHA1);
    43. 
  
    
    
  
  43.             byte[] resBytes = charset == null ? res.getBytes() : res.getBytes(charset);
    44. 
  
    
    
  
  44.             return BASE64Util.getInstance().encode(md.digest(resBytes).toString());
    45. 
  
    
    
  
  45.         } catch (Exception e) {
    46. 
  
    
    
  
  46.             e.printStackTrace();
    47. 
  
    
    
  
  47.         }
    48. 
  
    
    
  
  48.         return null;
    49. 
  
    
    
  
  49.     }
    50. 
  
    
    
  
    51. 
  
    
    
  
  51.     /**
    52. 
  
    
    
  
  52.      * 使用 SHA1 方法加密（可以设密码）
    53. 
  
    
    
  
  53.      */
    54. 
  
    
    
  
  54.     public String encode(String res, String key) {
    55. 
  
    
    
  
  55.         try {
    56. 
  
    
    
  
  56.             SecretKey sk = null;
    57. 
  
    
    
  
  57.             if (key == null) {
    58. 
  
    
    
  
  58.                 KeyGenerator kg = KeyGenerator.getInstance(HmacSHA1);
    59. 
  
    
    
  
  59.                 sk = kg.generateKey();
    60. 
  
    
    
  
  60.             } else {
    61. 
  
    
    
  
  61.                 byte[] keyBytes = charset == null ? key.getBytes() : key.getBytes(charset);
    62. 
  
    
    
  
  62.                 sk = new SecretKeySpec(keyBytes, HmacSHA1);
    63. 
  
    
    
  
  63.             }
    64. 
  
    
    
  
  64.             Mac mac = Mac.getInstance(HmacSHA1);
    65. 
  
    
    
  
  65.             mac.init(sk);
    66. 
  
    
    
  
  66.             byte[] result = mac.doFinal(res.getBytes());
    67. 
  
    
    
  
  67.             return BASE64Util.getInstance().encode(result.toString());
    68. 
  
    
    
  
  68.         } catch (Exception e) {
    69. 
  
    
    
  
  69.             e.printStackTrace();
    70. 
  
    
    
  
  70.         }
    71. 
  
    
    
  
  71.         return null;
    72. 
  
    
    
  
  72.     }
    73. 
  
    
    
  
  73. }
    74.


数字签名

1.对消息指定值进行md5等摘要运算，得到消息摘要。 2.使用发送方私钥对消息摘要进行加密（并不对消息本身加密） 3.接收方使用发送方公钥进行解密，计算哈希值。来判断消息是否一致。 注意：如果参数被截取到，消息本身还是看到的。

混合使用（非对称加密+数字签名）

首先接收方和发送方都有一对秘钥。 发送方： 1.对消息进行md5等摘要运算，得到消息摘要。 2.使用发送方私钥对消息摘要进行加密，该过程也称作签名。（确保了接收方能够确认自己的身份） 3.使用接收方的公钥对消息进行加密（确保了消息只能由期望的接收方解密） 4.发送消息和消息摘要 接收方： 1.使用发送发的公钥对消息摘要进行解密（确认了消息是由谁发送的），获得原始消息摘要 2.使用自己的私钥对消息进行解密（安全的获得了消息内容） 3.将消息进行散列运算，获得本地消息摘要。 4.将原始消息摘要与本地消息摘要对比(验签)，确认消息是否被篡改。

缺点：比较耗时。



以上是关于对称加密与非对称加密的主要内容，如果未能解决你的问题，请参考以下文章

对称加密与非对称加密

对称加密与非对称加密算法

聊聊对称加密与非对称加密

对称加密与非对称加密各自的应用场景

对称加密与非对称加密

对称加密与非对称加密