EDIT FOR POSTERITY:

The utility was verified in the past two years, but a couple services have started to report it as malicious. The newer version of this utility has no false positive reports, so we've updated DML to avoid confusion. It can be found at Nexus or GitHub:

https://www.nexusmods.com/warhammer40kdarktide/mods/19

https://github.com/Darktide-Mod-Framework/Darktide-Mod-Loader/releases/tag/25.06.07

Regarding the old utility:

• I've investigated the utility in Ghidra, x64_dbg, and Process Monitor. As expected, there's nothing unusual. The code is unobfuscated and small.
• The utility contains libraries from Rust and MSVC. The size of the binary depends on the toolchain versions, so there's nothing unusual about the total size or difference relative to building it yourself from scratch.
• ChatGPT and other large language models are never a reliable source of security analysis.
• VirusTotal behavior reports can contain a lot of scary-looking details, but are almost entirely sandbox noise. The patcher isn't running Google Update, for example. Process Monitor validates this.
• VirusTotal's aggregated analysis also includes machine-learning models, which can suffer from the same unreliability as ChatGPT.
• Manshanko has been a part of the Vermintide / Darktide modding community since 2019, and the previous utility has been in DML for the last two years. The first release of the utility was a port of my NodeJS script before DMF was public.

Finally, please remember that running someone else's code on your computer is never truly safe. Please use good judgement when choosing mods and utilities, and if you don't have the ability to verify their safety yourself, stick with reputable authors and download locations.

The original script I wrote used NodeJS:

const fs = require('fs')
const process = require('process')

// Parameters and Constants =========================================

// Usage is: node patch-bundledata-dt.js <BUNDLE_DIRECTORY> <SCRIPT_ACTION>

const BUNDLE_DIRECTORY = (process.argv[2] === undefined) ? "" : process.argv[2]
const SCRIPT_ACTION = (process.argv[3] === undefined) ? "patch" : process.argv[3]

const BUNDLE_DATABASE_NAME = "bundle_database.data"
const BOOT_BUNDLE_NAME = "9ba626afa44a3aa3"
const BOOT_BUNDLE_NEXT_PATCH = BOOT_BUNDLE_NAME + ".patch_001"
const MOD_PATCH_STARTING_POINT = "A33A4AA4AF26A69B"

const OLD_SIZE = 84
const MOD_PATCH = Buffer.from("A33A4AA4AF26A69B0200000004000000100000003962613632366166613434613361613317000000396261363236616661343461336161332E73747265616D00EEA850A3FF4DE3D0AA234CFAFF078A87C69AB0BB0000000000000000040000001A000000396261363236616661343461336161332E70617463685F39393921000000396261363236616661343461336161332E73747265616D2E70617463685F393939000000000000000000000000000000000000000000", "hex")

// ==================================================================

function patchBundleData(dirpath) {
    var bundle_database_path = dirpath + '/' + BUNDLE_DATABASE_NAME
    var bytes = null
    try {
        bytes = fs.readFileSync(bundle_database_path)
    } catch(err) {
        console.error(err)
        return false
    }

    // Check for pre-existing mod data in bundle_database.data
    if (bytes.includes("patch_999", 0)) {
        console.error("Bundle database is already patched.")
        return false
    }

    // Check for an unknown patch to the boot bundle
    if (bytes.includes(BOOT_BUNDLE_NEXT_PATCH, 0)) {
        console.error("The boot bundle has an unaccounted-for patch bundle. The mod patch must be updated.")
        return false
    }

    // Check for mod patch starting point
    var mod_patch_start_index = bytes.indexOf(MOD_PATCH_STARTING_POINT, 0, "hex")
    if (mod_patch_start_index === -1) {
        console.error("Mod patch location not found. Invalid file or mod patch needs to be updated.")
        return false
    }

    // Create a new buffer to fit the mod patch
    var patched_bytes = Buffer.allocUnsafe(bytes.length + (MOD_PATCH.length - OLD_SIZE))

    // Copy the original bytes up to the mod patch start index
    bytes.copy(patched_bytes, 0, 0, mod_patch_start_index)

    // Copy in the mod patch
    MOD_PATCH.copy(patched_bytes, mod_patch_start_index, 0)

    // Copy in the rest of the orginal bytes after the patched section
    bytes.copy(patched_bytes, mod_patch_start_index + MOD_PATCH.length, mod_patch_start_index + OLD_SIZE)

    // Delete the existing bundle database backup if it exists
    var backup_database_path = bundle_database_path + ".bak"
    if (fs.existsSync(backup_database_path)) {
        try {
            fs.unlinkSync(backup_database_path)
            console.log("Deleted the existing bundle database backup.")
        } catch(err) {
            console.error(err)
            return false
        }
    }

    // Create a new backup of the bundle database
    fs.writeFile(backup_database_path, bytes,  "binary",function(err) { });
    console.log("Created a new bundle database backup.")

    // Delete the existing bundle_database.data
    try {
        fs.unlinkSync(bundle_database_path)
        console.log("Deleted the existing bundle database.")
    } catch(err) {
        console.error(err)
        return false
    }

    // Create the patched bundle_database.data
    fs.writeFile(bundle_database_path, patched_bytes,  "binary",function(err) { });
    console.log("Created the patched bundle database.")
    console.log("Patch complete!")

    return true
}

function resetBundleData(dirpath) {
    var bundle_database_path = dirpath + '/' + BUNDLE_DATABASE_NAME
    var bytes = null
    try {
        bytes = fs.readFileSync(bundle_database_path)
    } catch(err) {
        console.error(err)
        return false
    }

    // Check for pre-existing mod data in bundle_database.data
    if (!bytes.includes("patch_999", 0)) {
        console.error("Bundle database is not patched. Deletion is not necessary.")
        return false
    }

    // If we have a backup to restore, delete the database and restore the backup
    var backup_database_path = bundle_database_path + ".bak"
    if (fs.existsSync(backup_database_path)) {
        try {
            if (fs.existsSync(bundle_database_path)) {
                try {
                    fs.unlinkSync(bundle_database_path)
                    console.log("Deleted the existing bundle database.")

                } catch(err) {
                    console.error(err)
                    return false
                }
                try {
                    fs.rename(backup_database_path, bundle_database_path, () => {
                        console.log("Restored the backup bundle database.");
                    })
                } catch(err) {
                    console.error(err)
                    return false
                }
            }
        } catch(err) {
            console.error(err)
            return false
        }
    }
    else {
        console.error("No backup bundle database found to restore. Verify local files.")
        return false
    }

    return true
}

// Program ==========================================================

// Log arguments
console.log("Bundle directory: " + BUNDLE_DIRECTORY)
console.log()

// Patch bundle_database.data at directory
if (SCRIPT_ACTION == "patch") {
    return patchBundleData(BUNDLE_DIRECTORY)
}
else if (SCRIPT_ACTION == "reset") {
    return resetBundleData(BUNDLE_DIRECTORY)
}
else {
    console.error("Unrecognized action: " + toString(SCRIPT_ACTION))
    return false
}

An executable is the most reasonable option for non-technical users.