RSA典型非对称加密算法

私钥加密-->公钥解密，反之亦然，但不安全。也能够当作数字签名。

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);

              

       }

}