awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
ufrisk avatar

ufrisk/MemProcFS

0
View on GitHub↗
4,202 stars·515 forks·C·AGPL-3.0·21 views

MemProcFS

MemProcFS is a volatile memory analysis tool and cross-platform memory acquisition system. It functions as a memory forensic virtual file system, mapping physical memory and kernel objects into a virtual directory structure that allows users to analyze system artifacts using standard file system tools.

The project distinguishes itself by providing a virtual file system for memory forensics, enabling the browsing and querying of physical memory as read-only files and folders. It also incorporates a Yara-based memory scanner to identify malware signatures and injected code within physical memory.

The engine covers a broad range of forensic capabilities, including process and thread inspection, network connection listing, and Windows registry analysis. It supports data ingestion from live systems, crash dumps, and virtual machines, while providing symbol resolution to translate raw memory addresses into meaningful names.

Integration is supported through a multi-language programmatic interface and native library wrappers for C and Java, as well as headless Python scripting for automated workflows.

Features

  • Memory Analysis - Implements a comprehensive engine for acquiring and analyzing volatile system memory and static memory dumps.
  • Memory Forensics - Analyzes physical memory dumps or live system state to identify security threats and recover system artifacts.
  • Volatile Memory Acquisition Tools - Provides a cross-platform system for capturing volatile memory from live systems, virtual machines, and remote agents.
  • Debug Symbol Resolvers - Downloads and caches symbols from remote servers to translate raw memory addresses into meaningful function names.
  • YARA Rule Execution - Identifies malicious patterns in process and kernel virtual address spaces using compiled or source YARA rule sets.
  • Virtual File Systems - Maps physical memory and kernel artifacts into a virtual directory structure for analysis via standard file system tools.
  • Forensic Memory Virtualization - Exposes physical memory and kernel objects as a virtualized directory structure of read-only files and folders.
  • Forensic Agent Communication - Minimizes network bandwidth by transmitting only file system access requests to remote analysis agents.
  • Memory Dump Parsers - Parses memory dump files across various CPU architectures to enable deep forensic analysis.
  • Remote Memory Filesystems - Acquires remote physical memory and presents it as a local virtual filesystem for exploration.
  • Physical and Virtual Memory Operations - Performs direct read and write operations on physical and virtual memory for specific processes or system-wide.
  • Thread Inspection - Exposes thread-specific data including kernel structures and stacks as files within a virtual directory.
  • Volatile Memory Ingestion - Ingests memory data from raw dump files, crash dumps, live captures, or hardware interfaces for analysis.
  • Binary Pattern Searching - Scans memory for specific binary patterns or signatures using regular expressions and YARA rules.
  • Hardware Memory Acquisition Tools - Captures volatile RAM via drivers, virtual machines, hardware interfaces, or remote agents for real-time incident response.
  • Memory Malware Analysis - Scans system memory for malicious patterns and injected code using tools like Yara rules.
  • Process Enumeration - Identifies running software by retrieving a collection of active processes from the targeted memory source.
  • Remote Memory Analysis - Analyzes memory on remote machines and optimizes network bandwidth by transmitting only specific file system access requests.
  • YARA-Based Scanning - Uses compiled Yara rules to scan physical and virtual address spaces for malicious signatures and injected code.
  • Process Metadata Inspection - Retrieves detailed process lists, module bases, function addresses, and memory maps including heaps and page table entries.
  • DNS Cache Recovery - Extracts DNS records cached by the operating system and presents them as searchable text files.
  • Headless Forensic Scripting - Executes automated Python scripts at startup to perform forensics without mounting a virtual file system.
  • Multi-Language Plugin Frameworks - Supports custom forensic capabilities through a modular system allowing extensions written in multiple programming languages.
  • Memory Analysis APIs - Offers a multi-language programmatic interface to read physical and virtual process memory without mounting a file system.
  • Kernel Object Reconstruction - Recovers file objects from the kernel pool and process handles to present a reconstructed file system.
  • DMA Memory Acquisition - Provides capabilities to acquire system memory by bypassing the CPU via hardware interfaces such as PCIe DMA.
  • Forensic Memory Mapping - Maps physical memory and system artifacts into a virtual file system for analysis with standard tools.
  • Virtual Address Translators - Translates guest physical addresses to host physical or virtual addresses within a virtual machine environment.
  • Page File Integration - Incorporates disk-based page files into the memory analysis engine to recover data swapped out of physical RAM.
  • Guest-to-Host Address Translation - Translates guest physical addresses to host virtual addresses to enable memory analysis within hypervisor-based virtual machines.
  • Programmatic Memory Interfaces - Integrates memory analysis capabilities into custom applications using native libraries or multi-language interfaces.
  • Guest-to-Host Address Translation - Extracts and translates guest memory from hypervisors to analyze the state of virtualized operating systems.
  • Memory Dump Visualizers - Exposes physical memory as a virtual file system to analyze memory dumps or live memory.
  • Guest Memory Parsing - Extracts the memory of hypervisor-based virtual machines and presents them as separate file systems for analysis.
  • Virtual Machine Detection - Identifies supported virtual machines in memory and mounts them as separate file systems or memory views.
  • Windows Registry Interfaces - Enumerates registry hives and provides interfaces to read or write their memory space for configuration analysis.
  • Memory-Based File Recovery - Extracts files from memory by locating process file handles and copying the associated data.
  • Evasion Technique Detection - Identifies evasion techniques like process hollowing by flagging discrepancies between process structures and image addresses.
  • Incident Response Triage - Connects to remote hosts or virtual machines to rapidly acquire and analyze volatile memory during investigations.
  • Injected Module Detection - Locates executable modules in private virtual address descriptors to identify hidden malware.
  • Memory Event Log Extraction - Exposes event logs found in physical memory as read-only files for use with external log viewers.
  • Process Callstack Analysis - Analyzes runtime callstacks of user-mode threads to identify function call traces using symbol resolution.
  • User-Mode Malware Detection - Scans physical memory for indicators of malicious activity like code injection and presents results as files.
  • Modular Plugin Architectures - Adds custom forensic capabilities through a modular architecture that supports multiple programming languages for extensions.
  • Active Connection Monitors - Displays active TCP connections, including addresses and associated process names, as a text file.
  • System Information Summaries - Provides a high-level overview of the kernel, operating system, and active users via a read-only text file.
  • Memory Forensics - Accesses physical memory as a virtual file system.
  • Digital Forensics - Tool for accessing physical memory as a virtual file system.
  • Memory Analysis Tools - Virtual file system for viewing physical memory as files.
  • Memory Forensics - Virtual file system for accessing physical memory.

Star history

Star history chart for ufrisk/memprocfsStar history chart for ufrisk/memprocfs

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Projects sharing features with MemProcFS

These projects share indexed features with MemProcFS. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • ufrisk/pcileechufrisk avatar

    ufrisk/pcileech

    7,738View on GitHub↗

    pcileech is a toolkit for executing DMA attacks, analyzing PCIe bus traffic, performing kernel patching, and conducting remote volatile memory forensics. It functions as a hardware memory acquisition tool and a PCIe DMA attack framework designed to read and write remote system memory via direct hardware interfaces. The project provides capabilities for capturing and displaying raw transaction layer packets from the PCIe bus and mounting live RAM as local drives for analysis. It enables the modification of system memory signatures and the execution of shellcode or implants within the kernel wi

    C
    View on GitHub↗7,738
  • volatilityfoundation/volatility3volatilityfoundation avatar

    volatilityfoundation/volatility3

    4,192View on GitHub↗

    Volatility3 is a memory forensics framework and analysis tool used to parse volatile memory dumps. It extracts digital artifacts and reconstructs the runtime state of a system to recover process information, network artifacts, and other forensic evidence. The system functions as a plugin-based forensic engine and an operating system symbol resolver. It maps raw memory addresses to known system structures using symbol tables and translation layers, and provides an extensible architecture for creating custom scanners and renderers. The framework includes a command-line memory explorer for real

    Python
    View on GitHub↗4,192
  • velocidex/velociraptorVelocidex avatar

    Velocidex/velociraptor

    3,769View on GitHub↗

    Velociraptor is a digital forensics and incident response platform, endpoint detection and response system, and visibility tool. It provides a query engine and remote forensic collector used to hunt for indicators of compromise and perform triage across a fleet of hosts. The system is distinguished by its specialized query language for interrogating host state and parsing binary files. It features a notebook environment that combines markdown documentation with executable query cells to standardize investigative workflows and enable collaborative reporting. The platform covers a wide range o

    Godigital-forensicsendpoint-discoveryendpoint-protection
    View on GitHub↗3,769
  • neo23x0/lokiNeo23x0 avatar

    Neo23x0/Loki

    3,763View on GitHub↗

    Loki is an endpoint detection tool, forensic artifact analyzer, and threat intelligence scanner. It functions as a YARA-based indicator of compromise scanner designed to identify malicious persistence mechanisms, web shells, and unauthorized administration tools across local and remote systems. The project distinguishes itself by integrating multi-source threat intelligence, allowing for the loading of custom signature sets and encrypted indicators. It combines hash-based artifact detection with YARA rule execution to scan files, process memory, and registry hives for known malicious byte seq

    Python
    View on GitHub↗3,763
Compare all 30 related projects→

Frequently asked questions

What does ufrisk/memprocfs do?

MemProcFS is a volatile memory analysis tool and cross-platform memory acquisition system. It functions as a memory forensic virtual file system, mapping physical memory and kernel objects into a virtual directory structure that allows users to analyze system artifacts using standard file system tools.

What are the main features of ufrisk/memprocfs?

The main features of ufrisk/memprocfs are: Memory Analysis, Memory Forensics, Volatile Memory Acquisition Tools, Debug Symbol Resolvers, YARA Rule Execution, Virtual File Systems, Forensic Memory Virtualization, Forensic Agent Communication.

Which projects share features with ufrisk/memprocfs?

Projects with overlapping indexed features include: ufrisk/pcileech — pcileech is a toolkit for executing DMA attacks, analyzing PCIe bus traffic, performing kernel patching, and… volatilityfoundation/volatility3 — Volatility3 is a memory forensics framework and analysis tool used to parse volatile memory dumps. It extracts digital… velocidex/velociraptor — Velociraptor is a digital forensics and incident response platform, endpoint detection and response system, and… neo23x0/loki — Loki is an endpoint detection tool, forensic artifact analyzer, and threat intelligence scanner. It functions as a… volatilityfoundation/volatility — Volatility is a memory forensics framework and digital forensics tool designed to extract and analyze evidence from… dotnet/diagnostics — The diagnostics project provides a cross-platform diagnostic infrastructure and command-line toolkit for monitoring…