RAS非对称加密解密，公钥私钥

package com.test;

import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
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 java.util.HashMap;
import java.util.Map;
import javax.crypto.Cipher;
import org.apache.commons.codec.binary.Base64;

public class RSAsecurity {
    
    public static Map<String,String> getKeyint length){
        try {
            //1.初始化秘钥
            
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance"RSA");
        
            //秘钥长度
            keyPairGenerator.initializelength);
            //初始化秘钥对
            KeyPair keyPair = keyPairGenerator.generateKeyPair);
            //公钥
            RSAPublicKey rsaPublicKey = RSAPublicKey) keyPair.getPublic);
            //私钥
            RSAPrivateKey rsaPrivateKey = RSAPrivateKey) keyPair.getPrivate);
            
            byte[] publicKeyByte = rsaPublicKey.getEncoded);
            
            byte[] privateKeyByte = rsaPrivateKey.getEncoded);
            
            String publicKey = Base64.encodeBase64StringpublicKeyByte);
            
            String privateKey = Base64.encodeBase64StringprivateKeyByte);
            
            Map<String,String> map = new HashMap<String,String>);
            
            map.put"publicKey", publicKey);
            
            map.put"privateKey", privateKey);
            
            return map;
        
        } catch NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace);
        }
        return new HashMap<String,String>);
    }
    
    public static void mainString[] args) {
        //Map<String,String> map = RSAsecurity.getKey1024);
        //System.out.printlnmap.get"publicKey"));
        RSAsecurity.pubENpriDE);
        //System.out.println"---");
    }
    
    /*RSA 工具类。提供加密，解密，生成密钥对等方法。 
    RSA加密原理概述   
    RSA的安全性依赖于大数的分解，公钥和私钥都是两个大素数（大于100的十进制位）的函数。
    据猜测，从一个密钥和密文推断出明文的难度等同于分解两个大素数的积   
    密钥的产生：   
    1.选择两个大素数 p,q ,计算 n=p*q;   
    2.随机选择加密密钥 e ,要求 e 和 p-1)*q-1)互质   
    3.利用 Euclid 算法计算解密密钥 d , 使其满足 e*d = 1modp-1)*q-1)) 其中 n,d 也要互质)   
    4:至此得出公钥为 n,e) 私钥为 n,d)   
    RSA速度   
    * 由于进行的都是大数计算，使得RSA最快的情况也比DES慢上100倍，无论 是软件还是硬件实现。   
    * 速度一直是RSA的缺陷。一般来说只用于少量数据 加密。*/
    
    public static void priENpubDE) {
        String src="RSA%20加密字符串";
        try {
            //1.初始化秘钥
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance"RSA");
            //秘钥长度
            keyPairGenerator.initialize1024);
            //初始化秘钥对
            KeyPair keyPair = keyPairGenerator.generateKeyPair);
            //公钥
            RSAPublicKey rsaPublicKey = RSAPublicKey) keyPair.getPublic);
            String publicKeyStr = Base64.encodeBase64StringrsaPublicKey.getEncoded));
            //私钥
            RSAPrivateKey rsaPrivateKey = RSAPrivateKey) keyPair.getPrivate);
            String privateKeyStr = Base64.encodeBase64StringrsaPrivateKey.getEncoded));
            
            //2.私钥加密，公钥解密----加密
            //生成私钥
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpecBase64.decodeBase64privateKeyStr));
            KeyFactory keyFactory =KeyFactory.getInstance"RSA");
            PrivateKey privateKey = keyFactory.generatePrivatepkcs8EncodedKeySpec);
            //Cipher类为加密和解密提供密码功能，通过getinstance实例化对象
            Cipher cipher =Cipher.getInstance"RSA");
            //初始化加密
            cipher.initCipher.ENCRYPT_MODE,privateKey);
            byte[] result = cipher.doFinalsrc.getBytes));
            System.out.println"私钥加密，公钥解密----加密:"+Base64.encodeBase64Stringresult));
            
            //3.私钥加密，公钥解密----解密
            //生成公钥
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpecBase64.decodeBase64publicKeyStr));
            keyFactory=KeyFactory.getInstance"RSA");
            PublicKey publicKey= keyFactory.generatePublicx509EncodedKeySpec);
            cipher = Cipher.getInstance"RSA");
            //初始化解密
            cipher.initCipher.DECRYPT_MODE,publicKey);
            result = cipher.doFinalresult);
            System.out.println"私钥加密，公钥解密----解密:"+new Stringresult));
        } catch Exception e) {
            e.printStackTrace);
        }
    }
    
    public static void pubENpriDE) {
        String src="RSA%20加密字符串";
        try {
            //1.初始化秘钥
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance"RSA");
            //秘钥长度
            keyPairGenerator.initialize512);
            //初始化秘钥对
            KeyPair keyPair = keyPairGenerator.generateKeyPair);
            //公钥
            RSAPublicKey rsaPublicKey = RSAPublicKey) keyPair.getPublic);
            //私钥
            RSAPrivateKey rsaPrivateKey = RSAPrivateKey) keyPair.getPrivate);
            
            //2.公钥加密，私钥解密----加密
            X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpecrsaPublicKey.getEncoded));
            KeyFactory keyFactory = KeyFactory.getInstance"RSA");
            PublicKey publicKey = keyFactory.generatePublicx509EncodedKeySpec);
            //初始化加密
            //Cipher类为加密和解密提供密码功能，通过getinstance实例化对象
            Cipher cipher =Cipher.getInstance"RSA");
            cipher.initCipher.ENCRYPT_MODE,publicKey);
            //加密字符串
            byte[] result = cipher.doFinalsrc.getBytes));
            System.out.println"公钥加密，私钥解密----加密:"+Base64.encodeBase64Stringresult));

            //3.公钥加密，私钥解密-----解密
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpecrsaPrivateKey.getEncoded));     
            keyFactory=KeyFactory.getInstance"RSA");
            PrivateKey  privateKey = keyFactory.generatePrivatepkcs8EncodedKeySpec);
            //初始化解密
            cipher.initCipher.DECRYPT_MODE, privateKey);
            //解密字符串
            result = cipher.doFinalresult);
            System.out.println"公钥加密，私钥解密-----解密:"+new Stringresult));
        } catch Exception e) {
            e.printStackTrace);
        }
    }
}