awesome-repositories.com
Blog
awesome-repositories.com

Entdecke die besten Open-Source-Repositories mit KI-gestützter Suche.

EntdeckenKuratierte SuchenOpen-Source-AlternativenSelf-hosted SoftwareBlogSitemap
ProjektÜber unsRanking-MethodikPresseMCP-Server
RechtlichesDatenschutzAGB
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
HyperDbg avatar

HyperDbg/HyperDbg

0
View on GitHub↗
3,885 Stars·488 Forks·C·GPL-3.0·4 Aufrufehyperdbg.org↗

HyperDbg

HyperDbg is a hardware-assisted kernel-mode debugging platform that leverages virtualization to monitor and control system execution. By utilizing hypervisor-level primitives, it enables deep system analysis and instrumentation without relying on standard operating system debugging interfaces. The framework provides a comprehensive environment for inspecting both kernel and user-mode processes, allowing for granular control over execution flow and system state.

The project distinguishes itself through a transparent debugging layer designed to remain invisible to the target environment. It employs advanced techniques such as extended page table hooking and hardware-assisted branch recording to intercept memory access and processor control flow transitions. These capabilities allow for stealthy analysis, effectively bypassing common anti-debugging and anti-hypervisor detection mechanisms by masking timing discrepancies and avoiding traditional software hooks.

Beyond its core monitoring capabilities, the platform includes a robust scripting engine that supports event-driven automation. Users can define custom logic to execute in response to specific system triggers, enabling complex workflows like conditional breakpoints, automated memory patching, and real-time data manipulation. The system also supports remote debugging through a dedicated message bus, facilitating connectivity between a host debugger and a target machine via serial or network protocols.

The tool provides extensive support for symbol-based memory mapping, allowing users to translate raw addresses into human-readable data structures and function names. It is designed for installation and use across local and remote environments, including physical hardware and virtualized guests.

Features

  • Stealth Debugging Modes - Provides a hardware-assisted kernel-mode debugging platform that remains invisible to the target environment by leveraging hypervisor-level isolation.
  • Kernel-Mode Execution Models - Intercepts user-mode and kernel-mode activity using hardware-assisted virtualization to remain transparent to the target system.
  • Kernel Debuggers - Provides a kernel-mode debugging platform that uses hardware-assisted virtualization to monitor and control system execution.
  • Debugging and Analysis - Links the debugger to local or remote targets for kernel-mode and user-mode analysis.

KI-Suche

Entdecke weitere awesome Repositories

Beschreibe in einfachen Worten, was du brauchst — die KI bewertet tausende kuratierte Open-Source-Projekte nach Relevanz.

Start searching with AI
  • Stealth Debugging Layers - Conceals the analysis environment from the target system by masking timing discrepancies and avoiding standard software debugging interfaces.
  • System Memory Managers - Displays, edits, and searches memory regions and modifies processor registers.
  • Conditional Triggers - Triggers debugger pauses or events only when specific criteria, such as memory access or register states, are met.
  • Debug Session Management - Connects to, disconnects from, or listens for sessions to facilitate remote or local system analysis.
  • Instruction Stepping Tools - Executes the next instruction while automatically skipping over function calls.
  • Breakpoint Debugging - Inserts breakpoint instructions at specific memory addresses to pause execution in both user and kernel modes.
  • Stealth Breakpoint Interception - Intercepts execution at specific memory addresses using hardware virtualization to trigger debugging events without modifying the underlying code.
  • Remote Debugger Connectivity - Links a debugger host to a target machine via serial or network protocols for remote kernel-mode analysis.
  • Event-Driven Scripting - Executes custom logic or logging routines directly within the kernel when specific system events occur.
  • Hardware Exception Interceptors - Hooks specific processor faults, traps, or aborts within the interrupt descriptor table to trigger analysis.
  • System Debugging - Provides low-level system debugging capabilities for inspecting kernel and user-mode execution flow and state.
  • Virtual CPU Register Accessors - Provides read and write access to general-purpose, control, and debug registers for system state manipulation.
  • Memory Inspectors - Reads and displays memory at specific addresses in various formats including hex bytes, double-words, or quad-words, optionally scoped to a specific process or physical address.
  • Execution Flow Control - Provides capabilities for controlling execution paths, stepping through code, and pausing processes during debugging.
  • Virtual Machine Introspection Debugging - Inspects and controls the execution state of virtualized guest systems by hooking hardware events and memory access.
  • System and Hardware Event Hooks - Hooks processor instructions, interrupts, and memory operations to trigger custom logic during kernel and user-mode execution.
  • Hypervisor Presence Obfuscation - Obfuscates the analysis tool to resist detection by timing or microarchitectural attacks.
  • Cross-Mode Execution Debugging - Monitors both user-mode and kernel-mode processes by virtualizing the system for unified execution tracking.
  • System-Wide Virtualized Debugging - Monitors system execution by virtualizing the operating system to analyze both kernel and user-mode applications.
  • Stealthy Kernel Debugging - Uses hardware virtualization to monitor system events and memory access without modifying the target environment.
  • Memory Inspection Tools - Reads, writes, and searches raw memory contents to analyze data structures or inject changes into target processes.
  • Kernel Function Instrumentation - Uses hardware-assisted virtualization to intercept system events and monitor execution without modifying the target kernel.
  • Kernel Execution Analysis - Analyzes kernel-mode processes using a hypervisor to monitor memory and instruction flow without standard OS interfaces.
  • Stealthy Memory Hook Implementations - Intercepts memory access and execution using extended page tables to create invisible hooks.
  • Page Table Entry Management - Intercepts memory access and execution by manipulating page table permissions at the hardware level.
  • Physical and Virtual Memory Operations - Provides low-level primitives for reading and writing raw physical and virtual memory addresses to inspect or modify system state.
  • Processor State Managers - Views and updates CPU registers and flags to control execution flow during analysis.
  • Remote Kernel Debugging - Inspects and controls kernel state through breakpoints, instruction stepping, and memory modification.
  • System-Call Interception - Monitors system call execution with process-specific filtering and conditional triggering to modify system behavior.
  • Stealthy Execution Modifiers - Alters execution paths by modifying registers or memory from the hypervisor level, ensuring changes remain invisible.
  • EPT Execution Interceptors - Hooks memory addresses using Extended Page Tables to trigger debugger actions or custom code execution for high-performance stealth analysis.
  • Process and Thread Contexts - Provides the ability to switch between processes and threads to inspect specific execution contexts during debugging.
  • Anti-Debugger Bypassing - Evades detection by avoiding standard APIs and masking hypervisor presence against timing-based checks.
  • Anti-Debugging Evasion - Defeats anti-debugging techniques by masking timing discrepancies and avoiding standard interfaces.
  • Hypervisor Obfuscation - Hides the hypervisor from detection techniques to prevent software from identifying the analysis environment.
  • Transparent Debugging Modes - Conceals the analysis tool from detection mechanisms by enabling a transparent execution mode.
  • Hypervisor-Context Scripting - Runs user-defined logic within the hypervisor context upon specific events to modify registers or memory during runtime.
  • System Execution Interruptions - Pauses the target system and transfers control to the debugger for manual inspection.
  • Branch Execution Histories - Saves processor branch entries into internal storage to reconstruct and inspect execution control flow.
  • Function Hooking - Intercepts calls to specific kernel or user functions to monitor behavior, modify arguments, or redirect execution flow.
  • Stealthy Hook Implementations - Intercepts function calls using hidden hooks that operate with the speed of inline hooks while remaining invisible.
  • Memory Access Breakpoints - Tracks read, write, or execution operations on specific memory ranges using hardware virtualization to trigger debugger actions.
  • Debugging Event Triggers - Configures and transmits event triggers to the kernel to monitor specific system activities like instruction execution or memory hooks.
  • Conditional Debugging Triggers - Executes actions based on custom conditions defined via hex or assembly code.
  • Kernel Execution Path Tracing - Records function calls and return addresses to visualize execution paths and mode transitions.
  • Kernel-Mode Target Connections - Establishes a live connection to a target system for kernel-mode inspection and control.
  • Hardware Virtualization Monitoring - Leverages hardware virtualization to track memory operations and code coverage without modifying the target environment.
  • Process ID Attachment - Intercepts and halts execution threads of a specific process using its identifier for analysis.
  • Processor State Inspection - Reads processor registers, memory, and variables to provide a snapshot of the execution environment.
  • Processor Register Modifiers - Allows direct modification of processor registers and flags to alter execution flow during debugging.
  • Process Execution Control - Manages the lifecycle of applications under analysis by starting, attaching, or terminating processes.
  • Symbolic Data Structure Mapping - Maps memory layouts and creates custom structures based on symbols to simplify data interpretation.
  • Symbolic Memory Inspectors - Maps data, defines structures, and searches memory contents using symbol information to interpret complex system state.
  • Dynamic Analysis and Debugging - Switches debugging focus to specific processes or threads to isolate execution context.
  • Guest Execution Inspectors - Provides a debugging environment to halt and step through user-mode applications and execute scripts in both user and kernel modes.
  • Automated Debugging Workflows - Executes custom scripts and conditional logic to automate repetitive analysis tasks without manual intervention.
  • Debug Symbol Resolvers - Parses debugging symbols to map memory addresses to human-readable names and reconstruct data structures for inspection.
  • Iterative Task Execution - Repeats blocks of code using loops to automate repetitive analysis or data processing.
  • System Event Counters - Tracks and tallies the frequency of system events like page faults to identify performance patterns.
  • Memory Structure Overlays - Overlays defined data structures onto specific memory addresses to read or modify internal system values during debugging.
  • Remote User-Mode Debugging - Connects to remote targets via network to step through user-mode execution without kernel interruption.
  • Breakpoint Managers - Displays and manages configured breakpoints to control execution flow during analysis.
  • Session Termination - Safely stops analysis sessions by unloading kernel-mode drivers and modules.
  • Debugger Execution Resumption - Continues the execution of a paused debuggee in either local or remote debugging sessions after an interruption.
  • Event Filtering Logic - Triggers debugger actions only when specific criteria are met, allowing for precise control over execution flow.
  • Process Execution Restarting - Resets the execution of a previously started program with specified parameters and pauses execution automatically upon reaching the entry point.
  • Function Return Stepping - Enables stepping out of functions by executing until a return instruction is encountered.
  • Breakpoint Removal - Deletes active breakpoints from the target process or kernel to resume normal execution flow without interruption.
  • Debuggee - Calculates and displays the result of mathematical or memory-dereferencing expressions within the target system context.
  • Memory Pattern Searching - Scans memory ranges for byte sequences or values to locate data structures or code patterns.
  • Virtual - Scans memory ranges for specific byte, double-word, or quad-word patterns within a target process or kernel space to locate data.
  • Memory Search Tools - Scans a specified memory range or process for specific byte sequences or word values.
  • User-Mode Process Attachments - Connects to active user-mode processes at the hypervisor level to pause execution and intercept threads without standard OS APIs.
  • Execution Pausing - Interrupts the execution of a running user-mode thread to allow for instruction stepping or state inspection.
  • Symbol Table Inspection - Maps data structures and enumerations from symbol servers to interpret kernel memory.
  • Task Automation Scripts - Executes custom scripts to automate repetitive analysis routines and complex debugging workflows.
  • Hardware State Inspection - Dumps and inspects low-level system components including PCI devices, interrupt tables, and APIC configurations.
  • Code Injection Utilities - Executes user-defined machine code instructions in response to specific system events to extend debugger functionality.
  • System Resource Fault Injections - Triggers custom interrupts, exceptions, and page faults into the target environment to test stability and error handling.
  • Memory Symbol Resolution - Maps binary addresses to human-readable function names and source code using external symbol servers.
  • Model Specific Register Modifiers - Updates the value of specific model-specific registers on target processor cores during debugging sessions.
  • Navigation State Inspection - Switches between active processes and threads to inspect specific execution contexts within the target environment.
  • System-Level Debugging - Intercepts exceptions, interrupts, and Model Specific Register accesses to monitor low-level hardware interactions.
  • Assembly Assemblers - Converts human-readable assembly code into executable machine instructions and writes them directly into memory for analysis.
  • Custom Instrumentation Assemblers - Runs arbitrary machine code instructions when specific events trigger to perform low-level instrumentation.
  • Atomic Thread Synchronization - Implements spinlocks and atomic primitives to manage thread synchronization and prevent race conditions during debugging tasks.
  • Binary Assembly and Disassembly - Translates raw memory at specified virtual addresses into human-readable assembly instructions for analysis.
  • Binary Disassembly - Converts raw binary instructions into human-readable assembly language for analysis.
  • Disassemblers - Translates raw bytes at a specified physical memory address into human-readable assembly instructions for analysis and debugging purposes.
  • Structured Memory Dumping - Translates raw memory into defined data structures and enumerations using symbol information to visualize complex kernel objects.
  • Physical Memory Dumping - Transfers bytes between physical memory addresses for low-level data manipulation.
  • Guest Memory Analyzers - Dumps virtual memory to files and forces memory pages into RAM for detailed inspection.
  • CPUID Interceptors - Hooks the execution of CPUID instructions in kernel or user mode to inspect or modify register values.
  • System Instruction Interceptors - Intercepts execution of hardware-level instructions like CPUID, MSR, TSC, or I/O operations to analyze system behavior.
  • Time Stamp Counter Interceptions - Provides hooks for RDTSC and RDTSCP instructions to trigger debugger breaks or custom scripts during execution.
  • XSETBV Instruction Interceptors - Hooks the execution of the XSETBV instruction to monitor or modify system register states.
  • RDPMC Instruction Interceptors - Triggers debugger breaks upon execution of the RDPMC instruction to monitor performance counter access.
  • Cross-Core Synchronization Primitives - Maintains global variables accessible by multiple cores to synchronize analysis tasks.
  • Multi-Core Spinlock Synchronizers - Prevents race conditions when accessing shared global variables across multiple processor cores by implementing spinlocks within custom scripts.
  • Model Specific Register Inspection - Retrieves the current value of a specific model-specific register from processor cores to inspect low-level system configuration.
  • CPU Register Manipulators - Displays and updates processor registers and status flags to manipulate execution flow.
  • Debug Symbol Loaders - Loads debugging symbols and configures paths to map raw memory to human-readable names.
  • Debugging Symbol Managers - Loads, unloads, and refreshes symbol files to map memory addresses to human-readable names.
  • Debugger Process Management - Lists active system processes and switches the debugger context to specific processes for analysis.
  • Memory Access Validators - Verifies memory address accessibility to prevent system crashes during debugging operations.
  • Memory Address Identification - Verifies the validity of memory addresses to prevent errors during debugging.
  • Remote Physical Memory Writing - Writes byte, dword, or qword values directly to physical memory addresses to alter system state.
  • Execution Context Management - Controls thread contexts and memory mappings to isolate and examine specific execution flows.
  • Execution Mode Transition Monitors - Tracks switches between user-mode and kernel-mode execution to identify system calls, interrupts, or exceptions.
  • x86 I/O Port Accessors - Hooks specific hardware I/O port instructions to trigger debugger breaks or execute custom scripts.
  • Local Virtual Machine Attachments - Initiates a debugging session on the current host by inspecting the virtual machine state directly.
  • Hardware Interface Controllers - Reads and writes model-specific registers and checks CPU capabilities to interface directly with low-level processor features.
  • Hardware Debug Register Monitors - Intercepts and analyzes access to hardware debug registers using virtualization-based hooks to trigger custom scripts or debugger breaks.
  • Runtime Binary Patching - Modifies binary instructions of a running process by writing directly to memory to alter program behavior.
  • Kernel Component Debugging - Halts the system to perform deep kernel-mode analysis and instruction stepping via serial connections.
  • Physical Address Mapping - Resolves physical memory addresses to corresponding virtual addresses within process contexts.
  • Interrupt Descriptor Tables - Displays current entries of the Interrupt Descriptor Table to analyze interrupt handling.
  • External Interrupt Interceptors - Hooks hardware interrupts within the interrupt descriptor table to trigger analysis events before or after the interrupt is injected.
  • Process Context Selection - Allows isolating debugging operations to a specific process or thread context.
  • Kernel Execution Halters - Stops the entire system to allow stepping through and instrumenting individual kernel instructions.
  • Integer Atomic Operations - Executes thread-safe atomic arithmetic on shared variables across multiple processor cores to ensure accurate event counting.
  • Memory Address Translation Layers - Converts between virtual and physical memory addresses for low-level system inspection.
  • Memory Block Operations - Evaluates memory regions to identify differences or verify identical contents during debugging.
  • Memory Content Manipulation - Writes arbitrary values to memory addresses to patch code or modify data structures at runtime.
  • Multi-Process Debug Sessions - Manages and switches between multiple process or thread contexts to analyze complex multi-tasking environments.
  • Operating System State Analysis - Displays stack backtraces, loaded modules, and system status to provide context on the current execution environment.
  • Virtual Address Translators - Resolves virtual memory addresses to physical addresses, optionally scoped to specific processes.
  • Physical Memory Mapping - Reads, writes, searches, and disassembles raw physical memory for analysis.
  • Process Execution Launchers - Launches target applications from their entry point under debugger control to monitor execution from the start.
  • Process Memory Scanners - Scans physical or virtual memory ranges for specific patterns within target processes.
  • Process Tracing and Debugging - Enables attaching to and monitoring local or remote processes for stealthy analysis and reverse engineering.
  • Process Launch and Debugging - Executes target applications and pauses at the entry point for hypervisor-level analysis.
  • Raw Memory Block Copies - Transfers specified bytes between memory addresses to facilitate data inspection or modification.
  • Overlapping Memory Copies - Transfers data between virtual or physical memory addresses to facilitate inspection and modification.
  • Remote Debugging Bridges - Provides a dedicated message bus for connecting a host debugger to remote targets via serial or network protocols.
  • Local Host Debugging - Analyzes host system execution directly without needing remote hardware or nested virtualization.
  • Debugging Context Managers - Lists intercepted processes and threads and switches debugger focus between them using hypervisor-level control.
  • Hypercall Interceptors - Provides mechanisms to intercept and analyze hypercalls for monitoring system behavior and injecting custom logic.
  • System Instrumentation Frameworks - Provides a toolkit for intercepting processor events, memory access, and system instructions for real-time analysis.
  • System Memory Inspection - Reads, modifies, and searches for specific data patterns within system memory.
  • Memory Write Operations - Provides the ability to modify target process memory to alter program state during debugging.
  • Target Memory Reading - Retrieves and displays raw data from specific memory addresses in the debuggee using various formatting styles.
  • Modular Scripting - Organizes debugging and automation logic into discrete, dynamically loaded script files for improved maintainability.
  • Execution Thread Managers - Inspects active threads and switches execution context to specific threads for analysis.
  • Memory Dumpers - Writes specified ranges of virtual memory from a target process or system state to a local file.
  • Instruction-Level Debugging - Enables full control over virtualized environments, including pausing execution and instruction-level inspection.
  • Batch Scripts - Runs sequences of commands from text files to automate repetitive analysis or configuration tasks.
  • Execution Context Switching - Changes the debugger focus between processes and threads to analyze targeted execution flows.
  • Conditional Logic - Evaluates expressions based on register or memory states to branch execution flow using conditional structures.
  • Event-Driven Execution Halters - Stops all CPU cores when a specific event occurs, preventing further instructions from running until user permission.
  • Expression Evaluators - Processes expressions using standard syntax to support memory dereferencing and bitwise logic.
  • Scripted Analysis Evaluators - Executes mathematical expressions or multi-line scripts within the target process or kernel environment.
  • Halters - Triggers a debugger pause when specific memory conditions or function arguments are met during execution.
  • Thread-Synchronized Execution - Acquires spinlocks on global variables to ensure exclusive access to shared resources during multi-threaded script execution.
  • Program Execution - Modifies memory at a specific address to change the flow of a running program.
  • System Halting - Interrupts the processor and transfers control to the debugger to allow for manual inspection of system state.
  • Stack Backtrace Generators - Retrieves and displays the current thread's call stack, supporting both 32-bit and 64-bit execution environments.
  • Anti-Debugging Protections - Analyzes the environment to identify and report active anti-debugging or anti-hypervisor techniques.
  • Debugger Stealth - Exits transparent mode to stop hiding the debugger presence from the target system.
  • Malware Analysis - Monitors suspicious software behavior and intercepts system calls while remaining invisible to anti-debugging techniques.
  • Runtime Memory Patching - Modifies target memory addresses to patch code or alter data during runtime analysis.
  • Process Termination Utilities - Stops the execution of processes currently being monitored or attached to by the debugger.
  • System Context Retrievers - Exposes system state information such as process IDs, thread addresses, and environment block pointers through dedicated pseudo-registers.
  • Custom Logic Scripts - Performs complex calculations and data manipulations using a C-like scripting syntax.
  • Dynamic Function Interception - Hooks specific system or application functions to capture arguments and execution state for analysis.
  • Execution Flow Analyzers - Disassembles machine code and manages branch recording data to reconstruct and trace execution paths.
  • Event-Triggered - Halts all processor cores upon a triggered event to allow manual inspection of system state.
  • System - Stops the system and transfers control to the debugger for manual inspection.
  • Branch Record Exporters - Outputs captured branch entries to the console to visualize recent execution flow.
  • Memory Access Interception - Identifies which instructions read from or write to specific memory structures.
  • Hypervisor-Level Process Launches - Launches programs with hypervisor-level interception to avoid reliance on standard operating system APIs.
  • Debug Message Buses - Provides communication channels for routing system logs and debug information to external consoles.
  • Execution Event Hooks - Attaches user-defined callbacks to low-level execution events like instructions, memory access, and syscalls.
  • Execution Event Managers - Controls the triggering and forwarding of system events to monitor specific behaviors.
  • Programmatic Debugging Event Registration - Triggers specific debugging events or monitoring actions by sending control codes directly to the hypervisor interface.
  • System Event Handlers - Configures and triggers custom handlers for system-level activities including syscalls and interrupts.
  • System Event Managers - Controls the short-circuiting behavior of active system events to manage debugger processing.
  • User Register State Management - Displays and modifies processor registers and status flags to analyze execution state.
  • MSR Write Interceptors - Provides hooks to monitor or modify model-specific register writes at the hypervisor level.
  • Event Debugging Utilities - Configures custom triggers for kernel or user-mode events by sending control codes to the hypervisor.
  • Kernel Function Call Monitoring - Logs function calls and parameters to monitor program flow and kernel interactions.
  • System Return - Intercepts the execution of sysret instructions to track transitions from kernel-mode to user-mode.
  • Hardware Inspection - Provides tools for querying technical specifications and hardware metadata like PCI devices, IDT entries, and APIC modes.
  • Remote Debug Execution Control - Pauses execution, steps through kernel code, or resumes normal operation of a connected debuggee from the host.
  • Processor Core Selection - Provides the ability to switch the debugger's focus between different CPU cores for granular kernel-mode analysis.
  • System Logging and Debugging - Captures session output to log files to maintain a record of analysis events.
  • System Monitoring - Observes system behavior in a non-intrusive mode that buffers messages and avoids halting the target environment.
  • Event-Triggered Scripts - Executes custom scripts in response to specific system events to modify memory and register states.
  • Execution State Inspectors - Retrieves the current operational status of the target system, including connection details and active mode.
  • Binary Analysis - Provides a hypervisor-based debugger for Windows.

    • Star-Verlauf

    Star-Verlauf für hyperdbg/hyperdbgStar-Verlauf für hyperdbg/hyperdbg

    Open-Source-Alternativen zu HyperDbg

    Ähnliche Open-Source-Projekte, sortiert nach der Anzahl der gemeinsamen Funktionen mit HyperDbg.
    • pwndbg/pwndbgAvatar von pwndbg

      pwndbg/pwndbg

      10,051Auf GitHub ansehen↗

      pwndbg is a GDB plugin and binary analysis framework designed for reverse engineering, exploit development, and low-level program analysis. It extends the core functionality of the debugger to provide advanced memory inspection and automation tools. The project distinguishes itself with specialized capabilities for heap analysis across glibc, jemalloc, and musl, as well as a comprehensive kernel debugging toolkit for inspecting Linux kernel tasks and slab allocators. It includes an integrated ROP gadget searcher for constructing exploit chains and an LLM-powered debugging assistant that provi

      Pythonbinary-ninjacapture-the-flagctf
      Auf GitHub ansehen↗10,051
    • korcankaraokcu/pinceAvatar von korcankaraokcu

      korcankaraokcu/PINCE

      2,767Auf GitHub ansehen↗

      PINCE is a dynamic debugger, instruction tracer, and memory scanner designed for the analysis and manipulation of running processes. It functions as a process memory manipulator and editor, allowing for the identification, modification, and monitoring of values within a target application's active memory. The tool distinguishes itself through memory pointer analysis, tracing addresses and offsets to locate static pointers that lead to dynamic data across different sessions. It also enables the execution of internal functions within a running process by manipulating the instruction pointer and

      Pythonassemblercheat-enginedebugging-tool
      Auf GitHub ansehen↗2,767
    • puremourning/vimspectorAvatar von puremourning

      puremourning/vimspector

      4,306Auf GitHub ansehen↗

      Vimspector is a visual debugger integration for Vim that enables developers to step through code and inspect program state without leaving the editor. It utilizes the Debug Adapter Protocol to provide a unified interface for debugging multiple programming languages through various debug adapters. The project distinguishes itself by supporting low-level analysis and specialized environments, including bare metal hardware debugging for microcontrollers and the ability to perform disassembly analysis and process memory dumping. It also provides remote debugging capabilities by proxying requests

      Vim Scriptcppdebug-adapter-protocoldebugger
      Auf GitHub ansehen↗4,306
    • probe-rs/probe-rsAvatar von probe-rs

      probe-rs/probe-rs

      2,599Auf GitHub ansehen↗

      probe-rs is an embedded debugging toolset used for flashing, debugging, and inspecting microcontrollers via hardware debug probes. It functions as an embedded firmware flasher, a memory manager for reading and writing to processor registers, and a server implementing the Debug Adapter Protocol to connect hardware debugging to various code editors. The project includes a CMSIS-Pack target parser to extract device metadata and flash configurations from industry-standard definition files. It provides a driver-based probe abstraction to interact with various hardware debug probes regardless of th

      Rustarmarm-corescoresight
      Auf GitHub ansehen↗2,599
    Alle 30 Alternativen zu HyperDbg anzeigen→

    Häufig gestellte Fragen

    Was macht hyperdbg/hyperdbg?

    HyperDbg is a hardware-assisted kernel-mode debugging platform that leverages virtualization to monitor and control system execution. By utilizing hypervisor-level primitives, it enables deep system analysis and instrumentation without relying on standard operating system debugging interfaces. The framework provides a comprehensive environment for inspecting both kernel and user-mode processes, allowing for granular control over execution flow and system state.

    Was sind die Hauptfunktionen von hyperdbg/hyperdbg?

    Die Hauptfunktionen von hyperdbg/hyperdbg sind: Stealth Debugging Modes, Kernel-Mode Execution Models, Kernel Debuggers, Debugging and Analysis, Stealth Debugging Layers, System Memory Managers, Conditional Triggers, Debug Session Management.

    Welche Open-Source-Alternativen gibt es zu hyperdbg/hyperdbg?

    Open-Source-Alternativen zu hyperdbg/hyperdbg sind unter anderem: pwndbg/pwndbg — pwndbg is a GDB plugin and binary analysis framework designed for reverse engineering, exploit development, and… korcankaraokcu/pince — PINCE is a dynamic debugger, instruction tracer, and memory scanner designed for the analysis and manipulation of… puremourning/vimspector — Vimspector is a visual debugger integration for Vim that enables developers to step through code and inspect program… probe-rs/probe-rs — probe-rs is an embedded debugging toolset used for flashing, debugging, and inspecting microcontrollers via hardware… x64dbg/scyllahide — ScyllaHide is an anti-debugger bypass plugin and reverse engineering tool designed to hide a debugger from a target… hugsy/gef — GEF is a Python-based extension for GDB that serves as a framework for binary analysis, exploit development, and…