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加密算法問題的解答就分享到這里了，希望以上內容可以對大家有一定的幫助，如果你還有很多疑惑沒有解開，可以關注億速云行業資訊頻道了解更多相關知識。