Java非对称加密RSA工具类v11.docx

Java非对称加密RSA工具类v11.docx

《Java非对称加密RSA工具类v11.docx》由会员分享，可在线阅读，更多相关《Java非对称加密RSA工具类v11.docx（9页珍藏版）》请在冰豆网上搜索。

Java非对称加密RSA工具类v11

这里简单讲一下RSA：

我们平时所知道的密码什么的都基本是一个，DES、AES的加密解密也都是用同一个密码，但是RSA就不一样了，RSA有2个密码：

公钥、私钥。

为什么要用2个密码？

要怎么用？

用2个密码自然是为了数据的安全，防止丢失数据后被人恶意破解。

至于怎么用，其实就是用公钥加密后只能用私钥解密，私钥加密后只能用公钥解密。

就以支付宝的集成为例，你得在本地生成公钥跟私钥，然后上床给支付宝，之后传输数据的时候就是用这对密码来加解密的。

（当然，加解密的步骤支付宝已经帮你做了，你是不用去写RSA的代码的）

题外话：

其实我一直觉得支付宝这个生成公钥私钥可以在支付宝平台做的，每次都要我在本地生成，然后还要去传给支付宝平台，真的有一点点、一点点的烦。

。

。

---

v1.1 加入分段处理

packagecom.lwx.encrypt;

importjava.security.Key;

importjava.security.KeyFactory;

importjava.security.KeyPair;

importjava.security.KeyPairGenerator;

importjava.security.interfaces.RSAPrivateCrtKey;

importjava.security.interfaces.RSAPublicKey;

importjava.security.spec.PKCS8EncodedKeySpec;

importjava.security.spec.X509EncodedKeySpec;

importjavax.crypto.Cipher;

publicclassRSA{

publicstaticvoidmain（String...args）{

RSArsa=RSA.create（）;

StringpubKey=rsa.getPublicKey（）;

StringpriKey=rsa.getPrivateKey（）;

//原文

StringBufferres=newStringBuffer（）;

for（inti=0;i<40;i++）{

res.append（"测试"）;

}

System.out.println（"原文对比:

"+res.toString（））;

System.out.println（"------------"）;

StringenStr=rsa.encodeByPublicKey（res.toString（）,pubKey）;

StringdeStr=rsa.decodeByPrivateKey（enStr,priKey）;

System.out.println（"公钥加密:

"+enStr）;

System.out.println（"私钥解密:

"+deStr）;

System.out.println（"------------"）;

enStr=rsa.encodeByPrivateKey（res.toString（）,priKey）;

deStr=rsa.decodeByPublicKey（enStr,pubKey）;

System.out.println（"私钥加密:

"+enStr）;

System.out.println（"公钥解密:

"+deStr）;

}

publicstaticfinalStringKEY_ALGORITHM="RSA";

publicstaticfinalStringsplit="";//分隔符

publicstaticfinalintmax=117;//加密分段长度//不可超过117

privatestaticRSAme;

privateRSA（）{}//单例

publicstaticRSAcreate（）{

if（me==null）{

me=newRSA（）;

}

//生成公钥、私钥

try{

KeyPairGeneratorkpg=KeyPairGenerator.getInstance（KEY_ALGORITHM）;

kpg.initialize（1024）;

KeyPairkp=kpg.generateKeyPair（）;

me.publicKey=（RSAPublicKey）kp.getPublic（）;

me.privateKey=（RSAPrivateCrtKey）kp.getPrivate（）;

}catch（Exceptione）{

e.printStackTrace（）;

}

returnme;

}

privateRSAPublicKeypublicKey;

privateRSAPrivateCrtKeyprivateKey;

/**获取公钥*/

publicStringgetPublicKey（）{

returnparseByte2HexStr（publicKey.getEncoded（））;

}

/**获取私钥*/

publicStringgetPrivateKey（）{

returnparseByte2HexStr（privateKey.getEncoded（））;

}

/**加密-公钥*/

publicStringencodeByPublicKey（Stringres,Stringkey）{

byte[]resBytes=res.getBytes（）;

byte[]keyBytes=parseHexStr2Byte（key）;//先把公钥转为2进制

StringBufferresult=newStringBuffer（）;//结果

//如果超过了100个字节就分段

if（keyBytes.length<=max）{//不超过直接返回即可

returnencodePub（resBytes,keyBytes）;

}else{

intsize=resBytes.length/max+（resBytes.length%max>0?

1:

0）;

for（inti=0;i

intlen=i==size-1?

resBytes.length%max:

max;

byte[]bs=newbyte[len];//临时数组

System.arraycopy（resBytes,i*max,bs,0,len）;

result.append（encodePub（bs,keyBytes））;

if（i!

=size-1）result.append（split）;

}

returnresult.toString（）;

}

}

/**加密-私钥*/

publicStringencodeByPrivateKey（Stringres,Stringkey）{

byte[]resBytes=res.getBytes（）;

byte[]keyBytes=parseHexStr2Byte（key）;

StringBufferresult=newStringBuffer（）;

//如果超过了100个字节就分段

if（keyBytes.length<=max）{//不超过直接返回即可

returnencodePri（resBytes,keyBytes）;

}else{

intsize=resBytes.length/max+（resBytes.length%max>0?

1:

0）;

for（inti=0;i

intlen=i==size-1?

resBytes.length%max:

max;

byte[]bs=newbyte[len];//临时数组

System.arraycopy（resBytes,i*max,bs,0,len）;

result.append（encodePri（bs,keyBytes））;

if（i!

=size-1）result.append（split）;

}

returnresult.toString（）;

}

}

/**解密-公钥*/

publicStringdecodeByPublicKey（Stringres,Stringkey）{

byte[]keyBytes=parseHexStr2Byte（key）;

//先分段

String[]rs=res.split（"\\"+split）;

//分段解密

if（rs!

=null）{

intlen=0;

//组合byte[]

byte[]result=newbyte[rs.length*max];

for（inti=0;i

byte[]bs=decodePub（parseHexStr2Byte（rs[i]）,keyBytes）;

System.arraycopy（bs,0,result,i*max,bs.length）;

len+=bs.length;

}

byte[]newResult=newbyte[len];

System.arraycopy（result,0,newResult,0,len）;

//还原字符串

returnnewString（newResult）;

}

returnnull;

}

/**解密-私钥*/

publicStringdecodeByPrivateKey（Stringres,Stringkey）{

byte[]keyBytes=parseHexStr2Byte（key）;

//先分段

String[]rs=res.split（"\\"+split）;

//分段解密

if（rs!

=null）{

intlen=0;

//组合byte[]

byte[]result=newbyte[rs.length*max];

for（inti=0;i

byte[]bs=decodePri（parseHexStr2Byte（rs[i]）,keyBytes）;

System.arraycopy（bs,0,result,i*max,bs.length）;

len+=bs.length;

}

byte[]newResult=newbyte[len];

System.arraycopy（result,0,newResult,0,len）;

//还原字符串

returnnewString（newResult）;

}

returnnull;

}

/**将二进制转换成16进制*/

publicstaticStringparseByte2HexStr（bytebuf[]）{

StringBuffersb=newStringBuffer（）;

for（inti=0;i

Stringhex=Integer.toHexString（buf[i]&0xFF）;

if（hex.length（）==1）{

hex='0'+hex;

}

sb.append（hex.toUpperCase（））;

}

returnsb.toString（）;

}

/**将16进制转换为二进制*/

publicstaticbyte[]parseHexStr2Byte（StringhexStr）{

if（hexStr.length（）<1）

returnnull;

byte[]result=newbyte[hexStr.length（）/2];

for（inti=0;i

inthigh=Integer.parseInt（hexStr.substring（i*2,i*2+1）,16）;

intlow=Integer.parseInt（hexStr.substring（i*2+1,i*2+2）,16）;

result[i]=（byte）（high*16+low）;

}

returnresult;

}

/**加密-公钥-无分段*/

privateStringencodePub（byte[]res,byte[]keyBytes）{

X509EncodedKeySpecx5=newX509EncodedKeySpec（keyBytes）;//用2进制的公钥生成x509

try{

KeyFactorykf=KeyFactory.getInstance（KEY_ALGORITHM）;

KeypubKey=kf.generatePublic（x5）;//用KeyFactory把x509生成公钥pubKey

Ciphercp=Cipher.getInstance（kf.getAlgorithm（））;//生成相应的Cipher

cp.init（Cipher.ENCRYPT_MODE,pubKey）;//给cipher初始化为加密模式，以及传入公钥pubKey

returnparseByte2HexStr（cp.doFinal（res））;//以16进制的字符串返回

}catch（Exceptione）{

System.out.println（"公钥加密失败"）;

e.printStackTrace（）;

}

returnnull;

}

/**加密-私钥-无分段*/

privateStringencodePri（byte[]res,byte[]keyBytes）{

PKCS8EncodedKeySpecpk8=newPKCS8EncodedKeySpec（keyBytes）;

try{

KeyFactorykf=KeyFgetInstance（KEY_ALGORITHM）;

KeypriKey=kf.generatePrivate（pk8）;

Ciphercp=Cipher.getInstance（kf.getAlgorithm（））;

cp.init（Cipher.ENCRYPT_MODE,priKey）;

returnparseByte2HexStr（cp.doFinal（res））;

}catch（Exceptione）{

System.out.println（"私钥加密失败"）;

e.printStackTrace（）;

}

returnnull;

}

/**解密-公钥-无分段*/

privatebyte[]decodePub（byte[]res,byte[]keyBytes）{

X509EncodedKeySpecx5=newX509EncodedKeySpec（keyBytes）;

try{

KeyFactorykf=KeyFactory.getInstance（KEY_ALGORITHM）;

KeypubKey=kf.generatePublic（x5）;

Ciphercp=Cipher.getInstance（kf.getAlgorithm（））;

cp.init（Cipher.DECRYPT_MODE,pubKey）;

returncp.doFinal（res）;

}catch（Exceptione）{

System.out.println（"公钥解密失败"）;

e.printStackTrace（）;

}

returnnull;

}

/**解密-私钥-无分段*/

privatebyte[]decodePri（byte[]res,byte[]keyBytes）{

PKCS8EncodedKeySpecpk8=newPKCS8EncodedKeySpec（keyBytes）;

try{

KeyFactorykf=KeyFactory.getInstance（KEY_ALGORITHM）;

KeypriKey=kf.generatePrivate（pk8）;

Ciphercp=Cipher.getInstance（kf.getAlgorithm（））;

cp.init（Cipher.DECRYPT_MODE,priKey）;

returncp.doFinal（res）;

}catch（Exceptione）{

System.out.println（"私钥解密失败"）;

e.printStackTrace（）;

}

returnnull;

}

}