2. 程式人生 > >Android資料加密之Rsa加密

Android資料加密之Rsa加密

阿新 • • 發佈：2019-01-14

前言：

     最近無意中和同事交流資料安全傳輸的問題，想起自己曾經使用過的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資料加密之Rsa加密

前言：      最近無意中和同事交流資料安全傳輸的問題，想起自己曾經使用過的Rsa非對稱加密演算法，閒下來總結一下。      其他幾種加密方式： 什麼是Rsa加密？ RSA演算法是最流行的公鑰密碼演算法，使用長度可以變化的金鑰。RSA是第一個既能用於資料加密也能用於數字簽名的演算法。RSA演算

iOS常用加密之RSA加密解密

pen style 工作 eight else mark 分段 load port 前言： iOS常用的加密有很多種，前兩天在工作中遇到了RSA加密，現在把代嗎分享出來。 RSA基本原理 RSA使用"秘匙對"對數據進行加密解密.在加密解密數據前,需要先生成公鑰(publi

Android資料加密之RSA+AES混合加密

在上一篇Android資料加密 中已經介紹了Android中資料加密的情況，並且在總結中給出了RSA+AES混合加密的方案，下面就來介紹一下RSA+AES混合加密。 1.RSA+AES混合加密過程 Android端的資料加密過程： -首先生成一對

Android資料加密之Aes加密

前言：     專案中除了登陸，支付等介面採用rsa非對稱加密，之外的採用aes對稱加密，今天我們來認識一下aes加密。      其他幾種加密方式： 什麼是aes加密？      高階加密標準（英語：Advanced Encryption Standard，縮寫：AES），在密碼學中又稱Rijn

Android資料加密之Des加密

前言：      端午節前有個同事諮詢我有關Android DES加密的相關實現，簡單的實現了一下，今天來總結一下。      其他幾種加密方式： DES加密介紹：      DES是一種對稱加密演算法，所謂對稱加密演算法即：加密和解密使用相同金鑰的演算法。DES加密演算法出自IBM的研究，後來被

Android資料加密之MD5加密

前言：       專案中無論是密碼的儲存或者說判斷檔案是否是同一檔案，都會用到MD5演算法，今天來總結一下MD5加密演算法。 什麼是MD5加密？      MD5英文全稱“Message-Digest Algorithm 5”，翻譯過來是“訊息摘要演算法5”，由MD2、MD3、MD4演變過來的，是一種

Android資料儲存之Sqlite採用SQLCipher資料庫加密實戰

前言：   最近研究了Android Sqlite資料庫（文章地址：http://www.cnblogs.com/whoislcj/p/5506294.html）以及ContentProvider程式間資料共享（http://www.cnblogs.com/whoislcj/p/5507928.html），

登錄頁面之RSA加密

ext number public 加密 公鑰加密 req 等於 賬號安全 fcc 我的項目是金融類項目，所以一般的form表單做登錄頁面未免太草率，所以決定使用加密技術RSA， RSA是目前使用最為廣泛的非對稱性加密算法，其設計思路為：將兩個大素數進行相乘，乘積作為公

非對稱加密之RSA演算法

1977年，MIT的三位老師Rivest、Shamir 和 Adleman 設計了一種演算法，可以實現非對稱加密。這種演算法以他們三個人的名字命名為RSA。RSA演算法是使用最為廣泛的非對稱加密演算法。 RSA加密利用了單向函式正向求解很簡單，反向求解很複雜的特

java 加密之RSA演算法加密與解密的例項詳解

前言：  RSA是第一個比較完善的公開金鑰演算法，它既能用於加密，也能用於數字簽名。RSA以它的三個發明者Ron Rivest, Adi Shamir, Leonard Adleman的名字首字母命名，這個演算法經受住了多年深入的密碼分析，雖然密碼分析者既不能證明也不能否定R

android Java 中使用RSA加密爬坑記錄

1整體流程 後臺生成一個RSA祕鑰對，包括公鑰和私鑰 後臺將公鑰字串下發給客戶端， 然後客戶端用此公鑰生成一個RSAPublicKey物件，再將手機號密碼等資料用此物件加密， 客戶端將加密的資料傳送給後臺， 後臺將加密的資料用私鑰解密。 由於後臺

程式設計師之網路安全系列（三）：資料加密之對稱加密演算法

系列目錄: 前文回顧 假如，明明和麗麗相互不認識，明明想給麗麗寫一封情書，讓隔壁老王送去 如何保證隔壁老王不能看到情書內容？（保密性) 如何保證隔壁老王不修改情書的內容？（完整性) 如何保證隔壁老王不冒充明明？（身份認證) 如何保證明明不能否認情書是自己寫的？（來源的不可否認) 上一節，我們使用了Ha

Android 資料儲存之 SQLite資料庫儲存

轉載自：https://www.cnblogs.com/woider/p/5136734.html ----------------------------------------SQLite資料庫---------------------------------------------- SQLite是一

Android資料儲存之SQLite簡單用法

實現效果圖如下： activity_main.xml佈局檔案 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/a

Android 資料儲存之File

public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { sup

京東post登陸引數js分析，密碼加密的RSA加密實現

老規矩先用錯誤資訊登陸一下抓一下包，看看有那些post欄位： uuid: cf0d4f92-c83b-451a-bc31-be4bf9c546a5eid: 5535JQZQ4ZUMHJEPDFQ7EIQIP4PRSWDLEXGJCVNFQRGNKOKGFFSFH

Android資料儲存之File

檔案儲存分為兩種: (1)內部儲存:  存放路徑為/data/data/package_name/files/ (2)外部儲存:  SD卡 (3)擴充對資源xml檔案的操作 一、內部儲存 1.兩個函式openFileOutput  寫入  許可權:MODE_PRIVATE，

Java 加密之Desede加密（不用Base64）

專案中用到了DES加密，經過一番搜尋網上找到不少程式碼，但都用到了Base64編碼，可是這個東西是sun自用的包，不推薦使用的，心理彆扭就自己找到了不用它的方法。程式碼如下： import java.io.UnsupportedEncodingException; impo

Android資料儲存之SharedPreferences詳細總結

Android中常見的幾種儲存方式： SharedPreferences SQLite資料庫儲存 檔案儲存 網路儲存 其中也許最常用的就是SharedPreferences儲存和檔案儲存了，今天總結一下SharedPreferences。帶著問題學習Sh

對稱加密之AES加密

加密和解密過程中，我們一般使用byte，因為這樣不容易產生亂碼，如果直接是String型別，被加密解密後的String，對中文來說，前後的Unicode是否一致，就很難保證了。 之前說了使用異或運算子加密。在Java中，有API提供，讓我們實現AES對稱加密。