Android传输数据时加密详解
Android传输数据时加密详解
ONEGoal,ONEPassion!
——————–MD5加密———————
MD5即Message-DigestAlgorithm5（信息-摘要算法5），用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），主流编程语言普遍已有MD5实现。将数据（如汉字）运算为另一固定长度值，是杂凑算法的基础原理，MD5的前身有MD2、MD3和MD4
MD5算法具有以下特点：
1、压缩性：任意长度的数据，算出的MD5值长度都是固定的。
2、容易计算：从原数据计算出MD5值很容易。
3、抗修改性：对原数据进行任何改动，哪怕只修改1个字节，所得到的MD5值都有很大区别。
4、强抗碰撞：已知原数据和其MD5值，想找到一个具有相同MD5值的数据（即伪造数据）是非常困难的。
5.MD5加密是不可逆的.
MD5算法：
publicstaticStringgetMD5(Stringstr){
byte[]source=str.getBytes()
Strings=null;
charhexDigits[]={''0'',''1'',''2'',''3'',''4'',''5'',''6'',''7'',''8'',''9'',
''a'',''b'',''c'',''d'',''e'',''f''};//用来将字节转换成16进制表示的字符
try{
java.security.MessageDigestmd=java.security.MessageDigest
.getInstance("MD5");
md.update(source);
bytetmp[]=md.digest();//MD5的计算结果是一个128位的长整数，
//用字节表示就是16个字节
charstr0[]=newchar[162];//每个字节用16进制表示的话，使用两个字符，所以表示成16
//进制需要32个字符
intk=0;//表示转换结果中对应的字符位置
for(inti=0;i<16;i++){//从第一个字节开始，对MD5的每一个字节//转换成16
//进制字符的转换
bytebyte0=tmp[i];//取第i个字节
str0[k++]=hexDigits[byte0>>>4&0xf];//取字节中高4位的数字转换,//>>>
//为逻辑右移，将符号位一起右移
str0[k++]=hexDigits[byte0&0xf];//取字节中低4位的数字转换
}
s=newString(str0);//换后的结果转换为字符串
}catch(NoSuchAlgorithmExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
returns;
}
MD5使用场景：
传输类似用户名的密码时.此时使用MD5直接将数据加密后提交到后台.因为后台不需要知道用户名密码.可以直接将接收到的经过MD5加密后数据存储到数据库.这也就是为什么许多应用只能重置密码,却不能找回密码.
特别注意:
现在由于网络MD5数据库比较大,如果直接使用md5加密的话,很容易被破译出来.这是在加密的过程中”加盐”就可以大大避免直接被破译的危险.
———————RSA非对称可逆加密———————
RSA加密原理概述：
RSA的安全性依赖于大数的分解，公钥和私钥都是两个大素数（大于100的十进制位）的函数。从一个密钥和密文推断出明文的难度等同于分解两个大素数的积
1.选择两个大素数p,q,计算n=pq;
2.随机选择加密密钥e,要求e和(p-1)(q-1)互质
3.利用Euclid算法计算解密密钥d,使其满足ed=1(mod(p-1)(q-1))(其中n,d也要互质)
4:至此得出公钥为(n,e)私钥为(n,d)加解密方法：
1.首先将要加密的信息m(二进制表示)分成等长的
数据块m1,m2,…,mi块长s(尽可能大),其中2^s
2:对应的密文是：ci=mi^e(modn)
3:解密时作如下计算：mi=ci^d(modn)
RSA速度:
由于进行的都是大数计算，使得RSA最快的情况也比DES慢上100倍，无论是软件还是硬件实现。速度一直是RSA的缺陷。一般来说只用于少量数据加密。
1.如何生成密钥对(公钥,私钥)：
第一种方式:通过OpenSSl工具生成密钥对
OpenSSl工具下载：OpenSSl工具（64位的也可使用）使用OpenSSl工具生成密钥对的过程如下：
首先双击打开bin文件夹下的openssl.exe，打开之后是一个命令行窗口,执行下面窗口:
RSA密钥生成命令:
生成RSA私钥：
genrsa-outrsa_private_key.pem1024
1
1
这条命令是让openssl随机生成了一份私钥，加密长度是1024位，密钥长度，范围：512～2048。执行完命令后就可在bin文件夹下看到rsa_private_key.pem文件了。
用文本类工具打开可看到里面的内容：
-----BEGINRSAPRIVATEKEY-----
MIICXAIBAAKBgQC8rPqGGsar+BWI7vAtaaDOqphy41j5186hCU9DcchV4HWiv0Hv
Q3KXAEqHfZiAHZSyMSRMmDZVnqJwCVWFvKUPqU1RsCPZ9Imk+9ZXVkM3DDdw74v/
s6YMNx8cTuxybRCJUfOKbyC79cnHgmQqqkODv+EnprBtNKE4k8g90jNmbwIDAQAB
AoGAS06Hl+ssDQuyHLux5Y5ZfuOcgY64vtAiSyhaGMNbgNtcWJ8aBBPZsueM19OL
gOdNqGnw4RmH5liw4SL4na6T+qGpblEW/4G1eQXXJvfIBhlYJupaSvhuTf3msFw4
z9GY8V29deGPx5/6FRVTPTqnLoxUlfloOCYCeDJrXa9+YGECQQD24cdN9MT3HqfP
3S+UEDHO3XaDq38V3sCnKQ5mSYtnst/NV/g4bqYUOYElQW27p0YgwhHLlxWPke8a
4Jz/r4lnAkEAw6TfA36kUZfnFIXNM/0250jyZDE/yEKBXhThO8DAXAyAaEHjxA7K
+eprXP7ayFIfy+nrz/W5Iy81ibP5G/4tuQJBALaDn9ZP+DVBIoqXWI87kbb/Hpik
9mTysrZhsdWI1Viqcq3aNRVzJ7CX+pPSVQ9/0GZzUriST0w+dOgH2clkuk0CQDXX
hdh8XdRmrZ2kRRjtstJr7OlN9HO0ec3eiS3cmhO7DQukNn6aY5nrvahWKve+Qino
MpGE2nKoZ1+CPChMB2ECQG8utIhzAGH0lKbv/3+SzDERStrFYn/WqpWG3qSXAMye
s24khuRPtMYPzIxI/wZYPazbKgxuERAhiRtpz0e9jvI=
-----ENDRSAPRIVATEKEY-----
这里面的内容是标准的ASCII字符，中间的一大串字符就是私钥数据了。
生成RSA公钥：
rsa-inrsa_private_key.pem-outrsa_public_key.pem-pubout
打开文件看下里面的内容:
-----BEGINPUBLICKEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC8rPqGGsar+BWI7vAtaaDOqphy
41j5186hCU9DcchV4HWiv0HvQ3KXAEqHfZiAHZSyMSRMmDZVnqJwCVWFvKUPqU1R
sCPZ9Imk+9ZXVkM3DDdw74v/s6YMNx8cTuxybRCJUfOKbyC79cnHgmQqqkODv+En
prBtNKE4k8g90jNmbwIDAQAB
-----ENDPUBLICKEY-----
这样密钥就基本生成了，不过这样密钥对的私钥是无法在代码中直接使用的，要想使用它需要借助RSAPrivateKeyStructure这个类，Java是不自带的。所以为了方便使用，我们需要对私钥进行PKCS#8编码，命令如下：
pkcs8-topk8-inrsa_private_key.pem-outpkcs8_rsa_private_key.pem-nocrypt
这条命令的结果依然是在bin文件夹生成了pkcs8_rsa_private_key.pem文件，打开内容如下：
-----BEGINPRIVATEKEY-----
MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBALys+oYaxqv4FYju
8C1poM6qmHLjWPnXzqEJT0NxyFXgdaK/Qe9DcpcASod9mIAdlLIxJEyYNlWeonAJ
VYW8pQ+pTVGwI9n0iaT71ldWQzcMN3Dvi/+zpgw3HxxO7HJtEIlR84pvILv1yceC
ZCqqQ4O/4SemsG00oTiTyD3SM2ZvAgMBAAECgYBLToeX6ywNC7Icu7Hljll+45yB
jri+0CJLKFoYw1uA21xYnxoEE9my54zX04uA502oafDhGYfmWLDhIvidrpP6oalu
URb/gbV5Bdcm98gGGVgm6lpK+G5N/eawXDjP0ZjxXb114Y/Hn/oVFVM9OqcujFSV
+Wg4JgJ4Mmtdr35gYQJBAPbhx030xPcep8/dL5QQMc7ddoOrfxXewKcpDmZJi2ey
381X+DhuphQ5gSVBbbunRiDCEcuXFY+R7xrgnP+viWcCQQDDpN8DfqRRl+cUhc0z
/TbnSPJkMT/IQoFeFOE7wMBcDIBoQePEDsr56mtc/trIUh/L6evP9bkjLzWJs/kb
/i25AkEAtoOf1k/4NUEiipdYjzuRtv8emKT2ZPKytmGx1YjVWKpyrdo1FXMnsJf6
k9JVD3/QZnNSuJJPTD506AfZyWS6TQJANdeF2Hxd1GatnaRFGO2y0mvs6U30c7R5
zd6JLdyaE7sNC6Q2fppjmeu9qFYq975CKegykYTacqhnX4I8KEwHYQJAby60iHMA
YfSUpu//f5LMMRFK2sVif9aqlYbepJcAzJ6zbiSG5E+0xg/MjEj/Blg9rNsqDG4R
ECGJG2nPR72O8g==
-----ENDPRIVATEKEY-----
第二种方式:通过批处理文件直接生成.强烈建议使用
下载支付宝提供的密钥对生成工具.
http://download.csdn.net/detail/fengltxx/9674172
解压,阅读文档操作:
密钥对已经生成了.我们怎么使用呢?
公钥互换:
a.首先要有两对密钥:
android端一对(android公钥,android私钥)
服务器端一对(服务器公钥,服务器私钥)
b.开始交换
1.android开发人员将android公钥(字符串形式公钥,或者文件形式建议文件形式)给服务器人员
2.服务器发开人员将服务器公钥(字符串形式公钥,或者文件形式建议文件形式)给android开发人员
c.数据传输过程加密,解密
android开发人员传输数据时使用服务器公钥加密
服务器开发人员拿着私钥对android端传递过来的数据进行解密
注意:加密,解密时.需要将字符串形式的密钥转换成Key对象的密钥
2.封装RSA的工具类，方便加密解密的操作：
RSAUtils工具类:
packagecom.example.rsa;
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.math.BigInteger;
importjava.security.KeyFactory;
importjava.security.KeyPair;
importjava.security.KeyPairGenerator;
importjava.security.NoSuchAlgorithmException;
importjava.security.PrivateKey;
importjava.security.PublicKey;
importjava.security.interfaces.RSAPrivateKey;
importjava.security.interfaces.RSAPublicKey;
importjava.security.spec.InvalidKeySpecException;
importjava.security.spec.PKCS8EncodedKeySpec;
importjava.security.spec.RSAPublicKeySpec;
importjava.security.spec.X509EncodedKeySpec;
importjavax.crypto.Cipher;
publicfinalclassRSAUtils
{
privatestaticStringRSA="RSA";
/
随机生成RSA密钥对(默认密钥长度为1024)
@return
/
publicstaticKeyPairgenerateRSAKeyPair()
{
returngenerateRSAKeyPair(1024);
}
/
随机生成RSA密钥对
@paramkeyLength
密钥长度，范围：512～2048
一般1024
@return
/
publicstaticKeyPairgenerateRSAKeyPair(intkeyLength)
{
try
{
KeyPairGeneratorkpg=KeyPairGenerator.getInstance(RSA);
kpg.initialize(keyLength);
returnkpg.genKeyPair();
}catch(NoSuchAlgorithmExceptione)
{
e.printStackTrace();
returnnull;
}
}
/
用公钥加密
每次加密的字节数，不能超过密钥的长度值减去11
@paramdata
需加密数据的byte数据
@parampubKey
公钥
@return加密后的byte型数据
/
publicstaticbyte[]encryptData(byte[]data,PublicKeypublicKey)
{
try
{
Ciphercipher=Cipher.getInstance(RSA);
//编码前设定编码方式及密钥
cipher.init(Cipher.ENCRYPT_MODE,publicKey);
//传入编码数据并返回编码结果
returncipher.doFinal(data);
}catch(Exceptione)
{
e.printStackTrace();
returnnull;
}
}
/
用私钥解密
@paramencryptedData
经过encryptedData()加密返回的byte数据
@paramprivateKey
私钥
@return
/
publicstaticbyte[]decryptData(byte[]encryptedData,PrivateKeyprivateKey)
{
try
{
Ciphercipher=Cipher.getInstance(RSA);
cipher.init(Cipher.DECRYPT_MODE,privateKey);
returncipher.doFinal(encryptedData);
}catch(Exceptione)
{
returnnull;
}
}
/
通过公钥byte[](publicKey.getEncoded())将公钥还原，适用于RSA算法
@paramkeyBytes
@return
@throwsNoSuchAlgorithmException
@throwsInvalidKeySpecException
/
publicstaticPublicKeygetPublicKey(byte[]keyBytes)throwsNoSuchAlgorithmException,
InvalidKeySpecException
{
X509EncodedKeySpeckeySpec=newX509EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(RSA);
PublicKeypublicKey=keyFactory.generatePublic(keySpec);
returnpublicKey;
}
/
通过私钥byte[]将公钥还原，适用于RSA算法
@paramkeyBytes
@return
@throwsNoSuchAlgorithmException
@throwsInvalidKeySpecException
/
publicstaticPrivateKeygetPrivateKey(byte[]keyBytes)throwsNoSuchAlgorithmException,
InvalidKeySpecException
{
PKCS8EncodedKeySpeckeySpec=newPKCS8EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(RSA);
PrivateKeyprivateKey=keyFactory.generatePrivate(keySpec);
returnprivateKey;
}
/
使用N、e值还原公钥
@parammodulus
@parampublicExponent
@return
@throwsNoSuchAlgorithmException
@throwsInvalidKeySpecException
/
publicstaticPublicKeygetPublicKey(Stringmodulus,StringpublicExponent)
throwsNoSuchAlgorithmException,InvalidKeySpecException
{
BigIntegerbigIntModulus=newBigInteger(modulus);
BigIntegerbigIntPrivateExponent=newBigInteger(publicExponent);
RSAPublicKeySpeckeySpec=newRSAPublicKeySpec(bigIntModulus,bigIntPrivateExponent);
KeyFactorykeyFactory=KeyFactory.getInstance(RSA);
PublicKeypublicKey=keyFactory.generatePublic(keySpec);
returnpublicKey;
}
/
使用N、d值还原私钥
@parammodulus
@paramprivateExponent
@return
@throwsNoSuchAlgorithmException
@throwsInvalidKeySpecException
/
publicstaticPrivateKeygetPrivateKey(Stringmodulus,StringprivateExponent)
throwsNoSuchAlgorithmException,InvalidKeySpecException
{
BigIntegerbigIntModulus=newBigInteger(modulus);
BigIntegerbigIntPrivateExponent=newBigInteger(privateExponent);
RSAPublicKeySpeckeySpec=newRSAPublicKeySpec(bigIntModulus,bigIntPrivateExponent);
KeyFactorykeyFactory=KeyFactory.getInstance(RSA);
PrivateKeyprivateKey=keyFactory.generatePrivate(keySpec);
returnprivateKey;
}
/
从字符串中加载公钥
@parampublicKeyStr
公钥数据字符串
@throwsException
加载公钥时产生的异常
/
publicstaticPublicKeyloadPublicKey(StringpublicKeyStr)throwsException
{
try
{
byte[]buffer=Base64Utils.decode(publicKeyStr);
KeyFactorykeyFactory=KeyFactory.getInstance(RSA);
X509EncodedKeySpeckeySpec=newX509EncodedKeySpec(buffer);
return(RSAPublicKey)keyFactory.generatePublic(keySpec);
}catch(NoSuchAlgorithmExceptione)
{
thrownewException("无此算法");
}catch(InvalidKeySpecExceptione)
{
thrownewException("公钥非法");
}catch(NullPointerExceptione)
{
thrownewException("公钥数据为空");
}
}
/
从字符串中加载私钥
加载时使用的是PKCS8EncodedKeySpec（PKCS#8编码的Key指令）。
@paramprivateKeyStr
@return
@throwsException
/
publicstaticPrivateKeyloadPrivateKey(StringprivateKeyStr)throwsException
{
try
{
byte[]buffer=Base64Utils.decode(privateKeyStr);
//X509EncodedKeySpeckeySpec=newX509EncodedKeySpec(buffer);
PKCS8EncodedKeySpeckeySpec=newPKCS8EncodedKeySpec(buffer);
KeyFactorykeyFactory=KeyFactory.getInstance(RSA);
return(RSAPrivateKey)keyFactory.generatePrivate(keySpec);
}catch(NoSuchAlgorwww.shanxiwang.netithmExceptione)
{
thrownewException("无此算法");
}catch(InvalidKeySpecExceptione)
{
thrownewException("私钥非法");
}catch(NullPointerExceptione)
{
thrownewException("私钥数据为空");
}
}
/
从文件中输入流中加载公钥
@paramin
公钥输入流
@throwsException
加载公钥时产生的异常
/
publicstaticPublicKeyloadPublicKey(InputStreamin)throwsException
{
try
{
returnloadPublicKey(readKey(in));
}catch(IOExceptione)
{
thrownewException("公钥数据流读取错误");
}catch(NullPointerExceptione)
{
thrownewException("公钥输入流为空");
}
}
/
从文件中加载私钥
@paramkeyFileName
私钥文件名
@return是否成功
@throwsException
/
publicstaticPrivateKeyloadPrivateKey(InputStreamin)throwsException
{
try
{
returnloadPrivateKey(readKey(in));
}catch(IOExceptione)
{
thrownewException("私钥数据读取错误");
}catch(NullPointerExceptione)
{
thrownewException("私钥输入流为空");
}
}
/
读取密钥信息
@paramin
@return
@throwsIOException
/
privatestaticStringreadKey(InputStreamin)throwsIOException
{
BufferedReaderbr=newBufferedReader(newInputStreamReader(in));
StringreadLine=null;
StringBuildersb=newStringBuilder();
while((readLine=br.readLine())!=null)
{
if(readLine.charAt(0)==''-'')
{
continue;
}else
{
sb.append(readLine);
sb.append(''\r'');
}
}
returnsb.toString();
}
/
打印公钥信息
@parampublicKey
/
publicstaticvoidprintPublicKeyInfo(PublicKeypublicKey)
{
RSAPublicKeyrsaPublicKey=(RSAPublicKey)publicKey;
System.out.println("----------RSAPublicKey----------");
System.out.println("Modulus.length="+rsaPublicKey.getModulus().bitLength());
System.out.println("Modulus="+rsaPublicKey.getModulus().toString());
System.out.println("PublicExponent.length="+rsaPublicKey.getPublicExponent().bitLength());
System.out.println("PublicExponent="+rsaPublicKey.getPublicExponent().toString());
}
publicstaticvoidprintPrivateKeyInfo(PrivateKeyprivateKey)
{
RSAPrivateKeyrsaPrivateKey=(RSAPrivateKey)privateKey;
System.out.println("----------RSAPrivateKey----------");
System.out.println("Modulus.length="+rsaPrivateKey.getModulus().bitLength());
System.out.println("Modulus="+rsaPrivateKey.getModulus().toString());
System.out.println("PrivateExponent.length="+rsaPrivateKey.getPrivateExponent().bitLength());
System.out.println("PrivatecExponent="+rsaPrivateKey.getPrivateExponent().toString());
}
}
上面需要注意的就是加密是有长度限制的，过长的话会抛异常！！！
代码中有些需要使用Base64再转换的，而java中不自带，Android中自带，所以自己写出一个来，方便Java后台使用.
Base64Utils工具类:
packagecom.example.rsa;
importjava.io.UnsupportedEncodingException;
publicclassBase64Utils
{
privatestaticchar[]base64EncodeChars=newchar[]
{''A'',''B'',''C'',''D'',''E'',''F'',''G'',''H'',''I'',''J'',''K'',''L'',''M'',''N'',''O'',''P'',''Q'',''R'',''S'',''T'',
''U'',''V'',''W'',''X'',''Y'',''Z'',''a'',''b'',''c'',''d'',''e'',''f'',''g'',''h'',''i'',''j'',''k'',''l'',''m'',
''n'',''o'',''p'',''q'',''r'',''s'',''t'',''u'',''v'',''w'',''x'',''y'',''z'',''0'',''1'',''2'',''3'',''4'',''5'',
''6'',''7'',''8'',''9'',''+'',''/''};
privatestaticbyte[]base64DecodeChars=newbyte[]
{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,52,53,
54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,
12,13,14,15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,-1,26,27,28,29,
30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,-1,-1,
-1,-1,-1};
/
加密
@paramdata
@return
/
publicstaticStringencode(byte[]data)
{
StringBuffersb=newStringBuffer();
intlen=data.length;
inti=0;
intb1,b2,b3;
while(i
{
b1=data[i++]&0xff;
if(i==len)
{
sb.append(base64EncodeChars[b1>>>2]);
sb.append(base64EncodeChars[(b1&0x3)<<4]);
sb.append("==");
break;
}
b2=data[i++]&0xff;
if(i==len)
{
sb.append(base64EncodeChars[b1>>>2]);
sb.append(base64EncodeChars[((b1&0x03)<<4)|((b2&0xf0)>>>4)]);
sb.append(base64EncodeChars[(b2&0x0f)<<2]);
sb.append("=");
break;
}
b3=data[i++]&0xff;
sb.append(base64EncodeChars[b1>>>2]);
sb.append(base64EncodeChars[((b1&0x03)<<4)|((b2&0xf0)>>>4)]);
sb.append(base64EncodeChars[((b2&0x0f)<<2)|((b3&0xc0)>>>6)]);
sb.append(base64EncodeChars[b3&0x3f]);
}
returnsb.toString();
}
/
解密
@paramstr
@return
/
publicstaticbyte[]decode(Stringstr)
{
try
{
returndecodePrivate(str);
}catch(UnsupportedEncodingExceptione)
{
e.printStackTrace();
}
returnnewbyte[]
{};
}
privatestaticbyte[]decodePrivate(Stringstr)throwsUnsupportedEncodingException
{
StringBuffersb=newStringBuffer();
byte[]data=null;
data=str.getBytes("US-ASCII");
intlen=data.length;
inti=0;
intb1,b2,b3,b4;
while(i
{
do
{
b1=base64DecodeChars[data[i++]];
}while(i
if(b1==-1)
break;
do
{
b2=base64DecodeChars[data[i++]];
}while(i
if(b2==-1)
break;
sb.append((char)((b1<<2)|((b2&0x30)>>>4)));
do
{
b3=data[i++];
if(b3==61)
returnsb.toString().getBytes("iso8859-1");
b3=base64DecodeChars[b3];
}while(i
if(b3==-1)
break;
sb.append((char)(((b2&0x0f)<<4)|((b3&0x3c)>>>2)));
do
{
b4=data[i++];
if(b4==61)
returnsb.toString().getBytes("iso8859-1");
b4=base64DecodeChars[b4];
}while(i
if(b4==-1)
break;
sb.append((char)(((b3&0x03)<<6)|b4));
}
returnsb.toString().getBytes("iso8859-1");
}
}
3.终于要开始加密啦：
packagecom.example.rsa;
importjava.io.InputStream;
importjava.security.PrivateKey;
importjava.security.PublicKey;
importandroid.app.Activity;
importandroid.os.Bundle;
importandroid.util.Base64;
importandroid.view.View;
importandroid.view.View.OnClickListener;
importandroid.widget.Button;
importandroid.widget.EditText;
publicclassMainActivityextendsActivityimplementsOnClickListener
{
privateButtonbtn1,btn2;//加密，解密
privateEditTextet1,et2,et3;//需加密的内容，加密后的内容，解密后的内容
//注意copy密钥字符串时,不要有空格.这对密钥必须是一对
privatestaticStringPUCLIC_KEY="公钥";
privatestaticStringPRIVATE_KEY="私钥";
@Override
protectedvoidonCreate(BundlesavedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initView();
}
privatevoidinitView()
{
btn1=(Button)findViewById(R.id.btn1);
btn2=(Button)findViewById(R.id.btn2);
btn1.setOnClickListener(this);
btn2.setOnClickListener(this);
et1=(EditText)findViewById(R.id.et1);
et2=(EditText)findViewById(R.id.et2);
et3=(EditText)findViewById(R.id.et3);
}
@Override
publicvoidonClick(Viewv)
{
switch(v.getId())
{
---------------此处模拟android端数据使用<服务器端公钥>加密后传到服务器--------------
//加密
caseR.id.btn1:
Stringsource=et1.getText().toString().trim();
try
{
//从字符串中得到公钥
//PublicKeypublicKey=RSAUtils.loadPublicKey(PUCLIC_KEY);
//从文件中得到公钥
InputStreaminPublic=getResources().getAssets().open("rsa_public_key_me.pem");
PublicKeypublicKey=RSAUtils.loadPublicKey(inPublic);
//加密
byte[]encryptByte=RSAUtils.encryptData(source.getBytes(),publicKey);
//为了方便观察吧加密后的数据用base64加密转一下，要不然看起来是乱码,所以解密是也是要用Base64先转换
Stringafterencrypt=Base64Utils.encode(encryptByte);
et2.setText(afterencrypt);
}catch(Exceptione)
{
e.printStackTrace();
}
break;
-----------------这里模拟服务器端人员拿到加密后的数据用<服务器私钥>解密-----------
//解密
caseR.id.btn2:
StringencryptContent=et2.getText().toString().trim();
try
{
//从字符串中得到私钥
//PrivateKeyprivateKey=RSAUtils.loadPrivateKey(PRIVATE_KEY);
//从文件中得到私钥
InputStreaminPrivate=getResources().getAssets().open("rsa_private_key_pkcs8_me.pem");
PrivateKeyprivateKey=RSAUtils.loadPrivateKey(inPrivate);
//因为RSA加密后的内容经Base64再加密转换了一下，所以先Base64解密回来再给RSA解密
byte[]decryptByte=RSAUtils.decryptData(Base64Utils.decode(encryptContent),privateKey);
StringdecryptStr=newString(decryptByte);
et3.setText(decryptStr);
}catch(Exceptione)
{
e.printStackTrace();
}
break;
default:
break;
}
}
}
|
|
