gemlite.core.util.RSAUtils.java Source code

Java tutorial

Introduction

Here is the source code for gemlite.core.util.RSAUtils.java

Source

/*                                                                         
 * Copyright 2010-2013 the original author or authors.                     
 *                                                                         
 * Licensed under the Apache License, Version 2.0 (the "License");         
 * you may not use this file except in compliance with the License.        
 * You may obtain a copy of the License at                                 
 *                                                                         
 *      http://www.apache.org/licenses/LICENSE-2.0                         
 *                                                                         
 * Unless required by applicable law or agreed to in writing, software     
 * distributed under the License is distributed on an "AS IS" BASIS,       
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and     
 * limitations under the License.                                          
 */
package gemlite.core.util;

import gemlite.core.internal.support.context.GemliteContext;
import gemlite.core.util.LogUtil;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
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.Date;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

import org.apache.commons.lang.StringUtils;

/**
 * <p>
 * RSA/?/??
 * </p>
 * <p>
 * ?Ron [R]ivest??Adi [S]hamirLeonard [A]dleman
 * </p>
 * <p>
 * ?BASE64??<br/>
 * ????<br/>
 * ????????
 * </p>
 * 
 * @author gsong
 * @date 2015-08-18
 * @version 1.0
 */
public class RSAUtils {

    /**
     * RSA
     */
    public static final String KEY_ALGORITHM = "RSA";

    /**
     * ??
     */
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

    /**
     * ?key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";

    /**
     * ??key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    /**
     * RSA?
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

    /**
     * RSA?
     */
    private static final int MAX_DECRYPT_BLOCK = 128;

    /**
     * <p>
     * ?(?)
     * </p>
     * 
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(512);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    /**
     * <p>
     * ?????
     * </p>
     * 
     * @param data
     *          ?
     * @param privateKey
     *          ?(BASE64?)
     * 
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateK);
        signature.update(data);
        return Base64Utils.encode(signature.sign());
    }

    /**
     * <p>
     * ??
     * </p>
     * 
     * @param data
     *          ?
     * @param publicKey
     *          (BASE64?)
     * @param sign
     *          ??
     * 
     * @return
     * @throws Exception
     * 
     */
    public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PublicKey publicK = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicK);
        signature.update(data);
        return signature.verify(Base64Utils.decode(sign));
    }

    /**
     * <P>
     * ?
     * </p>
     * 
     * @param encryptedData
     *          ?
     * @param privateKey
     *          ?(BASE64?)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // ?
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /**
     * <p>
     * 
     * </p>
     * 
     * @param encryptedData
     *          ?
     * @param publicKey
     *          (BASE64?)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData, 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);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // ?
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /**
     * <p>
     * 
     * </p>
     * 
     * @param data
     *          ??
     * @param publicKey
     *          (BASE64?)
     * @return
     * @throws Exception
     */
    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);
        // ?
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        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;
    }

    /**
     * <p>
     * ?
     * </p>
     * 
     * @param data
     *          ??
     * @param privateKey
     *          ?(BASE64?)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        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;
    }

    /**
     * <p>
     * ??
     * </p>
     * 
     * @param keyMap
     *          
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return Base64Utils.encode(key.getEncoded());
    }

    /**
     * <p>
     * ?
     * </p>
     * 
     * @param keyMap
     *          
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return Base64Utils.encode(key.getEncoded());
    }

    /**
     * ?key?
     * @param filePath
     * @return
     */
    public static String readKey(String filePath) {
        StringBuilder sb = new StringBuilder();
        File file = new File(filePath);
        if (file.exists() && file.isFile())
            try {
                InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(file), "gbk");
                BufferedReader reader = new BufferedReader(inputStreamReader);
                String nextLine;
                while ((nextLine = reader.readLine()) != null) {
                    sb.append(nextLine);
                }
            } catch (Exception e) {
                LogUtil.getCoreLog().warn("readKey file :{} failure :{}", filePath, e);
            }
        return sb.toString();
    }

    /**
     * ?key?
     * @param filePath
     * @return
     */
    public static String writeKey(String filePath, String content) {
        StringBuilder sb = new StringBuilder();
        File file = new File(filePath);
        try {
            String charsetName = "utf-8";
            OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(file), charsetName);
            BufferedWriter pw = new BufferedWriter(writer);
            pw.write(content);
            pw.close();
        } catch (Exception e) {
            LogUtil.getCoreLog().warn("writeKey file :{} failure :{}", filePath, e);
        }
        return sb.toString();
    }

    public static byte[] readBytes(String filePath) {
        byte[] content = new byte[0];
        File file = new File(filePath);
        if (file.exists() && file.isFile())
            try {
                InputStream in = new FileInputStream(file);
                BufferedInputStream bufin = new BufferedInputStream(in);
                int buffSize = 1024;
                ByteArrayOutputStream out = new ByteArrayOutputStream(buffSize);
                byte[] temp = new byte[buffSize];
                int size = 0;
                while ((size = bufin.read(temp)) != -1) {
                    out.write(temp, 0, size);
                }
                bufin.close();
                content = out.toByteArray();
            } catch (Exception e) {
                LogUtil.getCoreLog().warn("readKey file :{} failure :{}", filePath, e);
            }
        return content;
    }

    /**
     * ?key?
     * @param filePath
     * @return
     */
    public static String writeBytes(String filePath, byte[] content) {
        StringBuilder sb = new StringBuilder();
        File file = new File(filePath);
        if (file.exists())
            file.delete();
        try {
            FileOutputStream out = new FileOutputStream(file);
            out.write(content);
            out.close();
        } catch (Exception e) {
            LogUtil.getCoreLog().warn("writeBytes file :{} failure :{}", filePath, e);
        }
        return sb.toString();
    }

    public static boolean checkLicense() {
        String pubFile = RSAUtils.class.getClassLoader().getResource("public.key").getPath();
        String license = RSAUtils.class.getClassLoader().getResource("license.store").getPath();
        String publicKey = RSAUtils.readKey(pubFile);
        long today = DateUtil.today();
        try {
            byte[] encoded = RSAUtils.readBytes(license);
            byte[] decodedData = RSAUtils.decryptByPublicKey(encoded, publicKey);
            String dd = new String(decodedData);
            if (StringUtils.equals(dd, "dev"))
                return true;
            long d = DateUtil.toLong(dd);

            if (d < today) {
                LogUtil.getCoreLog().error("License expired at :{}", new Date(d));
                return false;
            }
            //???30??
            if (d < (today + 30 * 24 * 60 * 60 * 1000L)) {
                LogUtil.getCoreLog().warn("License will expired at :{}", new Date(d));
            }
        } catch (Exception e) {
            LogUtil.getCoreLog().error("License error:{}", e);
            return false;
        }
        return true;
    }
}