由於RSA演算法是不對稱加密演算法，所以每次加密得到的資料都不相同，同理加簽得到的資料每次也不一樣。

簡單的說下不對稱演算法，就是兩把不同，但是完全匹配的祕鑰，去進行加解密，公鑰對外提供進行資料加密，私鑰自己儲存，對加密的資料進行解密。所以私鑰不要洩露。

RSA演算法原理：

1、任意互質的兩個質數p,q。

2、得到連個質數的乘積n。

3、得到兩個質數的歐元函式f(n)=(p-1) * (q-1)。

4、任取一個小於f(n)並與其互質的質數e。

5、存在一個數d，使得e^d % f(n) = 1。

6、則（n,e）為公鑰，(n,d)為私鑰。

加密：待加密資料t:

t^te% n = m(m為加密後的資料);

解密：m^d % n = t(t為原資料)

Java實現RSA演算法加密解密，加簽以及驗籤程式碼如下：

1、Base64工具類：

//Base64加密public static String encryptBase64(byte[] key){
    return new String(Base64.encodeBase64(key));
}

//Base64解密
public static byte[] decryptBase64(String key) throws IOException {
    return new BASE64Decoder().decodeBuffer(key);
}
 

2、獲取RSA祕鑰對：

public static Map<String, Object> keyMap()throws Exception{
    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
    keyPairGenerator.initialize(1024);
    KeyPair keyPair = keyPairGenerator.generateKeyPair();
    PublicKey publicKey = keyPair.getPublic();
    PrivateKey privateKey = keyPair.getPrivate();

    Map<String, Object> keyMap = new 
 
HashMap<>(2);
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);
    return keyMap;
}

public static void keyToFile(Map keymap)throws Exception{
    PublicKey publicKey = (PublicKey) keymap.get(PUBLIC_KEY);
    PrivateKey privateKey = (PrivateKey)keymap.get(PRIVATE_KEY);
    String encryptBase64PublicKey = encryptBase64(publicKey.getEncoded());
    String encryptBase64PrivateKey = encryptBase64(privateKey.getEncoded());
    FileWriter fw = new FileWriter("src/main/resources/pubKey.txt");//按需要儲存路徑，下同

    FileWriter fw1 = new FileWriter("src/main/resources/priKey.txt");
    fw.write(encryptBase64PublicKey);
    fw.flush();
    fw.close();
    fw1.write(encryptBase64PrivateKey);
    fw1.flush();
    fw1.close();
}

public static RSAPublicKey getPublicKeyForFile() throws Exception {
    File file = new File("src/main/resources/pubKey.txt");

    FileInputStream fis = new FileInputStream(file);
    BufferedReader br = new BufferedReader(new InputStreamReader(fis));
    String readLine = null;
    StringBuffer sb = new StringBuffer();
    while ((readLine = br.readLine()) != null) {
        sb.append(readLine);
    }
    String publicKeyStr = sb.toString();
    System.out.println("從檔案獲取到的公鑰：" + publicKeyStr);
    //Base64解密
byte[] decryptBase64 = GetKey.decryptBase64(publicKeyStr);
    //選取金鑰編碼規則
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decryptBase64);
    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    RSAPublicKey rsaPublicKey = (RSAPublicKey) keyFactory.generatePublic(keySpec);
    return rsaPublicKey;
}

5、從檔案中獲取私鑰：

//從檔案中獲取私鑰
public static RSAPrivateKey getPrivateKeyForFile() throws Exception {
    FileInputStream fis = new FileInputStream("src/main/resources/priKey.keyStore");
    BufferedReader br = new BufferedReader(new InputStreamReader(fis));
    String readLine = null;
    StringBuffer sb = new StringBuffer();
    while ((readLine = br.readLine()) != null) {
        sb.append(readLine);
    }
    String privateKey = sb.toString();
    System.out.println("從檔案獲取到的私鑰：" + privateKey);
    //Base64解密
byte[] bytes = GetKey.decryptBase64(privateKey);
    PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(bytes);
    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8EncodedKeySpec);
    return rsaPrivateKey;
}

6.公鑰加密/私鑰解密：

public static byte[] encryptOrDecrypt(Key key, byte[] data, int mode) throws Exception {
    //加密演算法：RSA/ECB/PKCS1Padding

    ByteArrayOutputStream out = new ByteArrayOutputStream();

    //提供者
    Provider provider = new BouncyCastleProvider();
    Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", provider);
    cipher.init(mode, key);
    int blockSize = cipher.getBlockSize();
    int length = data.length;
    int num = length / blockSize + 1;
    int cache = blockSize;
    byte[] bytes = null;
    for (int i = 0; i < num; i++) {
        if (i == num - 1) {
            cache = length % blockSize;
            if (cache == 0) {
                return out.toByteArray();
            }
        }
        bytes = cipher.doFinal(data, i * blockSize, cache);
        out.write(bytes);
    }
    return out.toByteArray();
}

 public static String addSign(PrivateKey privateKey, String context)throws Exception{        //加簽演算法：SHA1WithRSA

Signature signature = Signature.getInstance("SHA1WithRSA");
        signature.initSign(privateKey);
        signature.update(context.getBytes("utf-8"));
        byte[] sign = signature.sign();
        return encryptBase64(sign);
    }

public static boolean verifySign(PublicKey publicKey, String context, String signData)throws Exception{Signature signature = Signature.getInstance("SHA1WithRSA");
        signature.initVerify(publicKey);
        byte[] bytes = decryptBase64(signData);
        signature.update(context.getBytes("utf-8"));
        boolean verify = signature.verify(bytes);
        return verify;
    }

public class Sign {

  private final static String PUBLIC_KEY = "PUBLIC_KEY";
  private final static String PRIVATE_KEY = "PRIVATE_KEY";

Map<String, Object> map = keyMap();
keyToFile(map);

RSAPublicKey rsaPublicKey = getPublicKeyForFile();

System.out.println("rsaPublicKey公鑰是：" + rsaPublicKey);

RSAPrivateKey rsaPrivateKey = getPrivateKeyForFile();

System.out.println("rsaPublicKey私鑰是：" + rsaPrivateKey);

String data = "這是一個加密字串"

//加密

byte[] encrypt = encryptOrDecrypt(rsaPublicKey, data.getBytes("utf-8"), Cipher.ENCRYPT_MODE);

String s = encryptBase64(encrypt);
System.out.println("加密後的資料：" + s);

//加簽

String signData = addSign(rsaPrivateKey, data);

System.out.println("加簽後的資料：" + signData);

//驗籤

boolean b = verifySign(rsaPublicKey, data, signData);
System.out.println("驗簽得到的布林值為：" + b);

 } catch (Exception e) {
        e.printStackTrace();
    }
}

<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-jdk16</artifactId>
    <version>1.46</version>
</dependency>