Android传输数据时加密详解

Android传输数据时加密详解

Android传输数据时加密详解

ONEGoal,ONEPassion!

---------------------MD5加密---------------

MD5B|JMessage-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[]={O,T,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[J=md.digest();//MD5的计算结果是一个128位的长整数，

//用字节表示就是16个字节

charstrO[]=newchar[16*2];//每个字节用16进制表示的话，使用两个字符，

所以表示成16

//进制需要32个字符

intk=0;//表示转换结果中对应的字符位置

for(inti=0;i<16;i++){//从第一个字节开始，对MD5的每一个字节〃转换

成16

//进制字符的转换

bytebyteO=tmpfi];//取第i个字节

strO[k++]=hexDigitslbyteO»>4&Oxf];//取字节中高4位的数字转

换,〃»>

//为逻辑右移，将符号位一起右移

strO[k++]=hexDigits[byteO&Oxf|;//取字节中低4位的数字转换

s-newString(strO);//换后的结果转换为字符串

}catch(NoSuchAlgorithmExceptione){

//TODOAuto-generatedcatchblock

e.printStackTrace();

returns;

MD5使用场景：

传输类似用户名的密码时.此时使用MD5直接将数据加密后提交到后台.因为后台不需

要知道用户名密码.可以直接将接收到的经过MD5加密后数据存储到数据库.这也就是为什

么许多应用只能重置密码，却不能找回密码.

特别注意：

现在由于网络MD5数据库比较大，如果直接使用md5加密的话彳艮容易被破译出来.这是

在加密的过程中“加盐”就可以大大避免直接被破译的危险.

RSA非对称可逆加密

RSA加密原理概述：

RSA的安全性依赖于大数的分解，公钥和私钥都是两个大素数(大于100的十进制位)

的函数。从一个密钥和密文推断出明文的难度等同于分解两个大素数的积

1.选择两个大素数p,q,计算n=p*q;

2.随机选择加密密钥e,要求e和(p-l)*(q-l)互质

3.利用Euclid算法计算解密密钥d,使其满足e*d=l(mod(p-l)*(q-l))(其中n,d也要

互质)

4:至此得出公钥为(n,e)私钥为*(n,d)加解密方法：

1.首先将要加密的信息m(二进制表示)分成等长的

数据块ml,m2,—,mi块长s(尽可能大)，其中2As<n

2:对应的密文是：ci=miAe(modn)

3:解密时作如下计算：mi=ciAd(modn)

RSA速度：

由于进行的都是大数计算，使得RSA最快的情况也比DES慢上100倍，无论是软件

还是硬件实现。速度一直是RSA的缺陷。一般来说只用于少量数据加密。

1.如何生成密钥对（公钥，私钥）:

第一种方式:通过OpenSSl工具生成密钥对

OpenSSl工具下载：OpenSSl工具（64位的也可使用）使用OpenSSl工具生成密钥对

的过程如下：

首先双击打开bin文件夹下的openssl.exe,打开之后是一个命令行窗口，执行下面窗口：

RSA密钥生成命令：

生成RSA私钥：

genrsa-outrsa_private_key.pem1024

1

1

这条命令是让。penssl随机生成了一份私钥，加密长度是1024位，密钥长度，范围：

512—2048o执行完命令后就可在bin文件夹下看到rsa_private_key.pem文件了。

用文本类工具打开可看到里面的内容：

BEGINRSAPRIVATEKEY-——

MIICXAIBAAKBgQC8rPqGGsar+BWI7vAtaaDOqphy4lj5186hCU9DcchV4HWivOHv

Q3KXAEqHfZiAHZSyMSRMinDZVnqJwCVWFvKUPqUlRsCPZ9Imk+9ZXVkM3DDdw

74v/

s6YMNx8cTuxybRCJUfOKbyC79cnHgmQqqkODv+EnprBtNKE4k8g90jNmbwIDAQAB

AoGAS06Hl+ssDQuyHLux5Y5ZfuOcgY64vtAiSyhaGMNbgNtcWJ8aBBPZsueM19OL

gOdNqGnw4RmH51iw4SL4na6T+qGpblEW/4GleQXXJvflBhlYJupaSvhuTf3msFw4

z9GY8V29deGPx5/6FRVTPTqnLoxUlfloOCYCeDJrXa9+YGECQQD24cdN9MT3HqfP

3S+UEDHO3XaDq38V3sCnKQ5mSYtnst/NV/g4bqYUOYElQW27p0YgwhHLlxWPke8a

4Jz/r41nAkEAw6TfA36kUZfnFIXNM/0250jyZDE/yEKBXhThO8DAXAyAaEHjxA7K

+eprXP7aynfy+nrz/W5Iy8libP5G/4tuQJBALaDn9ZP+DVBIoqXWI87kbb/Hpik

9mTysrZhsdWIlViqcq3aNRVzJ7CX+pPSVQ9/OGZzUriSTOw+dOgH2clkukOCQDXX

hdh8XdRmrZ2kRRjtstJr7OlN9HO0ec3eiS3cmhO7DQukNn6aY5nrvahWKve+Qino

MpGE2nKoZl+CPChMB2ECQG8utIhzAGH01Kbv/3+SzDERStrFYn/WqpWG3qSXAMye

s24khuRPtMYPzIxI/wZYPazbKgxuERAhiRtpz0e9jvI=

--ENDRSAPRIVATEKEY--

这里面的内容是标准的ASCII字符，中间的一大串字符就是私钥数据了。

生成RSA公钥：

rsa-inrsa_private_key.pem-outrsa_public_key.pem-pubout

打开文件看下里面的内容：

-----BEGINPUBLICKEY---

MIGfMAOGCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC8rPqGGsar+BWI7vAtaaDOqp

hy

41j5186hCU9DcchV4HWivOHvQ3KXAEqHfZiAHZSyMSRMmDZVnqJwCVWFvKUPqU

1R

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-——

MIICdgIBADANBgkqhkiG9wOBAQEFAASCAmAwggJcAgEAAoGBALys+oYaxqv4FYju

8C1poM6qmHLjWPnXzqEJT0NxyFXgdaK/Qe9DcpcASod9mIAdlLIxJEyYNlWeonAJ

VYW8pQ+pTVGwI9n0iaT71IdWQzcMN3Dvi/+zpgw3HxxO7HJtEIlR84pvILv1yceC

ZCqqQ4O/4SemsG00oTiTyD3SM2ZvAgMBAAECgYBLToeX6ywNC7Icu7Hljll+45yB

jri+OCJLKFoYw1uA21xYnxoEE9my54zX04uA502oafDhGYfmWLDhIvidrpP6oalu

URb/gbV5Bdcm98gGGVgm61pK+G5N/eawXDjP0ZjxXb114Y/Hn/oVFVM9OqcujFSV

+Wg4JgJ4Mmtdr35gYQJBAPbhx030xPcep8/dL5QQMc7ddoOrfxXewKcpDmZJi2ey

381X+DhuphQ5gSVBbbunRiDCEcuXFY+R7xrgnP+viWcCQQDDpN8DfqRRl+cUhc0z

/TbnSPJkMT/IQoFeFOE7wMBcDIBoQePEDsr56mtc/trIUh/L6evP9bkjLzWJs/kb

/i25AkEAtoOflk/4NUEiipdYjzuRtv8emKT2ZPKytmGx1YjVWKpyrdo1FXMnsJf6

k9JVD3/QZnNSuJJPTD506AfZyWS6TQJANdeF2HxdlGatnaRFGO2y0mvs6U30c7R5

zd6JLdyaE7sNC6Q2fppjmeu9qFYq975CKegykYTacqhnX4I8KEwHYQJAby60iHMA

YfSUpu//f5LMMRFK2sVif9aqlYbepJcAzJ6zbiSG5E+0xg/MjEj/Blg9rNsqDG4R

ECGJG2nPR72O8g==

--ENDPRIVATEKEY--

第二种方式:通过批处理文件直接生成.强烈建议使用

下载支付宝提供的密钥对生成工具.

/detail/fengltxx/9674172

解压，阅读文档操作:

PTK

)|w

RSA□□rs«2j>ublk使丽融RtJlRAS

e_key.p«me_key_pkc_key-pe<n尚清先懵走再生

强珥筌勺SHAIhRS

.txtA1024.V-

这的'名件是执行完批处理命令后亶接生成的.可以直接拿着使用哈

密钥对己经生成了.我们怎么使用呢？

公钥互换：

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;

importerfaces.RSAPrivateKey;

importerfaces.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<br>

*一般1024

*@return

*/

publicstaticKeyPairgenerateRSAKeyPair(intkeyLength)

try

KeyPairGeneratorkpg=KeyPairGenerator.getlnstance(RSA);

kpg.initialize(keyLength);

returnkpg.genKeyPair();

}catch(NoSuchAlgorithmExceptione)

(

e.printStackTrace();

returnnull;

)

)

/**

*用公钥加密<br>

*每次加密的字节数，不能超过密钥的长度值减去11

*@paramdata

*需加密数据的byte数据

*@parampubKey

*公钥

*@return加密后的byte型数据

*/

publicstaticbyte[]encryptData(byte[]data,PublicKeypublicKey)

Ciphercipher=Cipher.getlnstance(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.getlnstance(RSA);

cipheranit(Cipher.DECRYPT_MODE,privateKey);

returncipher.doFinal(encryptedData);

}catch(Exceptione)

(

returnnull;

)

}

/**

"通过公钥byte[](publicKey.getEncoded())将公钥还原，适用于RSA算法

*

*@paramkeyBytes

*@retum

*@throwsNoSuchAlgorithmException

*@throwsInvalidKeySpecException

*/

publicstaticPublicKeygetPublicKey(byte[]keyBytes)throws

NoSuchAlgorithmException,

InvalidKeySpecException

(

X509EncodedKeySpeckeySpec=newX509EncodedKeySpec(keyBytes);

KeyFactorykeyFactory=KeyFactory.getlnstance(RSA);

PublicKeypublicKey=keyFactory.generatePublic(keySpec);

returnpublicKey;

*通过私钥byte[]将公钥还原，适用于RSA算法

*

*@paramkeyBytes

*@return

*@throwsNoSuchAlgorithmException

*@throwsInvalidKeySpecException

*/

publicstaticPrivateKeygetPrivateKey(byte[]keyBytes)throws

NoSuchAlgorithmException,

InvalidKeySpecException

PKCS8EncodedKeySpeckeySpec=newPKCS8EncodedKeySpec(keyBytes);

KeyFactorykeyFactory=KeyFactory.getlnstance(RSA);

PrivateKeyprivateKey=keyFactory.generatePrivate(keySpec);

returnprivateKey;

使用N、e值还原公钥

*@parammodulus

*@parampublicExponent

*@return

*@throwsNoSuchAlgorithmException

*@throwsInvalidKeySpecException

*/

publicstaticPublicKeygetPublicKey(Stringmodulus,StringpublicExponent)

throwsNoSuchAlgorithmException,InvalidKeySpecException

(

BigintegerbiglntModulus=newBiglnteger(modulus);

BigintegerbiglntPrivateExponent=newBiglnteger(publicExponent);

RSAPublicKeySpeckeySpec=newRSAPublicKeySpec(bigIntModulus,

biglntPrivateExponent);

KeyFactorykeyFactory=KeyFactory.getlnstance(RSA);

PublicKeypublicKey=keyFactory.generatePublic(keySpec);

returnpublicKey;

*使用N、d值还原私钥

*

*@parammodulus

求@paramprivateExponent

*@retum

*@throwsNoSuchAlgorithmException

*@throwsInvalidKeySpecException

*/

publicstaticPrivateKeygetPrivateKey(Stringmodulus,StringprivateExponent)

throwsNoSuchAlgorithmException,InvalidKeySpecException

(

BigintegerbiglntModulus=newBiglnteger(modulus);

BigintegerbiglntPrivateExponent=newBiglnteger(privateExponent);

RSAPublicKeySpeckeySpec=newRSAPublicKeySpec(bigIntModulus,

biglntPrivateExponent);

KeyFactorykeyFactory=KeyFactory.getlnstance(RSA);

PrivateKeyprivateKey=keyFactory.generatePrivate(keySpec);

returnprivateKey;

)

/**

*从字符串中加载公钥

*

*@parampublicKeyStr

*公钥数据字符串

*@throwsException

*加载公钥时产生的异常

*/

publicstaticPublicKeyloadPublicKey(StringpublicKeyStr)throwsException

(

try

(

byte[]buffer=Base64Utils.decode(publicKeyStr);

KeyFactorykeyFactory=KeyFactory.getlnstance(RSA);

X509EncodedKeySpeckeySpec=newX509EncodedKeySpec(buffer);

return(RSAPublicKey)keyFactory.generatePublic(keySpec);

}catch(NoSuchAlgorithmExceptione)

(

thrownewException("无此算法”);

}catch(InvalidKeySpecExceptione)

(

thrownewException("公钥非法”);

}catch(NullPointerExceptione)

(

thrownewException("公钥数据为空)

*从字符串中加载私钥＜b»

*力口载时使用的是PKCS8EncodedKeySpec(PKCS#8编码的Key指令)。

*

*@paramprivateKeyStr

*@return

*@throwsException

*/

publicstaticPrivateKeyloadPrivateKey(StringprivateKeyStr)throwsException

try

byte[]buffer=Base64Utils.decode(privateKeyStr);

//X509EncodedKeySpeckeySpec=newX509EncodedKeySpec(buffer);

PKCS8EncodedKeySpeckeySpec=newPKCS8EncodedKeySpec(buffer);

KeyFactorykeyFactory=KeyFactory.getlnstance(RSA);

return(RSAPrivateKey)keyFactory.generatePrivate(keySpec);

}catch(NoSuchAithmExceptione)

(

thrownewException0无此算法)

}catch(InvalidKeySpecExceptione)

(

thrownewException("私钥非法”);

}catch(NullPointerExceptione)

(

thrownewException("私钥数据为空”)；

*从文件中输入流中加载公钥

*

*@paramin

*公钥输入流

*@throwsException

*加载公钥时产生的异常

*/

publicstaticPublicKeyloadPublicKey(InputStreamin)throwsException

(

try

(

returnloadPublicKey(readKey(in));

}catch(lOExceptione)

(

thrownewException("公钥数据流读取错误)

}catch(NullPointerExceptione)

(

thrownewException("公钥输入流为空”)；

*从文件中加载私钥

*@paramkeyFileName

*私钥文件名

*@return是否成功

*@throwsException

*/

publicstaticPrivateKeyloadPrivateKey(InputStreamin)throwsException

(

try

(

returnloadPrivateKey(readKey(in));

}catch(lOExceptione)

(

thrownewException("私钥数据读取错误)

}catch(NullPointerExceptione)

(

thrownewException("私钥输入流为空”)；

*读取密钥信息

*

*@paramin

*@return

*@throwslOException

刃

privatestaticStringreadKey(InputStreamin)throwslOException

(

BufferedReaderbr=newBufferedReader(newInpulStreamReader(in));

StringreadLine=null;

StringBuildersb=newStringBuilder();

while((readLine=br.readLine())!=null)

(

if(readLine.charAt(O)=='-')

(

continue;

)else

(

sb.append(readLine);

sb.appendCXr1);

)

)

returnsb.toStringO;

*打印公钥信息

*

*@parampublicKey

*/

publicstaticvoidprintPublicKeyInfo(PublicKeypublicKey)

(

RSAPublicKeyrsaPublicKey=(RSAPublicKey)publicKey;

System.out.println(H---RSAPublicKey----------")；

System.out.printlnC'Modulus.leng^"+rsaPublicKey.getModulus().bitLength());

System.out.println(',Modulus=H+rsaPublicKey.getModulus().toString());

System.out.println(',PublicExponent.length=,'+

rsaPublicKey.getPublicExponent().bitLength());

System.out.println(nPublicExponent="+

rsaPublicKey.getPublicExponent().toString());

)

publicstaticvoidprintPrivateKeyInfo(PrivateKeyprivateKey)

(

RSAPrivateKeyrsaPrivateKey=(RSAPrivateKey)privateKey;

System.out.println(n----------RSAPrivateKey----------")；

System.out.println("Modulus.length=H+rsaPrivateKey.getModulus().bitLength());

System.out.println(',Modulus=u+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,BJC',D',E,F,G,N,P',Q,R,T,

U；'V','W',X','Y','Z','a',b'Jc',d,'e'，'f,'g'，h,'i；'j',k,T,'m',

h','o「p「q',匕T,2,3,4,5,

6,7,8,9,7'};

privatestaticbyte[]base64DecodeChars=newbytef]

{-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,

};

*加密

*

*@paramdata

*@return

*/

publicstaticStringencode(byte[]data)

(

StringBuffersb=newStringBulfer();

intlen=data.length;

inti=0;

intbl,b2,b3;

while(i<len)

(

bl=data[i++]&Oxff;

if(i==len)

(

sb.append(base64EncodeChars[b1»>2]);

sb.append(base64EncodeChars[(b1&0x3)«4]);

sb.append("==");

break;

)

b2=data[i++]&Oxff;

if(i==len)

sb.append(base64EncodeChars[b1»>2]);

sb.append(base64EncodeChars[((b1&0x03)«4)|((b2&OxfO)»>

4)])；

sb.append(base64EncodeChars[(b2&OxOf)«2]);

sb.append(n=u);

break;

)

b3=data[i++]&Oxff;

sb.append(base64EncodeChars[bl»>2]);

sb.append(base64EncodeChars[((bl&0x03)«4)|((b2&OxfO)»>4)]);

sb.append(base64EncodeChars[((b2&0x00«2)|((b3&OxcO)»>6)]);

sb.append(base64EncodeChars[b3&0x3f|);

(

returnsb.toString();

}

/**

*解密

*

*@paramstr

*@retum

*/

publicstaticbyte[]decode(Stringstr)

(

try

(

returndecodePrivate(str);

}catch(UnsupportedEncodingExceptione)

(

e.printStackTrace();

)

returnnewbyte[]

()；

)

privatestaticbyte[]decodePrivate(Stringstr)throwsUnsupportedEncodingException

(

StringBuffersb=newStringBulfer();

byte[]data=null;

data=str.getBytes(nUS-ASCII");

intlen=data.length;

inti=0;

intbl,b2,b3,b4;

while(i<len)

do

bl=base64DecodeChars[data[i++]];

}while(i<len&&bl==-1);

if(bl==-1)

break;

do

(

b2=base64DecodeChars[data[i++]];

}while(i<len&&b2==-1);

if(b2==-1)

break;

sb.append((char)((bl«2)|((b2&0x30)»>4)));

do

(

b3=data[i++];

if(b3==61)

returnsb.toString().getBytes(',iso8859-r,);

b3=base64DecodeChars[b3];

}while(i<len&&b3==-1);

if(b3==-1)

break;

sb.append((char)(((b2&OxOf)«4)|((b3&0x3c)»>2)));

do

{

b4=data[i++];

if(b4==61)

returnsb.toString().getBytes("iso8859-lu);

b4=base64DecodeChars[b4];

)while(i<len&&b4==-1);

if(b4==-l)

break;

sb.append((char)(((b3&0x03)«6)|b4));

)

returnsb.toString().getBytes(Hiso8859-1'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

(

privateButtonbtnl,btn2;//加密，解密

privateEditTextetl,et2,et3;〃需加密的内容，加密后的内容,解密后的内容

//注意copy密钥字符串时，不要有空格.这对密钥必须是一对

privatestaticStringPUCLIC_KEY=”公钥”；

privatestaticStringPRIVATE_KEY="私钥”；

@Ovenide

protectedvoidonCreate(BundlesavedlnstanceState)

(

super.onCreate(savedlnstanceState);

setContentView(R.layout.activity_main);

initView();

)

privatevoidinitView()

(

btnl=(Button)findViewById(R.id.btn1);

btn2=(Button)findViewById(R.id.btn2);

bln1.setOnClickListener(this);

btn2.setOnClickListener(this);

etl=(EditText)findViewById(R.id.et1);

et2=(EditText)findViewById(R.id.et2);

et3=(EditText)findViewById(R.id.et3);

@Ovenide

publicvoidonClick(Viewv)

(

switch(v.getld())

(

----------此处模拟android端数据使用〈服务器端公钥〉加密后传到服务器

//力口密

case