/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package javaapplication1;

import java.io.ByteArrayOutputStream;

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.Signature;

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;

/**

 *

 * @author jk

 */

public class RSAUtils {

    /**

     * 加密算法RSA

     */

    public static final String KEY_ALGORITHM = "RSA";

     //  public static final String ECB_PKCS1_PADDING = "RSA";//加密填充方式

      public static final String ECB_PKCS1_PADDING = "RSA/ECB/PKCS1Padding";//加密填充方式

       private static final int _rsa_keysize = 1024;

    /**

     * RSA最大加密明文大小,keysize=1024, (1024/8)-11=117

     */

    private static final int MAX_ENCRYPT_BLOCK = (_rsa_keysize/8)-11;

    public static final String _charset = "UTF-8";

    public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {

        byte[] keyBytes = Base64Utils.decode(publicKey);

        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

        Key publicK = keyFactory.generatePublic(x509KeySpec);

        // 对数据加密

        String getAgorithm = keyFactory.getAlgorithm();

        getAgorithm = ECB_PKCS1_PADDING;

        Cipher cipher = Cipher.getInstance(getAgorithm);

        cipher.init(Cipher.ENCRYPT_MODE, publicK);

        int inputLen = data.length;

        ByteArrayOutputStream out = new ByteArrayOutputStream();

        int offSet = 0;

        byte[] cache;

        int i = 0;

        // 对数据分段加密

        while (inputLen - offSet > 0) {

            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {

                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);

            } else {

                cache = cipher.doFinal(data, offSet, inputLen - offSet);

            }

            out.write(cache, 0, cache.length);

            i++;

            offSet = i * MAX_ENCRYPT_BLOCK;

        }

        byte[] encryptedData = out.toByteArray();

        out.close();

        return encryptedData;

    }

    /**

     * java端公钥加密

     */

    public static String encryptedDataOnJava(String data, String PUBLICKEY) {

        try {

            data = Base64Utils.encode(encryptByPublicKey(data.getBytes(_charset), PUBLICKEY));

        } catch (Exception e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        return data;

    }

}

package javaapplication1;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.OutputStream;

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

/**

 *  */

/**

 * <p>

 * BASE64编码解码工具包

 * </p>

 * <p>

 * 依赖javabase64-1.3.1.jar

 * </p>

 *

 * @author IceWee

 * @date 2012-5-19

 * @version 1.0

 */

public class Base64Utils {

    /**

     *      */

    /**

     * 文件读取缓冲区大小

     */

    private static final int CACHE_SIZE = 1024;

    public static final String _charset = "UTF-8";

    /**

     *      */

    /**

     * <p>

     * BASE64字符串解码为二进制数据

     * </p>

     *

     * @param base64

     * @return

     * @throws Exception

     */

    public static byte[] decode(String str) throws Exception {

        Base64 _base64 = new Base64();

        return _base64.decodeBase64(str.getBytes(_charset));

    }

    /**

     *      */

    /**

     * <p>

     * 二进制数据编码为BASE64字符串

     * </p>

     *

     * @param bytes

     * @return

     * @throws Exception

     */

    public static String encode(byte[] bytes) throws Exception {

        Base64 _base64 = new Base64();

        return new String(_base64.encodeBase64Chunked(bytes));

    }

    /**

     *      */

    /**

     * <p>

     * 将文件编码为BASE64字符串

     * </p>

     * <p>

     * 大文件慎用，可能会导致内存溢出

     * </p>

     *

     * @param filePath 文件绝对路径

     * @return

     * @throws Exception

     */

    public static String encodeFile(String filePath) throws Exception {

        byte[] bytes = fileToByte(filePath);

        return encode(bytes);

    }

    /**

     *      */

    /**

     * <p>

     * BASE64字符串转回文件

     * </p>

     *

     * @param filePath 文件绝对路径

     * @param base64 编码字符串

     * @throws Exception

     */

    public static void decodeToFile(String filePath, String base64) throws Exception {

        byte[] bytes = decode(base64);

        byteArrayToFile(bytes, filePath);

    }

    /**

     *      */

    /**

     * <p>

     * 文件转换为二进制数组

     * </p>

     *

     * @param filePath 文件路径

     * @return

     * @throws Exception

     */

    public static byte[] fileToByte(String filePath) throws Exception {

        byte[] data = new byte[0];

        File file = new File(filePath);

        if (file.exists()) {

            FileInputStream in = new FileInputStream(file);

            ByteArrayOutputStream out = new ByteArrayOutputStream(2048);

            byte[] cache = new byte[CACHE_SIZE];

            int nRead = 0;

            while ((nRead = in.read(cache)) != -1) {

                out.write(cache, 0, nRead);

                out.flush();

            }

            out.close();

            in.close();

            data = out.toByteArray();

        }

        return data;

    }

    /**

     *      */

    /**

     * <p>

     * 二进制数据写文件

     * </p>

     *

     * @param bytes 二进制数据

     * @param filePath 文件生成目录

     */

    public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {

        InputStream in = new ByteArrayInputStream(bytes);

        File destFile = new File(filePath);

        if (!destFile.getParentFile().exists()) {

            destFile.getParentFile().mkdirs();

        }

        destFile.createNewFile();

        OutputStream out = new FileOutputStream(destFile);

        byte[] cache = new byte[CACHE_SIZE];

        int nRead = 0;

        while ((nRead = in.read(cache)) != -1) {

            out.write(cache, 0, nRead);

            out.flush();

        }

        out.close();

        in.close();

    }

}