类GPT调用key的生成与验证

2023-10-29

像Chat-GPT服务，接口鉴权就使用一个简单的Key，而不使用appId和appKey的模式。那这个key到底有什么神奇之处呢？为什么可以鉴权呢？

这个key是根据复杂的规则生成的，随便修改一个或几个字母是不可能有效的，甚至不知道规则的暴力破解也不奏效。

现在，我也需要生成一个类似的key，这个key能提供给用户离线使用，封装进程序，用户在不能破解应用源代码的前提下，必须使用这个key才能使用离线应用。

自定义key的生成规则，详见下文代码。

KeyHelper

KeyHelper提供生成和验证key的方法

import com.btsi.bcos.base.utils.Calc256HashUtil;
import com.btsi.bcos.base.utils.UuidGenerateUtil;
import lombok.extern.slf4j.Slf4j;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 密钥生成验证 Helper
 * @date 2023/9/18 5:21 PM
 */
@Slf4j
public class KeyHelper {

    /**
     * 生成密钥key
     *
     * <p> 生成规则如下
     *
     * <p>（0）xxxx-
     *
     * <p>（1）UID8位1
     *
     * <p>（2）UID8位2
     *
     * <p>（3）（1）和（2）交叉，SHA-256前4位+SHA-256后4位
     *
     * <p>（4）（1）+（3）+（2），SHA-256前1-9位
     *
     * <p>（5）（0）+（1）+（2）+（4）+（3），SHA-256后2-10位
     *
     * @return 密钥
     */
    public static String generateKey() {

        // 定义StringBuilder
        StringBuilder stringBuilder = new StringBuilder();

        // 定义（0）
        String zeroStr = "xxxx-";

        // 定义第一个8位
        String firstUid = UuidGenerateUtil.generateShortUuid(8);
        // 定义第二个8位
        String secondUid = UuidGenerateUtil.generateShortUuid(8);

        // 计算第三段
        // 1和2交叉
        StringBuilder firstAndSecond = new StringBuilder();
        // 遍历交叉
        for (int i = 0; i < firstUid.length(); i++) {
            firstAndSecond.append(firstUid.charAt(i)).append(secondUid.charAt(i));
        }
        // SHA256的值
        String firstAndSecondStrHash = Calc256HashUtil.calc256HashByStr(firstAndSecond.toString());
        // 取前四位和后四位
        String thirdStr =
                firstAndSecondStrHash.substring(0, 4)
                        + firstAndSecondStrHash.substring(firstAndSecondStrHash.length() - 4);

        // 计算第四段
        // 拼接需要哈希的字符串
        String fourthWaitHashStr = firstUid + thirdStr + secondUid;
        // 计算Hash
        String fourthStrHash = Calc256HashUtil.calc256HashByStr(fourthWaitHashStr);
        // 取1-9位
        String fourthStr = fourthStrHash.substring(1, 9);

        // 计算第六段
        // 拼接需要哈希的字符串
        String sixthWaitHashStr = zeroStr + firstUid + secondUid + fourthStr + thirdStr;
        // 计算hash
        String sixthStrHash = Calc256HashUtil.calc256HashByStr(sixthWaitHashStr);
        // 取2-10位
        String sixthStr = sixthStrHash.substring(2, 10);

        // 追加StringBuilder
        stringBuilder
                .append(zeroStr)
                .append(firstUid)
                .append(secondUid)
                .append(thirdStr)
                .append(fourthStr)
                .append(sixthStr);

        // 返回key
        return stringBuilder.toString();
    }

    /**
     * 验证密钥
     *
     * @return 验证结果
     */
    public static Boolean verifyKey(String key) {

        // 校验长度
        if (key.length() != 45) {
            log.error("密钥校验失败");
            return false;
        }

        // 定义（0）
        String zeroRealStr = "xxxx-";

        // 取出zeroStr
        String zeroStr = key.substring(0, 5);
        // 校验zeroStr
        if (!zeroRealStr.equals(zeroStr)) {
            log.error("密钥校验失败");
            return false;
        }

        // 取出第一个8位
        String firstUid = key.substring(5, 13);
        // 取出第二个8位
        String secondUid = key.substring(13, 21);
        // 取出第三个8位
        String thirdStr = key.substring(21, 29);
        // 取出第四个8位
        String fourthStr = key.substring(29, 37);
        // 取出第五个8位
        String sixthStr = key.substring(37, 45);

        // 计算第三段
        // 1和2交叉
        StringBuilder firstAndSecond = new StringBuilder();
        // 遍历交叉
        for (int i = 0; i < firstUid.length(); i++) {
            firstAndSecond.append(firstUid.charAt(i)).append(secondUid.charAt(i));
        }
        // SHA256的值
        String firstAndSecondStrHash = Calc256HashUtil.calc256HashByStr(firstAndSecond.toString());
        // 取前四位和后四位
        String thirdRealStr =
                firstAndSecondStrHash.substring(0, 4)
                        + firstAndSecondStrHash.substring(firstAndSecondStrHash.length() - 4);
        // 校验第三段
        if (!thirdRealStr.equals(thirdStr)) {
            log.error("密钥校验失败");
            return false;
        }

        // 计算第四段
        // 拼接需要哈希的字符串
        String fourthWaitHashStr = firstUid + thirdRealStr + secondUid;
        // 计算Hash
        String fourthStrHash = Calc256HashUtil.calc256HashByStr(fourthWaitHashStr);
        // 取1-9位
        String fourthRealStr = fourthStrHash.substring(1, 9);
        // 校验第四段
        if (!fourthRealStr.equals(fourthStr)) {
            log.error("密钥校验失败");
            return false;
        }

        // 计算第六段
        // 拼接需要哈希的字符串
        String sixthWaitHashStr =
                zeroRealStr + firstUid + secondUid + fourthRealStr + thirdRealStr;
        // 计算hash
        String sixthStrHash = Calc256HashUtil.calc256HashByStr(sixthWaitHashStr);
        // 取2-10位
        String sixthRealStr = sixthStrHash.substring(2, 10);
        // 校验第六段
        if (!sixthRealStr.equals(sixthStr)) {
            log.error("密钥校验失败");
            return false;
        }

        // 校验成功
        return true;
    }
}

Calc256HashUtil

import lombok.extern.slf4j.Slf4j;

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 计算哈希值工具类——SHA256
 * @date 2023/8/16 8:47 PM
 */
@Slf4j
public class Calc256HashUtil {

    /**
     * 计算字符串的哈希值
     *
     * @param str 字符串
     * @return 哈希值
     */
    public static String calc256HashByStr(String str) {

        return encrypt(str);
    }

    /**
     * 计算字符串的哈希值
     *
     * @param input 字符串
     * @return 哈希值
     */
    public static String encrypt(String input) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest(input.getBytes(StandardCharsets.UTF_8));
            return bytesToHex(hash);
        } catch (NoSuchAlgorithmException e) {
            log.error("无法找到SHA-256算法", e);
            return null;
        }
    }

    /**
     * 将字节数组转换为十六进制字符串
     *
     * @param bytes 字节数组
     * @return 十六进制字符串
     */
    private static String bytesToHex(byte[] bytes) {
        StringBuilder hexString = new StringBuilder();
        for (byte b : bytes) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }
        return hexString.toString();
    }
}

UuidGenerateUtil

import java.util.UUID;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description UUID工具类
 * @date 2023/9/10 9:58 PM
 */
public class UuidGenerateUtil {

    public static String[] chars =
            new String[] {
                "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q",
                "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7",
                "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O",
                "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"
            };

    /**
     * 生成短UUID
     *
     * @param length 长度
     * @return 短UUID
     */
    public static String generateShortUuid(Integer length) {
        StringBuilder shortBuffer = new StringBuilder();
        String uuid = UUID.randomUUID().toString().replace("-", "");
        for (int i = 0; i < length; i++) {
            String str = uuid.substring(i * 4, i * 4 + 4);
            int x = Integer.parseInt(str, 16);
            shortBuffer.append(chars[x % 0x3E]);
        }
        return shortBuffer.toString();
    }
}

KeyServiceImpl

import com.btsi.bcos.base.key.KeyHelper;
import com.btsi.bcos.biz.key.model.resp.GenerateKeyResp;
import com.btsi.bcos.biz.key.service.KeyService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2023/9/18 6:25 PM
 */
@Slf4j
@Service
public class KeyServiceImpl implements KeyService {

    @Override
    public GenerateKeyResp generateKeyResp() {

        // 生成密钥
        String key = KeyHelper.generateKey();

        // 验证key
        Boolean verifyResult = KeyHelper.verifyKey(key);
        // 验证不成功
        if (Boolean.FALSE.equals(verifyResult)) {
            log.error("密钥验证失败！");
            return GenerateKeyResp.builder().build();
        }

        // 验证成功返回key
        return GenerateKeyResp.builder().key(key).build();
    }
}