非对称加密

[非对称加密算法］
需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。
非对称加密算法有哪些：
RSA、Elgamal、背包算法、Rabin、D-H、ECC（椭圆曲线加密算法）。
优点：
与对称密钥加密相比，优点在于无需共享的通用密钥，解密的私钥不发往任何用户。即使公钥在网上被截获，如果没有与其匹配的私钥，也无法解密，所截获的公钥是没有任何用处的。

RSA Algorithm

Theory reference document
大整数的因数分解，是一件非常困难的事情

"对极大整数做因数分解的难度决定了RSA算法的可靠性。换言之，对一极大整数做因数分解愈困难，RSA算法愈可靠。
　　假如有人找到一种快速因数分解的算法，那么RSA的可靠性就会极度下降。但找到这样的算法的可能性是非常小的。今天只有短的RSA密钥才可能被暴力破解。到2008年为止，世界上还没有任何可靠的攻击RSA算法的方式。
　　只要密钥长度足够长，用RSA加密的信息实际上是不能被解破的。"

RSA实现(java)

import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

import org.springframework.util.Base64Utils;

/**
 * RSA algorithm 
 * @author Peng
 *
 */
public abstract class RSAUtil {
 
 private static final String KEY_ALGORITHM = "RSA";
 /**
  * RSA encrypt mode，加密
  */
 public static final int ENCRYPT_MODE = Cipher.ENCRYPT_MODE;
 
 /**
  * RSA decrypt mode,解密
  */
 public static final int DECRYPT_MODE = Cipher.DECRYPT_MODE;
 
 /**
  * 生成RSA KeyPair
  * @return
  * @throws Exception
  */
 public static KeyPair generateKeyPair() throws Exception{
  KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
  keyPairGen.initialize(1024);
  return  keyPairGen.generateKeyPair();
 }

 /**
  * Encrypt and decrypt the data by private key.
  * @param data
  * @param key, The key that used base64 encoded.
  * @param mode
  * @return
  * @throws Exception
  */
 public static byte[] operByPrivateKey(byte[] data, String key, int mode) throws Exception{
  byte[] keyBytes = Base64Utils.decodeFromString(key);

  // Get the private key
  PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

  // encrypt or decrypt data
  Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  cipher.init(mode, privateKey);

  return cipher.doFinal(data);
 }

 /**
  * Encrypt and decrypt the data by public key
  * @param data
  * @param key, The key that used base64 encoded.
  * @param mode
  * @return
  * @throws Exception
  */
 public static byte[] operByPublicKey(byte[] data, String key, int mode) throws Exception {
  byte[] keyBytes = Base64Utils.decodeFromString(key);

  X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  Key publicKey = keyFactory.generatePublic(x509KeySpec);

  Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  cipher.init(mode, publicKey);

  return cipher.doFinal(data);
 }
}

测试

@Test
 public void testRsaAlgorithm() throws Exception{
  
  KeyPair keyPair = RSAUtil.generateKeyPair();
  String publicKey = Base64Utils.encodeToString(keyPair.getPublic().getEncoded());
  String privateKey = Base64Utils.encodeToString(keyPair.getPrivate().getEncoded());
  
  String data = "中国欢迎你";
  
  byte[] encodeData = RSAUtil.operByPublicKey(data.getBytes(), publicKey, RSAUtil.ENCRYPT_MODE);
  byte[] decodeData = RSAUtil.operByPrivateKey(encodeData, privateKey, Cipher.DECRYPT_MODE);
  
  System.out.println(new String(decodeData));
 }