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;iintlen=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;iintlen=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;ibyte[]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;ibyte[]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;iStringhex=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;iinthigh=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;
}
}
升级会员 