首页 > 代码库 > Android加密策略
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 = http://www.mamicode.com/(data == null) ? "" : data;>
了解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实现源码:<span style="font-weight: normal;">//模板类模板类写好了再按思路写个实现就可以了
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);
}</span>
======================以下是实现类代码=====================华丽的分界线======<span style="font-weight: normal;">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};</span>
<span style="font-weight: normal;">@Override
publicbytebaseIndex(byteb){
for(inti=0;i<base.length;i++){
if(base[i]==b){
return(byte)i;
}
}
return-1;
}</span>
<span style="font-weight: normal;">@Override
publicStringbackEncode(byte[]b){
StringBuffersb=newStringBuffer();
Vector<Byte>list=newVector<Byte>();
intreal_len=b.length;
intlen=real_len-2;
intmore_len=len&3;
intuse_len=len-more_len;</span>
<span style="font-weight: normal;">for(inti=0;i<use_len;i+=4){
list.add(backFirst(baseIndex(b[i]),baseIndex(b[i+1])));
list.add(backSecond(baseIndex(b[i+1]),baseIndex(b[i+2])));
list.add(backThird(baseIndex(b[i+2]),baseIndex(b[i+3])));
}
Enumeratione=list.elements();
bytebytes[]=newbyte[list.size()];
intk=-1;
while(e.hasMoreElements()){
bytes[++k]=(Byte)e.nextElement();
}
sb.append(newString(bytes));</span>
<span style="font-weight: normal;">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<<move;
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_l;
r_n=r_n<<move_b;
r_n=r_n>>>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);
}</span>
<span style="font-weight: normal;">@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);
}</span>
<span style="font-weight: normal;">@Override
publicbytebackThird(bytethird,bytefourth){
intr_t=third&0xff;
intr_f=fourth&0xff;
r_t=r_t<<6;
return(byte)((r_t|r_f)&0xff);
}</span>
<span style="font-weight: normal;">@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<use_len;i+=3){
bytes[0]=base[firstByte(b[i])];
bytes[1]=base[secondByte(b[i],b[i+1])];
bytes[2]=base[thirdByte(b[i+1],b[i+2])];
bytes[3]=base[fourthByte(b[i+2])];
sb.append(newString(bytes));
}
if(more_len==1){
byteb_2[]=newbyte[2];
b_2[0]=base[firstByte(b[len-1])];
b_2[1]=base[lastOneByte(b[len-1],6)];
sb.append(newString(b_2));
returnsb.append("==").toString();
}elseif(more_len==2){
byteb_3[]=newbyte[3];
b_3[0]=base[firstByte(b[len-2])];
b_3[1]=base[secondByte(b[len-2],b[len-1])];
b_3[2]=base[lastOneByte(b[len-1],4)];
sb.append(newString(b_3));
returnsb.append("=").toString();
}
returnsb.toString();
}</span>
<span style="font-weight: normal;">@Override
publicbytefirstByte(byteb){
//00000000000000000000000001010011
//01010011
intr_f=b&0xff;
r_f=r_f>>>2;
return(byte)(r_f&0x3f);
}</span>
<span style="font-weight: normal;">@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);
}</span>
<span style="font-weight: normal;">@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);
}</span>
<span style="font-weight: normal;">@Override
publicbytefourthByte(byteb){
intr_b=b&0xff;
r_b=r_b<<2;
r_b=r_b>>>2;
return(byte)(r_b&0x3f);
}
}</span>
更多语言实现-----点击打开链接
Android加密策略---结束语
加密就总结到这了,当然还有好多这里没有一一例举3DES(Triple DES):是基于DES,对一块数据用三个不同的密钥进行三次加密,强度更高;
RC2和 RC4:用变长密钥对大量数据进行加密,比 DES 快;
IDEA(International Data Encryption Algorithm)国际数据加密算法:使用 128 位密钥提供非常强的安全性;
最后感谢您的阅读~
了解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实现源码:<span style="font-weight: normal;">//模板类模板类写好了再按思路写个实现就可以了 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); }</span>======================以下是实现类代码=====================华丽的分界线======
<span style="font-weight: normal;">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};</span>
<span style="font-weight: normal;">@Override publicbytebaseIndex(byteb){ for(inti=0;i<base.length;i++){ if(base[i]==b){ return(byte)i; } } return-1; }</span>
<span style="font-weight: normal;">@Override publicStringbackEncode(byte[]b){ StringBuffersb=newStringBuffer(); Vector<Byte>list=newVector<Byte>(); intreal_len=b.length; intlen=real_len-2; intmore_len=len&3; intuse_len=len-more_len;</span>
<span style="font-weight: normal;">for(inti=0;i<use_len;i+=4){ list.add(backFirst(baseIndex(b[i]),baseIndex(b[i+1]))); list.add(backSecond(baseIndex(b[i+1]),baseIndex(b[i+2]))); list.add(backThird(baseIndex(b[i+2]),baseIndex(b[i+3]))); } Enumeratione=list.elements(); bytebytes[]=newbyte[list.size()]; intk=-1; while(e.hasMoreElements()){ bytes[++k]=(Byte)e.nextElement(); } sb.append(newString(bytes));</span>
<span style="font-weight: normal;">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<<move; 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_l; r_n=r_n<<move_b; r_n=r_n>>>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); }</span>
<span style="font-weight: normal;">@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); }</span>
<span style="font-weight: normal;">@Override publicbytebackThird(bytethird,bytefourth){ intr_t=third&0xff; intr_f=fourth&0xff; r_t=r_t<<6; return(byte)((r_t|r_f)&0xff); }</span>
<span style="font-weight: normal;">@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<use_len;i+=3){ bytes[0]=base[firstByte(b[i])]; bytes[1]=base[secondByte(b[i],b[i+1])]; bytes[2]=base[thirdByte(b[i+1],b[i+2])]; bytes[3]=base[fourthByte(b[i+2])]; sb.append(newString(bytes)); } if(more_len==1){ byteb_2[]=newbyte[2]; b_2[0]=base[firstByte(b[len-1])]; b_2[1]=base[lastOneByte(b[len-1],6)]; sb.append(newString(b_2)); returnsb.append("==").toString(); }elseif(more_len==2){ byteb_3[]=newbyte[3]; b_3[0]=base[firstByte(b[len-2])]; b_3[1]=base[secondByte(b[len-2],b[len-1])]; b_3[2]=base[lastOneByte(b[len-1],4)]; sb.append(newString(b_3)); returnsb.append("=").toString(); } returnsb.toString(); }</span>
<span style="font-weight: normal;">@Override publicbytefirstByte(byteb){ //00000000000000000000000001010011 //01010011 intr_f=b&0xff; r_f=r_f>>>2; return(byte)(r_f&0x3f); }</span>
<span style="font-weight: normal;">@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); }</span>
<span style="font-weight: normal;">@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); }</span>
<span style="font-weight: normal;">@Override publicbytefourthByte(byteb){ intr_b=b&0xff; r_b=r_b<<2; r_b=r_b>>>2; return(byte)(r_b&0x3f); } }</span>更多语言实现-----点击打开链接
Android加密策略---结束语
加密就总结到这了,当然还有好多这里没有一一例举
3DES(Triple DES):是基于DES,对一块数据用三个不同的密钥进行三次加密,强度更高;
RC2和 RC4:用变长密钥对大量数据进行加密,比 DES 快;
IDEA(International Data Encryption Algorithm)国际数据加密算法:使用 128 位密钥提供非常强的安全性;
最后感谢您的阅读~
Android加密策略
声明:以上内容来自用户投稿及互联网公开渠道收集整理发布,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任,若内容有误或涉及侵权可进行投诉: 投诉/举报 工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。