非对称加密算法RSA算法组件

package com.demo.test;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
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 java.util.HashMap;
import java.util.Map;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;

import org.apache.commons.codec.binary.Base64;


/**
 * 非对称加密算法RSA算法组件
 *
 */
public class RSAHelper {
    /**非对称密钥RSA算法*/
    public static final String KEY_ALGORITHM = "RSA";

    /**
     * 密钥长度，DH算法的默认密钥长度是1024
     * 密钥长度必须是64的倍数，在512到65536位之间
     */
    private static final int KEY_SIZE = 512;
    /**公钥键值*/
    private static final String PUBLIC_KEY = "RSAPublicKey";

    /**私钥键值*/
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    /**
     * 初始化密钥对
     * @return
     * @throws Exception
     */
    public static Map<String, Object> initKey() throws Exception {
        //实例化密钥生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //初始化密钥生成器
        keyPairGenerator.initialize(KEY_SIZE);
        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //公钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        //私钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        //将密钥存储在map中
        Map<String, Object> keyMap = new HashMap<String, Object>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;

    }


    /**
     * 
     * @param srcBytes
     * @param key
     * @param blockSize
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] srcBytes, byte[] key, int blockSize) throws 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.ENCRYPT_MODE, privateKey);
        byte[] resultBytes = null;
        if(blockSize > 0){
        	resultBytes = cipherDoFinal(cipher, srcBytes, blockSize);
        }else{
        	resultBytes = cipher.doFinal(srcBytes);
        }
        return resultBytes;
    }

    /**
     * 
     * @param srcBytes
     * @param key
     * @param blockSize
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] srcBytes, byte[] key, int blockSize) throws Exception {

        //实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        //密钥材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

        //数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        byte[] resultBytes = null;
        if(blockSize > 0){
        	resultBytes = cipherDoFinal(cipher, srcBytes, blockSize);
        }else{
        	resultBytes = cipher.doFinal(srcBytes);
        }
        return resultBytes;
    }

    /**
     * 
     * @param srcBytes
     * @param key
     * @param blockSize
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] srcBytes, byte[] key, int blockSize) throws 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);
        byte[] resultBytes = null;
        if(blockSize > 0){
        	resultBytes = cipherDoFinal(cipher, srcBytes, blockSize);
        }else{
        	resultBytes = cipher.doFinal(srcBytes);
        }
        return resultBytes;
    }

    /**
     * 
     * @param srcBytes
     * @param key
     * @param blockSize
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] srcBytes, byte[] key, int blockSize) throws Exception {

        //实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        //密钥材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
        //数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, pubKey);
        byte[] resultBytes = null;
        if(blockSize > 0){
        	resultBytes = cipherDoFinal(cipher, srcBytes, blockSize);
        }else{
        	resultBytes = cipher.doFinal(srcBytes);
        }
        return resultBytes;
    }

    /**
     * 
     * @param keyMap
     * @return
     */
    public static byte[] getPrivateKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }

    /**
     * 
     * @param keyMap
     * @return
     * @throws Exception
     */
    public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();
    }
    /**
     * 
     * @param cipher
     * @param srcBytes
     * @param segmentSize
     * @return
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     * @throws IOException
     */
    public static byte[] cipherDoFinal(Cipher cipher, byte[] srcBytes, int segmentSize)
            throws IllegalBlockSizeException, BadPaddingException, IOException {
        if (segmentSize <= 0){
            throw new RuntimeException("分段大小必须大于0");
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int inputLen = srcBytes.length;
        int offSet = 0;
        int i = 0;
        while (inputLen - offSet > 0) {
        	byte[] cache;
            if (inputLen - offSet > segmentSize) {
                cache = cipher.doFinal(srcBytes, offSet, segmentSize);
            } else {
                cache = cipher.doFinal(srcBytes, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * segmentSize;
        }
        byte[] data = out.toByteArray();
        out.close();
        return data;
    }
    
    public static void main(String[] args) throws Exception {
        //初始化密钥
        //生成密钥对
        /*Map<String, Object> keyMap = RSAHelper.initKey();
        //公钥
        byte[] publicKey = RSAHelper.getPublicKey(keyMap);
        //私钥
        byte[] privateKey = RSAHelper.getPrivateKey(keyMap);*/

        String publicKeyStr = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALSP6BrYxB7FghU7OXZfm/OpQP5cj3dmnq0F8iIokbDhSVKeU/yLoZGd4cPie199Mw8C8Rcz80lBO2FIUbO74tUCAwEAAQ==";
        String privateKeyStr = "MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEAtI/oGtjEHsWCFTs5dl+b86lA/lyPd2aerQXyIiiRsOFJUp5T/IuhkZ3hw+J7X30zDwLxFzPzSUE7YUhRs7vi1QIDAQABAkB5+5qPwI/GRiKam1c3vGHMXDT3YqrdvGtIcvLg1s2OU5C5o8B1iMi6S/rOlQw4UYxhFPBSA0naCyO8WEmwoF8FAiEA7nieY73aHCnRU+W0Ch6h0XYCxdtPoILROhGr0c/2t1sCIQDB1ZjMO5BfAyErAlBynx96ZiPUiFC/v1ZUDhVSKnMVjwIgKtekrQqoqrKgltAHvmGudLEc4mr6LT4TVLlkAve3vU0CIQCS658Mtt1AVzPt0Kw/pUML2J2x+70RCiuaPK6GgCyJGwIgLIhcDi8LNmgTvPssgwP5THzCW5frMoRd17e95vYN55k=";
        byte[] publicKey = Base64.decodeBase64(publicKeyStr);
        //私钥
        byte[] privateKey = Base64.decodeBase64(privateKeyStr);
        String str = "["
        		+ "{\"fileName\":\"attpc-6.0.1-dangbei.apk\",\"md5\":\"d87b3b5183f97d9683045f6287ec7778\",\"packageName\":\"com.antutu.tvbenchmark\",\"versionName\":\"6.0.1\",\"versionCode\":\"6000100\"},"
        		+ "{\"fileName\":\"dangbeimarket_4.1.2_znds.apk\",\"md5\":\"0326b2918c27bfc591667456f0d0ec92\",\"packageName\":\"com.dangbeimarket\",\"versionName\":\"4.1.2\",\"versionCode\":\"176\"},"
        		+ "{\"fileName\":\"com.xiaobaifile.tv.apk\",\"md5\":\"5a6c8cf9ef7941d7057e41ecc626f79f\",\"packageName\":\"com.xiaobaifile.tv\",\"versionName\":\"2.8.0\",\"versionCode\":\"45\"}]";
        //str = "乙方向甲方发送数据RSA算法";
        System.out.println("原文:" + str);
        byte[] code1 = RSAHelper.encryptByPrivateKey(str.getBytes(), privateKey,KEY_SIZE / 8 - 11);//注意段的大小
        System.out.println("加密后的数据：" + Base64.encodeBase64String(code1));
        byte[] decode1 = RSAHelper.decryptByPublicKey(code1, publicKey,KEY_SIZE / 8);//注意段的大小
        System.out.println("解密后的数据：" + new String(decode1));

        
    }
}

Java工程需要引用的包：commons-codec-1.9.jar
Android开发需要注意以下问题：
1.commons-codec-1.9.jar是不能直接用在Android应用中，需要用jarjar.jar替换包名后再使用。
java -jar jarjar-1.4.jar process rule.txt commons-codec-1.9.jar his-commons-codec-1.9.jar
2.在Android客户端RSA解密出现部分乱码的问题解决方案：
在客户端获取解密的Cipher类时要使用 Cipher.getInstance(“RSA/ECB/PKCS1Padding”);
在后端使用Cipher.getInstance(“RSA”);来获取.