Android數(shù)據(jù)加密之Rsa加密

文章來源:http://www.cnblogs.com/whoislcj/p/5885006.html
前言:
最近無意中和同事交流數(shù)據(jù)安全傳輸?shù)膯栴}征椒,想起自己曾經(jīng)使用過的Rsa非對稱加密算法,閑下來總結(jié)一下璃弄。
其他幾種加密方式:
Android數(shù)據(jù)加密之Rsa加密

Android數(shù)據(jù)加密之Aes加密

Android數(shù)據(jù)加密之Des加密

Android數(shù)據(jù)加密之MD5加密

Android數(shù)據(jù)加密之Base64編碼算法

Android數(shù)據(jù)加密之異或加密算法

什么是Rsa加密哥捕?
RSA算法是最流行的公鑰密碼算法牧抽,使用長度可以變化的密鑰。RSA是第一個既能用于數(shù)據(jù)加密也能用于數(shù)字簽名的算法遥赚。RSA算法原理如下:1.隨機(jī)選擇兩個大質(zhì)數(shù)p和q,p不等于q阐肤,計算N=pq凫佛; 2.選擇一個大于1小于N的自然數(shù)e,e必須與(p-1)(q-1)互素孕惜。 3.用公式計算出d:d×e = 1 (mod (p-1)(q-1)) 愧薛。4.銷毀p和q。最終得到的N和e就是“公鑰”衫画,d就是“私鑰”毫炉,發(fā)送方使用N去加密數(shù)據(jù),接收方只有使用d才能解開數(shù)據(jù)內(nèi)容削罩。RSA的安全性依賴于大數(shù)分解瞄勾,小于1024位的N已經(jīng)被證明是不安全的,而且由于RSA算法進(jìn)行的都是大數(shù)計算弥激,使得RSA最快的情況也比DES慢上倍进陡,這是RSA最大的缺陷,因此通常只能用于加密少量數(shù)據(jù)或者加密密鑰微服,但RSA仍然不失為一種高強(qiáng)度的算法趾疚。

該如何使用呢?
** 第一步**:首先生成秘鑰對

/**
     * 隨機(jī)生成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;
        }
    }

具體加密實現(xiàn):

公鑰加密

/**
     * 用公鑰對字符串進(jìn)行加密
     *
     * @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);
        // 加密數(shù)據(jù)
        Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);
        cp.init(Cipher.ENCRYPT_MODE, keyPublic);
        return cp.doFinal(data);
    }

私鑰加密

/**
     * 私鑰加密
     *
     * @param data       待加密數(shù)據(jù)
     * @param privateKey 密鑰
     * @return byte[] 加密數(shù)據(jù)
     */
    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);
        // 數(shù)據(jù)加密
        Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
        cipher.init(Cipher.ENCRYPT_MODE, keyPrivate);
        return cipher.doFinal(data);
    }

公鑰解密

/**
     * 公鑰解密
     *
     * @param data      待解密數(shù)據(jù)
     * @param publicKey 密鑰
     * @return byte[] 解密數(shù)據(jù)
     */
    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);
        // 數(shù)據(jù)解密
        Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
        cipher.init(Cipher.DECRYPT_MODE, keyPublic);
        return cipher.doFinal(data);
    }

私鑰解密

/**
     * 使用私鑰進(jìn)行解密
     */
    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);

        // 解密數(shù)據(jù)
        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;//秘鑰默認(rèn)長度
    public static final byte[] DEFAULT_SPLIT = "#PART#".getBytes();    // 當(dāng)要加密的內(nèi)容超過bufferSize以蕴,則采用partSplit進(jìn)行分塊加密
    public static final int DEFAULT_BUFFERSIZE = (DEFAULT_KEY_SIZE / 8) - 11;// 當(dāng)前秘鑰支持加密的最大字節(jié)數(shù)

關(guān)于加密填充方式:之前以為上面這些操作就能實現(xiàn)rsa加解密糙麦,以為萬事大吉了,呵呵丛肮,這事還沒完赡磅,悲劇還是發(fā)生了,Android這邊加密過的數(shù)據(jù)腾供,服務(wù)器端死活解密不了仆邓,原來android系統(tǒng)的RSA實現(xiàn)是"RSA/None/NoPadding"鲜滩,而標(biāo)準(zhǔn)JDK實現(xiàn)是"RSA/None/PKCS1Padding" ,這造成了在android機(jī)上加密后無法在服務(wù)器上解密的原因节值,所以在實現(xiàn)的時候這個一定要注意徙硅。

實現(xiàn)分段加密:搞定了填充方式之后又自信的認(rèn)為萬事大吉了,可是意外還是發(fā)生了搞疗,RSA非對稱加密內(nèi)容長度有限制嗓蘑,1024位key的最多只能加密127位數(shù)據(jù),否則就會報錯(javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes) 匿乃, RSA 是常用的非對稱加密算法桩皿。最近使用時卻出現(xiàn)了“不正確的長度”的異常,研究發(fā)現(xiàn)是由于待加密的數(shù)據(jù)超長所致幢炸。RSA 算法規(guī)定:待加密的字節(jié)數(shù)不能超過密鑰的長度值除以 8 再減去 11(即:KeySize / 8 - 11)泄隔,而加密后得到密文的字節(jié)數(shù),正好是密鑰的長度值除以 8(即:KeySize / 8)宛徊。

公鑰分段加密

/**
     * 用公鑰對字符串進(jìn)行分段加密
     *
     */
    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       要加密的原始數(shù)據(jù)
     * @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 待解密數(shù)據(jù)
     * @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,則表明已經(jīng)確認(rèn)是split段
                                isMatchSplit = true;
                            }
                        }
                    }
                } else {
                    // split只有一位闸天,則已經(jīng)匹配了
                    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,則表明已經(jīng)確認(rèn)是split段
                                isMatchSplit = true;
                            }
                        }
                    }
                } else {
                    // split只有一位苞氮,則已經(jīng)匹配了
                    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;
    }

這樣總算把遇見的問題解決了湾揽,項目中使用的方案是客戶端公鑰加密,服務(wù)器私鑰解密笼吟,服務(wù)器開發(fā)人員說是出于效率考慮库物,所以還是自己寫了個程序測試一下真正的效率

第一步:準(zhǔn)備100條對象數(shù)據(jù)

List<Person> personList=new ArrayList<>();
        int testMaxCount=100;//測試的最大數(shù)據(jù)條數(shù)
        //添加測試數(shù)據(jù)
        for(int i=0;i<testMaxCount;i++){
            Person person =new Person();
            person.setAge(i);
            person.setName(String.valueOf(i));
            personList.add(person);
        }
        //FastJson生成json數(shù)據(jù)

        String jsonData=JsonUtils.objectToJsonForFastJson(personList);

        Log.e("MainActivity","加密前json數(shù)據(jù) ---->"+jsonData);
        Log.e("MainActivity","加密前json數(shù)據(jù)長度 ---->"+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數(shù)據(jù) --1-->"+encryStr);
        Log.e("MainActivity","加密后json數(shù)據(jù)長度 --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數(shù)據(jù) --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數(shù)據(jù) --2-->"+encryStr);
        Log.e("MainActivity","加密后json數(shù)據(jù)長度 --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數(shù)據(jù) --2-->"+decryStr);

運(yùn)行結(jié)果:


對比發(fā)現(xiàn):私鑰的加解密都很耗時,所以可以根據(jù)不同的需求采用不能方案來進(jìn)行加解密赞厕。個人覺得服務(wù)器要求解密效率高艳狐,客戶端私鑰加密,服務(wù)器公鑰解密比較好一點(diǎn)

加密后數(shù)據(jù)大小的變化:數(shù)據(jù)量差不多是加密前的1.5倍


干我們這行皿桑,啥時候懈怠毫目,就意味著長進(jìn)的停止,長進(jìn)的停止就意味著被淘汰诲侮,只能往前沖镀虐,直到鳳凰涅槃的一天!

最后編輯于
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
  • 序言:七十年代末沟绪,一起剝皮案震驚了整個濱河市刮便,隨后出現(xiàn)的幾起案子,更是在濱河造成了極大的恐慌绽慈,老刑警劉巖恨旱,帶你破解...
    沈念sama閱讀 222,681評論 6 517
  • 序言:濱河連續(xù)發(fā)生了三起死亡事件辈毯,死亡現(xiàn)場離奇詭異,居然都是意外死亡搜贤,警方通過查閱死者的電腦和手機(jī)谆沃,發(fā)現(xiàn)死者居然都...
    沈念sama閱讀 95,205評論 3 399
  • 文/潘曉璐 我一進(jìn)店門,熙熙樓的掌柜王于貴愁眉苦臉地迎上來仪芒,“玉大人唁影,你說我怎么就攤上這事〉嗝” “怎么了据沈?”我有些...
    開封第一講書人閱讀 169,421評論 0 362
  • 文/不壞的土叔 我叫張陵,是天一觀的道長饺蔑。 經(jīng)常有香客問我锌介,道長,這世上最難降的妖魔是什么膀钠? 我笑而不...
    開封第一講書人閱讀 60,114評論 1 300
  • 正文 為了忘掉前任掏湾,我火速辦了婚禮,結(jié)果婚禮上肿嘲,老公的妹妹穿的比我還像新娘。我一直安慰自己筑公,他們只是感情好雳窟,可當(dāng)我...
    茶點(diǎn)故事閱讀 69,116評論 6 398
  • 文/花漫 我一把揭開白布。 她就那樣靜靜地躺著匣屡,像睡著了一般封救。 火紅的嫁衣襯著肌膚如雪。 梳的紋絲不亂的頭發(fā)上捣作,一...
    開封第一講書人閱讀 52,713評論 1 312
  • 那天誉结,我揣著相機(jī)與錄音,去河邊找鬼券躁。 笑死惩坑,一個胖子當(dāng)著我的面吹牛,可吹牛的內(nèi)容都是我干的也拜。 我是一名探鬼主播以舒,決...
    沈念sama閱讀 41,170評論 3 422
  • 文/蒼蘭香墨 我猛地睜開眼,長吁一口氣:“原來是場噩夢啊……” “哼慢哈!你這毒婦竟也來了蔓钟?” 一聲冷哼從身側(cè)響起,我...
    開封第一講書人閱讀 40,116評論 0 277
  • 序言:老撾萬榮一對情侶失蹤卵贱,失蹤者是張志新(化名)和其女友劉穎滥沫,沒想到半個月后侣集,有當(dāng)?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體,經(jīng)...
    沈念sama閱讀 46,651評論 1 320
  • 正文 獨(dú)居荒郊野嶺守林人離奇死亡兰绣,尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內(nèi)容為張勛視角 年9月15日...
    茶點(diǎn)故事閱讀 38,714評論 3 342
  • 正文 我和宋清朗相戀三年世分,在試婚紗的時候發(fā)現(xiàn)自己被綠了。 大學(xué)時的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片狭魂。...
    茶點(diǎn)故事閱讀 40,865評論 1 353
  • 序言:一個原本活蹦亂跳的男人離奇死亡罚攀,死狀恐怖,靈堂內(nèi)的尸體忽然破棺而出雌澄,到底是詐尸還是另有隱情斋泄,我是刑警寧澤,帶...
    沈念sama閱讀 36,527評論 5 351
  • 正文 年R本政府宣布镐牺,位于F島的核電站炫掐,受9級特大地震影響,放射性物質(zhì)發(fā)生泄漏睬涧。R本人自食惡果不足惜募胃,卻給世界環(huán)境...
    茶點(diǎn)故事閱讀 42,211評論 3 336
  • 文/蒙蒙 一、第九天 我趴在偏房一處隱蔽的房頂上張望畦浓。 院中可真熱鬧痹束,春花似錦、人聲如沸讶请。這莊子的主人今日做“春日...
    開封第一講書人閱讀 32,699評論 0 25
  • 文/蒼蘭香墨 我抬頭看了看天上的太陽夺溢。三九已至论巍,卻和暖如春,著一層夾襖步出監(jiān)牢的瞬間风响,已是汗流浹背嘉汰。 一陣腳步聲響...
    開封第一講書人閱讀 33,814評論 1 274
  • 我被黑心中介騙來泰國打工, 沒想到剛下飛機(jī)就差點(diǎn)兒被人妖公主榨干…… 1. 我叫王不留状勤,地道東北人鞋怀。 一個月前我還...
    沈念sama閱讀 49,299評論 3 379
  • 正文 我出身青樓,卻偏偏與公主長得像荧降,于是被迫代替她去往敵國和親接箫。 傳聞我的和親對象是個殘疾皇子,可洞房花燭夜當(dāng)晚...
    茶點(diǎn)故事閱讀 45,870評論 2 361

推薦閱讀更多精彩內(nèi)容