在Android使用RSA 算法加解密

首先聊一下RSA 算法：  RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的所有密码攻击，已被ISO推荐为公钥数据加密标准,以下就是Rsa的原理机制：

????

看完这个RSA原理机制图 , 接下来我们用程序来体现出来： 

    首先我们可以从上图看到：明文--->公钥--->密文   密文-->密钥-->明文

    RSA由于public key<公钥> 和private key<密钥>的不同<也叫非对称算法加解密>,极大的提高了文件的安全性。  对称算法是同key的 ,这样很容易被人破解。

   RSA算法：

import java.security.Key;   
import java.security.KeyFactory;   
import java.security.KeyPair;   
import java.security.KeyPairGenerator;   
import java.security.PrivateKey;   
import java.security.PublicKey;   
import java.security.interfaces.RSAPrivateKey;   
import java.security.interfaces.RSAPublicKey;   
import java.security.spec.PKCS8EncodedKeySpec;   
import java.security.spec.X509EncodedKeySpec;   
    
import javax.crypto.Cipher;   
    
import sun.misc.BASE64Decoder;   
import sun.misc.BASE64Encoder;   
    
    
public class RSAHelper {   
    
        
      public static PublicKey getPublicKey(String key) throws Exception {   
            byte[] keyBytes;   
            keyBytes = (new BASE64Decoder()).decodeBuffer(key);   
    
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);   
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");   
            PublicKey publicKey = keyFactory.generatePublic(keySpec);   
            return publicKey;   
      }   
        
      public static PrivateKey getPrivateKey(String key) throws Exception {   
            byte[] keyBytes;   
            keyBytes = (new BASE64Decoder()).decodeBuffer(key);   
    
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);   
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");   
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);   
            return privateKey;   
      }   
    
        
      public static String getKeyString(Key key) throws Exception {   
            byte[] keyBytes = key.getEncoded();   
            String s = (new BASE64Encoder()).encode(keyBytes);   
            return s;   
      }   
    
    
      public static void main(String[] args) throws Exception {   
    
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");   
            //密钥位数   
            keyPairGen.initialize(1024);   
            //密钥对   
            KeyPair keyPair = keyPairGen.generateKeyPair();   
    
            // 公钥   
            PublicKey publicKey = (RSAPublicKey) keyPair.getPublic();   
    
            // 私钥   
            PrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();   
    
            String publicKeyString = getKeyString(publicKey);   
            System.out.println("public:\n" + publicKeyString);   
    
            String privateKeyString = getKeyString(privateKey);   
            System.out.println("private:\n" + privateKeyString);   
    
            //加解密类   
            Cipher cipher = Cipher.getInstance("RSA");//Cipher.getInstance("RSA/ECB/PKCS1Padding");   
    
            //明文   
            byte[] plainText = "我们都很好！邮件：@sina.com".getBytes();   
    
            //加密   
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);   
            byte[] enBytes = cipher.doFinal(plainText);   
    
           //通过密钥字符串得到密钥   
            publicKey = getPublicKey(publicKeyString);   
            privateKey = getPrivateKey(privateKeyString);   
    
            //解密   
            cipher.init(Cipher.DECRYPT_MODE, privateKey);   
            byte[]deBytes = cipher.doFinal(enBytes);   
    
            publicKeyString = getKeyString(publicKey);   
            System.out.println("public:\n" +publicKeyString);   
    
            privateKeyString = getKeyString(privateKey);   
            System.out.println("private:\n" + privateKeyString);   
    
            String s = new String(deBytes);   
            System.out.println(s);   
    
    
      }   
    
}   

在实际开发中！ 我们通过自己的modulus ,publicExponent 这两个是用户加密产生public key 而 privateExponet 用于产生private key  来开发的情况比较多。 

 

try{  
XmlPullParser parser = XmlPullParserFactory.newInstance()  
.newPullParser();  
 xpp.setInput( new StringReader ( xml string ) );  
parser.next();  
parser.require(XmlPullParser.START_TAG, null, “statuses”);  
while (parser.nextTag() != XmlPullParser.END_TAG) {  
parser.require(XmlPullParser.START_TAG, null, “status”);  
for (int i=0;i<3;i++){  
parser.nextTag();  
Log.v(“tag”,parser.getName()+”=”+ parser.nextText());  
}  
while (parser.nextTag() != XmlPullParser.END_TAG) {  
parser.require(XmlPullParser.START_TAG, null, “user”);  
while (parser.nextTag() != XmlPullParser.END_TAG) {  
String name = parser.getName();  
String text2 = parser.nextText();  
Log.v(“tag”,”text2″+text2);  
parser.require(XmlPullParser.END_TAG, null, name);  
}  
parser.require(XmlPullParser.END_TAG, null, “user”);  
}  
parser.require(XmlPullParser.END_TAG, null, “status”);  
}  
parser.require(XmlPullParser.END_TAG, null, “statuses”);  
parser.next();  
parser.require(XmlPullParser.END_DOCUMENT, null, null);  
// global.userinfo.dump();  
} catch (XmlPullParserException e) {  
} catch (Exception e) {  
}  

import java.math.BigInteger;   
  
import java.security.KeyFactory;   
  
import java.security.PrivateKey;   
  
import java.security.PublicKey;   
  
import java.security.spec.RSAPrivateKeySpec;   
  
import java.security.spec.RSAPublicKeySpec;   
  
    
  
import javax.crypto.Cipher;   
  
    
  
public class RsaKey {   
  
    
  
      public PublicKey getPublicKey(String modulus,String publicExponent) throws Exception {   
  
            BigInteger m = new BigInteger(modulus);   
  
            BigInteger e = new BigInteger(publicExponent);   
  
            RSAPublicKeySpec keySpec = new RSAPublicKeySpec(m,e);   
  
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");     
            PublicKey publicKey = keyFactory.generatePublic(keySpec);   
  
            return publicKey;   
  
      }   
  
    
  
      public PrivateKey getPrivateKey(String modulus,String privateExponent) throws Exception {   
  
            BigInteger m = new BigInteger(modulus);   
  
            BigInteger e = new BigInteger(privateExponent);   
  
            RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(m,e);   
  
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");   
  
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);   
  
            return privateKey;   
  
      }   
  
    
  
      public static void main(String[] args) throws Exception {   
  
            String modulus = "10103166745709600780215616551837697832816413714471062522342538060943596036859967333870827790358555455232243383580565187280643159050869924436081447583051139";   
  
            String publicExponent = "65537";   
  
            String privateExponet = "367979294475011322800474185715497882523349856362702385535371444397399388741997039894583483410120364529325888461124714276674612930833020362278754665756193";   
  
    
  
            RsaKey key = new RsaKey();   
  
            PublicKey publicKey = key.getPublicKey(modulus, publicExponent);   
  
            PrivateKey privateKey = key.getPrivateKey(modulus, privateExponet);   
  
    
  
    
  
            //加解密类   
  
            Cipher cipher = Cipher.getInstance("RSA");   //"RSA/ECB/PKCS1Padding"   就是：“算法/工作模式/填充模式”
  
    
  
            //明文   
  
            byte[] plainText = "hello world !".getBytes();   
  
    
  
            //加密   
  
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);   
  
        byte[] enBytes = cipher.doFinal(plainText);   
  
    
  
    
  
        cipher.init(Cipher.DECRYPT_MODE, privateKey);   
  
            byte[]deBytes = cipher.doFinal(enBytes);   
  
    
  
            String s = new String(deBytes);   
  
            System.out.println(s);   
  
    
  
      }   
   
}                               

最里面那个可以满足 <user>也是循环. 如果<user>不循环.

可以使用.

for (int i=0;i<3;i++){  
parser.nextTag();  
Log.v(“tag”,parser.getName()+”=”+ parser.nextText());  
}