Cross-Platform DFIR Tools: MalChelaGUI on Windows

It’s a Trick and a Treat

Sometimes the best breakthroughs are the ones you don’t plan for.  After a routine Windows update this week, I launched MalChelaGUI from the Ubuntu terminal on an Ubuntu WSL2 instance — and it simply opened. No X-server, no environment tweaks, no extra packages.

🎉 😱 A Rust native GUI app on Windows, via Ubuntu WSL terminal!

The latest WSL 2.5 + WSLg 1.0.66 update from Microsoft quietly unlocked full Wayland and GPU acceleration for Linux GUI apps on Windows 11 24H2.  (Note the latest WSL at the time of this post is 2.61)

The result? MalChelaGUI now runs as a true desktop app on Windows, powered entirely by Ubuntu WSL.  

Why This Matters

•  🧰 No configuration needed — just follow the default instructions at GItHub, and build MalChela as usual.  (WSL, Ubuntu 24.04 or later)
• 🪟 Native windowing — Clipboard, display scaling, and GPU acceleration all handled automatically.  
• 🦀 Cross-platform parity — macOS, Linux, and now Windows (via WSL) all run the same GUI experience.

It’s a small but meaningful proof of concept: cross-platform DFIR tooling can now live comfortably in every environment analysts work in — even Windows, without compromise.

Call for Testers

If you’re running Windows 11 24H2 or newer, update WSL and give it a try:

```powershellwsl --update

Then from Ubuntu WSL

./target/release/MalChelaGUI

If it launches successfully, drop me a note or tag me — I’d love to hear how it behaves across different hardware and GPU setups.

#DFIR #Forensics #GUI #Linux #MalChela #malwareanalysis #Rust #Windows #WSL

Enhance Threat Hunting with MITRE Lookup in MalChela 3.0.2

Understanding adversary behavior is core to modern forensics and threat hunting. With the release of MalChela 3.0.2, I’ve added a new tool to your investigative belt: MITRE Lookup — a fast, offline way to search the MITRE ATT&CK framework directly from your MalChela workspace.

Whether you’re triaging suspicious strings, analyzing IOCs, or pivoting off YARA hits, MalChela can now help you decode tactics, techniques, and procedures without ever leaving your terminal or GUI. MITRE Lookup is powered by a local JSON snapshot of the ATT&CK framework (Enterprise Matrix), parsed at runtime with support for fuzzy searching and clean terminal formatting. No internet required.

What It Does

The MITRE_lookup tool lets you:

• Search by Technique ID (e.g., T1027, T1566.001)
• Search by topic or keyword (e.g., ‘RDP’, ‘Wizard Spider’)
• Get tactic category, platforms, and detection guidance
• Optionally include expanded content with the –full flag
• Use from the CLI, MalChela launcher, or GUI modal

Example:

$ ./target/release/MITRE_lookup -- T1059.003T1059.003 - Windows Command ShellTactic(s): executionPlatforms: WindowsDetection: Usage of the Windows command shell may be common on administrator, developer, or power user systems depending on job function. If scripting is restricted for normal users, then any attempt to enable scripts running on a system would be considered suspicious. If scripts are not commonly used on a system, but enabled, scripts running out of cycle from patching or other administrator functions are suspicious. Scripts should be captured from the file system when possible to determine their actions and intent...

GUI Integration

• Select MITRE Lookup in the left-hand Toolbox menu
• Use the input field at the top of the modal to enter a keyword or technique ID (e.g., `T1059` or `registry`)
• Use the “Full” checkbox for un-truncated output
• “Save to Case” option

Saving for Later

You can save MITRE Lookup results directly from the GUI, either as a standalone markdown file to a designated folder, or into the active Case Notes panel for later reference. This makes it easy to preserve investigative context, cite specific TTPs in reports, or build a threat narrative across multiple tools. The saved output uses clean Markdown formatting — readable in any editor or compatible with case management platforms. This feature is already live in v3.0.2 and will evolve further with upcoming case linkage support.

Why MITRE ATT&CK in MalChela?

MalChela already focuses on contextual forensics — understanding not just what an artifact is, but why it matters. By embedding MITRE ATT&CK into your daily toolchain:

• You reduce pivot fatigue from switching between tools/web tabs
• You boost investigation speed during triage and reporting
• You enable a more threat-informed analysis process

Whether you’re tagging findings, crafting YARA rules, or writing case notes, the MITRE integration helps turn technical output into meaningful insight — all from within the MalChela environment.

#DFIR #Forensics #MalChela #Malware #MITREATTCK

Sharper Strings and Smarter Signals: MalChela 3.0.1

It’s a strange but satisfying feeling to hit version 3.0, then realize soon after you’re already back in the weeds fixing, refining, and optimizing. That’s what this 3.0.1 release is all about — a tight round of updates aimed at boosting clarity and cutting noise, especially when running mStrings or working within the FileMiner panel. Additionally, a number of optimizations came about in getting MalChela to run smoothly on Toby, and to minimize any unnecessary re-building of the binaries. This post walks through what’s new and improved.

🧠 Smarter Detections in mStrings

The mstrings tool — one of the most feature-rich in the toolkit — got a round of refinements:

• Generic Executable detection removed: This was too noisy and matched a lot of clean files. It’s been replaced by more focused patterns.
• Suspicious DLLs now detected more precisely: Legit Windows DLLs like ole32.dll and gdiplus.dll are now excluded unless they’re paired with indicators like GetProcAddress, LoadLibrary, or manual syscall patterns.
• Rule cleanup and expansion: Several detections were removed, refined, or added (like packer stubs and dropper markers) to better target actual malicious behavior.
• Tighter MITRE mapping: Each detection is now carefully aligned to a corresponding MITRE ATT&CK technique, often down to the sub-technique level.

If you’ve ever run mstrings and felt unsure which hits mattered most — or got buried in generic noise — this update should feel much cleaner.

Reminder: You can easily update the detection criteria by modifying detections.yaml.

Have a detection to contribute to the project? Submit a pull request.

🔍 Built-In MITRE Lookup (GUI)

If a detection shows a MITRE ID like T1082, you can now look it up directly inside the GUI. The new MITRE Lookup Bar sits at the top of the config panel (only when running mstrings). Paste a technique ID, hit Lookup, and it’ll open the official MITRE ATT&CK page in your browser.

🗂️ FileMiner Improvements

The FileMiner GUI panel saw some polish too:

• “Select All” functionality: You can now batch-run tools across multiple matching files in a case — a huge time-saver during triage.

🧰 Build and Setup Updates

Two quick notes for folks cloning the repo for the first time:

• The release.sh script now builds all binaries in release mode — one command to build everything cleanly.
• Docs and README were updated to recommend building in –release mode from the start, especially for smoother GUI usage.

🧪 Platform Testing

Confirmed functional on:

• macOS (Silicon)
• Ubuntu (Desktop and minimal)
• REMnux (custom REMnux tools.yaml)
• Raspberry Pi (Zero 2W and 4B)
• Windows via WSL (CLI)

Still some quirks with native Windows support due to YARA compatibility and pathing, but if you’re a Windows power user and want to pitch in, I’d love your help.

💭 Final Thoughts

MalChela isn’t trying to replace your favorite tools — it’s trying to bundle them in ways that save time, reveal context, and give you clarity during analysis. The 3.0.1 release doesn’t bring sweeping new features, but it does make the experience tighter, more predictable, and more useful where it counts.

As always, thanks to those who’ve tested it, given feedback, or just watched quietly from the shadows. 🕵️‍♂️ If you want to contribute — whether it’s rules, regex, docs, or bugs — you’ll find me at dwmetz/MalChela.

Happy hunting.

#DFIR #Forensics #Github #MalChela #Malware #malwareanalysis

MalChela v3.0 enhances investigative workflows by introducing cases for organization, replacing MismatchMiner with FileMiner for improved file analysis, and suggesting tools based on file characteristics, streamlining the analysis process. #MalChela #DFIR #MalwareAnalysis

http://bakerstreetforensics.com/2025/06/20/malchela-v3-0-case-management-fileminer-and-smarter-triage/

Hashes for the Masses: Finding What Matters in a Sea of Samples #DFIR #MalwareAnalysis #Hash #MalChela

http://bakerstreetforensics.com/2025/05/26/hashes-for-the-masses-finding-what-matters-in-a-sea-of-samples/

MalChela 2.2 “REMnux” Release

MalChela’s 2.2 update is packed with practical and platform-friendly improvements. It includes native support for REMnux, better tool settings, and deeper integrations with analysis tools like YARA-X, Tshark, Volatility3, and the newly improved fileanalyzer module.

🦀 REMnux Edition: Built-In Support, Zero Tweaks

When the GUI loads a REMnux-specific tools.yaml profile, it enters REMnux mode.

Native binaries and Python scripts like capa, oledump.py, olevba, and FLOSS are loaded into the MalChela tools menu, allowing you to mix and match operations with the embedded MalChela utilities and the full REMnux tool stack. No manual configuration needed—just launch and go. MalChela currently supports the following REMnux programs right out of the box:

If you only need a subset of tools you can easily save and restore that a custom profile.

TShark Panel with Built-In Reference

A new TShark integration exposes features including:

• A filter builder panel
• Commonly used fields reference
• Tooltip hints for each example (e.g., `ip.addr == 192.168.1.1` shows “Any traffic to or from 192.168.1.1”)
• One-click copy support

This helps analysts build and understand filters quickly—even if TShark isn’t something they use every day. Using the syntax builder in MalChela you can use the exact commands directly in Tshark or Wireshark.

YARA-X Support (Install Guide Included)

Support for YARA-X (via the `yr` binary) is now built in. YARA-X is not bundled with REMnux by default, but install instructions are included in the User Guide for both macOS and Linux users.

Once installed, MalChela allows for rule-based scanning from the GUI,and with YARA-X, it’s faster than ever.

fileanalyzer: Fuzzy Hashing, PE Metadata, and More

MalChela’s fileanalyzer tool has also been updated to include:

• Fuzzy hashing support via `ssdeep`
• BLAKE3 hashing for fast, secure fingerprints
• Expanded PE analysis, including:
• Import and Export Table parsing (list of imported and exported functions)
• Compilation Timestamp (for detection of suspicious or forged build times)
• Section Characteristics (flags like IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_CNT_CODE, etc., for detecting anomalous sections)

These improvements provide deeper insight into executable structure, helping analysts detect anomalies such as packers, suspicious timestamps, or unexpected imports/exports. Useful for everything from sample triage to correlation, fileanalyzer now digs deeper—without slowing down.

Memory Forensics Gets a Boost: Volatility 3 Now Supported

With the 2.2 release, MalChela introduces support for Volatility 3, the modern Python-based memory forensics framework. Whether you’re running MalChela in REMnux or on a customized macOS or Linux setup, you can now access the full power of Volatility directly from the MalChela GUI.

There’s an intuitive plugin selector that dynamically adjusts available arguments based on your chosen plugin,. You can search, sort, and browse available plugins, and even toggle output options like –dump-dir with ease.

Like Tshark, there is an added plugin reference panel with searchable descriptions and argument overviews — a real time-saver when navigating Volatility’s deep and often complex toolset.

Smarter Tool Configuration via YAML

The tool configuration system continues to evolve:

• Tools now declare their input type (file, folder, or hash)
• The GUI dynamically adjusts the interface to match
• Alternate profiles (like REMnux setups) can be managed simply by swapping `tools.yaml` files via the GUI
• Easily backup or restore your custom setups
• Restore the default toolset to get back to basics

This structure helps keep things clean—whether you’re testing, teaching, or deploying in a lab environment.

Embedded Documentation Access

The GUI now includes a link to the full MalChela User Guide in PDF. You can also access the documentation online.

From tool usage and CLI flags to configuration tips and install steps, it’s all just a click away—especially useful in offline environments or when onboarding new analysts. I’ll be honest, this is likely the most comprehensive user guide I’ve ever written.

Whether you’re reviewing binaries, building hash sets, or exploring network captures—MalChela 2.2 is designed bring together the tools you need, and make it easier to interoperate between them.

The new REMnux mode makes it even easier to get up and running with dozens of third party integrations.

Have an idea for a feature or application you’d like to see supported — reach out to me.

GitHub: REMnux Release

MalChela User Guide: Online, PDF, Web

Shop: T-shirts, hats, stickers, and more

#DFIR #Github #MalChela #Malware #MalwareAnalysis #Memory #Network #NSRL #PCAP #Python #REMnux #Rust #Tshark #VirusTotal #Volatility #yara

MalChela 2.2 “REMnux” Release
More tools. More Docs. More Power.
#DFIR #MalwareAnalysis #YaraX #Volatility #Tshark #MalChela

http://bakerstreetforensics.com/2025/05/21/malchela-2-2-remnux-release/

MalChela v2.1 Released: Smoother Workflows, Easier Tool Integration

🧰 A Toolkit That Grows With You

Version 2.1 of MalChela, the modular digital forensics and malware analysis launcher, is now available. This release focuses on flexibility and simplicity — especially when integrating third-party tools and refining workflows between CLI and GUI.

Whether you’re testing suspicious files, generating YARA rules, or examining malware indicators from different sources, the updated interface helps you move fluidly from one tool to another — without losing your place or rewriting commands.

🔄 Run, Re-run, Refine

One of the most helpful improvements in 2.1 is the ability to quickly rerun tools with updated arguments. There’s no need to backtrack or manually rebuild command lines. Just update the Arguments field in the GUI, click Run, and MalChela will handle the rest.

If you’re pivoting between tools like mstrings, pdf-parser, or capa, the consistent interface lets you switch input, adjust flags, and review results in one console — no clutter, no confusion.

🔌 Integration Made Easy

You can now seamlessly add external tools — including Python scripts, native binaries, or custom Rust programs — using just the tools.yaml configuration file. Each tool can define:

• Input type (file, folder, or hash)
• Command structure
• Where input should appear in the argument list
• Whether it’s a script, binary, or cargo-built tool

The GUI reads these definitions and builds a dynamic interface to support them, removing the guesswork of launching external programs.

💾 One Report to Rule Them All

In past versions, you might have seen multiple output files for a single run — especially when running scripts that already saved their own logs. That’s no longer the case.

With 2.1, all tools now produce a single unified report when run through the GUI. Even scripts that don’t natively generate output will have their results captured and saved by MalChela, giving you clean, consistent documentation for every tool.

🐚 CLI Power, GUI Convenience

MalChela still supports CLI-based workflows (cargo run -p toolname) and a menu-driven terminal launcher. But the GUI now offers a refined experience for analysts who want more visibility, easier input selection, and better organization of results — without losing the precision of command-line control.

🚀 Try It Out

MalChela is open-source and free to use. You can:

• Download the latest release
• Add your own tools using the updated tools.yaml
• Review the User Guide for setup tips and sample workflows

🎥 A Video Tour

If you haven’t seen it yet, be sure to check out the YouTube video where I walk through some of the different functions in MalChela in the new GUI, stepping through basic static analysis to yara rule writing – all in minutes.

🙏 Thank You

A huge thank you to the community of forensic analysts and developers who continue to test, refine, and inspire this project. If you have feedback, feature ideas, or tools you’d like to see integrated — reach out, submit a PR, or just let me know what’s working.

#DFIR #digitalforensics #Forensics #MalChela #Malware #MalwareAnalysis #malwareanalysis #opensource #Rust #rustlang #threatintel #yara