DBeaverUltimate-22.1.0-x86_64 Patch

2022-08-12

1. 前言

近些日子Navicat突然告急，不给用了。迫于无奈之下只好重觅一款新的DB连接工具，多番搜索下，看上了DBeaver，虽然依旧不太好用，但聊胜于无。

刚好论坛上最近有师傅发布了相关Patch的文章，跟着学习一手。

2. 环境

系统：Windows 11 家庭中文版 21H2

Java版本：Java11

软件版本：dbeaver-ue-22.1.0-x86_64

工具：IDEA 2021.2

3. License加密分析

因为本人不会Java分析，所以这里分析流程直接按师傅的来（ps：太菜了。。看不懂Java。。。。）

首先是打开后弹出的错误提示，这里就不在放图了，我们直接定位到日志报错处

1	C:\Users\xxx\AppData\Roaming\DBeaverData\workspace6\.metadata\dbeaver-debug.log

根据报错日志可以看出导入License调用的方法在LicenseServiceEmbedded.java处

这里采用idea创建一个项目，然后将我们的jar包导入进来，从而方便查看代码。左侧是分析过程中所用到的jar包，由于已经看过大佬们分析的流程了，因此这里我不在全部导入分析。

// D:\DBeaverUltimate\plugins

com.dbeaver.app.ultimate_22.1.0.202206121739.jar
com.dbeaver.lm.core_2.0.112.202206121739.jar
com.dbeaver.remote.client_1.0.2.202206121739.jar
org.jkiss.lm_1.0.136.202206121739.jar
org.jkiss.utils_2.1.166.202206121739.jar

分析上图中的代码，可以看到调用了方法LMLicenseManager，ctrl+左键跳转

转到LMLicenseManager.java代码中分析

可以在LMLicenseManager.java代码中看到importLicense的方法，继续索引，查看该方法中的getDecryptionKey

分析该方法可知，我们的key来源于某一jar包下的keys文件夹中，文件名以-public.key结尾

查找后可知，该文件位于com.dbeaver.app.ultimate_22.1.0.202206121739.jar包中

同时能够得出String id =product.getId();中获取的id是dbeaver-ue。

不过问题不大，我们回到org.jkiss.lm_1.0.136.202206121739.jar中继续看LMLicense

在LMLicense中我们可以看到我们的加密方式，依旧是老办法，ctrl+左键点过去看看

可以看到我们的加密方式为RSA/ECB/PKCS1Padding，在com.dbeaver.app.ultimate_22.1.0.202206121739.jar包中找到的dbeaver-ue.publick.key文件为RSA加密需要的公钥。

4. License Patch

到这里我们的加密分析就告一段落了，接下来是License Patch。首先来顺一下思路

生成一对RSA加解密使用的公钥和私钥
将com.dbeaver.app.ultimate_22.1.0.202206121739.jar中的公钥替换为自己生成的公钥
用自己的私钥生成一个License文件导入DBeaver中
绕过License网络校验（这个后面出bug了再讲）

首先是我们的org.jkiss.lm_1.0.136.202206121739.jar文件，其中的LMMain.class类中已经实现了密钥生成、License生成、解密License、导入License的代码。大佬说稍作修改就能使用，这里我直接采用大佬的脚本（ps：菜狗不会改。。。）

import org.jkiss.lm.*;
import org.jkiss.utils.Base64;

import java.io.*;
import java.security.Key;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Date;


public class DBeaverLicenseActiveMain {
    private static final LMProduct TEST_PRODUCT;

    static {
        TEST_PRODUCT = new LMProduct(
                "dbeaver-ue",
                "DB",
                "DBeaver Ultimate",
                "DBeaver Ultimate Edition",
                "22.1",
                LMProductType.DESKTOP,
                new Date(),
                new String[0]
        );
    }


    public static void main(String[] args) throws Exception {
        System.out.println("LM 2.0");
        // 生成RAS密钥对
        if (args.length > 0 && args[0].equals("gen-keys")) {
            System.out.println("Test key generation");
            generateKeyPair();
            // 生成加密License
        } else if (args.length > 0 && args[0].equals("encrypt-license")) {
            System.out.println("Encrypt license");
            encryptLicense();
            // 解密License
        } else if (args.length > 0 && args[0].equals("decrypt-license")) {
            System.out.println("Decrypt license");
            decryptLicense();
            // 导入License测试
        } else if (args.length > 0 && args[0].equals("import-license")) {
            System.out.println("Import license");
            importLicense();
            // 生成明文License
        } else {
            System.out.println("Test license generation");
            generateLicense();
        }
    }

    private static void encryptLicense() throws Exception {
        PrivateKey privateKey = readPrivateKey();
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String licenseID = LMUtils.generateLicenseId(TEST_PRODUCT);
        System.out.println("License ID: " + licenseID);
        System.out.println("Product ID (" + TEST_PRODUCT.getId() + "):");
        String productID = in.readLine();
        if (productID.isEmpty()) {
            productID = TEST_PRODUCT.getId();
        }

        System.out.println("Product version (" + TEST_PRODUCT.getVersion() + "):");
        String productVersion = in.readLine();
        if (productVersion.isEmpty()) {
            productVersion = TEST_PRODUCT.getVersion();
        }

        System.out.println("Owner ID (10000):");
        String ownerID = in.readLine();
        if (ownerID.isEmpty()) {
            ownerID = "10000";
        }

        System.out.println("Owner company (foxcookie):");
        String ownerCompany = in.readLine();
        if (ownerCompany.isEmpty()) {
            ownerCompany = "foxcookie";
        }

        System.out.println("Owner name (foxs cookie):");
        String ownerName = in.readLine();
        if (ownerName.isEmpty()) {
            ownerName = "foxs cookie";
        }

        System.out.println("Owner email (foxcookie@foxs.org):");
        String ownerEmail = in.readLine();
        if (ownerEmail.isEmpty()) {
            ownerEmail = "foxcookie@foxs.org";
        }

        LMLicense license = new LMLicense(
                licenseID,
                LMLicenseType.ULTIMATE,
                new Date(),
                new Date(),
                (Date) null,
                LMLicense.FLAG_UNLIMITED_SERVERS,
                productID,
                productVersion,
                ownerID,
                ownerCompany,
                ownerName,
                ownerEmail);
        byte[] licenseData = license.getData();
        byte[] licenseEncrypted = LMEncryption.encrypt(licenseData, privateKey);
        System.out.println("--- LICENSE ---");
        System.out.println(Base64.splitLines(Base64.encode(licenseEncrypted), 76));
    }

    private static void decryptLicense() throws Exception {
        PublicKey publicKey = readPublicKey();
        System.out.println("License:");
        byte[] encryptedLicense = LMUtils.readEncryptedString(System.in);
        LMLicense license = new LMLicense(encryptedLicense, publicKey);
        System.out.println(license);
    }

    private static void importLicense() throws Exception {
        final PrivateKey privateKey = readPrivateKey();
        final PublicKey publicKey = readPublicKey();
        System.out.println("License:");
        byte[] encryptedLicense = LMUtils.readEncryptedString(System.in);
        LMLicenseManager lm = new LMLicenseManager(new LMKeyProvider() {
            public Key getEncryptionKey(LMProduct product) {
                return privateKey;
            }

            public Key getDecryptionKey(LMProduct product) {
                return publicKey;
            }
        }, (LMLicenseValidator) null);
        lm.importLicense(TEST_PRODUCT, encryptedLicense);
    }

    private static void generateKeyPair() throws LMException {
        KeyPair keyPair = LMEncryption.generateKeyPair(2048);
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();
        System.out.println("--- PUBLIC KEY ---");
        System.out.println(Base64.splitLines(Base64.encode(publicKey.getEncoded()), 76));
        System.out.println("--- PRIVATE KEY ---");
        System.out.println(Base64.splitLines(Base64.encode(privateKey.getEncoded()), 76));
    }

    private static void generateLicense() throws LMException {
        System.out.println("Gen keys");
        KeyPair keyPair = LMEncryption.generateKeyPair(2048);
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();
        System.out.println("Gen Test license");
        String licenseID = LMUtils.generateLicenseId(TEST_PRODUCT);
        LMLicense license = new LMLicense(
                licenseID,
                LMLicenseType.ULTIMATE,
                new Date(),
                new Date(),
                (Date) null,
                LMLicense.FLAG_UNLIMITED_SERVERS,
                TEST_PRODUCT.getId(),
                TEST_PRODUCT.getVersion(),
                "10000",
                "foxcookie",
                "foxs cookie",
                "foxcookie@foxs.org");
        byte[] subData = license.getData();
        byte[] encrypted = LMEncryption.encrypt(subData, privateKey);
        String encodedBase64 = Base64.splitLines(Base64.encode(encrypted), 76);
        byte[] encodedBinary = Base64.decode(encodedBase64);
        LMLicense licenseCopy = new LMLicense(encodedBinary, publicKey);
        System.out.println(licenseCopy);
        System.out.println("Gen subscription");
        LMSubscription subscription = new LMSubscription(
                licenseID,
                LMSubscriptionPeriod.MONTH,
                new Date(),
                new Date(),
                1,
                true);
        subData = LMEncryption.encrypt(subscription.getData(), privateKey);
        String subBase64 = Base64.splitLines(Base64.encode(subData), 76);
        byte[] subBinary = Base64.decode(subBase64);
        LMSubscription subCopy = new LMSubscription(subBinary, publicKey);
        System.out.println(subCopy);
    }

    private static PrivateKey readPrivateKey() throws LMException {
        File keyFile = new File(new File(System.getProperty("user.home"), ".jkiss-lm"), "private-key.txt");
        if (!keyFile.exists()) {
            throw new LMException("Cannot find private key file (" + keyFile.getAbsolutePath() + ")");
        } else {
            try {
                Throwable var1 = null;
                Object var2 = null;

                try {
                    InputStream keyStream = new FileInputStream(keyFile);

                    PrivateKey var10000;
                    try {
                        byte[] privateKeyData = LMUtils.readEncryptedString(keyStream);
                        var10000 = LMEncryption.generatePrivateKey(privateKeyData);
                    } finally {
                        if (keyStream != null) {
                            keyStream.close();
                        }

                    }

                    return var10000;
                } catch (Throwable var12) {
                    if (var1 == null) {
                        var1 = var12;
                    } else if (var1 != var12) {
                        var1.addSuppressed(var12);
                    }
                    throw var1;
                }
            } catch (Throwable var13) {
                throw new LMException(var13);
            }
        }
    }

    private static PublicKey readPublicKey() throws LMException {
        File keyFile = new File(new File(System.getProperty("user.home"), ".jkiss-lm"), "public-key.txt");
        if (!keyFile.exists()) {
            throw new LMException("Cannot find public key file (" + keyFile.getAbsolutePath() + ")");
        } else {
            try {
                Throwable var1 = null;
                try {
                    InputStream keyStream = new FileInputStream(keyFile);

                    PublicKey var10000;
                    try {
                        byte[] keyData = LMUtils.readEncryptedString(keyStream);
                        var10000 = LMEncryption.generatePublicKey(keyData);
                    } finally {
                        if (keyStream != null) {
                            keyStream.close();
                        }

                    }

                    return var10000;
                } catch (Throwable var12) {
                    if (var1 == null) {
                        var1 = var12;
                    } else if (var1 != var12) {
                        var1.addSuppressed(var12);
                    }

                    throw var1;
                }
            } catch (Throwable var13) {
                throw new LMException(var13);
            }
        }
    }
}

好，现在脚本有了，接下来我们传入参数gen-keys，然后生成我们的密钥对

接着分别创建

private-key.txt：私钥

public-key.txt``dbeaver-ue-public.key：公钥

将我们生成的内容复制进去后，将private-key.txt``public-key.txt放入C:\Users\xxx\.jkiss-lm内

同时用dbeaver-ue-public.key替换我们上面提到的jar包中的dbeaver-ue-public.key

这里可以直接采用压缩工具直接进行操作，不需要解包重打包一类的操作。

现在公钥和私钥都有了，接下来就是我们的License了。修改传参为encrypt-license，生成我们的License，方法同上。

运行后得到我们的License，到这里我们的Patch暂时算是成功了，可是情况真的如此吗？

让我们将License导入来试一下吧。

可以看到，虽然我们成功导入了License，但是我们的程序依旧不能使用，这是问什么呢？

其实原因在上面便说到了，我们还没有绕过License的网络检测，这里之所以导入License后依旧不能使用便是这个原因。

5. License绕过网络检测

这里我们继续回到dbeaver-debug.log，可以看到我们的异常信息如下。在日志中可以看出，License的验证方法在com.dbeaver.lm.validate.PublicLicenseValidator.validateLicense

依据路径查看代码

分析可知，我们的验证步骤在result = LMPublicAPI.checkLicenseStatus(monitor, clientId, licenseManager, license, product);中，查看代码

分析我们这块的代码可知，如果返回的licenseStatusText为空，那么该方法会直接返回LMLicenseStatus.VALID的校验状态（有效状态）。

继续分析调用的checkLicenseStatus方法

这里请求了网络接口，调用的请求方法为父类中的方法，在com.dbeaver.remote.client_1.0.2.202206121739.jar中

在类com.dbeaver.remote.client.AbstractRemoteClient可以看到HTTP请求的客户端构造代码如下：

返回类com.dbeaver.lm.validate.PublicServiceClient中，可以看到其构造客户端的代码如下：

能够从上述代码中分析出，PUBLIC_SERVICE_URL为接口的请求地址，该变量的来源位于上面的红框内。

回到获取校验结果String licenseStatusText = client.checkLicenseStatus(license, product);代码处，可以分析出，当请求的路径无法访问时，那么得到的licenseStatusText就为空值了，这样即可直接得到有效的验证结果。

从上图的代码中可以看出，我们只需将DEBUG_MODE设置为True，亦或是使https://dbeaver.com/lmp/无法访问，均可达到我们的目的。

因此，我们现在得到了两种绕过License校验的方法

在hosts文件中添加127.0.0.1 dbeaver.com
在配置dbeaver.ini中设置lm.debug.mode=true

这里我们采用第二种方法，因为不喜欢修改hosts文件，不方便

现在我们再次打开我们的DBeaver

成功Patch。当然，其实我们绕过网络检测这一步也可以放在最前面，这样在第一次导入License时即可成功使用了。

这里主要是为了完整的复现一个程序Patch的流程，因此将绕过网络监测放在了后面，实际应用时不需如此。

6. 总结

不得不感慨，论坛里的师傅们是真的强大，两位大佬的分析帖子仅仅只差了一天。在第一天看完大佬的帖子没有复现成功，因为源码没看明白，第二天就看到了另一位大佬对源码写了份分析贴，同时还补充了一个绕过License网络校验的方法。只能感慨自己要学的东西还是太多了，虽然感触良多，却也不虚此行。这篇文章就先写到这里吧，学无止境，贵在坚持。

7. 参考链接

https://www.52pojie.cn/thread-1666440-1-1.html

https://www.52pojie.cn/thread-1668139-1-1.html

https://www.52pojie.cn/thread-1668629-1-1.html

本文作者： foxcookie
发布时间： 2022-08-12
最后更新： 2023-07-21
本文标题： DBeaverUltimate-22.1.0-x86_64 Patch
本文链接： https://foxcookie.github.io/2022/08/12/DBeaverUltimate-22.1.0-x86_64 Patch/
版权声明： 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明出处！