公钥私钥RSA加密

一、摘要

公钥（Public Key）与私钥（Private Key）是通过一种算法得到的一个密钥对（即一个公钥和一个私钥），公钥是密钥对中公开的部分，私钥则是非公开的部分。公钥通常用于加密会话密钥、验证数字签名，或加密可以用相应的私钥解密的数据。通过这种算法得到的密钥对能保证在世界范围内是独一的。使用这个密钥对的时候，如果用其中一个密钥加密一段数据，必须用另一个密钥解密。比如用公钥加密数据就必须用私钥解密，如果用私钥加密也必须用公钥解密，否则解密将不会成功。

二、背景

网络间双方通信需要有一种加密方式，RSA公钥加密是目前被推荐的加密标准。

三、推广建议

RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的所有密码攻击。

RSA算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

四、正文

举例：

比如有两个用户Alice和Bob，Alice想把一段明文通过双钥加密的技术发送给Bob，Bob有一对公钥和私钥，那么加密解密的过程如下：

Bob将他的公开密钥传送给Alice。

Alice用Bob的公开密钥加密她的消息，然后传送给Bob。

Bob用他的私人密钥解密Alice的消息。

　　上面的过程可以用下图表示，Alice使用Bob的公钥进行加密，Bob用自己的私钥进行解密。

例子和图出自《网络安全基础应用与标准第二版》

总结：公钥和私钥是成对的，它们互相解密。

公钥加密，私钥解密。

私钥数字签名，公钥验证。

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

/**
 * 使用RSA私钥加密数据
 *
 * @param  pubKeyInByte
 *            打包的byte[]形式私钥
 * @param data
 *            要加密的数据
 * @return 加密数据
 */
public static byte[] encryptByRSA1(byte[] privKeyInByte, byte[] data) {
    try {
        PKCS8EncodedKeySpec priv_spec = new PKCS8EncodedKeySpec(
                privKeyInByte);
        KeyFactory mykeyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privKey = mykeyFactory.generatePrivate(priv_spec);
        Cipher cipher = Cipher.getInstance(mykeyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privKey);
        return cipher.doFinal(data);
    } catch (Exception e) {
        return null;
    }
 
}
 
/**
 * 用RSA公钥解密
 *
 * @param privKeyInByte
 *            公钥打包成byte[]形式
 * @param data
 *            要解密的数据
 * @return 解密数据
 */
public static byte[] decryptByRSA1(byte[] pubKeyInByte, byte[] data) {
    try {
        KeyFactory mykeyFactory = KeyFactory.getInstance("RSA");
        X509EncodedKeySpec pub_spec = new X509EncodedKeySpec(pubKeyInByte);
        PublicKey pubKey = mykeyFactory.generatePublic(pub_spec);
        Cipher cipher = Cipher.getInstance(mykeyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    } catch (Exception e) {
        return null;
    }
}
 
  
 
/**
 * 公钥加密
 * @param data 待加密数据
 * @param key 密钥
 * @return byte[] 加密数据
 * */
public static byte[] encryptByPublicKey(byte[] data,byte[] key) throws Exception{
 
    //实例化密钥工厂
    KeyFactory keyFactory=KeyFactory.getInstance("RSA");
    //初始化公钥
    //密钥材料转换
    X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);
    //产生公钥
    PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);
 
    //数据加密
    Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE, pubKey);
    return cipher.doFinal(data);
}
/**
 * 私钥解密
 * @param data 待解密数据
 * @param key 密钥
 * @return byte[] 解密数据
 * */
public static byte[] decryptByPrivateKey(byte[] data,byte[] key) throws Exception{
    //取得私钥
    PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);
    KeyFactory keyFactory=KeyFactory.getInstance("RSA");
    //生成私钥
    PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);
    //数据解密
    Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, privateKey);
    return cipher.doFinal(data);
}
 
  
 
//Java生成公钥私钥
 
//实例化密钥生成器
KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("RSA");
//初始化密钥生成器
 
/**
 * 密钥长度，DH算法的默认密钥长度是1024
 * 密钥长度必须是64的倍数，在512到65536位之间
 * */
 
 
keyPairGenerator.initialize(1024);
//生成密钥对
KeyPair keyPair=keyPairGenerator.generateKeyPair();
//甲方公钥
RSAPublicKey publicKey=(RSAPublicKey) keyPair.getPublic();
System.out.println("系数："+publicKey.getModulus()+"  加密指数："+publicKey.getPublicExponent());
//甲方私钥
RSAPrivateKey privateKey=(RSAPrivateKey) keyPair.getPrivate();
System.out.println("系数："+privateKey.getModulus()+"解密指数："+privateKey.getPrivateExponent());
 
System.out.println("公钥："+ Base64.encodeBase64String(publicKey));
System.out.println("私钥："+Base64.encodeBase64String(privateKey));