Java中怎么使用RSA加密算法

Java中怎么使用RSA加密算法，针对这个问题，这篇文章详细介绍了相对应的分析和解答，希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。

代码如下

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
 
public class RSADecrypt {
  public static Map<String, String> createKeyPair() throws NoSuchAlgorithmException {
    //创建秘钥对生成器
    KeyPairGenerator generator = KeyPairGenerator.getInstance("rsa");
    //初始化密钥对生成器
    generator.initialize(1024);
    //生成密钥对
    KeyPair keyPair = generator.generateKeyPair();
    //获取公钥私钥
    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    String publicKeyStr = new String(publicKey.getEncoded());
    String privateKeyStr = new String(privateKey.getEncoded());
    //公钥私钥存放map
    Map<String, String> keyMap = new HashMap<>();
    keyMap.put("publicKey", publicKeyStr);
    keyMap.put("privateKey", privateKeyStr);
    return keyMap;
  }
 
  /**
   * 获取公钥
   * @param publicKey
   * @return
   */
  public static RSAPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
    KeyFactory keyFactory = KeyFactory.getInstance("rsa");
    //X509编码
    X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey.getBytes());
    RSAPublicKey rsaPublicKey = (RSAPublicKey) keyFactory.generatePublic(x509EncodedKeySpec);
    return rsaPublicKey;
  }
 
  /**
   * 获取私钥
   * @param privateKey
   * @return
   */
  public static RSAPrivateKey getPrivateKey(String privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
    KeyFactory keyFactory = KeyFactory.getInstance("rsa");
    //PKCS#8编码
    PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey.getBytes());
    RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8EncodedKeySpec);
    return rsaPrivateKey;
  }
 
  /**
   * 公钥加密
   * @param src
   * @param publicKey
   * @return
   */
  public static byte[] publicEncrypt(String src, RSAPublicKey publicKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
    Cipher cipher = Cipher.getInstance("rsa");
    cipher.init(Cipher.ENCRYPT_MODE,publicKey);
    byte[] encryptedData = cipher.doFinal(src.getBytes());
    return encryptedData;
  }
 
  /**
   * 私钥解密
   * @param data
   * @param privateKey
   * @return
   * @throws NoSuchPaddingException
   * @throws NoSuchAlgorithmException
   * @throws InvalidKeyException
   * @throws BadPaddingException
   * @throws IllegalBlockSizeException
   */
  public static String privateDecrypt(byte[] data, RSAPrivateKey privateKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
    Cipher cipher = Cipher.getInstance("rsa");
    cipher.init(Cipher.DECRYPT_MODE,privateKey);
    byte[] result = cipher.doFinal(data);
    return new String(result);
  }
 
  public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeySpecException, IllegalBlockSizeException, InvalidKeyException, BadPaddingException, NoSuchPaddingException {
    Map<String,String> keyPair = createKeyPair();
    RSAPublicKey publicKey = getPublicKey(keyPair.get("publicKey"));
    RSAPrivateKey privateKey = getPrivateKey(keyPair.get("privateKey"));
    String str = "hello world";
    /**
     * 公钥加密，私钥解密
     */
    byte[] encryptedData = publicEncrypt(str,publicKey);
    String result = privateDecrypt(encryptedData, privateKey);
 
    /**
     * 私钥加密，公钥解密
     */
    byte[] encrypted = privateEncrypt(str, privateKey);
    String source = publicDecrypt(encrypted, publicKey);
 
  }
 
  /**
   * 私钥加密
   * @param src
   * @param privateKey
   * @return
   * @throws NoSuchPaddingException
   * @throws NoSuchAlgorithmException
   * @throws InvalidKeyException
   * @throws BadPaddingException
   * @throws IllegalBlockSizeException
   */
  public static byte[] privateEncrypt(String src, RSAPrivateKey privateKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
    Cipher cipher = Cipher.getInstance("rsa");
    cipher.init(Cipher.DECRYPT_MODE,privateKey);
    byte[] result = cipher.doFinal(src.getBytes());
    return result;
  }
 
  /**
   * 公钥解密
   * @param data
   * @param publicKey
   * @return
   * @throws NoSuchPaddingException
   * @throws NoSuchAlgorithmException
   * @throws InvalidKeyException
   * @throws BadPaddingException
   * @throws IllegalBlockSizeException
   */
  public static String publicDecrypt(byte[] data, RSAPublicKey publicKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
    Cipher cipher = Cipher.getInstance("rsa");
    cipher.init(Cipher.DECRYPT_MODE,publicKey);
    byte[] result = cipher.doFinal(data);
    return new String(result);
  }
}

上面例子使用密钥长度1024，如果想使用2048密钥，只需要在初始化密钥对生成器做一些变动，其他部分可以复用。

generator.initialize(2048);

关于Java中怎么使用RSA加密算法问题的解答就分享到这里了，希望以上内容可以对大家有一定的帮助，如果你还有很多疑惑没有解开，可以关注亿速云行业资讯频道了解更多相关知识。