私钥加密–>公钥解密，反之亦然，但不安全。也可以当做数字签名。


public 
class 
RSACoder {


        
//非对称加密算法
        
public 
static 
final 
String 
KEY_ALGORITHM
= 
“RSA”
;
        
//公钥
        
private 
static 
final 
String 
PUBLIC_KEY
= 
“RSAPublicKey”
;
        
//私钥
        
private 
static 
final 
String 
PRIVATE_KEY
= 
“RSAPrivateKey”
;
        
//密钥长度，默认1024位，512~65536位，必须是64的倍数
        
private 
static 
final 
int 
KEY_SIZE
=512;
       
        
//私钥解密
        
public 
static 
byte
[] decryptByPrivateKey(
byte
[] data, 
byte
[] key) 
throws 
KeyException, Exception{
               
//取得私钥,
              PKCS8EncodedKeySpec pkcs8KeySpec= 
new 
PKCS8EncodedKeySpec(key);
              KeyFactory keyFactory=KeyFactory. getInstance(
KEY_ALGORITHM
);
              PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);
              
               
//对数据解密
              Cipher cipher=Cipher. getInstance(keyFactory.getAlgorithm());
              cipher.init(Cipher. 
DECRYPT_MODE
, privateKey);
               
return 
cipher.doFinal(data);
       }
       
        
//公钥解密
        
public 
static 
byte
[] decryptByPublicKey(
byte
[] data, 
byte
[] key) 
throws 
Exception{
              X509EncodedKeySpec x509= 
new 
X509EncodedKeySpec(key);
              KeyFactory keyFactory=KeyFactory. getInstance(
KEY_ALGORITHM
);
              
               
//生成公钥
              PublicKey publicKey=keyFactory.generatePublic(x509);
               
//对数据解密
              Cipher cipher=Cipher. getInstance(keyFactory.getAlgorithm());
              cipher.init(Cipher. 
DECRYPT_MODE
, publicKey);
               
return 
cipher.doFinal(data);
       }
       
        
//公钥加密
        
public 
static 
byte
[] encrpytByPublicKey(
byte
[] data, 
byte
[] key) 
throws 
Exception{
               
//取得公钥
              X509EncodedKeySpec x509= 
new 
X509EncodedKeySpec(key);
              KeyFactory keyFactory=KeyFactory. getInstance(
KEY_ALGORITHM
);
              PublicKey pubKey=keyFactory.generatePublic(x509);
               
//对数据加密
              Cipher cipher=Cipher. getInstance(keyFactory.getAlgorithm());
              cipher.init(Cipher. 
ENCRYPT_MODE
, pubKey);
               
return 
cipher.doFinal(data);
       }
       
        
//私钥加密
        
public 
static 
byte
[] encryptByPrivate(
byte
[] data, 
byte
[] key) 
throws 
Exception, GeneralSecurityException{
               
//取得私钥
              PKCS8EncodedKeySpec pkcs8= 
new 
PKCS8EncodedKeySpec(key);
              KeyFactory keyFactory=KeyFactory. getInstance(
KEY_ALGORITHM
);
               
//生成私钥
              PrivateKey privateKey=keyFactory.generatePrivate(pkcs8);
               
//对数据加密
              Cipher cipher=Cipher. getInstance(keyFactory.getAlgorithm());
              cipher.init(Cipher. 
ENCRYPT_MODE
, privateKey);
               
return 
cipher.doFinal(data);
       }
       
        
//取得私钥
        
public 
static 
byte
[] getPrivateKey(Map<String,Object> keyMap){
              Key key=(Key)keyMap.get( 
PRIVATE_KEY
);
               
return 
key.getEncoded();
       }
        
//取得公钥
        
public 
static 
byte
[] getPublicKey(Map<String,Object> keyMap){
              Key key=(Key)keyMap.get( 
PUBLIC_KEY
);
               
return 
key.getEncoded();
       }
       
        
//初始化密钥
        
public 
static 
Map<String,Object> initKey() 
throws 
Exception{
              KeyPairGenerator keyPairGen=KeyPairGenerator.getInstance( 
KEY_ALGORITHM
);
              keyPairGen.initialize( 
KEY_SIZE
);
              KeyPair keyPair=keyPairGen.generateKeyPair();
              
               
//公钥
              RSAPublicKey publicKey=(RSAPublicKey)keyPair.getPublic();
               
//私钥
              RSAPrivateKey privateKey=(RSAPrivateKey)keyPair.getPrivate();
              
               
//封装密钥
              Map<String,Object> keyMap= 
new 
HashMap<String,Object>(2);
              keyMap.put( 
PRIVATE_KEY
, privateKey);
              keyMap.put( 
PUBLIC_KEY
, publicKey);
               
return 
keyMap;
       }


}


public 
class 
RSATest {


        
private 
static 
byte
[] 
privateKey
;
        
private 
static 
byte
[] 
publicKey
;
       
        
public 
static 
void 
initKey() 
throws 
Exception{
               
//初始化密钥
              Map<String,Object> keyMap=RSACoder. initKey();
               
publicKey
=RSACoder.getPublicKey(keyMap);
               
privateKey
=RSACoder.getPrivateKey(keyMap);
              
              System. 
out
.println(
“公钥:\n” 
+Base64.encodeBase64String (
publicKey 
));
              System. 
out
.println(
“私钥：\n” 
+Base64.encodeBase64String (
privateKey 
));
       }
        
public 
static 
void 
main(String[] args) 
throws 
GeneralSecurityException, Exception {
               
// 
TODO 
Auto-generated method stub
               initKey();
              String inputStr1= 
“RSA加密算法” 
;
               
byte
[] data1=inputStr1.getBytes();
              System. 
out
.println(
“原文：\n” 
+inputStr1);
              
               
//私钥加密
               
byte
[] encodeData1=RSACoder.encryptByPrivate(data1, 
privateKey
);
              System. 
err
.println(
“加密后：\n” 
+Base64.encodeBase64String (encodeData1));
              
               
//公钥解密
               
byte
[] decodeData1=RSACoder.decryptByPublicKey(encodeData1, 
publicKey
);
              String outputStr1= 
new 
String(decodeData1);
              System. 
err
.println(
“解密后：\n” 
+outputStr1);
              
               assertEquals(inputStr1,outputStr1);
              
       }


}