RSA非对称加密方式

记录一下所学到的东西，不一定适合各种情况，因为架构的原因所以使用了jfinal的两个包，可以参考一下。

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 org.apache.commons.codec.binary.Base64;

import com.jfinal.kit.StrKit;
import com.jfinal.plugin.redis.Redis;

public class RSAtool {
/**
     * 生成密钥对
     * @throws Exception
     */
    public static void generatorKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(ALGORITHM_RSA);
        keyPairGen.initialize(1024);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
        byte[] keyBs = rsaPublicKey.getEncoded();
        String publicKey = encodeBase64(keyBs);
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
        keyBs = rsaPrivateKey.getEncoded();
        String privateKey = encodeBase64(keyBs);

        Redis.use().set("fp_publicKey", publicKey);
        Redis.use().set("fp_privateKey", privateKey);
    }

    /**
     * 获取公钥
     * @return
     * @throws Exception
     */
    public static PublicKey getPublicKey() throws Exception {
        X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(decodeBase64(getPublicKeyValue()));
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);
        return keyFactory.generatePublic(publicKeySpec);
    }

    public static String getPublicKeyValue() throws Exception {
        String publicKey = Redis.use().get("fp_publicKey");
        if (StrKit.isBlank(publicKey)) {
            generatorKeyPair();
        }
        return Redis.use().get("fp_publicKey");
    }

    public static String getPrivateKeyValue() throws Exception {
        String publicKey = Redis.use().get("fp_privateKey");
        if (StrKit.isBlank(publicKey)) {
            generatorKeyPair();
        }
        return Redis.use().get("fp_privateKey");
    }

    /**
     * 获取私钥
     * @return
     * @throws Exception
     */
    public static PrivateKey getPrivateKey() throws Exception {
        PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(decodeBase64(getPrivateKeyValue()));
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);
        return keyFactory.generatePrivate(privateKeySpec);
    }

    /**
     * 公钥加密
     * @param data
     * @return
     * @throws Exception
     */
    public static String encryptionByPublicKey(String source) throws Exception{
        PublicKey publicKey = getPublicKey();
        Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        cipher.update(source.getBytes("UTF-8"));
        String target = encodeBase64(cipher.doFinal());
        System.out.println("公钥加密后的数据：\r\n" + target);
        return target;
    }

    /**
     * 私钥解密
     * @param target
     * @throws Exception
     */
    public static String decryptionByPrivateKey(String target) throws Exception {
        PrivateKey privateKey = getPrivateKey();
        Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        cipher.update(decodeBase64(target));
        String source = new String(cipher.doFinal(), "UTF-8");
        return source;
    }
    /**
     * base64编码
     * @param source
     * @return
     * @throws Exception
     */
    public static String encodeBase64(byte[] source) throws Exception{
        return new String(Base64.encodeBase64(source), "UTF-8");
    }

    /**
     * Base64解码
     * @param target
     * @return
     * @throws Exception
     */
    public static byte[] decodeBase64(String target) throws Exception{
        return Base64.decodeBase64(target.getBytes("UTF-8"));
    }
}