Android加密策略

前言：

我們做項目的時候經常使用到加密算法，我了解的常用的加密算法有對稱加密和非對稱兩大類型，對稱加密就是加密和解密使用同一個密鑰，比如說大家廣為使用的DES加密算法；非對稱加密反之就是加密和解密使用不同的密鑰，一個“公鑰”一個“私鑰”，它們必須配對使用，否則不能打開文件，當然公鑰是對外公布的，私鑰不能對外公布，只能由持有人自己知道，他的優越性就在這，因為對稱式的加密方法如果在網絡上傳輸加密文件就很難不把密鑰告訴對方，不管用什麼方法都有可能被別竊聽到。而非對稱式的加密方法有2個密鑰，公鑰公開不怕別人知道，解密時用私鑰即可，很好的避免了密鑰的傳輸安全性問題，比如當前使用費對稱加密的HTTPS。  

常常聽小伙伴們提起MD5：

MD5算法嚴格來說，並不能算是一種加密算法，只能說是一種摘要算法(數據摘要算法是密碼學算法中灰常重要的一個分支，它通過對所有數據提取指紋信息以實現數據簽名、數據完整性校驗等功能，由於其不可逆性，有時會被用作敏感信息的加密。數據摘要算法也被稱為哈希算法和散列算法)。它主要以512位分組來處理輸入信息，且每一分組又被劃分為16個32位子分組，經過了一系列的處理後，算法的輸出由四哥32位分組組成，將這四個32位分組級聯後將生成一個128位散列值。 那麼我們在開發中一般使用MD5來簽名用戶和密碼。  

了解SHA：

安全哈希算法（Secure Hash Algorithm）主要適用於數字簽名標准（Digital Signature Standard DSS）裡面定義的數字簽名算法（Digital Signature Algorithm DSA）。對於長度小於2^64位的消息，SHA1會產生一個160位的消息摘要。該算法經過加密專家多年來的發展和改進已日益完善，並被廣泛使用。該算法的思想是接收一段明文，然後以一種不可逆的方式將它轉換成一段（通常更小）密文，也可以簡單的理解為取一串輸入碼（稱為預映射或信息），並把它們轉化為長度較短、位數固定的輸出序列即散列值（也稱為信息摘要或信息認證代碼）的過程。散列函數值可以說是對明文的一種“指紋”或是“摘要”所以對散列值的數字簽名就可以視為對此明文的數字簽名。 ----摘自百度百科 SHA1java實現源碼

public class SHA1Util {
     private static final boolean hexcase = false;
     private static final String b64pad = "=";
     private static final int chrsz = 8;
     // 得到字符串SHA-1值的方法
    public static String hex_sha1(String s) {
         s = (s == null) ? "" : s;
         return binb2hex(core_sha1(str2binb(s), s.length() * chrsz));
     }
     public static String b64_hmac_sha1(String key, String data) {
         return binb2b64(core_hmac_sha1(key, data));
     }
     public static String b64_sha1(String s) {
         s = (s == null) ? "" : s;
         return binb2b64(core_sha1(str2binb(s), s.length() * chrsz));
     }
     private static String binb2b64(int[] binarray) {
         String tab = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789+/";
         String str = "";
         binarray = strechbinarray(binarray, binarray.length * 4);
         for (int i = 0; i < binarray.length * 4; i += 3) {
             int triplet = (((binarray[i >> 2] >> 8 * (3 - i % 4)) & 0xff) << 16)
                     | (((binarray[i + 1 >> 2] >> 8 * (3 - (i + 1) % 4)) & 0xff) << 8)
                     | ((binarray[i + 2 >> 2] >> 8 * (3 - (i + 2) % 4)) & 0xff);
             for (int j = 0; j < 4; j++) {
                 if (i * 8 + j * 6 > binarray.length * 32) {
                     str += b64pad;
                 } else {
                     str += tab.charAt((triplet >> 6 * (3 - j)) & 0x3f);
                 }
             }
         }
         return cleanb64str(str);
     }
     private static String binb2hex(int[] binarray) {
         String hex_tab = hexcase ? "0123456789abcdef" : "0123456789abcdef";
         String str = "";
         for (int i = 0; i < binarray.length * 4; i++) {
             char a = (char) hex_tab.charAt((binarray[i >> 2] >> ((3 - i % 4) * 8 + 4)) & 0xf);
             char b = (char) hex_tab.charAt((binarray[i >> 2] >> ((3 - i % 4) * 8)) & 0xf);
             str += (new Character(a).toString() + new Character(b).toString());
         }
         return str;
     }
     private static String binb2str(int[] bin) {
         String str = "";
         int mask = (1 << chrsz) - 1;
         for (int i = 0; i < bin.length * 32; i += chrsz) {
             str += (char) ((bin[i >> 5] >>> (24 - i % 32)) & mask);
         }
         return str;
     }
     private static int bit_rol(int num, int cnt) {
         return (num << cnt) | (num >>> (32 - cnt));
     }
     private static String cleanb64str(String str) {
         str = (str == null) ? "" : str;
         int len = str.length();
         if (len <= 1) {
             return str;
         }
         char trailchar = str.charAt(len - 1);
         String trailstr = "";
         for (int i = len - 1; i >= 0 && str.charAt(i) == trailchar; i--) {
             trailstr += str.charAt(i);
         }
         return str.substring(0, str.indexOf(trailstr));
     }
     private static int[] complete216(int[] oldbin) {
         if (oldbin.length >= 16) {
             return oldbin;
         }
         int[] newbin = new int[16 - oldbin.length];
         for (int i = 0; i < newbin.length; newbin[i] = 0, i++)
             ;
         return concat(oldbin, newbin);
     }
     private static int[] concat(int[] oldbin, int[] newbin) {
         int[] retval = new int[oldbin.length + newbin.length];
         for (int i = 0; i < (oldbin.length + newbin.length); i++) {
             if (i < oldbin.length) {
                 retval[i] = oldbin[i];
             } else {
                 retval[i] = newbin[i - oldbin.length];
             }
         }
         return retval;
     }
     private static int[] core_hmac_sha1(String key, String data) {
         key = (key == null) ? "" : key;
         data = (data == null) ? "" : data;
         int[] bkey = complete216(str2binb(key));
         if (bkey.length > 16) {
             bkey = core_sha1(bkey, key.length() * chrsz);
         }
         int[] ipad = new int[16];
         int[] opad = new int[16];
         for (int i = 0; i < 16; ipad[i] = 0, opad[i] = 0, i++)
             ;
         for (int i = 0; i < 16; i++) {
             ipad[i] = bkey[i] ^ 0x36363636;
             opad[i] = bkey[i] ^ 0x5c5c5c5c;
         }
         int[] hash = core_sha1(concat(ipad, str2binb(data)), 512 + data.length() * chrsz);
         return core_sha1(concat(opad, hash), 512 + 160);
     }
     private static int[] core_sha1(int[] x, int len) {
         int size = (len >> 5);
         x = strechbinarray(x, size);
         x[len >> 5] |= 0x80 << (24 - len % 32);
         size = ((len + 64 >> 9) << 4) + 15;
         x = strechbinarray(x, size);
         x[((len + 64 >> 9) << 4) + 15] = len;
         int[] w = new int[80];
         int a = 1732584193;
         int b = -271733879;
         int c = -1732584194;
         int d = 271733878;
         int e = -1009589776;
         for (int i = 0; i < x.length; i += 16) {
             int olda = a;
             int oldb = b;
             int oldc = c;
             int oldd = d;
             int olde = e;
             for (int j = 0; j < 80; j++) {
                 if (j < 16) {
                     w[j] = x[i + j];
                 } else {
                     w[j] = rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);
                 }
                 int t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)), safe_add(safe_add(e, w[j]), sha1_kt(j)));
                 e = d;
                 d = c;
                 c = rol(b, 30);
                 b = a;
                 a = t;
             }
             a = safe_add(a, olda);
             b = safe_add(b, oldb);
             c = safe_add(c, oldc);
             d = safe_add(d, oldd);
             e = safe_add(e, olde);
         }
         int[] retval = new int[5];
         retval[0] = a;
         retval[1] = b;
         retval[2] = c;
         retval[3] = d;
         retval[4] = e;
         return retval;
     }
     private static void dotest() {
         String key = "key";
         String data = "data";
         System.out.println("hex_sha1(" + data + ")=" + hex_sha1(data));
         System.out.println("b64_sha1(" + data + ")=" + b64_sha1(data));
         System.out.println("str_sha1(" + data + ")=" + str_sha1(data));
         System.out.println("hex_hmac_sha1(" + key + "," + data + ")=" + hex_hmac_sha1(key, data));
         System.out.println("b64_hmac_sha1(" + key + "," + data + ")=" + b64_hmac_sha1(key, data));
         System.out.println("str_hmac_sha1(" + key + "," + data + ")=" + str_hmac_sha1(key, data));
     }
     public static String hex_hmac_sha1(String key, String data) {
         return binb2hex(core_hmac_sha1(key, data));
     }
     private static int rol(int num, int cnt) {
         return (num << cnt) | (num >>> (32 - cnt));
     }
     private static int safe_add(int x, int y) {
         int lsw = (int) (x & 0xffff) + (int) (y & 0xffff);
         int msw = (x >> 16) + (y >> 16) + (lsw >> 16);
         return (msw << 16) | (lsw & 0xffff);
     }
     private static int sha1_ft(int t, int b, int c, int d) {
         if (t < 20)
             return (b & c) | ((~b) & d);
         if (t < 40)
             return b ^ c ^ d;
         if (t < 60)
             return (b & c) | (b & d) | (c & d);
         return b ^ c ^ d;
     }
     private static int sha1_kt(int t) {
         return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 : (t < 60) ? -1894007588 : -899497514;
     }
     private static boolean sha1_vm_test() {
         return hexcase ? hex_sha1("abc").equals("a9993e364706816aba3e25717850c26c9cd0d89d") : hex_sha1("abc").equals(
                 "a9993e364706816aba3e25717850c26c9cd0d89d");
     }
     public static String str_hmac_sha1(String key, String data) {
         return binb2str(core_hmac_sha1(key, data));
     }
     public static String str_sha1(String s) {
         s = (s == null) ? "" : s;
         return binb2str(core_sha1(str2binb(s), s.length() * chrsz));
     }
     private static int[] str2binb(String str) {
         str = (str == null) ? "" : str;
         int[] tmp = new int[str.length() * chrsz];
         int mask = (1 << chrsz) - 1;
         for (int i = 0; i < str.length() * chrsz; i += chrsz) {
             tmp[i >> 5] |= ((int) (str.charAt(i / chrsz)) & mask) << (24 - i % 32);
         }
         int len = 0;
         for (int i = 0; i < tmp.length && tmp[i] != 0; i++, len++)
             ;
         int[] bin = new int[len];
         for (int i = 0; i < len; i++) {
             bin[i] = tmp[i];
         }
         return bin;
     }
     private static int[] strechbinarray(int[] oldbin, int size) {
         int currlen = oldbin.length;
         if (currlen >= size + 1) {
             return oldbin;
         }
         int[] newbin = new int[size + 1];
         for (int i = 0; i < size; newbin[i] = 0, i++)
             ;
         for (int i = 0; i < currlen; i++) {
             newbin[i] = oldbin[i];
         }
         return newbin;
     }
     public static void main(String args[]) {
         System.out.println("admin的SHA1的值為：" + hex_sha1("admin") + ",length=" + hex_sha1("admin").length());
     }
 }

 

 

了解AES：

高級加密標准（英語：Advanced Encryption Standard，縮寫：AES），在密碼學中又稱Rijndael加密法，是美國聯邦政府采用的一種區塊加密標准。這個標准用來替代原先的DES，已經被多方分析且廣為全世界所使用。經過五年的甄選流程，高級加密標准由美國國家標准與技術研究院（NIST）於2001年11月26日發布於FIPS PUB 197，並在2002年5月26日成為有效的標准。2006年，高級加密標准已然成為對稱密鑰加密中最流行的算法之一。 ----摘自百度百科 詳細參考aes  

了解DES：

DES全稱為Data Encryption Standard，即數據加密標准，是一種使用密鑰加密的塊算法，1977年被美國聯邦政府的國家標准局確定為聯邦資料處理標准（FIPS），並授權在非密級政府通信中使用，隨後該算法在國際上廣泛流傳開來。需要注意的是，在某些文獻中，作為算法的DES稱為數據加密算法（Data Encryption Algorithm,DSA），已與作為標准的DES區分開來。 ----摘自百度百科 算法說明: DES算法把64位的明文輸入塊變為64位的密文輸出塊,它所使用的密鑰也是64位（實際用到了56位，第8、16、24、32、40、48、56、64位是校驗位， 使得每個密鑰都有奇數個1），其算法主要分為兩步： 1）初始置換 其功能是把輸入的64位數據塊按位重新組合,並把輸出分為L0、R0兩部分,每部分各長32位,其置換規則為將輸入的第58位換到第一位,第50位換到第2位……依此類推,最後一位是原來的第7位。L0、R0則是換位輸出後的兩部分，L0是輸出的左32位,R0是右32位,例:設置換前的輸入值為D1D2D3……D64,則經過初始置換後的結果為:L0=D58D50……D8;R0=D57D49……D7。 其置換規則見下表： 58,50,42,34,26,18,10,2,60,52,44,36,28,20,12,4, 62,54,46,38,30,22,14,6,64,56,48,40,32,24,16,8, 57,49,41,33,25,17,9,1,59,51,43,35,27,19,11,3, 61,53,45,37,29,21,13,5,63,55,47,39,31,23,15,7, 2）逆置換 經過16次迭代運算後,得到L16、R16,將此作為輸入,進行逆置換,逆置換正好是初始置換的逆運算，由此即得到密文輸出。 此算法是對稱加密算法體系中的代表,在計算機網絡系統中廣泛使用.

了解RSA：

RSA公鑰加密算法是1977年由羅納德·李維斯特（Ron Rivest）、阿迪·薩莫爾（Adi Shamir）和倫納德·阿德曼（Leonard Adleman）一起提出的。1987年首次公布，當時他們三人都在麻省理工學院工作。RSA就是他們三人姓氏開頭字母拼在一起組成的。 RSA是目前最有影響力的公鑰加密算法，它能夠抵抗到目前為止已知的絕大多數密碼攻擊，已被ISO推薦為公鑰數據加密標准。 今天只有短的RSA鑰匙才可能被強力方式解破。到2008年為止，世界上還沒有任何可靠的攻擊RSA算法的方式。只要其鑰匙的長度足夠長，用RSA加密的信息實際上是不能被解破的。但在分布式計算和量子計算機理論日趨成熟的今天，RSA加密安全性受到了挑戰。 RSA算法基於一個十分簡單的數論事實：將兩個大質數相乘十分容易，但是想要對其乘積進行因式分解卻極其困難，因此可以將乘積公開作為加密密鑰。 附上實現細節:實現細節

了解BASE64：

Base64是網絡上最常見的用於傳輸8Bit字節代碼的編碼方式之一，大家可以查看RFC2045～RFC2049，上面有MIME的詳細規范。Base64編碼可用於在HTTP環境下傳遞較長的標識信息。例如，在Java Persistence系統Hibernate中，就采用了Base64來將一個較長的唯一標識符（一般為128-bit的UUID）編碼為一個字符串，用作HTTP表單和HTTP GET URL中的參數。在其他應用程序中，也常常需要把二進制數據編碼為適合放在URL（包括隱藏表單域）中的形式。此時，采用Base64編碼具有不可讀性，即所編碼的數據不會被人用肉眼所直接看到。   編碼規則: ①.把3個字符變成4個字符。 ②每76個字符加一個換行符。 ③.最後的結束符也要處理。 舉例說明: 轉換前 10101101,10111010,01110110 轉換後 00101011, 00011011 ,00101001 ,00110110 十進制 43 27 41 54 對應碼表中的值 r b p 2 所以上面的24位編碼，編碼後的Base64值為 rbp2 解碼同理，把 rbq2 的二進制位連接上再重組得到三個8位值，得出原碼。 （解碼只是編碼的逆過程，有關MIME的RFC還有很多，如果需要詳細情況請自行查找。） 第一個字節，根據源字節的第一個字節處理。 規則：源第一字節右移兩位，去掉低2位，高2位補零。 既：00 + 高6位 第二個字節，根據源字節的第一個字節和第二個字節聯合處理。 規則如下，第一個字節高6位去掉然後左移四位，第二個字節右移四位 即：源第一字節低2位 + 源第2字節高4位 第三個字節，根據源字節的第二個字節和第三個字節聯合處理， 規則第二個字節去掉高4位並左移兩位（得高6位），第三個字節右移6位並去掉高6位（得低2位），相加即可 第四個字節，規則，源第三字節去掉高2位即可 //用更接近於編程的思維來說，編碼的過程是這樣的： //第一個字符通過右移2位獲得第一個目標字符的Base64表位置，根據這個數值取到表上相應的字符，就是第一//個目標字符。 //然後將第一個字符與0x03(00000011)進行與(&)操作並左移4位,接著第二個字符右移4位與前者相或(|)，即獲得第二個目標字符。 //再將第二個字符與0x0f(00001111)進行與(&)操作並左移2位,接著第三個字符右移6位與前者相或(|)，獲得第三個目標字符。 //最後將第三個字符與0x3f(00111111)進行與(&)操作即獲得第四個目標字符。 //在以上的每一個步驟之後，再把結果與 0x3F 進行 AND位操作，就可以得到編碼後的字符了。 可是等等……聰明的你可能會問到，原文的字節數量應該是3的倍數啊，如果這個條件不能滿足的話，那該怎麼辦呢？ 我們的解決辦法是這樣的：原文剩余的字節根據編碼規則繼續單獨轉(1變2,2變3;不夠的位數用0補全)，再用=號補滿4個字節。這就是為什麼有些Base64編碼會以一個或兩個等號結束的原因，但等號最多只有兩個。因為： 一個原字節至少會變成兩個目標字節 所以余數任何情況下都只可能是0，1，2這三個數中的一個。如果余數是0的話，就表示原文字節數正好是3的倍數（最理想的情況）。如果是1的話，轉成2個Base64編碼字符，為了讓Base64編碼是4的倍數，就要補2個等號；同理，如果是2的話，就要補1個等號。 java實現源碼：

//模板類模板類寫好了再按思路寫個實現就可以了
publicinterfaceBase64{
/**
*根據傳進來的字符的字節碼，查詢base64碼表的索引，並返回所查到的索引
*
*@paramb一個編碼後的字節碼
*@return返回base64碼表的索引
*/
publicabstractbytebaseIndex(byteb);
/**
*解碼的方法
*傳進來的是編碼後的base64字符的字節碼
*解析時是4個一組進行解析
*@paramb編碼後的字符的字節碼數組
*@return返回原來的字符串
*/
publicabstractStringbackEncode(byte[]b);
/**
*解碼
*將4個字節碼中的第1個的後6位（00xxxxxx）和第2個
*字節的前4位的後2位（00yy0000）
*還原為原來的字節碼（xxxxxxyy）
*
*@paramfirst4個字節碼中的第1個
*@paramsecond4個字節碼中的第2個
*@return原來的字符的字節碼
*/publicabstractbytebackFirst(bytefirst,bytesecond);
/**
*解碼
*將4個字節碼中的第2個的後4位（0000xxxx）和第3個
*字節的前6位的後4位（00yyyy00）
*還原為原來的字節碼（xxxxyyyy）
*@paramsecond4個字節碼中的第2個
*@paramthird4個字節碼中的第3個
*@return原來的字符的字節碼
*/
publicabstractbytebackSecond(bytesecond,bytethird);
/**
*解碼
*將4個字節碼中的第3個的後2位（000000xx）和第4個
*字節的後6位（00yyyyyy）
*還原為原來的字節碼（xxyyyyyy）
*@paramthird傳進來的第3個字符
*@paramfourth傳進來的第4個字符
*@return原來的字符的字節碼
*/publicabstractbytebackThird(bytethird,bytefourth);
/**
*解碼
*將編碼後的字符串數組的最後2個字節碼還原為原來的字節碼
*假如數組末尾剩下2個字節：
*將倒數第2個字節的前後6位(00xxxxxx)
*和倒數第一個字節的後2位(000000yy)
*還原為原來的編碼（xxxxxxyy）
*假如數組末尾剩下3個字節：
*將倒數第2個字節的前後4位(0000xxxx)
*和倒數第一個字節的後4位(0000yyyy)
*還原為原來的編碼（xxxxyyyy）
*@paramlast_b倒數第2個字節
*@paramnext_b倒數第1個字節
*@parammove_l倒數第2個字節移動位數的參數
*@parammove_b倒數第1個字節移動位數的參數
*@return原來的字符的字節碼
*/
publicbytebackLastOne(bytelast_b,bytenext_b,intmove_l,intmove_b);
/**
*編碼
*將傳進來的字符編碼為base64，返回一個base64的字符串
*編碼時3個字節一組進行編碼，傳進來的是要進行編碼的字符串數組
*@paramb要進行編碼的字符串數組
*@return編碼後的字符串
*/
publicabstractStringencode(byte[]b);
/**
*假如字符長度%3！=0，使用此方法編碼末尾字符
*假如b=xxxxyyyy
*假如末尾字節個數等於1：
*將這個字節的前6位作為一個字節(00xxxxyy)
*將這個字節的後6位作為一個字節(00xxyyyy)
*假如末尾字節個數等於2：
*將這個字節的後6位作為一個字節(00xxyyyy)
*@paramb末尾的字符的字節碼
*@parammove末尾的字符的字節碼要移動的位數的參數
*@return編碼後的字節碼
*/
publicabstractbytelastOneByte(byteb,intmove);
/**
*編碼
*假如b=xxxxyyyy
*將第1個字節的前6位編碼為base64
*將3個字節中的第1個子節碼轉為（00xxxxyy）
*@paramb3個字節中的第1個字節
*@return編碼後的字節碼
*/
publicabstractbytefirstByte(byteb);
/**
*編碼
*假如last_b=xxxxyyyynext_b=kkkkffff
*將3個字節中的第1個字節的最後2位（000000yy）
*和第2個字節的前4位（kkkk0000）編碼為（00yykkkk）
*
*@paramlast_b3個字節中的第1個字節
*@paramnext_b3個字節中的第2個字節
*@return編碼後的字節碼
*/
publicabstractbytesecondByte(bytelast_b,bytenext_b);
/**
*編碼
*假如last_b=xxxxyyyynext_b=kkkkffff
*將3個字節中的第2個字節的最後4位（0000yyyy）
*和第4個字節的前2位（kk000000）編碼為（00yyyykk）
*
*
*@paramlast_b3個字節中的第2個字節
*@paramnext_b3個字節中的第3個字節
*@return編碼後的字節碼
*/
publicabstractbytethirdByte(bytelast_b,bytenext_b);
/**
*編碼
*假如b=xxxxyyyy
*將3個字節中的第3個字節的最後6位（00xxyyyy）
*轉碼為（00xxyyyy）
*@paramb3個字節中的第3個字節
*@return編碼後的字節碼
*/
publicabstractbytefourthByte(byteb);
}

======================以下是實現類代碼=====================華麗的分界線======

importjava.util.Enumeration;
importjava.util.Vector;
publicclassMyBase64EncoderimplementsBase64{
/**
*base64碼表
*/
privatestaticfinalbytebase[]={0x41,0x42,0x43,0x44,0x45,0x46,
0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x51,
0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x61,0x62,
0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,
0x6e,0x6f,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,
0x79,0x7a,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,
0x39,0x2b,0x2f};

@Override
publicbytebaseIndex(byteb){
for(inti=0;i

@Override
publicStringbackEncode(byte[]b){
StringBuffersb=newStringBuffer();
Vectorlist=newVector();
intreal_len=b.length;
intlen=real_len-2;
intmore_len=len&3;
intuse_len=len-more_len;

for(inti=0;i

if(more_len==2){
byteb_1[]=newbyte[1];
b_1[0]=backLastOne(baseIndex(b[len-2]),baseIndex(b[len-1]),2,6);
sb.append(newString(b_1));
}
if(more_len==3){
byteb_2[]=newbyte[2];
b_2[0]=backFirst(baseIndex(b[len-3]),baseIndex(b[len-2]));
b_2[1]=backLastOne(baseIndex(b[len-2]),baseIndex(b[len-1]),4,4);
sb.append(newString(b_2));
}
returnsb.toString();
}
@Override
publicbytelastOneByte(byteb,intmove){
intr_b=b&0xff;
r_b=r_b<>>2;
return(byte)(r_b&0x3f);
}
@Override
publicbytebackLastOne(bytelast_b,bytenext_b,intmove_l,intmove_b){
intr_l=last_b&0xff;
intr_n=next_b&0xff;
r_l=r_l<>>move_b;
return(byte)((r_l|r_n)&0xff);
}
@Override
publicbytebackFirst(bytefirst,bytesecond){
intr_f=first&0xff;
intr_s=second&0xff;
r_f=r_f<<2;
r_s=r_s>>>4;
return(byte)((r_f|r_s)&0xff);
}


@Override
publicbytebackSecond(bytesecond,bytethird){
intr_s=second&0xff;
intr_t=third&0xff;
r_s=r_s<<4;
r_t=r_t>>>2;
return(byte)((r_s|r_t)&0xff);
}

@Override
publicbytebackThird(bytethird,bytefourth){
intr_t=third&0xff;
intr_f=fourth&0xff;
r_t=r_t<<6;
return(byte)((r_t|r_f)&0xff);
}
@Override
publicStringencode(byte[]b){
StringBuffersb=newStringBuffer();
intlen=b.length;
intmore_len=len%3;
intuse_len=len-more_len;
byte[]bytes=newbyte[4];
for(inti=0;i@Override
publicbytefirstByte(byteb){
//00000000000000000000000001010011
//01010011
intr_f=b&0xff;
r_f=r_f>>>2;
return(byte)(r_f&0x3f);
}

@Override
publicbytesecondByte(bytelast_b,bytenext_b){
intr_l=last_b&0xff;
intr_n=next_b&0xff;
r_l=r_l<<6;
r_l=r_l>>>2;
r_n=r_n>>>4;
return(byte)((r_l|r_n)&0x3f);
}

@Override
publicbytethirdByte(bytelast_b,bytenext_b){
intr_l=last_b&0xff;
intr_n=next_b&0xff;
r_l=r_l<<4;
r_l=r_l>>>2;
r_n=r_n>>>6;
return(byte)((r_l|r_n)&0x3f);
}

@Override
publicbytefourthByte(byteb){
intr_b=b&0xff;
r_b=r_b<<2;
r_b=r_b>>>2;
return(byte)(r_b&0x3f);
}
}

更多語言實現-----點擊打開鏈接

Android加密策略---結束語

加密就總結到這了，當然還有好多這裡沒有一一例舉

3DES（Triple DES）：是基於DES，對一塊數據用三個不同的密鑰進行三次加密，強度更高；

RC2和 RC4：用變長密鑰對大量數據進行加密，比 DES 快；

IDEA（International Data Encryption Algorithm）國際數據加密算法：使用 128 位密鑰提供非常強的安全性；

 

最後感謝您的閱讀~