加密算法通常被分为两种：对称加密算法和非对称加密算法。其中，对称加密算法在加密和解密时使用的密钥相同；非对称加密算法在加密和解密时使用的密钥不同，分为公钥和私钥。此外，还有一类叫做消息摘要算法，是对数据进行摘要并且不可逆的算法。

非对称加密算法

非对称加密算法在加密和解密时使用两个不同的密钥，其中一个可以公开的密钥被称为公钥，另外一个完全保密的密钥被称为私钥。只有同一个公钥私钥对才能正常加密和解密。对于同一个公钥私钥对，如果使用公钥对数据进行加密，只有用对应的私钥才能进行解密；如果使用私钥对数据进行加密，只有用对应的公钥才能进行解密。
常见的非对称加密算法有：RSA算法、DSA。

RSA算法

RSA算法利用了两个数论特性：

  1. p1、p2为两个质数， n=p1 * p2。已知p1、p2求n简单，已知n求p1、p2很难。
  2. (m^e) mod n=c，已知m、e、n求c简单，已知e、n、c求m很难。

公钥私钥生成过程：随机选取两个质数p1、p2，n=p1 * p2，再随机选取一个与φ(n)互质且小于φ(n)的整数e，然后再计算e对于φ(n)的模反元素d，最后得到n和e为公钥，n和d为私钥。
加密过程：(m^e) mod n = c，其中m为明文，c为密文，n和e为公钥。
解密过程：(c^d) mod n = m，其中m为明文，c为密文，n和d为私钥。
我们用Java写个例子：

  1. import javax.crypto.Cipher;
  2. import java.nio.charset.Charset;
  3. import java.nio.charset.StandardCharsets;
  4. import java.security.GeneralSecurityException;
  5. import java.security.KeyFactory;
  6. import java.security.KeyPair;
  7. import java.security.KeyPairGenerator;
  8. import java.security.PrivateKey;
  9. import java.security.PublicKey;
  10. import java.security.spec.PKCS8EncodedKeySpec;
  11. import java.security.spec.X509EncodedKeySpec;
  12. import java.util.Base64;
  14. public class RsaUtil {
  16.     private static final String RSA = "RSA";
  17.     private static final Charset CHARSET = StandardCharsets.UTF_8;
  19.     /**
  20.      * 加密
  21.      *
  22.      * @param input     明文
  23.      * @param publicKey 公钥
  24.      * @return 密文
  25.      * @throws GeneralSecurityException
  26.      */
  27.     public static String encrypt(String input, String publicKey) throws GeneralSecurityException {
  28.         Cipher cipher = Cipher.getInstance(RSA);
  29.         PublicKey pubKey = KeyFactory.getInstance(RSA)
  30.                 .generatePublic(new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey)));
  31.         cipher.init(Cipher.ENCRYPT_MODE, pubKey);
  32.         byte[] data = cipher.doFinal(input.getBytes(CHARSET));
  33.         return Base64.getEncoder().encodeToString(data);
  34.     }
  36.     /**
  37.      * 解密
  38.      *
  39.      * @param input      密文
  40.      * @param privateKey 私钥
  41.      * @return 明文
  42.      * @throws GeneralSecurityException
  43.      */
  44.     public static String decrypt(String input, String privateKey) throws GeneralSecurityException {
  45.         Cipher cipher = Cipher.getInstance(RSA);
  46.         PrivateKey priKey = KeyFactory.getInstance("RSA")
  47.                 .generatePrivate(new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey)));
  48.         cipher.init(Cipher.DECRYPT_MODE, priKey);
  49.         byte[] data = cipher.doFinal(Base64.getDecoder().decode(input));
  50.         return new String(data, CHARSET);
  51.     }
  53.     public static void main(String[] args) throws GeneralSecurityException {
  54.         // 生成公钥／私钥对:
  55.         KeyPairGenerator kpGen = KeyPairGenerator.getInstance(RSA);
  56.         kpGen.initialize(1024);
  57.         KeyPair keyPair = kpGen.generateKeyPair();
  58.         String publicKey = Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded());
  59.         String privateKey = Base64.getEncoder().encodeToString(keyPair.getPrivate().getEncoded());
  60.         System.out.println("公钥：" + publicKey);
  61.         System.out.println("私钥：" + privateKey);
  63.         String msg = "我喜欢你，可以做我女朋友吗？";
  64.         System.out.println("加密前：" + msg);
  65.         String pwd = RsaUtil.encrypt(msg, publicKey);
  66.         System.out.println("加密后：" + pwd);
  67.         System.out.println("解密后：" + RsaUtil.decrypt(pwd, privateKey));
  68.     }
  69. }

运行结果如下：

  1. 公钥：MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDd4brSm8gdJqFi04m3aW8kjVYbd/T4ymyc7l3c2WmwOhVPlZO1eaZJpTvas61rW0HPf267CRIhc52Zp2+e1hoknApvT0gKeRkfSwC5aws/yoT2vZ9J627QbCFkFc8mmfP8LJ5V/rCpmUE12dIW4xVlEYtWPzmNK2iTMzuR99Jq9wIDAQAB
  2. 私钥：MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAN3hutKbyB0moWLTibdpbySNVht39PjKbJzuXdzZabA6FU+Vk7V5pkmlO9qzrWtbQc9/brsJEiFznZmnb57WGiScCm9PSAp5GR9LALlrCz/KhPa9n0nrbtBsIWQVzyaZ8/wsnlX+sKmZQTXZ0hbjFWURi1Y/OY0raJMzO5H30mr3AgMBAAECgYEAuxPtKlAwzOtaXXIQhrV+AWqttGFTCkXaiAKu31vssap3d2+daACWxTdtHPwr9v2tol9GpKqEP/I0am5zPZA13x+tv068x2TxGf8ZEbp579CKE3NrzTrnhtJN31TT82HIJoJ0TsNUhHbwZPWVAsq98afSCP1rn5RY/kwJ6bzsjhECQQD8Ev044KaUdWd0WZoomMP+5tATUL0HTMmUiBEvrXjOWG2mjuD4M5n/9C11FZWFg+o75riAUiNYE5dfGyK1uDP5AkEA4VZdUOTPt0DclMESX3lOddS3o+TL/OkowErP0mAl3NzbJ1PnDUifQ0q1IZUoCi1nG9eVZScS8xZ7oa7ICgdybwJBAIY/OrsK8cyJBlLx0WcjjOZ5WIGg8zsrCwRevwBsW7VRZPxahbfKC49EJN2BZENaMOo8AzDcDdS/glN1aTPsaUkCQAVLhj3UYp0nxQcp0ki0DQfvy7DqO3Dh+bcrCt8iq0EZX3z5F8DUKAnow4DahGpYzsd0tWn/FQ7pRFZ0SPcTXbkCQQCp7ay9nEo2hEH08E5LekFsuipDjCEpeCgKojZUmFCh7BdawG6XzCLzNMMIIIjqRHlrJaxS41WhedPZR4nTNxGF
  3. 加密前：我喜欢你，可以做我女朋友吗？
  4. 加密后：tRt5hdF0XB8V2wk6BWC2i8UWVQj/jOCRZn3wIfGYqVaYJ9OjC/+VRUI3c5WgpZlKCZd5zrHo3g1LuQ02G934Gcb51cKH4uhWxRY8oxUgs/fibkvc9+w1X7FQarFwAGCs5SddHIL/vYUxHIvQslelyP9l9/EFpgSs0WWSfOfKcUc=
  5. 解密后：我喜欢你，可以做我女朋友吗？

RSA算法解决了对称算法的安全性依赖于同一个密钥的缺点。不过，RSA算法在计算上相当复杂，性能欠佳、远远不如对称加密算法。因此，在一般实际情况下，往往通过非对称加密算法来随机创建临时的对称密钥，然后通过对称加密来传输大量、主体的数据。

DSA

DSA（Digital Signature Algorithm，数字签名算法）是 Schnorr 和 ElGamal 签名算法的变种，基于模算数和离散对数的复杂度。美国国家标准技术研究所（NIST）于1991年提出将DSA用于其DSS（DigitalSignature Standard，数字签名标准），并于1994年将其作为FIPS 186采用。和RSA算法使用公钥加密私钥解密的方式不同，DSA使用私钥对数据进行加密生成数字签名，然后使用公钥解密后的数据和原数据进行对比，以验证数字签名。数字签名提供信息鉴定（接收者可以验证消息的来源），完整性（接收方可以验证消息自签名以来未被修改）和不可否认性（发送方不能错误地声称它们没有签署消息）。
我们用Java写个例子：

  1. import java.nio.charset.Charset;
  2. import java.nio.charset.StandardCharsets;
  3. import java.security.GeneralSecurityException;
  4. import java.security.KeyFactory;
  5. import java.security.KeyPair;
  6. import java.security.KeyPairGenerator;
  7. import java.security.PrivateKey;
  8. import java.security.PublicKey;
  9. import java.security.Signature;
  10. import java.security.spec.PKCS8EncodedKeySpec;
  11. import java.security.spec.X509EncodedKeySpec;
  12. import java.util.Base64;
  14. public class DsaUtil {
  16.     private static final String DSA = "DSA";
  17.     private static final String SHA1withDSA = "SHA1withDSA";
  18.     private static final Charset CHARSET = StandardCharsets.UTF_8;
  20.     /**
  21.      * 签名
  22.      *
  23.      * @param data       数据
  24.      * @param privateKey 私钥
  25.      * @return 签名
  26.      * @throws GeneralSecurityException
  27.      */
  28.     public static String sign(String data, String privateKey) throws GeneralSecurityException {
  29.         PrivateKey priKey = KeyFactory.getInstance(DSA)
  30.                 .generatePrivate(new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey)));
  31.         Signature signature = Signature.getInstance(SHA1withDSA);
  32.         signature.initSign(priKey);
  33.         signature.update(data.getBytes(CHARSET));
  34.         return Base64.getEncoder().encodeToString(signature.sign());
  35.     }
  37.     /**
  38.      * 验证
  39.      *
  40.      * @param data      数据
  41.      * @param publicKey 公钥
  42.      * @param sign      签名
  43.      * @return 是否验证通过
  44.      */
  45.     public static boolean verify(String data, String publicKey, String sign) throws GeneralSecurityException {
  46.         try {
  47.             PublicKey pubKey = KeyFactory.getInstance(DSA)
  48.                     .generatePublic(new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey)));
  49.             Signature signature = Signature.getInstance(SHA1withDSA);
  50.             signature.initVerify(pubKey);
  51.             signature.update(data.getBytes(CHARSET));
  52.             return signature.verify(Base64.getDecoder().decode(sign));
  53.         } catch (Exception e) {
  54.             throw new RuntimeException(e);
  55.         }
  56.     }
  58.     public static void main(String[] args) throws GeneralSecurityException {
  59.         // 生成公钥／私钥对:
  60.         KeyPairGenerator kpGen = KeyPairGenerator.getInstance(DSA);
  61.         kpGen.initialize(1024);
  62.         KeyPair keyPair = kpGen.generateKeyPair();
  63.         String publicKey = Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded());
  64.         String privateKey = Base64.getEncoder().encodeToString(keyPair.getPrivate().getEncoded());
  65.         System.out.println("公钥：" + publicKey);
  66.         System.out.println("私钥：" + privateKey);
  68.         String msg = "我喜欢你，可以做我女朋友吗？";
  69.         System.out.println("数据：" + msg);
  70.         String sign = DsaUtil.sign(msg, privateKey);
  71.         System.out.println("签名：" + sign);
  72.         System.out.println("验证是否通过：" + DsaUtil.verify(msg, publicKey, sign));
  73.     }
  75. }

运行结果如下：

  1. 公钥：MIIBtzCCASwGByqGSM44BAEwggEfAoGBAP1/U4EddRIpUt9KnC7s5Of2EbdSPO9EAMMeP4C2USZpRV1AIlH7WT2NWPq/xfW6MPbLm1Vs14E7gB00b/JmYLdrmVClpJ+f6AR7ECLCT7up1/63xhv4O1fnxqimFQ8E+4P208UewwI1VBNaFpEy9nXzrith1yrv8iIDGZ3RSAHHAhUAl2BQjxUjC8yykrmCouuEC/BYHPUCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoDgYQAAoGABDM1s78NZ4C0Bh9V86Z1lylEyCjCg2oAj6Kxd3/2IXhSlplnSpJPLlomet9yWJpagLQieIWHAIyq6JLmdcVxOxUvnLIsrvWKIPr4lz7pIqO1xi4AYunP48gPECHlMgOKPyik3ZkQQ3iHl9MiaWOaeisqsw/gzTUtE1xi8CVscks=
  2. 私钥：MIIBSwIBADCCASwGByqGSM44BAEwggEfAoGBAP1/U4EddRIpUt9KnC7s5Of2EbdSPO9EAMMeP4C2USZpRV1AIlH7WT2NWPq/xfW6MPbLm1Vs14E7gB00b/JmYLdrmVClpJ+f6AR7ECLCT7up1/63xhv4O1fnxqimFQ8E+4P208UewwI1VBNaFpEy9nXzrith1yrv8iIDGZ3RSAHHAhUAl2BQjxUjC8yykrmCouuEC/BYHPUCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoEFgIUA1HUKjMiSvazMzpKczR6w6DDbeM=
  3. 数据：我喜欢你，可以做我女朋友吗？
  4. 签名：MCwCFHhnd/3yRCIygyD1GPa1K9ZVQ+4rAhR8zAtlrBim9KKEkv+Fxz47opvSuA==
  5. 验证是否通过：true

通过Java的示例可以看到，不会直接对数据进行私钥的加密，而是先通过信息摘要算法对数据进行摘要，然后对摘要信息进行私钥的加密。

总结

非对称加密算法在加密和解密时使用两个不同的密钥，分别被称为公钥和私钥，只有同一个公钥私钥对才能正常加密和解密。
常见的非对称加密算法有：RSA算法、DSA。RSA算法主要进行对数据的公钥加密，DSA主要是对数据的签名验证。