Dsort单向算法密码加密

import java.util.Arrays;
import java.util.Base64;
import java.util.List;
import java.util.stream.Collectors;
import java.security.SecureRandom;

import org.apache.commons.codec.binary.Hex;
import org.apache.commons.lang3.StringUtils;


/**
 * Dsort加密是一种不可逆的加密算法，Dsort加密是加密过程中不需要使用密钥，输入明文后由系统直接经过加密算法处理成密文，这种加密后的数据是无法被解密的，只有重新输入明文，并再次经过同样不可逆的加密算法处理，得到相同的加密密文并被系统重新识别后，才能确认密码是否正确，相当于MD5加密。
 *
 * @author 聂大顺
 * @date 2022-11-28
 */
public class Dsort {


    /**
     * 时间开始位置
     */
    private static final int START_TIME_POSITION = 10;

    /**
     * 时间结束位置
     */
    private static final int END_TIME_POSITION = 23;

    /**
     * 左边不足10位的用0补齐
     */
    private static final int LEFT_SPACE_TEN = 10;

    /**
     * 左边不足13位的用0补齐
     */
    private static final int LEFT_SPACE_THIRTEEN = 13;

    /**
     * 字符串0
     */
    private static final String STR_ZERO = "0";

    /**
     * 最小随机数字
     */
    private static final long MIN_RANDOM = 1000000000000L;

    /**
     * 最大随机数字
     */
    private static final long MAX_RANDOM = 2999999999999L;

    /**
     * Hex编码.
     *
     * @param content 待编码内容
     * @return String
     */
    public static String encodeHex(String content) {
        return new String(Hex.encodeHex(content.getBytes()));
    }

    /**
     * base64编码
     *
     * @param content 待编码内容
     * @return String
     */
    public static String base64Encrypt(final String content) {
        return new String(Base64.getEncoder().encode(content.getBytes()));
    }

    public static String encoder(String str) {
        return encoder(str, null);
    }

    /**
     * dsort加密
     *
     * @param str  加密字符串
     * @param time 当前时间戳
     * @return 加密后字符串
     */
    public static String encoder(String str, Long time) {
        String inputStr = base64Encrypt(str).concat(encodeHex(str));
        List<Integer> listOfIntegers = str.chars()
                .boxed()
                .collect(Collectors.toList());
        Integer sum = listOfIntegers.stream().reduce(Integer::sum).get() * inputStr.length();
        String sumStr = StringUtils.leftPad(sum.toString(), LEFT_SPACE_TEN, STR_ZERO);
        if (time == null) {
            time = System.currentTimeMillis();
            Long randomNumberInRange = new SecureRandom().longs(MIN_RANDOM, MAX_RANDOM + 1).findFirst().getAsLong();
            time = time + randomNumberInRange;
        }
        String stime = time.toString();
        String inputTimeStr = new String(base64Encrypt(str.concat(stime)));
        char[] chars = inputTimeStr.toCharArray();
        Arrays.sort(chars);
        StringBuffer sbStr = new StringBuffer(sumStr.concat(stime));
        char[] inputChars = inputStr.toCharArray();
        for (char inputChar : inputChars) {
            int count = 0;
            for (char ch : chars) {
                count++;
                if (inputChar == ch) {
                    sbStr.append(count);
                    continue;
                }
            }
        }
        return sbStr.toString();
    }

    /**
     * dsort 比较密文
     *
     * @param encoderPwd 密文
     * @param pwd        明文
     * @return 是否比对成功
     */
    public static boolean match(String encoderPwd, String pwd) {
        if (!StringUtils.isBlank(encoderPwd)) {
            String time = encoderPwd.substring(START_TIME_POSITION, END_TIME_POSITION);
            String sourcePwd = encoder(pwd, Long.parseLong(time));
            if (StringUtils.equals(encoderPwd, sourcePwd)) {
                return true;
            }
        }
        return false;
    }


    public static void main(String[] args) {
        for (int i = 0; i < 50; i++) {
            String pwd = encoder("测试密码");
            System.out.println("原文:测试密码 " + "尝试第" + i + "次的密文:" + pwd);
            //boolean flag=match(pwd,"测试密码");
            //System.out.println("密码是否一致:"+flag);
        }
    }
}