iOS開發 RSA加密解密與後臺之間的雙向加密詳解

阿新 • • 發佈：2018-12-23

序言

因為專案中需要用到RSA加密，剛開始也是有點亂，這兩天也整理的差不多了，希望能幫到大家。這次先上程式碼，我想大部分人肯定是著急解決問題，所以不要廢話太多。

iOS端

後臺是PHP，給我了一段公鑰和他用私鑰加密後的base64編碼，讓我先解一下，看看能否解出(請先不要糾結為什麼給我公鑰解密，公鑰私鑰都可以解密，具體後面會講到)。公鑰：

MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC3//sR2tXw0wrC2DySx8vNGlqt  
3Y7ldU9+LBLI6e1KS5lfc5jlTGF7KBTSkCHBM3ouEHWqp1ZJ85iJe59aF5gIB2kl  
Bd6h4wrbbHA2XE1sq21ykja/Gqx7/IRia3zQfxGv/qEkyGOx+XALVoOlZqDwh76o  
2 
n1vP1D+tD3amHsK7QIDAQAB

base64編碼後的加密資料(注意：後臺給你的一定是經過base64編碼後的):

eZVIkIEDb83YfdpOQCTg1SMfJtAHjdl92oKCALYeItxwvvyBsIR/L2e7y1+rXYCztBELXff/L9SijAYrUWOcvPVLPlkJbiJhZjRn+v4L9UeLtSUfO/qv30K3JROb2OniOvRImK3ZcBq319VT8e62zjJscGBIlwfFfMxRVT/mAzY=

下面使用RSA這是一個封裝的第三方框架，只需要將下面這兩個檔案匯入到專案中，便可以使用(不用再匯入其他的一些框架)，別的框架不敢保證能使用，但這個是肯定可以使用的。

1.png

程式碼：

 //公鑰
    NSString *publicKey = @"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC3//sR2tXw0wrC2DySx8vNGlqt3Y7ldU9+LBLI6e1KS5lfc5jlTGF7KBTSkCHBM3ouEHWqp1ZJ85iJe59aF5gIB2klBd6h4wrbbHA2XE1sq21ykja/Gqx7/IRia3zQfxGv/qEkyGOx+XALVoOlZqDwh76o2n1vP1D+tD3amHsK7QIDAQAB";
    //base64編碼後的加密資料
    NSString *base64Str = @"eZVIkIEDb83YfdpOQCTg1SMfJtAHjdl92oKCALYeItxwvvyBsIR/L2e7y1+rXYCztBELXff/L9SijAYrUWOcvPVLPlkJbiJhZjRn+v4L9UeLtSUfO/qv30K3JROb2OniOvRImK3ZcBq319VT8e62zjJscGBIlwfFfMxRVT/mAzY=" 
;
    //結果:注意，這裡是用公鑰進行解密的，方法一定要用對
    NSString *resultStr = [RSA decryptString:base64Str publicKey:publicKey];
    NSLog(@"結果 = %@",resultStr);

列印結果：

2
這只是先進行測試的資料，如果給你私鑰解密，就用別的方法，在RSA.h中可以很容易找到。
上面講述的是單向加密，那麼如何進行雙向加密呢？

1、 iOS端和後臺（這裡後臺使用的是java，因為我後臺語言只會java，效果都是一樣的）各生成自己的公鑰和私鑰。
2、 iOS端生成的公鑰和私鑰定義為iOSPublicKey、iOSPrivateKey，java端生成的公鑰私鑰定義為javaPublicKey、javaPrivateKey。將iOSPublicKey給java，讓它用iOSPublicKey加密資料傳給iOS端，iOS端用iOSPrivateKey解密；java端將javaPublicKey給iOS端，iOS端用javaPublicKey加密資料後上傳給java，java端利用javaPrivateKey去解密，這樣就實現了資料傳輸過程中的加密與解密，當然，也不一定非要按照我上面的步驟來，具體情況要和後臺商量如何加密。

具體實現：

iOS端

生成公鑰和私鑰

1）新建資料夾，用來儲存生成的私鑰和公鑰，開啟終端 cd 新建,進入到新建資料夾中，openssl,開啟openssl

genrsa -out rsa_private_key.pem 1024生成私鑰

pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform PEM -nocrypt這步一定要有,需要將私鑰轉成PKCS8的格式才能使用,此時複製私鑰(先複製私鑰,然後在4步取出公鑰)

4）rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem 生成公鑰

此時在新建資料夾中會出現兩個檔案

7
我們用文字編輯器開啟便可獲取iOS端生成的公鑰和私鑰。

Xcode專案實戰

還得利用上面提到的RSA檔案

 //公鑰
    NSString *publicKey = @"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDl5RBHD3abOyeYCOLkaWkpJXgJQfMklOWPmdJAnG1eD6CV+UOpUKMy5LtfGHQEM7ao5x3BpMx4MNRUYVwBAmU84PhwNm6xpTJrg5zZCloFmsX+E5ukWE5YFRu8i5+5d8LuQTTTv4XfzbTCTOhON8uj+ypkomETuVNwgRFVFjHd1QIDAQAB";
    //私鑰
    NSString *privateKey = @"MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAOXlEEcPdps7J5gI4uRpaSkleAlB8ySU5Y+Z0kCcbV4PoJX5Q6lQozLku18YdAQztqjnHcGkzHgw1FRhXAECZTzg+HA2brGlMmuDnNkKWgWaxf4Tm6RYTlgVG7yLn7l3wu5BNNO/hd/NtMJM6E43y6P7KmSiYRO5U3CBEVUWMd3VAgMBAAECgYEAkqHVDQ4O35oOegmI9plJauYsNvNqqzWRalN5aJ6dn3YmPiI8Bt2ZClgcLt6A+UEmy3qGX0HG7Q5wD9X9geNOQB3ZiD/pGAGW08wS/wTxnWSnSBwdtZ03pUttfnFctkxULfDq4iG1ywdjqEk3F8QVFajQ0c76kWbt9LGAv2OGIi0CQQD2CmbVFXy4JeNHK3TDoLMjsUCiLa+qPnyyVDLDG9Ozb7wN2ydTrMhI+0udmjKvy/Lm1E2bKyp42iYuubEqvSAXAkEA7zNZsOgUe0q73sxXqrLQ7Fs7TNtIEXghrGmkVTHN0I7uMKzQ7KEbA6hfcBm4hPMoLa6Ag3m9tiMNBWtDWc/Y8wJAK0//dEl5EC3TSccTohCbGJBukV47i1u+teHuobw3U2I7F7FZxfgntflPAWqQu7PKieob01IRAv9cM2OLFbv/dwJBAIniXedeQMA5ekaaIEbjwQ8eH/bTyJ1ZVH/gfbwmc2+vlJo2ZFCjJcFcA3fJO9ZXnGeI2cfwG22sksr24+IXsAUCQG5yvVIleTDYqWuWVG1Rc8fk5UFjoZzJpp0nil0z+0fR5rogr4fxcH7vbWsE0id7gSvtV7KxPzkvJTpOK3yGDN0=";
    //測試要加密的資料
    NSString *sourceStr = @"iOS端RSA";
    //公鑰加密
    NSString *encryptStr = [RSA encryptString:sourceStr publicKey:publicKey];
    //私鑰解密
    NSString *decrypeStr = [RSA decryptString:encryptStr privateKey:privateKey];
    NSLog(@"加密後的資料 %@ 解密後的資料 %@",encryptStr,decrypeStr);

列印結果：

經過測試，私鑰和公鑰是可以使用的。

Java端

我是用的是Eclipse，具體實現方法也是從網上找的，因為開啟的東西太多，忘了是哪篇部落格了，知道的請聯絡我，會註明作者的。

前期準備

9
RSAUtils.java程式碼：

package RSA;

import java.io.ByteArrayOutputStream;  
import java.security.Key;  
import java.security.KeyFactory;  
import java.security.KeyPair;  
import java.security.KeyPairGenerator;  
import java.security.PrivateKey;  
import java.security.PublicKey;  
import java.security.Signature;  
import java.security.interfaces.RSAPrivateKey;  
import java.security.interfaces.RSAPublicKey;  
import java.security.spec.PKCS8EncodedKeySpec;  
import java.security.spec.X509EncodedKeySpec;  
import java.util.HashMap;  
import java.util.Map;
import javax.crypto.Cipher;  
/** *//** 
 * <p> 
 * RSA公鑰/私鑰/簽名工具包 
 * </p> 
 * <p> 
 * 羅納德·李維斯特（Ron [R]ivest）、阿迪·薩莫爾（Adi [S]hamir）和倫納德·阿德曼（Leonard [A]dleman） 
 * </p> 
 * <p> 
 * 字串格式的金鑰在未在特殊說明情況下都為BASE64編碼格式<br/> 
 * 由於非對稱加密速度極其緩慢，一般檔案不使用它來加密而是使用對稱加密，<br/> 
 * 非對稱加密演算法可以用來對對稱加密的金鑰加密，這樣保證金鑰的安全也就保證了資料的安全 
 * </p> 
 *  
 * @author IceWee 
 * @date 2012-4-26 
 * @version 1.0 
 */  
public class RSAUtils {
    /** *//** 
     * 加密演算法RSA 
     */  
    public static final String KEY_ALGORITHM = "RSA";  
      
    /** *//** 
     * 簽名演算法 
     */  
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";  
  
    /** *//** 
     * 獲取公鑰的key 
     */  
    private static final String PUBLIC_KEY = "RSAPublicKey";  
      
    /** *//** 
     * 獲取私鑰的key 
     */  
    private static final String PRIVATE_KEY = "RSAPrivateKey";  
      
    /** *//** 
     * RSA最大加密明文大小 
     */  
    private static final int MAX_ENCRYPT_BLOCK = 117;  
      
    /** *//** 
     * RSA最大解密密文大小 
     */  
    private static final int MAX_DECRYPT_BLOCK = 128;  
  
    /** *//** 
     * <p> 
     * 生成金鑰對(公鑰和私鑰) 
     * </p> 
     *  
     * @return 
     * @throws Exception 
     */  
    public static Map<String, Object> genKeyPair() throws Exception {  
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);  
        keyPairGen.initialize(1024);  
        KeyPair keyPair = keyPairGen.generateKeyPair();  
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
        Map<String, Object> keyMap = new HashMap<String, Object>(2);  
        keyMap.put(PUBLIC_KEY, publicKey);  
        keyMap.put(PRIVATE_KEY, privateKey);  
        return keyMap;  
    }  
      
    /** *//** 
     * <p> 
     * 用私鑰對資訊生成數字簽名 
     * </p> 
     *  
     * @param data 已加密資料 
     * @param privateKey 私鑰(BASE64編碼) 
     *  
     * @return 
     * @throws Exception 
     */  
    public static String sign(byte[] data, String privateKey) throws Exception {  
        byte[] keyBytes = Base64Utils.decode(privateKey);  
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);  
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  
        signature.initSign(privateK);  
        signature.update(data);  
        return Base64Utils.encode(signature.sign());  
    }  
  
    /** *//** 
     * <p> 
     * 校驗數字簽名 
     * </p> 
     *  
     * @param data 已加密資料 
     * @param publicKey 公鑰(BASE64編碼) 
     * @param sign 數字簽名 
     *  
     * @return 
     * @throws Exception 
     *  
     */  
    public static boolean verify(byte[] data, String publicKey, String sign)  
            throws Exception {  
        byte[] keyBytes = Base64Utils.decode(publicKey);  
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        PublicKey publicK = keyFactory.generatePublic(keySpec);  
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  
        signature.initVerify(publicK);  
        signature.update(data);  
        return signature.verify(Base64Utils.decode(sign));  
    }  
  
    /** *//** 
     * <P> 
     * 私鑰解密 
     * </p> 
     *  
     * @param encryptedData 已加密資料 
     * @param privateKey 私鑰(BASE64編碼) 
     * @return 
     * @throws Exception 
     */  
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)  
            throws Exception {  
        byte[] keyBytes = Base64Utils.decode(privateKey);  
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.DECRYPT_MODE, privateK);  
        int inputLen = encryptedData.length;  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        int offSet = 0;  
        byte[] cache;  
        int i = 0;  
        // 對資料分段解密  
        while (inputLen - offSet > 0) {  
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {  
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);  
            } else {  
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);  
            }  
            out.write(cache, 0, cache.length);  
            i++;  
            offSet = i * MAX_DECRYPT_BLOCK;  
        }  
        byte[] decryptedData = out.toByteArray();  
        out.close();  
        return decryptedData;  
    }  
  
    /** *//** 
     * <p> 
     * 公鑰解密 
     * </p> 
     *  
     * @param encryptedData 已加密資料 
     * @param publicKey 公鑰(BASE64編碼) 
     * @return 
     * @throws Exception 
     */  
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)  
            throws Exception {  
        byte[] keyBytes = Base64Utils.decode(publicKey);  
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key publicK = keyFactory.generatePublic(x509KeySpec);  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.DECRYPT_MODE, publicK);  
        int inputLen = encryptedData.length;  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        int offSet = 0;  
        byte[] cache;  
        int i = 0;  
        // 對資料分段解密  
        while (inputLen - offSet > 0) {  
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {  
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);  
            } else {  
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);  
            }  
            out.write(cache, 0, cache.length);  
            i++;  
            offSet = i * MAX_DECRYPT_BLOCK;  
        }  
        byte[] decryptedData = out.toByteArray();  
        out.close();  
        return decryptedData;  
    }  
  
    /** *//** 
     * <p> 
     * 公鑰加密 
     * </p> 
     *  
     * @param data 源資料 
     * @param publicKey 公鑰(BASE64編碼) 
     * @return 
     * @throws Exception 
     */  
    public static byte[] encryptByPublicKey(byte[] data, String publicKey)  
            throws Exception {  
        byte[] keyBytes = Base64Utils.decode(publicKey);  
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key publicK = keyFactory.generatePublic(x509KeySpec);  
        // 對資料加密  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.ENCRYPT_MODE, publicK);  
        int inputLen = data.length;  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        int offSet = 0;  
        byte[] cache;  
        int i = 0;  
        // 對資料分段加密  
        while (inputLen - offSet > 0) {  
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {  
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);  
            } else {  
                cache = cipher.doFinal(data, offSet, inputLen - offSet);  
            }  
            out.write(cache, 0, cache.length);  
            i++;  
            offSet = i * MAX_ENCRYPT_BLOCK;  
        }  
        byte[] encryptedData = out.toByteArray();  
        out.close();  
        return encryptedData;  
    }  
  
    /** *//** 
     * <p> 
     * 私鑰加密 
     * </p> 
     *  
     * @param data 源資料 
     * @param privateKey 私鑰(BASE64編碼) 
     * @return 
     * @throws Exception 
     */  
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey)  
            throws Exception {  
        byte[] keyBytes = Base64Utils.decode(privateKey);  
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);  
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
        cipher.init(Cipher.ENCRYPT_MODE, privateK);  
        int inputLen = data.length;  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        int offSet = 0;  
        byte[] cache;  
        int i = 0;  
        // 對資料分段加密  
        while (inputLen - offSet > 0) {  
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {  
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);  
            } else {  
                cache = cipher.doFinal(data, offSet, inputLen - offSet);  
            }  
            out.write(cache, 0, cache.length);  
            i++;  
            offSet = i * MAX_ENCRYPT_BLOCK;  
        }  
        byte[] encryptedData = out.toByteArray();  
        out.close();  
        return encryptedData;  
    }  
  
    /** *//** 
     * <p> 
     * 獲取私鑰 
     * </p> 
     *  
     * @param keyMap 金鑰對 
     * @return 
     * @throws Exception 
     */  
    public static String getPrivateKey(Map<String, Object> keyMap)  
            throws Exception {  
        Key key = (Key) keyMap.get(PRIVATE_KEY);  
        return Base64Utils.encode(key.getEncoded());  
    }  
  
    /** *//** 
     * <p> 
     * 獲取公鑰 
     * </p> 
     *  
     * @param keyMap 金鑰對 xs
     * @return 
     * @throws Exception 
     */  
    public static String getPublicKey(Map<String, Object> keyMap)  
            throws Exception {  
        Key key = (Key) keyMap.get(PUBLIC_KEY);  
        return Base64Utils.encode(key.getEncoded());  
    } 
}

Base64Utils.java 檔案程式碼：

package RSA;
import java.io.ByteArrayInputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.InputStream;  
import java.io.OutputStream;
import it.sauronsoftware.base64.Base64;  

public class Base64Utils {
    /** *//** 
     * 檔案讀取緩衝區大小 
     */  
    private static final int CACHE_SIZE = 1024;  
      
    /** *//** 
     * <p> 
     * BASE64字串解碼為二進位制資料 
     * </p> 
     *  
     * @param base64 
     * @return 
     * @throws Exception 
     */  
    public static byte[] decode(String base64) throws Exception {  
        return Base64.decode(base64.getBytes());  
    }  
      
    /** *//** 
     * <p> 
     * 二進位制資料編碼為BASE64字串 
     * </p> 
     *  
     * @param bytes 
     * @return 
     * @throws Exception 
     */  
    public static String encode(byte[] bytes) throws Exception {  
        return new String(Base64.encode(bytes));  
    }  
      
    /** *//** 
     * <p> 
     * 將檔案編碼為BASE64字串 
     * </p> 
     * <p> 
     * 大檔案慎用，可能會導致記憶體溢位 
     * </p> 
     *  
     * @param filePath 檔案絕對路徑 
     * @return 
     * @throws Exception 
     */  
    public static String encodeFile(String filePath) throws Exception {  
        byte[] bytes = fileToByte(filePath);  
        return encode(bytes);  
    }  
      
    /** *//** 
     * <p> 
     * BASE64字串轉回檔案 
     * </p> 
     *  
     * @param filePath 檔案絕對路徑 
     * @param base64 編碼字串 
     * @throws Exception 
     */  
    public static void decodeToFile(String filePath, String base64) throws Exception {  
        byte[] bytes = decode(base64);  
        byteArrayToFile(bytes, filePath);  
    }  
      
    /** *//** 
     * <p> 
     * 檔案轉換為二進位制陣列 
     * </p> 
     *  
     * @param filePath 檔案路徑 
     * @return 
     * @throws Exception 
     */  
    public static byte[] fileToByte(String filePath) throws Exception {  
        byte[] data = new byte[0];  
        File file = new File(filePath);  
        if (file.exists()) {  
            FileInputStream in = new FileInputStream(file);  
            ByteArrayOutputStream out = new ByteArrayOutputStream(2048);  
            byte[] cache = new byte[CACHE_SIZE];  
            int nRead = 0;  
            while ((nRead = in.read(cache)) != -1) {  
                out.write(cache, 0, nRead);  
                out.flush();  
            }  
            out.close();  
            in.close();  
            data = out.toByteArray();  
         }  
        return data;  
    }  
      
    /** *//** 
     * <p> 
     * 二進位制資料寫檔案 
     * </p> 
     *  
     * @param bytes 二進位制資料 
     * @param filePath 檔案生成目錄 
     */  
    public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {  
        InputStream in = new ByteArrayInputStream(bytes);     
        File destFile = new File(filePath);  
        if (!destFile.getParentFile().exists()) {  
            destFile.getParentFile().mkdirs();  
        }  
        destFile.createNewFile();  
        OutputStream out = new FileOutputStream(destFile);  
        byte[] cache = new byte[CACHE_SIZE];  
        int nRead = 0;  
        while ((nRead = in.read(cache)) != -1) {     
            out.write(cache, 0, nRead);  
            out.flush();  
        }  
        out.close();  
        in.close();  
    }

}

Test.java檔案中

package RSA;
import java.util.Map;  


public class Test {
     static String publicKey;  
        static String privateKey;  
      
        static {  
            try {  
                Map<String, Object> keyMap = RSAUtils.genKeyPair();  
                publicKey = RSAUtils.getPublicKey(keyMap);  
                privateKey = RSAUtils.getPrivateKey(keyMap);  
                System.err.println("公鑰: \n\r" + publicKey);  
                System.err.println("私鑰： \n\r" + privateKey);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
    
    public static void main(String[] args) throws Exception {
        test();
    }
//加密資料
    static void test() throws Exception {  
        String source = "Java端RSA";  
        System.out.println("\r加密前文字：\r\n" + source);  
        byte[] data = source.getBytes();  
             
        byte[] encodedData = RSAUtils.encryptByPrivateKey(data,privateKey); 
        System.out.println("加密後文字：\r\n" + new String(encodedData));  
       
        byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey);  
        
        String target = new String(decodedData);  
        System.out.println("解密後文字: \r\n" + target);  
    }  
  //驗證簽名
    static void testSign() throws Exception {  
        System.err.println("私鑰加密——公鑰解密");  
        String source = "這是一行測試RSA數字簽名的無意義文字";  
        System.out.println("原文字：\r\n" + source);  
        byte[] data = source.getBytes();  
        byte[] encodedData = RSAUtils.encryptByPrivateKey(data, privateKey);  
        System.out.println("加密後：\r\n" + new String(encodedData));  
        byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey);  
        String target = new String(decodedData);  
        System.out.println("解密後: \r\n" + target);  
        System.err.println("私鑰簽名——公鑰驗證簽名");  
        String sign = RSAUtils.sign(encodedData, privateKey);  
        System.err.println("簽名:\r" + sign);  
        boolean status = RSAUtils.verify(encodedData, publicKey, sign);  
        System.err.println("驗證結果:\r" + status);  
    }  
}

列印結果：

10
在此，我們可以獲取java端生成的私鑰和公鑰
javaPrivateKey:

MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAICJzSMJQJWRMP/eAQpHpeFvoZ6TlEpDwzOu7U7COK0QFOfbSqw8+jVckcUXsbIeluay5kQBogrlzcBcEOUabMczFQRsb9Lo9fa1TObDPOb+Vexg2ndk6BjGO85npXTQlRx1PQzJ2JoFWjdwFxUX9bgkeZLgkYyPpQroHK4SIe5HAgMBAAECgYAYl8T67htAQp5IZjZ2vAyd3Fjk2UGnD936Nn7K8dgcLJaDYe6gk64fpY1yUz05YibnDtWFr3ZMdXlvU24cF3k2PoIyu/CK+/HxToAI1kx0yk52QdiBfiG9vPIqZmCCDWYm0kLE1ayEt2JMDbMWqlMfA7LWzlFEPsO63Jc4hH0BOQJBAPul4inORuoDgtBPxPGUcCICJJZ0xw+kFxgZjSnV0qcP3nQDdzqLiPPJ9Z8jJziIUEqXaxI0qOG7OFlMW8os5qUCQQCCwuBk/Gve/z+j386yiaJFQwxH8SAO97FuHDmYPJtdjrX7o6Uboq9GydzrPwNNK1odV4S858pXksZnU7K2lRl7AkEA6cv8i4qyJ8iLSK5T835Nj8sd4wsrxkRVkHZsyGl4BO6hZnex1hq9aoJASVGHpuY+co6rU4bJQK+Icq6WuQduYQJAaVcM5s3jKNaAMkhOf84ZB6sn7Zz2spggPBBI5beNgiVBveLrVAQPJ/vfGTS+OCDAi/rBWF1yyHHZm8v1oNkkmQJBAPJ5eXbeQngp3s4fi4wc+RuaXVpnwv1HHsUc3JlxfIRcuLthNKZJdLbQO8tjCfnEjztweJP6HjaO6VxZ50o/EDw=

javaPublicKey:

上面的只是生成公鑰和私鑰並且是在當前環境測試，也就是iOS測試自己的，Java測試自己的，我上面也已經說了，iOS端與後臺如何進行雙向加密的，下面具體測試。

雙向加密

iOS端加密，Java端解密
iOS端利用javaPublicKey加密資料

11
java端利用javaPrivate解密

12
列印結果：

Java端加密，iOS端解密
Java端利用 iOSPublicKey加密

15
iOS端利用iOSPrivateKey解密

列印結果：

最後

至此，單向加密與雙向加密，尤其是與後臺之間的加密已經講完了，因為之前看過一些文章有的很模糊，雙向加密的講解很少，並且一些文章的編輯格式真的是難看，根本就沒辦法看下去，所以花了一點時間講講我對這方面的理解，知識其實很淺，並不高深。
注意點：
1、關於iOS端儲存的私鑰和公鑰最好是生成檔案儲存，並且設定密碼，這樣為了更安全，這個網上都有，可以找找。
2、在RSA原理上公鑰和私鑰是可以互相加密互相解密的。公鑰加密，私鑰解密一般是用於加密資料的，私鑰加密公鑰解密是用於驗證身份的，也就是驗證簽名。但在iOS端只能用公鑰加密私鑰解密（不和後臺互動，只是在iOS平臺），只能用私鑰加密公鑰驗籤，請參考文章。如果是和後臺進行加密，無論後臺是用公鑰加密還是私鑰加密，iOS端都是可以解的。這個大家可以試試，在RSA檔案中，其實他在RSA.h中已經說明了
// enc with private key NOT working YET!
+ (NSString *)encryptString:(NSString *)str privateKey:(NSString *)privKey;
用私鑰加密的方法並未實現，具體iOS為何不能用私鑰加密公鑰解密還在搜尋資料中，如果有知道的童鞋請告知，不勝感謝。
8月4日解答:關於非對稱加密是沒有說用私鑰加密公鑰解密的,私鑰只能用來解密和生成簽名,公鑰只能用來加密和驗籤,特此宣告!

iOS開發 RSA加密解密與後臺之間的雙向加密詳解

序言

iOS端

具體實現：

iOS端

Java端

雙向加密

最後

iOS開發 RSA加密解密與後臺之間的雙向加密詳解

iOS開發--使用Charles（青花瓷）抓包圖文詳解

http與https之間的區別詳解

iOS開發-使用charles（青花瓷）抓包圖文詳解

Activity與Fragment之間的通訊詳解

iOS開發之模仿簡書App自定義TabBar詳解

iOS開發RSA加密和解密

Android開發-使用MD5 AES RSA BASE64 加密解密比如登入通訊Token加密

harbor的加密機制與後臺修改登錄密碼

[ARM-Linux開發]深入理解 sudo 與 su 之間的區別

iOS開發 SDWebImage 獲取快取與清除快取

DES加密 java與.net可以相互加密解密兩種方法

iOS開發之--巨集定義與const的區別及使用方法

iOS開發-UIWebView新增頭部與尾部控制元件 && 仿iOS 今日頭條新聞詳情頁結構實現

iOS開發——ActionSheet的使用與彈出選擇對話方塊

iOS開發:#pragma程式碼整理與警告處理

iOS開發：NSDate時區與格式化問題

java加密解密與數字證書的操作

RSA加解密與簽名驗籤

ios開發中類方法與例項方法區別以及self有什麼不同

iOS開發 RSA加密解密與後臺之間的雙向加密詳解

序言

iOS端

具體實現：

iOS端

Java端

雙向加密

最後

相關推薦