Android資料加密之Rsa加密

總李寫程式碼發表於2016-05-08

前言：

最近無意中和同事交流資料安全傳輸的問題，想起自己曾經使用過的Rsa非對稱加密演算法，閒下來總結一下。

其他幾種加密方式：

什麼是Rsa加密？

RSA演算法是最流行的公鑰密碼演算法，使用長度可以變化的金鑰。RSA是第一個既能用於資料加密也能用於數字簽名的演算法。

RSA演算法原理如下：

1.隨機選擇兩個大質數p和q，p不等於q，計算N=pq；
2.選擇一個大於1小於N的自然數e，e必須與(p-1)(q-1)互素。
3.用公式計算出d：d×e = 1 (mod (p-1)(q-1)) 。
4.銷燬p和q。

最終得到的N和e就是“公鑰”，d就是“私鑰”，傳送方使用N去加密資料，接收方只有使用d才能解開資料內容。

RSA的安全性依賴於大數分解，小於1024位的N已經被證明是不安全的，而且由於RSA演算法進行的都是大數計算，使得RSA最快的情況也比DES慢上倍，這是RSA最大的缺陷，因此通常只能用於加密少量資料或者加密金鑰，但RSA仍然不失為一種高強度的演算法。

該如何使用呢?

第一步：首先生成祕鑰對

    /**
     * 隨機生成RSA金鑰對
     *
     * @param keyLength 金鑰長度，範圍：512～2048
     *                  一般1024
     * @return
     */
    public static KeyPair generateRSAKeyPair(int keyLength) {
        try {
            KeyPairGenerator kpg = KeyPairGenerator.getInstance(RSA);
            kpg.initialize(keyLength);
            return kpg.genKeyPair();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return null;
        }
    }

具體加密實現：

公鑰加密

    /**
     * 用公鑰對字串進行加密
     *
     * @param data 原文
     */
    public static byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
        // 得到公鑰
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
        KeyFactory kf = KeyFactory.getInstance(RSA);
        PublicKey keyPublic = kf.generatePublic(keySpec);
        // 加密資料
        Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);
        cp.init(Cipher.ENCRYPT_MODE, keyPublic);
        return cp.doFinal(data);
    }

私鑰加密

    /**
     * 私鑰加密
     *
     * @param data       待加密資料
     * @param privateKey 金鑰
     * @return byte[] 加密資料
     */
    public static byte[] encryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
        // 得到私鑰
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
        KeyFactory kf = KeyFactory.getInstance(RSA);
        PrivateKey keyPrivate = kf.generatePrivate(keySpec);
        // 資料加密
        Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
        cipher.init(Cipher.ENCRYPT_MODE, keyPrivate);
        return cipher.doFinal(data);
    }

公鑰解密

 /**
     * 公鑰解密
     *
     * @param data      待解密資料
     * @param publicKey 金鑰
     * @return byte[] 解密資料
     */
    public static byte[] decryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
        // 得到公鑰
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
        KeyFactory kf = KeyFactory.getInstance(RSA);
        PublicKey keyPublic = kf.generatePublic(keySpec);
        // 資料解密
        Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
        cipher.init(Cipher.DECRYPT_MODE, keyPublic);
        return cipher.doFinal(data);
    }

私鑰解密

 /**
     * 使用私鑰進行解密
     */
    public static byte[] decryptByPrivateKey(byte[] encrypted, byte[] privateKey) throws Exception {
        // 得到私鑰
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
        KeyFactory kf = KeyFactory.getInstance(RSA);
        PrivateKey keyPrivate = kf.generatePrivate(keySpec);

        // 解密資料
        Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);
        cp.init(Cipher.DECRYPT_MODE, keyPrivate);
        byte[] arr = cp.doFinal(encrypted);
        return arr;
    }

幾個全域性變數解說：

    public static final String RSA = "RSA";// 非對稱加密金鑰演算法
    public static final String ECB_PKCS1_PADDING = "RSA/ECB/PKCS1Padding";//加密填充方式
    public static final int DEFAULT_KEY_SIZE = 2048;//祕鑰預設長度
    public static final byte[] DEFAULT_SPLIT = "#PART#".getBytes();    // 當要加密的內容超過bufferSize，則採用partSplit進行分塊加密
    public static final int DEFAULT_BUFFERSIZE = (DEFAULT_KEY_SIZE / 8) - 11;// 當前祕鑰支援加密的最大位元組數

關於加密填充方式：之前以為上面這些操作就能實現rsa加解密，以為萬事大吉了，呵呵，這事還沒完，悲劇還是發生了，Android這邊加密過的資料，伺服器端死活解密不了，原來android系統的RSA實現是"RSA/None/NoPadding"，而標準JDK實現是"RSA/None/PKCS1Padding" ，這造成了在android機上加密後無法在伺服器上解密的原因，所以在實現的時候這個一定要注意。

實現分段加密：搞定了填充方式之後又自信的認為萬事大吉了，可是意外還是發生了，RSA非對稱加密內容長度有限制，1024位key的最多隻能加密127位資料，否則就會報錯(javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes) ，　RSA 是常用的非對稱加密演算法。最近使用時卻出現了“不正確的長度”的異常，研究發現是由於待加密的資料超長所致。RSA 演算法規定：待加密的位元組數不能超過金鑰的長度值除以 8 再減去 11（即：KeySize / 8 - 11），而加密後得到密文的位元組數，正好是金鑰的長度值除以 8（即：KeySize / 8）。

公鑰分段加密

/**
     * 用公鑰對字串進行分段加密
     *
     */
    public static byte[] encryptByPublicKeyForSpilt(byte[] data, byte[] publicKey) throws Exception {
        int dataLen = data.length;
        if (dataLen <= DEFAULT_BUFFERSIZE) {
            return encryptByPublicKey(data, publicKey);
        }
        List<Byte> allBytes = new ArrayList<Byte>(2048);
        int bufIndex = 0;
        int subDataLoop = 0;
        byte[] buf = new byte[DEFAULT_BUFFERSIZE];
        for (int i = 0; i < dataLen; i++) {
            buf[bufIndex] = data[i];
            if (++bufIndex == DEFAULT_BUFFERSIZE || i == dataLen - 1) {
                subDataLoop++;
                if (subDataLoop != 1) {
                    for (byte b : DEFAULT_SPLIT) {
                        allBytes.add(b);
                    }
                }
                byte[] encryptBytes = encryptByPublicKey(buf, publicKey);
                for (byte b : encryptBytes) {
                    allBytes.add(b);
                }
                bufIndex = 0;
                if (i == dataLen - 1) {
                    buf = null;
                } else {
                    buf = new byte[Math.min(DEFAULT_BUFFERSIZE, dataLen - i - 1)];
                }
            }
        }
        byte[] bytes = new byte[allBytes.size()];
        {
            int i = 0;
            for (Byte b : allBytes) {
                bytes[i++] = b.byteValue();
            }
        }
        return bytes;
    }

私鑰分段加密

  /**
     * 分段加密
     *
     * @param data       要加密的原始資料
     * @param privateKey 祕鑰
     */
    public static byte[] encryptByPrivateKeyForSpilt(byte[] data, byte[] privateKey) throws Exception {
        int dataLen = data.length;
        if (dataLen <= DEFAULT_BUFFERSIZE) {
            return encryptByPrivateKey(data, privateKey);
        }
        List<Byte> allBytes = new ArrayList<Byte>(2048);
        int bufIndex = 0;
        int subDataLoop = 0;
        byte[] buf = new byte[DEFAULT_BUFFERSIZE];
        for (int i = 0; i < dataLen; i++) {
            buf[bufIndex] = data[i];
            if (++bufIndex == DEFAULT_BUFFERSIZE || i == dataLen - 1) {
                subDataLoop++;
                if (subDataLoop != 1) {
                    for (byte b : DEFAULT_SPLIT) {
                        allBytes.add(b);
                    }
                }
                byte[] encryptBytes = encryptByPrivateKey(buf, privateKey);
                for (byte b : encryptBytes) {
                    allBytes.add(b);
                }
                bufIndex = 0;
                if (i == dataLen - 1) {
                    buf = null;
                } else {
                    buf = new byte[Math.min(DEFAULT_BUFFERSIZE, dataLen - i - 1)];
                }
            }
        }
        byte[] bytes = new byte[allBytes.size()];
        {
            int i = 0;
            for (Byte b : allBytes) {
                bytes[i++] = b.byteValue();
            }
        }
        return bytes;
    }

公鑰分段解密

 /**
     * 公鑰分段解密
     *
     * @param encrypted 待解密資料
     * @param publicKey 金鑰
     */
    public static byte[] decryptByPublicKeyForSpilt(byte[] encrypted, byte[] publicKey) throws Exception {
        int splitLen = DEFAULT_SPLIT.length;
        if (splitLen <= 0) {
            return decryptByPublicKey(encrypted, publicKey);
        }
        int dataLen = encrypted.length;
        List<Byte> allBytes = new ArrayList<Byte>(1024);
        int latestStartIndex = 0;
        for (int i = 0; i < dataLen; i++) {
            byte bt = encrypted[i];
            boolean isMatchSplit = false;
            if (i == dataLen - 1) {
                // 到data的最後了
                byte[] part = new byte[dataLen - latestStartIndex];
                System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
                byte[] decryptPart = decryptByPublicKey(part, publicKey);
                for (byte b : decryptPart) {
                    allBytes.add(b);
                }
                latestStartIndex = i + splitLen;
                i = latestStartIndex - 1;
            } else if (bt == DEFAULT_SPLIT[0]) {
                // 這個是以split[0]開頭
                if (splitLen > 1) {
                    if (i + splitLen < dataLen) {
                        // 沒有超出data的範圍
                        for (int j = 1; j < splitLen; j++) {
                            if (DEFAULT_SPLIT[j] != encrypted[i + j]) {
                                break;
                            }
                            if (j == splitLen - 1) {
                                // 驗證到split的最後一位，都沒有break，則表明已經確認是split段
                                isMatchSplit = true;
                            }
                        }
                    }
                } else {
                    // split只有一位，則已經匹配了
                    isMatchSplit = true;
                }
            }
            if (isMatchSplit) {
                byte[] part = new byte[i - latestStartIndex];
                System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
                byte[] decryptPart = decryptByPublicKey(part, publicKey);
                for (byte b : decryptPart) {
                    allBytes.add(b);
                }
                latestStartIndex = i + splitLen;
                i = latestStartIndex - 1;
            }
        }
        byte[] bytes = new byte[allBytes.size()];
        {
            int i = 0;
            for (Byte b : allBytes) {
                bytes[i++] = b.byteValue();
            }
        }
        return bytes;
    }

私鑰分段解密

  /**
     * 使用私鑰分段解密
     *
     */
    public static byte[] decryptByPrivateKeyForSpilt(byte[] encrypted, byte[] privateKey) throws Exception {
        int splitLen = DEFAULT_SPLIT.length;
        if (splitLen <= 0) {
            return decryptByPrivateKey(encrypted, privateKey);
        }
        int dataLen = encrypted.length;
        List<Byte> allBytes = new ArrayList<Byte>(1024);
        int latestStartIndex = 0;
        for (int i = 0; i < dataLen; i++) {
            byte bt = encrypted[i];
            boolean isMatchSplit = false;
            if (i == dataLen - 1) {
                // 到data的最後了
                byte[] part = new byte[dataLen - latestStartIndex];
                System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
                byte[] decryptPart = decryptByPrivateKey(part, privateKey);
                for (byte b : decryptPart) {
                    allBytes.add(b);
                }
                latestStartIndex = i + splitLen;
                i = latestStartIndex - 1;
            } else if (bt == DEFAULT_SPLIT[0]) {
                // 這個是以split[0]開頭
                if (splitLen > 1) {
                    if (i + splitLen < dataLen) {
                        // 沒有超出data的範圍
                        for (int j = 1; j < splitLen; j++) {
                            if (DEFAULT_SPLIT[j] != encrypted[i + j]) {
                                break;
                            }
                            if (j == splitLen - 1) {
                                // 驗證到split的最後一位，都沒有break，則表明已經確認是split段
                                isMatchSplit = true;
                            }
                        }
                    }
                } else {
                    // split只有一位，則已經匹配了
                    isMatchSplit = true;
                }
            }
            if (isMatchSplit) {
                byte[] part = new byte[i - latestStartIndex];
                System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
                byte[] decryptPart = decryptByPrivateKey(part, privateKey);
                for (byte b : decryptPart) {
                    allBytes.add(b);
                }
                latestStartIndex = i + splitLen;
                i = latestStartIndex - 1;
            }
        }
        byte[] bytes = new byte[allBytes.size()];
        {
            int i = 0;
            for (Byte b : allBytes) {
                bytes[i++] = b.byteValue();
            }
        }
        return bytes;
    }

這樣總算把遇見的問題解決了，專案中使用的方案是客戶端公鑰加密，伺服器私鑰解密，伺服器開發人員說是出於效率考慮，所以還是自己寫了個程式測試一下真正的效率

第一步：準備100條物件資料

        List<Person> personList=new ArrayList<>();
        int testMaxCount=100;//測試的最大資料條數
        //新增測試資料
        for(int i=0;i<testMaxCount;i++){
            Person person =new Person();
            person.setAge(i);
            person.setName(String.valueOf(i));
            personList.add(person);
        }
        //FastJson生成json資料

        String jsonData=JsonUtils.objectToJsonForFastJson(personList);

        Log.e("MainActivity","加密前json資料 ---->"+jsonData);
        Log.e("MainActivity","加密前json資料長度 ---->"+jsonData.length());

第二步生成祕鑰對

        KeyPair keyPair=RSAUtils.generateRSAKeyPair(RSAUtils.DEFAULT_KEY_SIZE);
        // 公鑰
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        // 私鑰
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

接下來分別使用公鑰加密私鑰解密私鑰加密公鑰解密

        //公鑰加密
        long start=System.currentTimeMillis();
        byte[] encryptBytes=    RSAUtils.encryptByPublicKeyForSpilt(jsonData.getBytes(),publicKey.getEncoded());
        long end=System.currentTimeMillis();
        Log.e("MainActivity","公鑰加密耗時 cost time---->"+(end-start));
        String encryStr=Base64Encoder.encode(encryptBytes);
        Log.e("MainActivity","加密後json資料 --1-->"+encryStr);
        Log.e("MainActivity","加密後json資料長度 --1-->"+encryStr.length());
        //私鑰解密
        start=System.currentTimeMillis();
        byte[] decryptBytes=  RSAUtils.decryptByPrivateKeyForSpilt(Base64Decoder.decodeToBytes(encryStr),privateKey.getEncoded());
        String decryStr=new String(decryptBytes);
        end=System.currentTimeMillis();
        Log.e("MainActivity","私鑰解密耗時 cost time---->"+(end-start));
        Log.e("MainActivity","解密後json資料 --1-->"+decryStr);

        //私鑰加密
        start=System.currentTimeMillis();
        encryptBytes=    RSAUtils.encryptByPrivateKeyForSpilt(jsonData.getBytes(),privateKey.getEncoded());
        end=System.currentTimeMillis();
        Log.e("MainActivity","私鑰加密密耗時 cost time---->"+(end-start));
        encryStr=Base64Encoder.encode(encryptBytes);
        Log.e("MainActivity","加密後json資料 --2-->"+encryStr);
        Log.e("MainActivity","加密後json資料長度 --2-->"+encryStr.length());
        //公鑰解密
        start=System.currentTimeMillis();
        decryptBytes=  RSAUtils.decryptByPublicKeyForSpilt(Base64Decoder.decodeToBytes(encryStr),publicKey.getEncoded());
        decryStr=new String(decryptBytes);
        end=System.currentTimeMillis();
        Log.e("MainActivity","公鑰解密耗時 cost time---->"+(end-start));
        Log.e("MainActivity","解密後json資料 --2-->"+decryStr);

執行結果：

對比發現：私鑰的加解密都很耗時，所以可以根據不同的需求採用不能方案來進行加解密。個人覺得伺服器要求解密效率高，客戶端私鑰加密，伺服器公鑰解密比較好一點

加密後資料大小的變化：資料量差不多是加密前的1.5倍

Android資料加密之Aes加密
2016-07-30
Android加密
Android資料加密之Des加密
2016-06-13
Android加密
Android資料加密之MD5加密
2016-09-20
Android加密
RSA加密
2017-11-15
加密
Android資料加密之異或加密演算法
2016-10-11
Android加密演算法
前後端資料加密傳輸 RSA非對稱加密
2018-07-04
後端加密
javascript RSA 加密
2018-06-07
JavaScript加密
Android、Java RSA加密踩坑記
2019-01-21
AndroidJava加密
RSA加密與解密
2021-09-09
加密解密
C# RSA 加密
2019-02-08
C#加密
RSA加密檔案
2010-04-06
加密
Android資料儲存之SQLCipher資料庫加密
2016-07-30
AndroidSQL資料庫加密
Android加密之檔案級加密
2018-05-05
Android加密
Windows phone應用開發[19]-RSA資料加密
2013-10-15
Windows加密
iOS中使用RSA對資料進行加密解密
2016-03-15
iOS加密解密
前後端API互動資料加密——AES與RSA混合加密完整例項
2019-05-29
後端API加密
RSA加密遇到的坑
2019-03-09
加密
RSA加密演算法
2018-10-17
加密演算法
php rsa長文加密解密
2024-04-12
PHP加密解密
php中aes加密和rsa加密的區別
2021-09-09
PHP加密
對稱加密、非對稱加密、RSA(總結)
2018-03-28
加密
PostgreSQL 資料加密之 pgcrypto
2020-10-20
SQL加密GC
RSA 非對稱加密&解密
2020-12-18
加密解密
iOS資料加密(Base64,雜湊函式,AES,RSA)
2017-12-12
iOS加密函式
資料亂碼（之.net加密）
2012-07-20
加密
Android資料加密之SHA安全雜湊演算法
2016-09-23
Android加密演算法
資料加密
2019-09-19
加密
資料加密（對稱加密和非對稱加密）
2018-09-19
加密
RSA加密解密（無資料大小限制，php、go、java互通實現）
2019-02-16
加密解密PHPGoJava
RSA加密原理&密碼學&HASH
2019-10-16
加密密碼學
nodejs常用加密方式 RSA & AES
2019-10-18
NodeJS加密
關於php rsa加密處理
2022-01-20
PHP加密
安全篇-AES/RSA加密機制
2018-07-18
加密
# RSA 公鑰加密演算法
2017-08-15
加密演算法
rsa加密概念和license總結
2010-03-07
加密
python實現aes加密解密，RSA簽名和驗籤，RSA加密解密，並呼叫介面
2014-09-29
Python加密解密
資料庫安全之TDE列加密
2017-01-09
資料庫加密
Android資料加密之Base64編碼演算法
2016-09-21
Android加密演算法

Android資料加密之Rsa加密

相關文章