fridaforge 0.3.0__py3-none-any.whl

fridaforge/__init__.py

@@ -0,0 +1,5 @@
+"""FridaForge: generate Frida scripts from IDA Pro and Binary Ninja."""
+
+from fridaforge._version import __version__
+
+__all__ = ["__version__"]

fridaforge/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

fridaforge/backend.py

@@ -0,0 +1,74 @@
+"""Host-agnostic backend interface for FridaForge commands."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum, auto
+
+
+class ContextKind(Enum):
+    """The host context a command needs to run."""
+
+    GLOBAL = auto()    # only the module is needed
+    ADDRESS = auto()   # the current address is needed
+    FUNCTION = auto()  # the current function is needed
+
+
+@dataclass(frozen=True)
+class FunctionRef:
+    """A resolved reference to a function in the loaded binary."""
+
+    start: int
+    name: str
+
+
+class Backend(ABC):
+    """The port each host (Binary Ninja, IDA) must implement."""
+
+    @abstractmethod
+    def get_module_name(self) -> str:
+        """Return the loaded module's base file name."""
+
+    @abstractmethod
+    def get_image_base(self) -> int:
+        """Return the image base address of the loaded binary."""
+
+    @abstractmethod
+    def get_current_address(self) -> int | None:
+        """Return the currently selected address, or ``None``."""
+
+    @abstractmethod
+    def get_current_function(self) -> FunctionRef | None:
+        """Return the currently selected function, or ``None``."""
+
+    @abstractmethod
+    def get_section_name_at(self, addr: int) -> str | None:
+        """Return the name of the section/segment containing *addr*."""
+
+    @abstractmethod
+    def get_instruction_mnemonic(self, addr: int) -> str | None:
+        """Return the mnemonic of the instruction at *addr*, or ``None``."""
+
+    @abstractmethod
+    def copy_to_clipboard(self, text: str) -> bool:
+        """Copy *text* to the system clipboard. Return success."""
+
+    @abstractmethod
+    def log_info(self, msg: str) -> None:
+        """Emit an informational message in the host's idiom."""
+
+    @abstractmethod
+    def log_warn(self, msg: str) -> None:
+        """Emit a warning message in the host's idiom."""
+
+    # --- concrete helpers shared by all hosts ---
+
+    def get_relative_address(self, addr: int) -> str:
+        """Return *addr*'s offset from the image base as a hex string."""
+        return hex(addr - self.get_image_base())
+
+    def _resolve_function_name(self, start: int, raw_name: str) -> str:
+        """Return *raw_name*, or a ``sub_<offset>`` fallback when empty."""
+        if raw_name:
+            return raw_name
+        relative_address = self.get_relative_address(start)
+        return f"sub_{relative_address.removeprefix('0x')}"

fridaforge/commands/__init__.py

@@ -0,0 +1,24 @@
+"""FridaForge command registry."""
+
+from fridaforge.commands.base import Command
+from fridaforge.commands.hook_dlopen_functions import DlopenHooksCommand
+from fridaforge.commands.hook_function import FunctionHookCommand
+from fridaforge.commands.modify_section_protection import (
+    ModifySectionProtectionCommand,
+)
+from fridaforge.commands.negate_cond_branch_arm64 import (
+    NegateArm64CondBranchCommand,
+)
+from fridaforge.commands.negate_cond_branch_x86 import (
+    NegateX86CondBranchCommand,
+)
+
+ALL_COMMANDS: list[Command] = [
+    FunctionHookCommand(),
+    DlopenHooksCommand(),
+    ModifySectionProtectionCommand(),
+    NegateArm64CondBranchCommand(),
+    NegateX86CondBranchCommand(),
+]
+
+__all__ = ["Command", "ALL_COMMANDS"]

fridaforge/commands/base.py

@@ -0,0 +1,31 @@
+"""Base class for host-agnostic FridaForge commands."""
+
+from abc import ABC, abstractmethod
+
+from fridaforge.backend import Backend, ContextKind
+
+
+class Command(ABC):
+    """A single user-facing feature, independent of the host.
+
+    Subclasses set the metadata class attributes and implement
+    :meth:`run`, which pulls data from the *backend* and copies the
+    generated snippet to the clipboard.
+    """
+
+    id: str
+    description: str
+    category: str
+    hotkey: str | None = None
+    context: ContextKind
+
+    @abstractmethod
+    def run(self, backend: Backend) -> None:
+        """Execute the command against the given backend."""
+
+    def _deliver(self, backend: Backend, snippet: str) -> None:
+        """Copy the snippet to the clipboard and report the outcome."""
+        if backend.copy_to_clipboard(snippet):
+            backend.log_info("Frida snippet copied to clipboard.")
+        else:
+            backend.log_warn("Failed to copy snippet to clipboard.")

fridaforge/commands/hook_dlopen_functions.py

@@ -0,0 +1,22 @@
+"""Command: generate Frida dlopen-family hooks."""
+
+from fridaforge.backend import Backend, ContextKind
+from fridaforge.commands.base import Command
+from fridaforge.core import DlopenHookGenerator
+
+
+class DlopenHooksCommand(Command):
+    id = "hook_dlopen_functions"
+    description = "Generate dlopen hooks (Basic for Android native libs)"
+    category = "Hooks"
+    hotkey = "Shift+D"
+    context = ContextKind.GLOBAL
+
+    def run(self, backend: Backend) -> None:
+        module_name = backend.get_module_name()
+        if not module_name:
+            backend.log_warn("Could not determine the module name.")
+            return
+
+        snippet = DlopenHookGenerator().generate(module_name)
+        self._deliver(backend, snippet)

fridaforge/commands/hook_function.py

@@ -0,0 +1,26 @@
+"""Command: generate a Frida function hook."""
+
+from fridaforge.backend import Backend, ContextKind
+from fridaforge.commands.base import Command
+from fridaforge.core import FunctionHookGenerator
+
+
+class FunctionHookCommand(Command):
+    id = "hook_function"
+    description = "Generate function hook"
+    category = "Hooks"
+    hotkey = "Shift+F"
+    context = ContextKind.FUNCTION
+
+    def run(self, backend: Backend) -> None:
+        func = backend.get_current_function()
+        if func is None:
+            backend.log_warn("No function at the current location.")
+            return
+
+        module_name = backend.get_module_name()
+        relative_address = backend.get_relative_address(func.start)
+        snippet = FunctionHookGenerator().generate(
+            module_name, relative_address, func.name
+        )
+        self._deliver(backend, snippet)

fridaforge/commands/modify_section_protection.py

@@ -0,0 +1,39 @@
+"""Command: generate a Frida section protection modification."""
+
+from fridaforge.backend import Backend, ContextKind
+from fridaforge.commands.base import Command
+from fridaforge.core import ModifySectionProtectionGenerator
+
+
+class ModifySectionProtectionCommand(Command):
+    id = "modify_section_protection"
+    description = "Modify current section permissions"
+    category = "Memory"
+    hotkey = "Shift+M"
+    context = ContextKind.ADDRESS
+
+    def run(self, backend: Backend) -> None:
+        addr = backend.get_current_address()
+        if addr is None:
+            backend.log_warn("Could not determine the current address.")
+            return
+
+        section_name = backend.get_section_name_at(addr)
+        if not section_name:
+            backend.log_warn(
+                f"Could not determine the containing section for {hex(addr)}."
+            )
+            return
+
+        if not section_name.startswith("."):
+            backend.log_warn(
+                f"Address is not in a standard section. "
+                f"(Section name: {section_name})"
+            )
+            return
+
+        module_name = backend.get_module_name()
+        snippet = ModifySectionProtectionGenerator().generate(
+            module_name, section_name
+        )
+        self._deliver(backend, snippet)

fridaforge/commands/negate_cond_branch_arm64.py

@@ -0,0 +1,42 @@
+"""Command: negate an ARM64 conditional branch."""
+
+from fridaforge.backend import Backend, ContextKind
+from fridaforge.commands.base import Command
+from fridaforge.core import NegateArm64CondBranchGenerator
+
+ARM64_COND_BRANCHES = {
+    "b.eq", "b.ne", "b.hs", "b.lo", "b.cs",
+    "b.mi", "b.pl", "b.vs", "b.vc",
+    "b.hi", "b.ls", "b.ge", "b.lt",
+    "b.gt", "b.le", "tbz", "tbnz",
+    "cbz", "cbnz",
+}
+
+
+class NegateArm64CondBranchCommand(Command):
+    id = "negate_cond_branch_arm64"
+    description = "Negate cond branch instruction (ARM64)"
+    category = "Patching"
+    hotkey = "Shift+A"
+    context = ContextKind.ADDRESS
+
+    def run(self, backend: Backend) -> None:
+        addr = backend.get_current_address()
+        if addr is None:
+            backend.log_warn("Could not determine the current address.")
+            return
+
+        mnemonic = (backend.get_instruction_mnemonic(addr) or "").lower()
+        if mnemonic not in ARM64_COND_BRANCHES:
+            backend.log_warn(
+                f"Instruction at {hex(addr)} ('{mnemonic}') "
+                f"is not a recognized ARM64 conditional branch."
+            )
+            return
+
+        module_name = backend.get_module_name()
+        relative_address = backend.get_relative_address(addr)
+        snippet = NegateArm64CondBranchGenerator().generate(
+            module_name, relative_address
+        )
+        self._deliver(backend, snippet)

fridaforge/commands/negate_cond_branch_x86.py

@@ -0,0 +1,44 @@
+"""Command: negate an x86 conditional branch."""
+
+from fridaforge.backend import Backend, ContextKind
+from fridaforge.commands.base import Command
+from fridaforge.core import NegateX86CondBranchGenerator
+
+X86_COND_BRANCHES = {
+    "je", "jne", "jz", "jnz",
+    "ja", "jnbe", "jae", "jnb", "jnc",
+    "jb", "jnae", "jc", "jbe", "jna",
+    "jg", "jnle", "jge", "jnl",
+    "jl", "jnge", "jle", "jng",
+    "jo", "jno", "js", "jns",
+    "jp", "jpe", "jnp", "jpo",
+}
+
+
+class NegateX86CondBranchCommand(Command):
+    id = "negate_cond_branch_x86"
+    description = "Negate cond branch instruction (x86)"
+    category = "Patching"
+    hotkey = "Shift+X"
+    context = ContextKind.ADDRESS
+
+    def run(self, backend: Backend) -> None:
+        addr = backend.get_current_address()
+        if addr is None:
+            backend.log_warn("Could not determine the current address.")
+            return
+
+        mnemonic = (backend.get_instruction_mnemonic(addr) or "").lower()
+        if mnemonic not in X86_COND_BRANCHES:
+            backend.log_warn(
+                f"Instruction at {hex(addr)} ('{mnemonic}') "
+                f"is not a recognized x86 conditional branch."
+            )
+            return
+
+        module_name = backend.get_module_name()
+        relative_address = backend.get_relative_address(addr)
+        snippet = NegateX86CondBranchGenerator().generate(
+            module_name, relative_address
+        )
+        self._deliver(backend, snippet)

fridaforge/core/__init__.py

@@ -0,0 +1,63 @@
+"""Base class for Frida snippet generators.
+
+Every generator **must** subclass :class:`SnippetGenerator` and:
+
+1. Set the ``template_filename`` class attribute to the name of a
+   JavaScript template file located in the ``templates/`` directory.
+2. Implement a ``generate()`` method with explicit, typed parameters
+   that builds a placeholder mapping and delegates to :meth:`_render`.
+
+Both constraints are validated at class-creation time; forgetting
+either one raises :class:`TypeError` immediately.
+"""
+
+from collections.abc import Mapping
+
+from fridaforge.core.utils import fill_template, read_template
+
+
+class SnippetGenerator:
+    """Abstract base for all Frida snippet generators."""
+
+    template_filename: str
+
+    def __init_subclass__(cls, **kwargs: object) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if not getattr(cls, "template_filename", None):
+            raise TypeError(
+                f"{cls.__name__} must define 'template_filename' "
+                f"as a non-empty class attribute."
+            )
+
+        if "generate" not in cls.__dict__:
+            raise TypeError(
+                f"{cls.__name__} must implement a 'generate()' method."
+            )
+
+    def _render(self, placeholders: Mapping[str, str | int]) -> str:
+        """Read the template, substitute placeholders, and return the result."""
+        template = read_template(self.template_filename)
+        return fill_template(template, placeholders)
+
+
+from fridaforge.core.hook_dlopen_functions import DlopenHookGenerator
+from fridaforge.core.hook_function import FunctionHookGenerator
+from fridaforge.core.modify_section_protection import (
+    ModifySectionProtectionGenerator,
+)
+from fridaforge.core.negate_cond_branch_arm64 import (
+    NegateArm64CondBranchGenerator,
+)
+from fridaforge.core.negate_cond_branch_x86 import (
+    NegateX86CondBranchGenerator,
+)
+
+__all__ = [
+    "SnippetGenerator",
+    "DlopenHookGenerator",
+    "FunctionHookGenerator",
+    "ModifySectionProtectionGenerator",
+    "NegateArm64CondBranchGenerator",
+    "NegateX86CondBranchGenerator",
+]

fridaforge/core/hook_dlopen_functions.py

@@ -0,0 +1,14 @@
+"""Generator for Frida dlopen hook snippets."""
+
+from fridaforge.core import SnippetGenerator
+
+
+class DlopenHookGenerator(SnippetGenerator):
+    """Generate a Frida script that hooks dlopen-family functions."""
+
+    template_filename = "hook_dlopen_functions.js"
+
+    def generate(self, module_name: str) -> str:
+        return self._render({
+            "MODULE_NAME_PLACEHOLDER": module_name,
+        })

fridaforge/core/hook_function.py

@@ -0,0 +1,21 @@
+"""Generator for Frida function hook snippets."""
+
+from fridaforge.core import SnippetGenerator
+
+
+class FunctionHookGenerator(SnippetGenerator):
+    """Generate a Frida ``Interceptor.attach`` script for a function."""
+
+    template_filename = "hook_function.js"
+
+    def generate(
+        self,
+        module_name: str,
+        function_relative_address: str,
+        function_name: str,
+    ) -> str:
+        return self._render({
+            "MODULE_NAME_PLACEHOLDER": module_name,
+            "FUNCTION_RELATIVE_ADDRESS_PLACEHOLDER": function_relative_address,
+            "FUNCTION_NAME_PLACEHOLDER": function_name,
+        })

fridaforge/core/modify_section_protection.py

@@ -0,0 +1,15 @@
+"""Generator for Frida section protection modification snippets."""
+
+from fridaforge.core import SnippetGenerator
+
+
+class ModifySectionProtectionGenerator(SnippetGenerator):
+    """Generate a Frida script that sets a section's protection to rwx."""
+
+    template_filename = "modify_section_protection.js"
+
+    def generate(self, module_name: str, section_name: str) -> str:
+        return self._render({
+            "MODULE_NAME_PLACEHOLDER": module_name,
+            "SECTION_NAME_PLACEHOLDER": section_name,
+        })

fridaforge/core/negate_cond_branch_arm64.py

@@ -0,0 +1,15 @@
+"""Generator for Frida ARM64 conditional branch negation snippets."""
+
+from fridaforge.core import SnippetGenerator
+
+
+class NegateArm64CondBranchGenerator(SnippetGenerator):
+    """Generate a Frida script that negates an ARM64 conditional branch."""
+
+    template_filename = "negate_cond_branch_arm64.js"
+
+    def generate(self, module_name: str, relative_address: str) -> str:
+        return self._render({
+            "MODULE_NAME_PLACEHOLDER": module_name,
+            "RELATIVE_ADDRESS_PLACEHOLDER": relative_address,
+        })

fridaforge/core/negate_cond_branch_x86.py

@@ -0,0 +1,15 @@
+"""Generator for Frida x86 conditional branch negation snippets."""
+
+from fridaforge.core import SnippetGenerator
+
+
+class NegateX86CondBranchGenerator(SnippetGenerator):
+    """Generate a Frida script that negates an x86 conditional branch."""
+
+    template_filename = "negate_cond_branch_x86.js"
+
+    def generate(self, module_name: str, relative_address: str) -> str:
+        return self._render({
+            "MODULE_NAME_PLACEHOLDER": module_name,
+            "RELATIVE_ADDRESS_PLACEHOLDER": relative_address,
+        })

fridaforge/core/utils.py

@@ -0,0 +1,33 @@
+"""Template loading and placeholder substitution utilities."""
+
+import os
+from collections.abc import Mapping
+
+TEMPLATES_DIR = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)), "..", "templates"
+)
+
+
+def read_template(template_filename: str) -> str:
+    """Read a JavaScript template file from the templates directory.
+
+    :param template_filename: The file name of the template
+        (e.g. ``hook_function.js``).
+    :return: The raw template content as a string.
+    """
+    filepath = os.path.join(TEMPLATES_DIR, template_filename)
+    with open(filepath, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def fill_template(template: str, data_to_replace: Mapping[str, str | int]) -> str:
+    """Replace ``[PLACEHOLDER]`` tokens in a template with actual values.
+
+    :param template: The template string containing placeholders.
+    :param data_to_replace: A mapping of placeholder names (without
+        brackets) to their replacement values.
+    :return: The filled template string.
+    """
+    for placeholder, value in data_to_replace.items():
+        template = template.replace(f"[{placeholder}]", str(value))
+    return template

fridaforge/templates/hook_dlopen_functions.js

@@ -0,0 +1,32 @@
+(function () {
+    const moduleName = "[MODULE_NAME_PLACEHOLDER]"; 
+
+    function hookOnLibraryLoad(dlopenFunctionAddr) {
+        Interceptor.attach(dlopenFunctionAddr, {
+            onEnter: function (args) {
+                const loadPath = args[0].readCString();
+                if (loadPath != null && loadPath.includes(moduleName)) {
+                    this.isTarget = true;
+                }
+            },
+            onLeave: function () {
+                if (this.isTarget) {
+                    console.log(`[+] ${moduleName} loaded!`);
+
+                    // ** Your code goes in here... **
+
+                    this.isTarget = false;
+                }
+            }
+        });
+    } 
+
+    const dlopenFunctions = ["dlopen", "android_dlopen_ext"];
+    for (let i = 0; i < dlopenFunctions.length; i++) {
+        const address = Module.getGlobalExportByName(dlopenFunctions[i]);
+        if (address != null) {
+            hookOnLibraryLoad(address);
+        }
+    }
+    
+})();

fridaforge/templates/hook_function.js

@@ -0,0 +1,27 @@
+(function () {
+    const moduleName = "[MODULE_NAME_PLACEHOLDER]"; 
+    const functionRelativeAddress = "[FUNCTION_RELATIVE_ADDRESS_PLACEHOLDER]";
+    const functionName = "[FUNCTION_NAME_PLACEHOLDER]";
+
+    const module = Process.findModuleByName(moduleName);
+    if (module != null) {
+        const targetAddr = module.base.add(functionRelativeAddress);
+        console.log(`[+] Hook installed for [${functionName}]`);
+        Interceptor.attach(targetAddr, {
+            onEnter: function (args) { 
+                console.log(`-> enetered [${functionName}] at [${targetAddr}]`);
+
+                // Your code goes here...
+
+            }, 
+            onLeave: function (retval) {
+                console.log(`<- leaving [${functionName}] at [${this.context.pc}]`);
+                
+                // Your code goes here...
+
+            }
+        });   
+    } else {
+        console.log("[!] Failed to find module");
+    }
+})();

fridaforge/templates/modify_section_protection.js

@@ -0,0 +1,36 @@
+(function () {
+    const moduleName = "[MODULE_NAME_PLACEHOLDER]"; 
+    const sectionName = "[SECTION_NAME_PLACEHOLDER]";
+
+    const module = Process.findModuleByName(moduleName);
+    if (module != null) {
+        let target;
+
+        const sections = module.enumerateSections()
+        for (let i = 0; i < sections.length; i++) {
+            const section = sections[i];
+            if (section.name == sectionName) {
+                target = section;
+                break;
+            }
+        }
+
+        if (target) {
+            const newPrermissions = 'rwx' // <-------- ** CHANGE THIS ACCORDING TO YOUR NEEDS **
+
+            console.log(`[+] Found section [${target.name}] at ${target.address}. size: ${target.size} (bytes)`);
+            console.log(`\tAttempting to change permissions from [${Memory.queryProtection(target.address)}] to [${newPrermissions}]`);
+            const protectionResult = Memory.protect(target.address, target.size, newPrermissions);
+            if (protectionResult) {
+                console.log(`\tSuccess! [${Memory.queryProtection(target.address)}]`);
+            } else {
+                console.log(`[!] Failed to change memory protection`);
+            }
+        } else {
+            console.log(`[!] Failed to find section ${sectionName}`);
+        }
+
+    } else {
+        console.log("[!] Failed to find module");
+    }
+})();

fridaforge/templates/negate_cond_branch_arm64.js

@@ -0,0 +1,30 @@
+(function () {
+    const moduleName = "[MODULE_NAME_PLACEHOLDER]"; 
+    const condBranchRelAddr = "[RELATIVE_ADDRESS_PLACEHOLDER]";
+
+    const module = Process.findModuleByName(moduleName);
+    if (module != null) {
+        const targetAddr = module.base.add(condBranchRelAddr);
+
+        console.log(`[+] Negating conditional branch at ${targetAddr}`);
+        console.log(`\tbefore: ${Instruction.parse(targetAddr)}`);
+        Memory.patchCode(targetAddr, 4, code => {
+            const raw = targetAddr.readU32();
+            let xorMask;
+            if ((raw & 0xFF000010) === 0x54000000) {
+                xorMask = 1;            // b.cond: condition in bit 0
+            } else if ((raw & 0x7E000000) === 0x36000000) {
+                xorMask = 1 << 24;     // tbz/tbnz: op in bit 24
+            } else if ((raw & 0x7E000000) === 0x34000000) {
+                xorMask = 1 << 24;     // cbz/cbnz: op in bit 24
+            } else {
+                console.log("[!] Unrecognized conditional branch encoding");
+                return;
+            }
+            code.writeU32(raw ^ xorMask);
+        });
+        console.log(`\tafter: ${Instruction.parse(targetAddr)}`);
+    } else {
+        console.log("[!] Failed to find module");
+    }
+})();

fridaforge/templates/negate_cond_branch_x86.js

@@ -0,0 +1,35 @@
+(function () {
+    const moduleName = "[MODULE_NAME_PLACEHOLDER]"; 
+    const condBranchRelAddr = "[RELATIVE_ADDRESS_PLACEHOLDER]";
+
+    const module = Process.findModuleByName(moduleName);
+    if (module != null) {
+        const targetAddr = module.base.add(condBranchRelAddr);
+
+        console.log(`[+] Negating conditional branch at ${targetAddr}`);
+        console.log(`\tbefore: ${Instruction.parse(targetAddr)}`);
+
+        let patchPtr;
+
+        const firstByte = targetAddr.readU8();
+        if (firstByte === 0x0F) {
+            const secondByte = targetAddr.add(1).readU8();
+            if ((secondByte & 0xF0) === 0x80) {
+                patchPtr = targetAddr.add(1);
+            }
+        } else if ((firstByte & 0xF0) === 0x70) {
+            patchPtr = targetAddr;
+        }
+
+        if (patchPtr) {
+            Memory.patchCode(patchPtr, 1, code => {
+                const raw = patchPtr.readU8();
+                code.writeU8(raw ^ 1);
+            })
+        }
+
+        console.log(`\tafter: ${Instruction.parse(targetAddr)}`);
+    } else {
+        console.log("[!] Failed to find module");
+    }
+})();

fridaforge-0.3.0.dist-info/METADATA

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: fridaforge
+Version: 0.3.0
+Summary: Generate Frida scripts from IDA Pro, Binary Ninja, and Ghidra
+Author: noobexon1
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/noobexon1/FridaForge
+Project-URL: Issues, https://github.com/noobexon1/FridaForge/issues
+Keywords: frida,binary-ninja,ida-pro,ghidra,reverse-engineering
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Disassemblers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<div align="center">
+
+<img src="https://raw.githubusercontent.com/noobexon1/FridaForge/main/assets/logo.jpg" alt="FridaForge logo"/>
+
+**Generate Frida scripts directly from IDA Pro, Binary Ninja, and Ghidra.** ⚡
+
+[![GitHub release](https://img.shields.io/github/v/release/noobexon1/FridaForge)](https://github.com/noobexon1/FridaForge/releases)
+[![GitHub stars](https://img.shields.io/github/stars/noobexon1/FridaForge)](https://github.com/noobexon1/FridaForge/stargazers)
+[![GitHub last commit](https://img.shields.io/github/last-commit/noobexon1/FridaForge)](https://github.com/noobexon1/FridaForge/commits)
+[![GitHub issues](https://img.shields.io/github/issues/noobexon1/FridaForge)](https://github.com/noobexon1/FridaForge/issues)
+[![GitHub downloads](https://img.shields.io/github/downloads/noobexon1/FridaForge/total)](https://github.com/noobexon1/FridaForge/releases)
+[![Release](https://img.shields.io/github/actions/workflow/status/noobexon1/FridaForge/release.yml?label=release)](https://github.com/noobexon1/FridaForge/actions/workflows/release.yml)
+![IDA Pro](https://img.shields.io/badge/IDA%20Pro-Plugin-blue)
+![Binary Ninja](https://img.shields.io/badge/Binary%20Ninja-Plugin-orange)
+![Ghidra](https://img.shields.io/badge/Ghidra-Plugin-green)
+![Frida](https://img.shields.io/badge/Frida-Instrumentation-red)
+[![GitHub License](https://img.shields.io/github/license/noobexon1/FridaForge)](LICENSE)
+
+</div>
+
+## 📸 Examples
+
+**Generate a function hook** — right-click in the disassembly/pseudocode view and pick an action:
+
+![Generating a function hook from the FridaForge context menu](https://raw.githubusercontent.com/noobexon1/FridaForge/main/assets/Screenshot_1.jpg)
+
+**Get a ready-to-use Frida script** — copied straight to your clipboard:
+
+![The generated Frida hook script](https://raw.githubusercontent.com/noobexon1/FridaForge/main/assets/Screenshot_2.jpg)
+
+## ✨ Features
+
+Right-click (or hit a hotkey) in your disassembler to generate ready-to-use Frida snippets — the result is instantly copied to your clipboard.
+
+- 🧩 **Composable scripts** — snippets are independent but can be nested to build complex instrumentation with a few clicks
+- 🎯 **Context-aware** — scripts auto-fill module name, function address, section, and any other detail available from your current context
+- 🧰 **Three hosts, one experience** — identical features, hotkeys, and menus in IDA Pro, Binary Ninja, and Ghidra
+- 📋 **Clipboard integration** — generated scripts are copied the moment you run an action
+
+### Supported Actions
+
+#### 🪝 Hooks
+
+| Action | Description | Hotkey |
+|---|---|---|
+| Generate function hook | Intercept calls to the selected function, log entry/exit | `Shift+F` |
+| Generate dlopen hooks | Monitor `dlopen` (including Android variants) to detect module loading | `Shift+D` |
+
+#### 🧠 Memory
+
+| Action | Description | Hotkey |
+|---|---|---|
+| Modify section protection | Change memory protection of the section at the current address | `Shift+M` |
+
+#### 🩹 Patching
+
+| Action | Description | Hotkey |
+|---|---|---|
+| Negate cond branch (ARM64) | Flip the condition of an ARM64 conditional branch | `Shift+A` |
+| Negate cond branch (x86/x64) | Flip the condition of an x86/x64 conditional branch | `Shift+X` |
+
+## 🔧 How it Works
+
+Each feature follows a simple pipeline: a **Frida template** (`fridaforge/templates/`) provides the JavaScript skeleton with placeholders, a **command** (`fridaforge/commands/`) gathers context through a host-agnostic **Backend**, and a **generator** (`fridaforge/core/`) fills the template to produce the final script.
+
+The shared core knows nothing about IDA, Binary Ninja, or Ghidra. Each host lives in `hosts/` and provides a thin **adapter** that implements the `Backend` interface (data extraction, clipboard, menu + hotkey registration). Add a feature once and it works in all three.
+
+## 📦 Installation
+
+Binary Ninja users can install straight from the Extension Manager. For everything else, grab the archive for your tool from the [latest release](https://github.com/noobexon1/FridaForge/releases). There's one per host — `fridaforge-binja-<version>.zip`, `fridaforge-ida-<version>.zip`, and `fridaforge-ghidra-<version>.zip`.
+
+### 🟠 Binary Ninja
+
+**Extension Manager (recommended):** open the Extension Manager (**Plugins → Manage Plugins**), search for **FridaForge**, and click **Install**. The shared core (`fridaforge` on PyPI) is installed automatically. Restart Binary Ninja if prompted.
+
+**Manual install:**
+
+1. Find your user plugins directory by running this in Binary Ninja's Python console:
+   ```python
+   binaryninja.user_plugin_path()
+   ```
+2. Extract `fridaforge-binja-<version>.zip` into that directory so that `<binja user plugins>/fridaforge/` exists.
+3. Restart Binary Ninja.
+
+> Switching from a manual install to the Extension Manager? Delete `<binja user plugins>/fridaforge/` first. Otherwise both copies load and every command appears twice.
+
+### 🔵 IDA Pro
+
+1. **Prerequisites:**
+   - IDA Pro (tested with 9.0, but any version with Python 3 and `idaapi` should work).
+   - PyQt5 for clipboard functionality (usually bundled with IDA's Python).
+2. Locate your IDA Pro user directory by running this in IDA's Python console:
+    ```python
+    import ida_diskio; print(ida_diskio.get_user_idadir())
+    ```
+    If not already there, create a `plugins` directory in the user directory. This is where the plugin will be installed.
+3. Extract `fridaforge-ida-<version>.zip` into the `plugins` directory.
+4. Restart IDA Pro. The plugin loads automatically. You should see FridaForge as an option after right-clicking in the disassembly view.
+
+### 🐉 Ghidra
+
+1. **Prerequisites:** Ghidra **11.3 or later** (PyGhidra ships bundled; no extra install needed).
+2. Unzip `fridaforge-ghidra-<version>.zip` into a folder of your choice.
+3. In Ghidra's CodeBrowser, open **Window → Script Manager**, click **Manage Script Directories** (the toolbar icon), and add the unzipped folder.
+4. The five actions appear under **Tools → FridaForge** (categorized into Hooks / Memory / Patching) and respond to the hotkeys `Shift+F/D/M/A/X`. The generated Frida script is copied to your clipboard; `[FridaForge]` messages print to the Ghidra console.
+
+> Ghidra actions are delivered as menu items + hotkeys (not a nested right-click popup), which is the supported integration path for PyGhidra scripts.
+
+### 🧱 Script Composition
+
+Snippets are designed to be independent building blocks. You can nest scripts inside each other — for example, hook a function, negate a conditional branch on entry, and restore it on exit. Complex instrumentation from a few clicks.
+
+## 🛠️ Building from Source
+
+```bash
+pip install pytest build
+pytest -v                     # run the host-agnostic test suite
+python build/build.py         # writes dist/fridaforge-binja-*.zip, dist/fridaforge-ida-*.zip and dist/fridaforge-ghidra-*.zip
+python -m build               # builds the fridaforge core package (sdist + wheel) published to PyPI
+```
+
+Builds are deterministic — the same source produces byte-identical archives.
+
+To release, run `python build/bump_version.py X.Y.Z`, commit, and push tag `vX.Y.Z`. CI publishes the core to PyPI, then attaches the three archives to a GitHub release.
+
+## 🤝 Contributing
+
+Contributions welcome! Got a useful Frida snippet? Turn it into a template so everyone can use it.
+
+1. Fork the repository.
+2. Create a new branch for your feature or fix.
+3. Make your changes (and add a test — the core is fully unit-tested without needing a host).
+4. Submit a pull request.
+
+| Adding... | Where |
+|---|---|
+| New Frida snippet | `fridaforge/templates/` (JS template) + `fridaforge/core/` (generator) + `fridaforge/commands/` (command) |
+| Host-specific behavior | `hosts/binja/` or `hosts/ida/` |
+
+Each command and generator lives in its own file — easy to contribute without merge conflicts.
+
+## 🗺️ Roadmap
+
+See [open issues](https://github.com/noobexon1/FridaForge/issues) for planned features and known bugs.
+
+## 📄 License
+
+[MIT](LICENSE)

fridaforge-0.3.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+fridaforge/__init__.py,sha256=4ta_Zh_8JSEfZq6VYqfMPXSiK_wG8Z3rFe_0BwBhbmk,144
+fridaforge/_version.py,sha256=VrXpHDu3erkzwl_WXrqINBm9xWkcyUy53IQOj042dOs,22
+fridaforge/backend.py,sha256=wBMlXB2SUkgZm34ZVcXDwG5PocHwHUW1J2d_XNyQA9M,2407
+fridaforge/commands/__init__.py,sha256=NdJuxFdKQxTgl7_CL8MVLIx1Is3A_g6KlmVu-pX3FAY,739
+fridaforge/commands/base.py,sha256=pzWnW4Mq6l1FMi83k3feMqmipHmAJeqP-RSdPplV8wc,978
+fridaforge/commands/hook_dlopen_functions.py,sha256=yCzxtCFcW2qsp_88HZ0tlg2u2NLcMEoc5jv-yU3eBAs,733
+fridaforge/commands/hook_function.py,sha256=FNcf4lh6YGNi4q1oZw6xfEez_mIacgI3ChJuuz2xwRA,859
+fridaforge/commands/modify_section_protection.py,sha256=3oTmdS9xyqJwN3goHS7ou7OdzxHxc4JN7Obk6kDDQII,1300
+fridaforge/commands/negate_cond_branch_arm64.py,sha256=j8Tn1pBQC8BeY5hAHykjK-rK3wsBQ2AGFFY4LbEeE1Q,1415
+fridaforge/commands/negate_cond_branch_x86.py,sha256=YvDraHVxzQaA8KZZiFsLucfP9nqOMAGRl9obNKQiqPU,1459
+fridaforge/core/__init__.py,sha256=ko96ZbhAuM6ZQvDbip09jQRVevjVA4h1bTSFGSyNq04,2084
+fridaforge/core/hook_dlopen_functions.py,sha256=jQ2v6v89lnlxLwmyYcETtkg-aD2tsA1uYXv81e2l2vU,406
+fridaforge/core/hook_function.py,sha256=k3ocxuxWNBsur80NXnTQAaTS-X7UEKL1lKyqYGOSBgw,632
+fridaforge/core/modify_section_protection.py,sha256=JXhd3aI8iHrOV6LOW4bpyOshxnhu347i_grsEEc2BDA,521
+fridaforge/core/negate_cond_branch_arm64.py,sha256=d60ZI5URwwN9xnODopCbs1lCx34LJ8qglnTdoLeSm9o,533
+fridaforge/core/negate_cond_branch_x86.py,sha256=AWMn3TL5XCH2GJoq4Uj7I2mSm8rj3m7YiLkE3rTDx1g,525
+fridaforge/core/utils.py,sha256=HrIAufxYmkcT9fahSnyDSO1dBoYIkiuhvNhj3n9H-ao,1159
+fridaforge/templates/hook_dlopen_functions.js,sha256=CR2thp5PaD7kQXfTnZHARWivy2ZYt2mEFAoNUdMXpBg,989
+fridaforge/templates/hook_function.js,sha256=qRflfuljNEsak2AKRDPTEfnqchi1hdVK8pgD4qM4fJQ,933
+fridaforge/templates/modify_section_protection.js,sha256=82T9gnbkIPdZBc3pYmKOGJGfJMEGMxRsS-8CytGelbI,1372
+fridaforge/templates/negate_cond_branch_arm64.js,sha256=hDDIqMqe8krjNju2g7FeenPpr9S6s-a8L9kPhZC7qUc,1245
+fridaforge/templates/negate_cond_branch_x86.js,sha256=z9GY73mmXP3UO_lNaNhVbtCHxvqDCxcBL-0VTUgwMIY,1117
+fridaforge-0.3.0.dist-info/licenses/LICENSE,sha256=ZSX9KeL8nzVwiFiEpXKkZi6NNBKnVpv7zNbS1aJ3Pt0,1066
+fridaforge-0.3.0.dist-info/METADATA,sha256=UF_fUDhGd8rB4Fww0g-7BmnCpqlIT_JZNtOmlkPZMnU,8757
+fridaforge-0.3.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+fridaforge-0.3.0.dist-info/top_level.txt,sha256=6hd6j8PoEAtXqJFEJDyZi3obFDJqTr5MZOh5BUorw2c,11
+fridaforge-0.3.0.dist-info/RECORD,,

fridaforge-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fridaforge-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 noobexon1
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fridaforge-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fridaforge