navicat 密码解密工具，15,16 选择12版本

运行效果

以下java代码 jdk1.8

import javax.crypto.*;
import javax.crypto.spec.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.nio.charset.StandardCharsets;

public class NavicatPasswordGUI {
    private JFrame frame;
    private JComboBox<String> versionComboBox;
    private JTextField originalPasswordTextField;
    private JTextField encryptedPasswordTextField;
    private JTextField decryptedPasswordTextField;

    private String blowKey = "3DC5CA39";
    private byte[] blowIv = hexStringToByteArray("d9c7c3c8870d64bd");
    private String aesKey = "libcckeylibcckey";
    private String aesIv = "libcciv libcciv ";

    public NavicatPasswordGUI() {
        frame = new JFrame("Navicat Password Encryption/Decryption");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 250);
        frame.setLayout(new GridLayout(5, 2));

        JLabel versionLabel = new JLabel("navicat Version:");
        versionComboBox = new JComboBox<>(new String[]{"11", "12"});
        frame.add(versionLabel);
        frame.add(versionComboBox);

        JLabel originalPasswordLabel = new JLabel("Original Password:");
        originalPasswordTextField = new JTextField();
        frame.add(originalPasswordLabel);
        frame.add(originalPasswordTextField);

        JLabel encryptedPasswordLabel = new JLabel("Encrypted Password:");
        encryptedPasswordTextField = new JTextField();
        encryptedPasswordTextField.setEditable(false);
        frame.add(encryptedPasswordLabel);
        frame.add(encryptedPasswordTextField);

        JLabel decryptedPasswordLabel = new JLabel("Decrypted Password:");
        decryptedPasswordTextField = new JTextField();
        frame.add(decryptedPasswordLabel);
        frame.add(decryptedPasswordTextField);

        JButton encryptButton = new JButton("Encrypt");
        frame.add(encryptButton);

        JButton decryptButton = new JButton("Decrypt");
        frame.add(decryptButton);

        encryptButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    int version = Integer.parseInt((String) versionComboBox.getSelectedItem());
                    String originalPassword = originalPasswordTextField.getText();
                    NavicatPassword navicatPassword = new NavicatPassword(version);
                    String encryptedPassword = navicatPassword.encrypt(originalPassword);
                    encryptedPasswordTextField.setText(encryptedPassword);
                } catch (Exception ex) {
                    JOptionPane.showMessageDialog(frame, "Error: " + ex.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
                }
            }
        });

        decryptButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    int version = Integer.parseInt((String) versionComboBox.getSelectedItem());
                    String encryptedPassword = decryptedPasswordTextField.getText();
                    NavicatPassword navicatPassword = new NavicatPassword(version);
                    String decryptedPassword = navicatPassword.decrypt(encryptedPassword);
                    originalPasswordTextField.setText(decryptedPassword);
                } catch (Exception ex) {
                    JOptionPane.showMessageDialog(frame, "Error: " + ex.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
                }
            }
        });

        frame.setVisible(true);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                new NavicatPasswordGUI();
            }
        });
    }

    private byte[] hexStringToByteArray(String s) {
        int len = s.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i + 1), 16));
        }
        return data;
    }
}

class NavicatPassword {
    private int version;
    private String blowKey = "3DC5CA39";
    private byte[] blowIv = hexStringToByteArray("d9c7c3c8870d64bd");
    private String aesKey = "libcckeylibcckey";
    private String aesIv = "libcciv libcciv ";

    public NavicatPassword(int version) {
        this.version = version;
    }

    public String encrypt(String input) throws Exception {
        switch (version) {
            case 11:
                return encryptEleven(input);
            case 12:
                return encryptTwelve(input);
            default:
                throw new IllegalArgumentException("Unsupported version: " + version);
        }
    }

    public String decrypt(String input) throws Exception {
        switch (version) {
            case 11:
                return decryptEleven(input);
            case 12:
                return decryptTwelve(input);
            default:
                throw new IllegalArgumentException("Unsupported version: " + version);
        }
    }

    private String encryptEleven(String input) throws Exception {
        int round = input.length() / 8;
        int leftLength = input.length() % 8;
        StringBuilder result = new StringBuilder();
        byte[] currentVector = blowIv.clone();

        for (int i = 0; i < round; i++) {
            byte[] temp = encryptBlock(xorBytes(input.getBytes(StandardCharsets.UTF_8), currentVector));
            currentVector = xorBytes(currentVector, temp);
            result.append(byteArrayToHexString(temp));
        }

        if (leftLength != 0) {
            currentVector = encryptBlock(currentVector);
            result.append(byteArrayToHexString(xorBytes(input.substring(8 * round).getBytes(StandardCharsets.UTF_8), currentVector)));
        }

        return result.toString().toUpperCase();
    }

    private byte[] encryptBlock(byte[] block) throws Exception {
        Cipher cipher = Cipher.getInstance("Blowfish/ECB/NoPadding");
        SecretKeySpec secretKeySpec = new SecretKeySpec(blowKey.getBytes(StandardCharsets.UTF_8), "Blowfish");
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
        return cipher.doFinal(block);
    }

    private byte[] decryptBlock(byte[] block) throws Exception {
        Cipher cipher = Cipher.getInstance("Blowfish/ECB/NoPadding");
        SecretKeySpec secretKeySpec = new SecretKeySpec(blowKey.getBytes(StandardCharsets.UTF_8), "Blowfish");
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
        return cipher.doFinal(block);
    }

    private byte[] xorBytes(byte[] bytes1, byte[] bytes2) {
        byte[] result = new byte[bytes1.length];
        for (int i = 0; i < bytes1.length; i++) {
            result[i] = (byte) (bytes1[i] ^ bytes2[i]);
        }
        return result;
    }

    private String decryptEleven(String upperString) throws Exception {
        String input = upperString.toLowerCase();
        int round = input.length() / 16;
        int leftLength = input.length() % 16;
        StringBuilder result = new StringBuilder();
        byte[] currentVector = blowIv.clone();

        for (int i = 0; i < round; i++) {
            byte[] encryptedBlock = hexStringToByteArray(input.substring(16 * i, 16 * (i + 1)));
            byte[] temp = xorBytes(decryptBlock(encryptedBlock), currentVector);
            currentVector = xorBytes(currentVector, encryptedBlock);
            result.append(byteArrayToHexString(temp));
        }

        if (leftLength != 0) {
            currentVector = encryptBlock(currentVector);
            result.append(byteArrayToHexString(xorBytes(input.substring(16 * round).getBytes(StandardCharsets.UTF_8), currentVector)));
        }

        return new String(hexStringToByteArray(result.toString()), StandardCharsets.UTF_8);
    }

    private String encryptTwelve(String input) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        SecretKeySpec secretKeySpec = new SecretKeySpec(aesKey.getBytes(StandardCharsets.UTF_8), "AES");
        IvParameterSpec ivSpec = new IvParameterSpec(aesIv.getBytes(StandardCharsets.UTF_8));
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivSpec);
        byte[] encrypted = cipher.doFinal(input.getBytes(StandardCharsets.UTF_8));
        return byteArrayToHexString(encrypted).toUpperCase();
    }

    private String decryptTwelve(String upperString) throws Exception {
        byte[] input = hexStringToByteArray(upperString.toLowerCase());
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        SecretKeySpec secretKeySpec = new SecretKeySpec(aesKey.getBytes(StandardCharsets.UTF_8), "AES");
        IvParameterSpec ivSpec = new IvParameterSpec(aesIv.getBytes(StandardCharsets.UTF_8));
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivSpec);
        byte[] decrypted = cipher.doFinal(input);
        return new String(decrypted, StandardCharsets.UTF_8);
    }

    private byte[] hexStringToByteArray(String s) {
        int len = s.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i + 1), 16));
        }
        return data;
    }

    private String byteArrayToHexString(byte[] bytes) {
        StringBuilder result = new StringBuilder();
        for (byte b : bytes) {
            result.append(String.format("%02X", b));
        }
        return result.toString();
    }
}