License文件生成原理

License是什么

如果你有一个产品，希望有权限的用户才可以访问，此时发布一个许可证给用户，就能控制权限了。license是一种商业模式，用户通过购买产品软件，获取license就可以使用。

实现方案

license通过认证和鉴权实现管控，认证指识别用户身份信息，鉴权指校验用户具有哪些功能权限信息；

认证实现方式：可以分为离线和在线，对于在线认证的实现方案，实现一个登录方案，通过账号和密码验证合法即可；离线一般通过绑定软件的机器码或者发放一个序列号实现。

鉴权实现方式：对于用户拥有的权限或者相应功能等信息加密后存放license文件中，在产品软件加载时校验。鉴权实现方式通常使用可逆的加密算法，例如：RSA非对称算法，授权公钥，校验时通过私钥解密。

实现代码

简单实现案例如下：

public class SecretTest {

    public static void main(String[] args) {
        KeyGenerater keyGenerater = new KeyGenerater();
        keyGenerater.generater();
        String plainText = "ASDFGHJklsghj%%@##$%^&";
        byte[] pubKey = keyGenerater.getPubKey();
        byte[] signText = Signaturer.sign(keyGenerater.getPriKey(), plainText);
        boolean isOk = SignProvider.verify(pubKey, plainText, signText);
        System.out.println(isOk);
    }


    private static final String ALGORITHM_RSA = "RSA";
    private static final String ALGORITHM_MD5_RSA = "MD5withRSA";

    static class SignProvider {
        private SignProvider(){

        }

        public static boolean verify(byte[] pubKeyText, String plainText, byte[] signText){

            try {
                // 解密由base64编码的公钥,并构造X509EncodedKeySpec对象
                X509EncodedKeySpec bobPubKeySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(pubKeyText));

                // RSA 对称加密算法
                KeyFactory factory = KeyFactory.getInstance(ALGORITHM_RSA);

                // 取出公钥对象
                PublicKey pubKey = factory.generatePublic(bobPubKeySpec);

                // 解密base64 编码的数字签名
                byte[] signed = Base64.getDecoder().decode(signText);
                Signature signature = Signature.getInstance(ALGORITHM_MD5_RSA);
                signature.initVerify(pubKey);
                signature.update(plainText.getBytes());

                // 验证签名是否正常
                if(signature.verify(signed)){
                    return true;
                }else{
                    return false;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return false;
        }
    }

    static class Signaturer {

        public static byte[] sign(byte[] priKeyText, String plainText){

            try {
                PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(priKeyText));
                KeyFactory factory = KeyFactory.getInstance(ALGORITHM_RSA);

                PrivateKey prikey = factory.generatePrivate(priPKCS8);

                // 用私钥 对信息生成数字签名
                Signature signature = Signature.getInstance(ALGORITHM_MD5_RSA);
                signature.initSign(prikey);
                signature.update(plainText.getBytes());

                byte[] signed = Base64.getEncoder().encode(signature.sign());
                return signed;
            } catch (Exception e) {
                e.printStackTrace();
            }

            return null;
        }

    }

    /**
     * 生成公钥
     */
    static class KeyGenerater {

        private static final String RANDOM_STR = "www.baidu.com";
        private byte[] priKey;
        private byte[] pubKey;

        public void generater(){
            try {
                KeyPairGenerator keyGen = KeyPairGenerator.getInstance(ALGORITHM_RSA);
                SecureRandom secrand = new SecureRandom();
                secrand.setSeed(RANDOM_STR.getBytes()); // 初始化随机产生器

                keyGen.initialize(1024, secrand);

                KeyPair keyPair = keyGen.genKeyPair();

                PublicKey pubkey = keyPair.getPublic();
                PrivateKey prikey = keyPair.getPrivate();

                pubKey = Base64.getEncoder().encode(pubkey.getEncoded());
                priKey = Base64.getEncoder().encode(prikey.getEncoded());
                System.out.println("pubKey = " + new String(pubKey));
                System.out.println("priKey = " + new String(priKey));
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
        }

        public byte[] getPriKey(){
            return priKey;
        }

        public byte[] getPubKey(){
            return pubKey;
        }
    }
}