gdare2 0.1.0__py3-none-any.whl

gdare2/__init__.py

@@ -0,0 +1,4 @@
+"""gdare2: a radare2-shaped client for Ghidra."""
+
+__version__ = "0.1.0"
+PROTOCOL_VERSION = 1

gdare2/__main__.py

@@ -0,0 +1,3 @@
+from gdare2.cli import main
+
+raise SystemExit(main())

gdare2/arch_matrix.py

@@ -0,0 +1,33 @@
+"""Raw-binary architecture configurations used by the arch matrix."""
+
+from __future__ import annotations
+
+# Keep this list in sync with gdare2d.import_plan.resolve_alias.
+ARCH_MATRIX = (
+    {"name": "x86-16", "arch": "x86", "bits": "16", "endian": "little", "language": "x86:LE:16:Real Mode"},
+    {"name": "x86-32", "arch": "x86", "bits": "32", "endian": "little", "language": "x86:LE:32:default"},
+    {"name": "x86-64", "arch": "x86", "bits": "64", "endian": "little", "language": "x86:LE:64:default"},
+    {"name": "arm-le", "arch": "armle", "bits": "32", "endian": "little", "language": "ARM:LE:32:v7"},
+    {"name": "arm-be", "arch": "armbe", "bits": "32", "endian": "big", "language": "ARM:BE:32:v7"},
+    {"name": "aarch64-le", "arch": "aarch64", "bits": "64", "endian": "little", "language": "AARCH64:LE:64:v8A"},
+    {"name": "aarch64-be", "arch": "aarch64be", "bits": "64", "endian": "big", "language": "AARCH64:BE:64:v8A"},
+    {"name": "mips-le", "arch": "mipsle", "bits": "32", "endian": "little", "language": "MIPS:LE:32:default"},
+    {"name": "mips-be", "arch": "mipsbe", "bits": "32", "endian": "big", "language": "MIPS:BE:32:default"},
+    {"name": "mips64-le", "arch": "mips64le", "bits": "64", "endian": "little", "language": "MIPS:LE:64:default"},
+    {"name": "mips64-be", "arch": "mips64be", "bits": "64", "endian": "big", "language": "MIPS:BE:64:default"},
+    {"name": "ppc-be", "arch": "ppc", "bits": "32", "endian": "big", "language": "PowerPC:BE:32:default"},
+    {"name": "ppc-le", "arch": "ppcle", "bits": "32", "endian": "little", "language": "PowerPC:LE:32:default"},
+    {"name": "ppc64-be", "arch": "ppc64", "bits": "64", "endian": "big", "language": "PowerPC:BE:64:default"},
+    {"name": "ppc64-le", "arch": "ppc64le", "bits": "64", "endian": "little", "language": "PowerPC:LE:64:default"},
+    {"name": "riscv32", "arch": "riscv32", "bits": "32", "endian": "little", "language": "RISCV:LE:32:default", "bytes": "13000000"},
+    {"name": "riscv64", "arch": "riscv64", "bits": "64", "endian": "little", "language": "RISCV:LE:64:default", "bytes": "13000000"},
+    {"name": "m68k", "arch": "m68k", "bits": "32", "endian": "big", "language": "68000:BE:32:default"},
+    {"name": "sparc", "arch": "sparc", "bits": "32", "endian": "big", "language": "sparc:BE:32:default"},
+    {"name": "sparc64", "arch": "sparc64", "bits": "64", "endian": "big", "language": "sparc:BE:64:default"},
+    {"name": "sh2a", "arch": "sh2a", "bits": "32", "endian": "big", "language": "SuperH:BE:32:SH-2A"},
+    {"name": "sh2", "arch": "sh2", "bits": "32", "endian": "big", "language": "SuperH:BE:32:SH-2"},
+)
+
+# Default decode probe: X86 NOPs plus RET.  Entries may override it when the
+# pattern is not a valid instruction for that architecture.
+RAW_BYTES = bytes.fromhex("90909090c3")

gdare2/argv.py

@@ -0,0 +1,417 @@
+"""Hand-rolled radare2-style argument parser."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from gdare2.errors import UsageError
+
+VALUE_FLAGS = frozenset("abcBeIikmpst")
+BOOLEAN_FLAGS = frozenset("0A1E2fhjLnNqQSTuvVw")
+DOUBLED = ("AA", "NN", "qq", "LL", "nn")
+IGNORED = {
+    "0": "output is never NUL-separated",
+    "1": "use the shell's 2>&1 instead",
+    "2": "use the shell's 2>&1 instead",
+    "E": "edit the rc file directly",
+    "f": "use `b $s` to set the block size",
+    "k": "gdare2 does not do syscall resolution",
+    "M": "use -e asm.demangle=false",
+    "nn": "-n already covers this",
+    "Q": "teardown saving is negligible",
+    "S": "use -e cfg.sandbox=true",
+    "t": "Ghidra analyses the project itself",
+    "T": "Ghidra has no IDA-style hash cache",
+    "u": "gdare2 does not filter symbol names",
+}
+# Ignored short options that still take a value in radare2.
+IGNORED_VALUE = frozenset("k")
+
+REJECTED = {
+    "C": "remote HTTP relay (-c+=...) is not implemented",
+    "d": "the debugger is not implemented",
+    "D": "the debugger is not implemented",
+    "F": "bin plugins are chosen by Ghidra's loader",
+    "H": "use -v or ?V for build information",
+    "r": "there is no debugger to profile",
+    "R": "there is no debugger to profile",
+    "x": "load permissions come from Ghidra's loader",
+    "X": "extraction plugins are not implemented",
+    "P": "rapatch would write with different semantics",
+    "o": "file-offset mapping is not implemented; use --list-offset for list pagination",
+    "z": "string loading is decided by Ghidra's analyser; use iz/izz",
+}
+
+LONG_VALUE = frozenset(
+    {
+        "attach",
+        "status",
+        "kill",
+        "project",
+        "project-name",
+        "program",
+        "ghidra-language",
+        "compiler",
+        "loader",
+        "linger",
+        "idle",
+        "timeout",
+        "startup-timeout",
+        "analysis-timeout",
+        "assembler",
+        "listen",
+        "color",
+        "endian",
+        "list-offset",
+        "pipe-listen",
+    }
+)
+LONG_BOOL = frozenset(
+    {
+        "help",
+        "version",
+        "no-spawn",
+        "save-on-close",
+        "no-save-on-close",
+        "sessions",
+        "json",
+        "force-language",
+        "force-base",
+        "wait",
+        "ephemeral",
+        "reimport",
+        "allow-exec",
+        "daemon-readonly",
+    }
+)
+
+
+@dataclass
+class Options:
+    file: str | None = None
+    commands: list[str] = field(default_factory=list)
+    evals: list[tuple[str, str]] = field(default_factory=list)
+    pre_scripts: list[str] = field(default_factory=list)
+    post_scripts: list[str] = field(default_factory=list)
+    ignored: list[tuple[str, str]] = field(default_factory=list)
+
+    analyze: int = 0
+    quiet: int = 0
+    json: bool = False
+    readonly: bool = True
+    skip_rc: int = 0
+    color: int | None = None
+    seek: str | None = None
+
+    arch: str | None = None
+    bits: str | None = None
+    base: str | None = None
+    endian: str | None = None
+    no_analysis: bool = False
+    project: str | None = None
+    project_name: str | None = None
+    program: str | None = None
+    ghidra_language: str | None = None
+    compiler: str | None = None
+    loader: str | None = None
+    loader_args: list[tuple[str, str]] = field(default_factory=list)
+    force_language: bool = False
+    force_base: bool = False
+    reimport: bool = False
+
+    attach: str | None = None
+    status: str | None = None
+    kill: str | None = None
+    spawn: bool = True
+    linger: float | None = None
+    idle: float | None = None
+    timeout: float | None = None
+    startup_timeout: float | None = None
+    analysis_timeout: float | None = None
+    list_offset: int | None = None
+    pipe_listen: str | None = None
+    save_on_close: bool | None = None
+    wait: bool = False
+    assembler: str | None = None
+    daemon_readonly: bool = False
+    ephemeral: bool = False
+    allow_exec: bool = False
+    listen: str | None = None
+
+    show_help: bool = False
+    show_version: int = 0
+    list_sessions: bool = False
+
+    @property
+    def wants_database(self) -> bool:
+        return not (
+            self.show_help
+            or self.show_version
+            or self.list_sessions
+            or self.kill
+            or self.status
+        )
+
+
+def parse(argv: list[str]) -> Options:
+    options = Options()
+    index = 0
+    only_positional = False
+    while index < len(argv):
+        token = argv[index]
+        index += 1
+        if only_positional or not token.startswith("-") or token == "-":
+            _set_file(options, token)
+            continue
+        if token == "--":
+            only_positional = True
+            continue
+        if token.startswith("--"):
+            index = _long(options, token[2:], argv, index)
+            continue
+        index = _short(options, token[1:], argv, index)
+    return options
+
+
+def _set_file(options: Options, token: str) -> None:
+    if options.file is not None:
+        raise UsageError(f"only one file can be opened, got {options.file!r} and {token!r}")
+    options.file = token
+
+
+def _long(options: Options, body: str, argv: list[str], index: int) -> int:
+    name, _, inline = body.partition("=")
+    if name == "loader-arg":
+        key = inline or _next(argv, index, "--loader-arg key")
+        index += 0 if inline else 1
+        value = _next(argv, index, "--loader-arg value")
+        index += 1
+        options.loader_args.append((key, value))
+        return index
+    if name in LONG_VALUE:
+        value = inline or _next(argv, index, f"--{name}")
+        index += 0 if inline else 1
+        _apply_long_value(options, name, value)
+        return index
+    if name in LONG_BOOL:
+        if inline:
+            raise UsageError(f"--{name} does not take a value")
+        _apply_long_bool(options, name)
+        return index
+    raise UsageError(f"unknown option --{name}")
+
+
+def _apply_long_value(options: Options, name: str, value: str) -> None:
+    if name == "attach":
+        options.attach = value
+    elif name == "status":
+        options.status = value
+    elif name == "kill":
+        options.kill = value
+    elif name == "project":
+        options.project = value
+    elif name == "project-name":
+        options.project_name = value
+    elif name == "program":
+        options.program = value
+    elif name == "ghidra-language":
+        options.ghidra_language = value
+    elif name == "compiler":
+        options.compiler = value
+    elif name == "loader":
+        options.loader = value
+    elif name == "linger":
+        options.linger = _float(value, "--linger")
+    elif name == "idle":
+        options.idle = _float(value, "--idle")
+    elif name == "timeout":
+        options.timeout = _float(value, "--timeout")
+    elif name == "startup-timeout":
+        options.startup_timeout = _float(value, "--startup-timeout")
+    elif name == "analysis-timeout":
+        options.analysis_timeout = _float(value, "--analysis-timeout")
+    elif name == "assembler":
+        if value not in ("ghidra", "rasm2", "auto"):
+            raise UsageError("--assembler must be ghidra, rasm2 or auto")
+        options.assembler = value
+    elif name == "listen":
+        options.listen = value
+    elif name == "color":
+        options.color = _int(value, "--color")
+    elif name == "endian":
+        if value not in ("big", "little"):
+            raise UsageError("--endian must be big or little")
+        options.endian = value
+    elif name == "list-offset":
+        offset = _int(value, "--list-offset")
+        if offset < 0:
+            raise UsageError("--list-offset must not be negative")
+        options.list_offset = offset
+    elif name == "pipe-listen":
+        options.pipe_listen = _parse_pipe_listen(value)
+
+
+def _apply_long_bool(options: Options, name: str) -> None:
+    if name == "help":
+        options.show_help = True
+    elif name == "version":
+        options.show_version = 1
+    elif name == "no-spawn":
+        options.spawn = False
+    elif name == "save-on-close":
+        options.save_on_close = True
+    elif name == "no-save-on-close":
+        options.save_on_close = False
+    elif name == "sessions":
+        options.list_sessions = True
+    elif name == "json":
+        options.json = True
+    elif name == "force-language":
+        options.force_language = True
+    elif name == "force-base":
+        options.force_base = True
+    elif name == "wait":
+        options.wait = True
+    elif name == "ephemeral":
+        options.ephemeral = True
+    elif name == "reimport":
+        options.reimport = True
+    elif name == "allow-exec":
+        options.allow_exec = True
+    elif name == "daemon-readonly":
+        options.daemon_readonly = True
+
+
+def _short(options: Options, cluster: str, argv: list[str], index: int) -> int:
+    position = 0
+    while position < len(cluster):
+        doubled = cluster[position : position + 2]
+        if doubled in DOUBLED:
+            _apply_doubled(options, doubled)
+            position += 2
+            continue
+        char = cluster[position]
+        if char in REJECTED:
+            raise UsageError(f"-{char} is not supported by gdare2: {REJECTED[char]}")
+        if char in IGNORED:
+            options.ignored.append((f"-{char}", IGNORED[char]))
+            if char in IGNORED_VALUE:
+                rest = cluster[position + 1 :]
+                if rest:
+                    return index
+                index += 1
+                _next(argv, index - 1, f"-{char}")
+            position += 1
+            continue
+        if char == "-":
+            break
+        if char in VALUE_FLAGS:
+            rest = cluster[position + 1 :]
+            if rest:
+                value = rest
+            else:
+                value = _next(argv, index, f"-{char}")
+                index += 1
+            _apply_short_value(options, char, value)
+            return index
+        if char in BOOLEAN_FLAGS:
+            _apply_short_flag(options, char)
+            position += 1
+            continue
+        raise UsageError(f"unknown option -{char}")
+    return index
+
+
+def _apply_doubled(options: Options, doubled: str) -> None:
+    if doubled == "AA":
+        options.analyze = 2
+    elif doubled == "NN":
+        options.skip_rc = 2
+    elif doubled == "qq":
+        options.quiet = 2
+    elif doubled == "LL":
+        options.list_sessions = True
+    elif doubled == "nn":
+        options.ignored.append(("-nn", IGNORED["nn"]))
+
+
+def _apply_short_value(options: Options, char: str, value: str) -> None:
+    if char == "a":
+        options.arch = value
+    elif char == "b":
+        options.bits = value
+    elif char in ("B", "m"):
+        options.base = value
+    elif char == "c":
+        options.commands.append(value)
+    elif char == "e":
+        key, separator, setting = value.partition("=")
+        if not separator:
+            raise UsageError(f"-e expects key=value, got {value!r}")
+        options.evals.append((key.strip(), setting.strip()))
+    elif char == "i":
+        options.post_scripts.append(value)
+    elif char == "I":
+        options.pre_scripts.append(value)
+    elif char == "k":
+        options.ignored.append(("-k", IGNORED["k"]))
+    elif char == "p":
+        options.project = value
+    elif char == "s":
+        options.seek = value
+    elif char == "t":
+        options.ignored.append(("-t", IGNORED["t"]))
+
+
+def _apply_short_flag(options: Options, char: str) -> None:
+    if char == "A":
+        options.analyze = max(options.analyze, 1)
+    elif char == "h":
+        options.show_help = True
+    elif char == "j":
+        options.json = True
+    elif char == "L":
+        options.list_sessions = True
+    elif char == "n":
+        options.no_analysis = True
+    elif char == "N":
+        options.skip_rc = max(options.skip_rc, 1)
+    elif char == "q":
+        options.quiet = max(options.quiet, 1)
+    elif char == "v":
+        options.show_version = 1
+    elif char == "V":
+        options.show_version = 2
+    elif char == "w":
+        options.readonly = False
+
+
+def _parse_pipe_listen(value: str) -> str:
+    """Validate ``--pipe-listen [host:]port`` and return it unchanged."""
+    host, _, port_text = value.rpartition(":")
+    if not port_text.isdigit():
+        raise UsageError("--pipe-listen expects [host:]port")
+    port = int(port_text)
+    if not 0 <= port <= 65535:
+        raise UsageError("--pipe-listen port must be 0-65535")
+    return value
+
+
+def _next(argv: list[str], index: int, what: str) -> str:
+    if index >= len(argv):
+        raise UsageError(f"{what} needs a value")
+    return argv[index]
+
+
+def _float(value: str, what: str) -> float:
+    try:
+        return float(value)
+    except ValueError:
+        raise UsageError(f"{what} needs a number, got {value!r}") from None
+
+
+def _int(value: str, what: str) -> int:
+    try:
+        return int(value, 0)
+    except ValueError:
+        raise UsageError(f"{what} needs a number, got {value!r}") from None

gdare2/assembler.py

@@ -0,0 +1,157 @@
+"""Assembler backends: Ghidra SLEIGH and an optional rasm2 fallback."""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+
+from gdare2.errors import GdarError, UnsupportedError, UsageError
+
+MAX_LINES = 1024
+RASM2_TIMEOUT = 15
+
+#: gdare2 architecture -> (rasm2 -a name, big endian)
+_RASM2_ARCH = {
+    "x86": ("x86", False),
+    "armle": ("arm", False),
+    "armbe": ("arm", True),
+    "aarch64": ("arm", False),
+    "aarch64be": ("arm", True),
+    "mipsle": ("mips", False),
+    "mipsbe": ("mips", True),
+    "mips64le": ("mips", False),
+    "mips64be": ("mips", True),
+    "ppcle": ("ppc", False),
+    "ppc": ("ppc", True),
+    "ppc64": ("ppc", True),
+    "ppc64le": ("ppc", False),
+    "riscv32": ("riscv", False),
+    "riscv64": ("riscv", False),
+    "sparc": ("sparc", True),
+    "sparc64": ("sparc", True),
+    "m68k": ("m68k", True),
+    "sh2": ("sh", True),
+    "sh2a": ("sh", True),
+}
+
+#: Ghidra language processors use upper-case names such as ARM/AARCH64; r2
+#: aliases are lower-case.  Map the canonical names as well so ELF imports
+#: work with the rasm2 backend without requiring a raw-binary -a alias.
+_RASM2_CANONICAL = {
+    "x86": "x86",
+    "arm": "arm",
+    "aarch64": "arm",
+    "mips": "mips",
+    "powerpc": "ppc",
+    "riscv": "riscv",
+    "sparc": "sparc",
+    "68000": "m68k",
+    "superh": "sh",
+}
+
+_HEXPAIRS = re.compile(r"^[0-9a-fA-F]+$")
+
+
+def assemble(session, ea: int, text: str) -> dict:
+    """Assemble *text* using the configured backend."""
+    mode = session.config.get_str("asm.assembler")
+    if mode == "ghidra":
+        return session.call_assembler("assemble", ea=int(ea), text=text)
+    if mode == "rasm2":
+        return rasm2_assemble(session, int(ea), text)
+    if mode == "auto":
+        try:
+            return session.call_assembler("assemble", ea=int(ea), text=text)
+        except GdarError as original:
+            binary = session.config.get_str("asm.rasm2")
+            if shutil.which(binary) is None:
+                raise original
+            try:
+                payload = rasm2_assemble(session, int(ea), text)
+            except GdarError:
+                raise original from None
+            session.stderr("WARN: assembler fallback to rasm2")
+            return payload
+    raise UsageError("e asm.assembler must be ghidra, rasm2 or auto")
+
+
+def assemble_write(session, ea: int, text: str) -> dict:
+    """Assemble and write, using one daemon call for the whole SLEIGH path."""
+    mode = session.config.get_str("asm.assembler")
+    if mode == "ghidra":
+        return session.call_assembler("assemble_write", ea=int(ea), text=text)
+    if mode == "auto":
+        try:
+            return session.call_assembler("assemble_write", ea=int(ea), text=text)
+        except GdarError as original:
+            binary = session.config.get_str("asm.rasm2")
+            if shutil.which(binary) is None:
+                raise original
+            try:
+                payload = rasm2_assemble(session, int(ea), text)
+            except GdarError:
+                raise original from None
+            session.stderr("WARN: assembler fallback to rasm2")
+    else:
+        payload = assemble(session, int(ea), text)
+    session.call("write_bytes", ea=int(ea), data=bytes(payload["bytes"]))
+    payload["addr"] = int(ea)
+    return payload
+
+
+def rasm2_assemble(session, ea: int, text: str) -> dict:
+    binary = session.config.get_str("asm.rasm2")
+    arch = str(session.info.get("arch") or "")
+    mapping = _RASM2_ARCH.get(arch.lower())
+    if mapping is None:
+        canonical = _RASM2_CANONICAL.get(arch.lower())
+        if canonical is not None:
+            mapping = (canonical, False)
+    if mapping is None:
+        raise UnsupportedError(f"rasm2 has no architecture mapping for {arch!r}")
+    rasm_arch, big_endian = mapping
+    big_endian = big_endian or session.info.get("endian") == "big"
+    bits = int(session.info.get("bits") or 32)
+    lines = [line.strip() for line in text.splitlines() if line.strip()]
+    if not lines:
+        raise UsageError("assembly text is empty")
+    if len(lines) > MAX_LINES:
+        raise UsageError(f"assembly is limited to {MAX_LINES} lines")
+
+    address = int(ea)
+    items = []
+    for line in lines:
+        command = [binary, "-a", rasm_arch, "-b", str(bits)]
+        if big_endian:
+            command.append("-e")
+        command.append(line)
+        try:
+            result = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                timeout=RASM2_TIMEOUT,
+                check=False,
+            )
+        except FileNotFoundError:
+            raise UnsupportedError(f"rasm2 not found: {binary}") from None
+        except subprocess.TimeoutExpired:
+            raise GdarError(f"rasm2 timed out after {RASM2_TIMEOUT}s") from None
+        hexpairs = result.stdout.strip().splitlines()[-1] if result.stdout.strip() else ""
+        if result.returncode != 0 or not hexpairs or len(hexpairs) % 2 or not _HEXPAIRS.match(hexpairs):
+            detail = (result.stderr or result.stdout or "no output").strip().splitlines()
+            raise GdarError(
+                f"rasm2 failed for {line!r}: {detail[-1] if detail else 'no output'}"
+            )
+        data = bytes.fromhex(hexpairs)
+        items.append(
+            {"addr": address, "text": line, "bytes": data, "size": len(data)}
+        )
+        address += len(data)
+    return {
+        "items": items,
+        "bytes": b"".join(item["bytes"] for item in items),
+        "size": sum(item["size"] for item in items),
+        "assembler": "rasm2",
+    }