package org.sxkj.common.utils.license;

import java.math.BigInteger;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

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

public abstract class RSAEnCoder{
public static final String KEY_ALGORITHM = "RSA";
public static final String KEY_PROVIDER = "BC";
public static final String SIGNATURE_ALGORITHM = "SHA1WithRSA";

	/**
	 * 初始化密钥对
	 */
	public static Map<String, Object> initKeys(String seed) throws Exception {
		Map<String, Object> keyMap = new HashMap<String, Object>();
		Security.addProvider(new BouncyCastleProvider());
		KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM, KEY_PROVIDER);

		keyPairGenerator.initialize(1024,new SecureRandom(seed.getBytes()));
		KeyPair pair = keyPairGenerator.generateKeyPair();
		RSAPublicKey rsaPublicKey = (RSAPublicKey) pair.getPublic();
		RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) pair.getPrivate();

		KeyFactory factory = KeyFactory.getInstance(KEY_ALGORITHM,KEY_PROVIDER);
		RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(rsaPublicKey.getModulus().toString()),new BigInteger(rsaPublicKey.getPublicExponent().toString()));
		RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(rsaPrivateKey.getModulus().toString()),new BigInteger(rsaPrivateKey.getPrivateExponent().toString()));

		PublicKey publicKey = factory.generatePublic(pubKeySpec);
		PrivateKey privateKey = factory.generatePrivate(priKeySpec);

		System.out.println("公钥：" + pubKeySpec.getModulus() + "----" + pubKeySpec.getPublicExponent());
		System.out.println("私钥：" + priKeySpec.getModulus() + "----" + priKeySpec.getPrivateExponent());
		keyMap.put("publicKey", publicKey);
		keyMap.put("privateKey", privateKey);

		return keyMap;
	}

	/**
	 * 私钥加密
	 * */
	public static byte[] encryptRSA(byte[] data,PrivateKey privateKey) throws Exception {

		Cipher cipher = Cipher.getInstance(KEY_ALGORITHM,KEY_PROVIDER);
		cipher.init(Cipher.ENCRYPT_MODE, privateKey);
		int dataSize = cipher.getOutputSize(data.length);
		// 获得加密块大小，如：加密前数据为128个byte，
        // 而key_size=1024 加密块大小为127
        // byte
        // ,加密后为128个byte;因此共有2个加密块
        // ，第一个127 byte第二个为1个byte

		int blockSize = cipher.getBlockSize(); // 获得加密块加密后块大小
		int blockNum = 0;
		if (data.length % blockSize == 0) {
			blockNum = data.length / blockSize;
		} else {
			blockNum = data.length / blockSize + 1;
		}
		byte[] raw = new byte[dataSize * blockNum];
		int i = 0;
		while (data.length - i * blockSize > 0) {
			if (data.length - i * blockSize > blockSize) {
				cipher.doFinal(data, i * blockSize, blockSize, raw, i * dataSize);
			} else {
				cipher.doFinal(data, i * blockSize, data.length - i * blockSize, raw, i * dataSize);
			}
			i++;
		}

		return raw;
	}

	/**
	 * 生成数字签名
	 * */
	public static String sign(byte[] encoderData,PrivateKey privateKey) throws Exception {

		Signature sig = Signature.getInstance(SIGNATURE_ALGORITHM,KEY_PROVIDER);
		sig.initSign(privateKey);
		sig.update(encoderData);
		return new String(Base64.encodeBase64(sig.sign()));
	}

	/**
	 * 校验数字签名
	 * */
	public static boolean verify (byte[] encoderData,String sign,PublicKey publicKey) throws Exception {

		Signature sig = Signature.getInstance(SIGNATURE_ALGORITHM,KEY_PROVIDER);
		sig.initVerify(publicKey);
		sig.update(encoderData);
		return sig.verify(Base64.decodeBase64(sign.getBytes()));
	}


	/**
	 * 使用模和指数生成RSA私钥
	 * @param modulus  模
	 * @param exponent  指数
	 * @return
	 */
	public static PrivateKey getPrivateKey(String modulus, String exponent) throws Exception {
	        BigInteger b1 = new BigInteger(modulus);
	        BigInteger b2 = new BigInteger(exponent);
	        Security.addProvider(new BouncyCastleProvider());
	        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM, KEY_PROVIDER);
	        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(b1, b2);
	        return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
	}

}