tentod 0.1.0__tar.gz

tentod-0.1.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: tentod
+Version: 0.1.0
+Summary: tentod
+Home-page: https://github.com/rijulg/tentod
+Author: Rijul Gupta
+Author-email: rijulg@gmail.com
+License: MIT
+Keywords: dotnet
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Utilities
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: class-argparse==0.1.4
+Requires-Dist: pythonnet==3.1.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# tentod
+
+```bash
+python -m tentod recover <assembly.dll>
+python -m tentod guide          # workflow for automated/LLM use
+```

tentod-0.1.0/README.md

@@ -0,0 +1,6 @@
+# tentod
+
+```bash
+python -m tentod recover <assembly.dll>
+python -m tentod guide          # workflow for automated/LLM use
+```

tentod-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"

tentod-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tentod-0.1.0/setup.py

@@ -0,0 +1,33 @@
+import os
+import setuptools
+
+with open("README.md", "r") as readme:
+    long_description = readme.read()
+
+setuptools.setup(
+    name="tentod",
+    packages=setuptools.find_namespace_packages(include=["tentod", "tentod.*"]),
+    package_data={"tentod": ["GUIDE.md"]},
+    version=os.environ.get("RELEASE_VERSION", "0.0.0"),
+    license="MIT",
+    description="tentod",
+    author="Rijul Gupta",
+    author_email="rijulg@gmail.com",
+    url="https://github.com/rijulg/tentod",
+    keywords=["dotnet"],
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    python_requires=">=3.13",
+    install_requires=[
+        "class-argparse==0.1.4",
+        "pythonnet==3.1.0",
+    ],
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: POSIX :: Linux",
+        "Programming Language :: Python :: 3.13",
+        "Topic :: Utilities",
+    ],
+)

tentod-0.1.0/tentod/GUIDE.md

@@ -0,0 +1,53 @@
+# tentod — guide for automated (LLM) use
+
+tentod recovers readable Python from .NET assemblies in stages. The
+deterministic stages are commands; the one creative stage (writing the Python)
+is done by you, the model, against the contract below. Print this any time with
+`python -m tentod guide`.
+
+## Turnkey workflow
+
+Given one assembly, or a list/folder of them, process **each assembly
+independently** — they share nothing, so fan out one worker per assembly and run
+these steps for each:
+
+1. **Recover.** `python -m tentod recover <assembly.dll>`
+   - If it prints `SKIP not a managed assembly`, the file is native or not a
+     .NET assembly — move on, it is not yours to process.
+   - Otherwise it prints the paths of the decompiled C#, the **deobfuscated C#**,
+     and `facts.json`, plus counts (`types`/`strings`/`routes`/`inlined`).
+2. **Read** the deobfuscated C# and `facts.json`. The deobfuscated C# is the
+   source of truth for control flow and every literal (routes, keys, headers).
+3. **Write** the Python module (see the contract below). Map the assembly's
+   namespace to directories: `A.B.C` → `A/B/C.py`.
+4. **Verify.** `python -m tentod verify <assembly.dll> <your_output.py>`
+   - Resolve every entry under `missing` (a required literal your Python lacks).
+   - Review every entry under `omitted`: each must be something you dropped on
+     purpose (an internal log line, a diagnostic message) — never a route, query
+     key, header, or secret name.
+5. **Report** the coverage line and any deliberate omissions for that assembly.
+
+Work on independent assemblies concurrently; each worker owns one assembly end
+to end (recover → write → verify).
+
+## Style contract for the Python you write
+
+Faithful, idiomatic Python — not a mechanical transliteration of the C#.
+
+1. **One module** at the namespace-mapped path.
+2. **Class-based.** No module-level functions. The public surface is a single
+   class; each user-facing operation is one public method.
+3. **Private helpers are `__`-prefixed** (name-mangled) — request building, key
+   resolution, response handling.
+4. **Module-level `CONSTANTS`** (base URLs, defaults) are fine.
+5. **Faithful.** Use the exact literals from the C#/facts. Invent nothing.
+   Reproduce behavior, not the C# class hierarchy — skip DTOs, DI, and
+   async-state-machine scaffolding a client does not need.
+6. **Type hints throughout.** Prefer the standard library.
+7. **Docstring states provenance** and lists any endpoints/behavior you
+   intentionally left out, so the omission is a decision, not an oversight.
+
+## Done
+
+`python -m tentod verify` reports `OK` (nothing under `missing`) and every
+`omitted` entry is one you can justify.

tentod-0.1.0/tentod/__init__.py

@@ -0,0 +1 @@
+"""tentod."""

tentod-0.1.0/tentod/__main__.py

@@ -0,0 +1,81 @@
+"""CLI."""
+
+from pathlib import Path
+
+from class_argparse import ClassArgParser
+
+from .assembly import DotNetAssembly, NotManagedAssembly
+from .pipeline import DotNetRecoveryPipeline
+
+DEFAULT_OUT_ROOT = "out"
+GUIDE = Path(__file__).with_name("GUIDE.md")
+
+
+class Main(ClassArgParser):
+    """tentod."""
+
+    def __init__(self) -> None:
+        super().__init__(name="tentod")
+
+    def __resolve(self, assembly: str) -> str:
+        p = Path(assembly)
+        if p.exists():
+            return str(p)
+        if not p.suffix:
+            withdll = p.with_suffix(".dll")
+            if withdll.exists():
+                return str(withdll)
+        raise SystemExit(f"not found: {assembly}")
+
+    def guide(self):
+        print(GUIDE.read_text())
+
+    def recover(
+        self,
+        assembly: str,
+        out_dir: str = DEFAULT_OUT_ROOT,
+        force: bool = False,
+    ):
+        dll = self.__resolve(assembly)
+        try:
+            result = DotNetRecoveryPipeline(dll, out_dir).recover(force=force)
+        except NotManagedAssembly:
+            print(f"SKIP not a managed assembly: {dll}")
+            return
+        print(result.csharp)
+        print(result.deobfuscated)
+        print(result.facts_path)
+        print(
+            f"types={len(result.facts.types)} "
+            f"strings={len(result.facts.flat_strings())} "
+            f"routes={len(result.facts.routes)} "
+            f"inlined={result.replacements}"
+        )
+
+    def verify(
+        self,
+        assembly: str,
+        python: str,
+        out_dir: str = DEFAULT_OUT_ROOT,
+    ):
+        dll = self.__resolve(assembly)
+        report = DotNetRecoveryPipeline(dll, out_dir).verify(python)
+        print(report.render())
+        if not report.ok:
+            raise SystemExit(1)
+
+    def strings(self, assembly: str):
+        try:
+            asm = DotNetAssembly.load(self.__resolve(assembly))
+        except NotManagedAssembly:
+            print(f"SKIP not a managed assembly: {assembly}")
+            return
+        for bank, entries in asm.decrypt_strings().items():
+            print(f"### {bank}")
+            for name, value in entries.items():
+                print(f"    {name}() = {value!r}")
+            print()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    Main()()

tentod-0.1.0/tentod/_runtime.py

@@ -0,0 +1,21 @@
+"""Runtime bootstrap."""
+
+import functools
+import os
+
+
+@functools.lru_cache(maxsize=1)
+def runtime():  # pragma: no cover
+    os.environ.setdefault("PYTHONNET_RUNTIME", "mono")
+    import clr  # noqa: F401
+
+    from System.Reflection import Assembly, BindingFlags
+
+    flags = (
+        BindingFlags.Static
+        | BindingFlags.Instance
+        | BindingFlags.Public
+        | BindingFlags.NonPublic
+        | BindingFlags.DeclaredOnly
+    )
+    return Assembly, flags

tentod-0.1.0/tentod/assembly.py

@@ -0,0 +1,134 @@
+"""Assembly reflection."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from ._runtime import runtime
+
+
+class NotManagedAssembly(Exception):
+    """Raised when a file is not a managed assembly (e.g. a native DLL)."""
+
+
+@dataclass
+class MethodInfo:
+    name: str
+    static: bool
+    returns: str
+    params: list[str] = field(default_factory=list)
+
+
+@dataclass
+class TypeInfo:
+    fullname: str
+    kind: str
+    methods: list[MethodInfo] = field(default_factory=list)
+    enum_members: list[str] = field(default_factory=list)
+
+
+class DotNetAssembly:
+    """A loaded assembly queried through reflection."""
+
+    __STRING_BANK_MIN = 3
+
+    def __init__(self, asm, flags=None) -> None:
+        self.__asm = asm
+        self.__flags = flags
+
+    @classmethod
+    def load(cls, dll_path: str) -> "DotNetAssembly":
+        assembly, flags = runtime()
+        try:
+            obj = assembly.LoadFrom(str(dll_path))
+        except Exception as e:
+            if "BadImageFormat" in type(e).__name__:
+                raise NotManagedAssembly(str(dll_path)) from e
+            raise
+        return cls(obj, flags)
+
+    @property
+    def full_name(self) -> str:
+        return str(self.__asm.FullName)
+
+    def __types(self):
+        try:
+            return list(self.__asm.GetTypes())
+        except Exception as e:
+            loaded = getattr(e, "Types", None)
+            return [t for t in loaded if t is not None] if loaded else []
+
+    def __is_accessor(self, m) -> bool:
+        return (
+            m.IsStatic
+            and m.ReturnType.Name == "String"
+            and len(m.GetParameters()) == 0
+            and not m.Name.startswith("get_")
+        )
+
+    def __string_banks(self):
+        banks = []
+        for t in self.__types():
+            accessors = [m for m in t.GetMethods(self.__flags) if self.__is_accessor(m)]
+            if len(accessors) >= self.__STRING_BANK_MIN:
+                banks.append((t, accessors))
+        return banks
+
+    def decrypt_strings(self) -> dict[str, dict[str, str]]:
+        out: dict[str, dict[str, str]] = {}
+        for t, accessors in self.__string_banks():
+            bank: dict[str, str] = {}
+            for m in accessors:
+                try:
+                    bank[m.Name] = str(m.Invoke(None, None))
+                except Exception:
+                    continue
+            if bank:
+                out[t.Name] = bank
+        return out
+
+    def enums(self) -> dict[str, list[str]]:
+        out: dict[str, list[str]] = {}
+        for t in self.__types():
+            if t.IsEnum:
+                try:
+                    out[t.FullName] = list(t.GetEnumNames())
+                except Exception:
+                    out[t.FullName] = []
+        return out
+
+    def __kind(self, t) -> str:
+        if t.IsEnum:
+            return "enum"
+        if t.IsInterface:
+            return "interface"
+        if t.IsValueType:
+            return "struct"
+        return "class"
+
+    def types(self, include_generated: bool = False) -> list[TypeInfo]:
+        bank_names = {t.Name for t, _ in self.__string_banks()}
+        result: list[TypeInfo] = []
+        for t in self.__types():
+            if not include_generated and (
+                t.Name in bank_names or "PrivateImplementationDetails" in t.FullName
+            ):
+                continue
+            ti = TypeInfo(fullname=t.FullName, kind=self.__kind(t))
+            if t.IsEnum:
+                try:
+                    ti.enum_members = list(t.GetEnumNames())
+                except Exception:
+                    pass
+            else:
+                for m in t.GetMethods(self.__flags):
+                    ti.methods.append(
+                        MethodInfo(
+                            name=m.Name,
+                            static=m.IsStatic,
+                            returns=m.ReturnType.Name,
+                            params=[p.ParameterType.Name for p in m.GetParameters()],
+                        )
+                    )
+            result.append(ti)
+        return result

tentod-0.1.0/tentod/decompiler.py

@@ -0,0 +1,59 @@
+"""Decompilation stage."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import shutil
+import subprocess
+
+
+class IlspyDecompiler:
+    """Wrapper over the ``ilspycmd`` executable."""
+
+    __TOOL_CANDIDATES = ("ilspycmd", "~/.dotnet/tools/ilspycmd")
+
+    def __init__(self, ilspycmd: str | None = None) -> None:
+        self.__exe = ilspycmd or self.__discover()
+
+    def __discover(self) -> str:
+        for cand in self.__TOOL_CANDIDATES:
+            found = shutil.which(cand) or (
+                str(Path(cand).expanduser())
+                if Path(cand).expanduser().exists()
+                else None
+            )
+            if found:
+                return found
+        raise RuntimeError("ilspycmd not found")
+
+    def __env(self) -> dict[str, str]:
+        env = dict(os.environ)
+        env.setdefault("DOTNET_ROLL_FORWARD", "Major")
+        env.setdefault("DOTNET_CLI_TELEMETRY_OPTOUT", "1")
+        env.setdefault("DOTNET_NOLOGO", "1")
+        return env
+
+    def decompile(self, dll_path: str, out_dir: str, force: bool = False) -> Path:
+        dll = Path(dll_path)
+        out = Path(out_dir)
+        out.mkdir(parents=True, exist_ok=True)
+        expected = out / f"{dll.stem}.decompiled.cs"
+        if expected.exists() and not force:
+            return expected
+        proc = subprocess.run(
+            [self.__exe, str(dll), "-o", str(out)],
+            env=self.__env(),
+            capture_output=True,
+            text=True,
+        )
+        if proc.returncode != 0:
+            raise RuntimeError(
+                f"ilspycmd failed ({proc.returncode}):\n{proc.stderr or proc.stdout}"
+            )
+        if expected.exists():
+            return expected
+        produced = sorted(out.glob("*.cs"))
+        if not produced:
+            raise RuntimeError(f"no .cs produced in {out}")
+        return produced[0]

tentod-0.1.0/tentod/deobfuscator.py

@@ -0,0 +1,50 @@
+"""Deobfuscation stage."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import re
+
+
+class StringDeobfuscator:
+    """Rewrites accessor calls to their decrypted literals."""
+
+    def __init__(self, string_banks: dict[str, dict[str, str]]) -> None:
+        self.__banks = string_banks
+
+    @staticmethod
+    def __csharp_literal(value: str) -> str:
+        esc = (
+            value.replace("\\", "\\\\")
+            .replace('"', '\\"')
+            .replace("\n", "\\n")
+            .replace("\r", "\\r")
+            .replace("\t", "\\t")
+        )
+        return f'"{esc}"'
+
+    def __bank_pattern(self, qualifier: str, bank: dict[str, str]) -> re.Pattern:
+        names = "|".join(re.escape(n) for n in sorted(bank, key=len, reverse=True))
+        return re.compile(re.escape(qualifier) + r"\.(" + names + r")\(\)")
+
+    def deobfuscate_text(self, source: str) -> tuple[str, int]:
+        count = 0
+        for qualifier, bank in self.__banks.items():
+            if not bank:
+                continue
+            pattern = self.__bank_pattern(qualifier, bank)
+
+            def repl(m: re.Match) -> str:
+                nonlocal count
+                count += 1
+                return self.__csharp_literal(bank[m.group(1)])
+
+            source = pattern.sub(repl, source)
+        return source, count
+
+    def deobfuscate_file(self, cs_in: str, cs_out: str) -> tuple[Path, int]:
+        rewritten, count = self.deobfuscate_text(Path(cs_in).read_text())
+        out = Path(cs_out)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(rewritten)
+        return out, count

tentod-0.1.0/tentod/facts.py

@@ -0,0 +1,51 @@
+"""Facts stage."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+import json
+
+from .assembly import DotNetAssembly
+
+
+@dataclass
+class AssemblyFacts:
+    assembly: str
+    strings: dict[str, dict[str, str]] = field(default_factory=dict)
+    enums: dict[str, list[str]] = field(default_factory=dict)
+    routes: list[str] = field(default_factory=list)
+    types: list[dict] = field(default_factory=list)
+
+    def flat_strings(self) -> list[str]:
+        seen: dict[str, None] = {}
+        for bank in self.strings.values():
+            for value in bank.values():
+                seen.setdefault(value, None)
+        return list(seen)
+
+    def to_json(self) -> str:
+        return json.dumps(asdict(self), indent=2, ensure_ascii=False)
+
+    @classmethod
+    def from_json(cls, text: str) -> "AssemblyFacts":
+        return cls(**json.loads(text))
+
+
+class FactsExtractor:
+    def extract(self, asm: DotNetAssembly) -> AssemblyFacts:
+        strings = asm.decrypt_strings()
+        routes = sorted(
+            {
+                value
+                for bank in strings.values()
+                for value in bank.values()
+                if value.startswith("/")
+            }
+        )
+        return AssemblyFacts(
+            assembly=asm.full_name,
+            strings=strings,
+            enums=asm.enums(),
+            routes=routes,
+            types=[asdict(t) for t in asm.types()],
+        )

tentod-0.1.0/tentod/pipeline.py

@@ -0,0 +1,61 @@
+"""Pipeline orchestration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from .assembly import DotNetAssembly
+from .decompiler import IlspyDecompiler
+from .deobfuscator import StringDeobfuscator
+from .facts import AssemblyFacts, FactsExtractor
+from .verify import RecoveryVerifier, VerifyReport
+
+
+@dataclass
+class RecoverResult:
+    csharp: Path
+    deobfuscated: Path
+    facts_path: Path
+    facts: AssemblyFacts
+    replacements: int
+
+
+class DotNetRecoveryPipeline:
+    def __init__(self, dll_path: str, out_root: str) -> None:
+        self.__dll = Path(dll_path)
+        self.__root = Path(out_root) / self.__dll.stem
+
+    @property
+    def root(self) -> Path:
+        return self.__root
+
+    @property
+    def facts_path(self) -> Path:
+        return self.__root / "facts.json"
+
+    def recover(self, force: bool = False) -> RecoverResult:
+        asm = DotNetAssembly.load(str(self.__dll))  # classifies before decompiling
+        banks = asm.decrypt_strings()
+        csharp = IlspyDecompiler().decompile(
+            str(self.__dll),
+            str(self.__root / "csharp"),
+            force=force,
+        )
+        deobf, replacements = StringDeobfuscator(banks).deobfuscate_file(
+            str(csharp),
+            str(self.__root / "deobf" / f"{self.__dll.stem}.deobf.cs"),
+        )
+        facts = FactsExtractor().extract(asm)
+        self.facts_path.write_text(facts.to_json())
+        return RecoverResult(csharp, deobf, self.facts_path, facts, replacements)
+
+    def load_facts(self) -> AssemblyFacts:
+        if self.facts_path.exists():
+            return AssemblyFacts.from_json(self.facts_path.read_text())
+        return FactsExtractor().extract(DotNetAssembly.load(str(self.__dll)))
+
+    def verify(self, python_path: str) -> VerifyReport:
+        facts = self.load_facts()
+        source = Path(python_path).read_text()
+        return RecoveryVerifier().verify(facts, source)

tentod-0.1.0/tentod/verify.py

@@ -0,0 +1,45 @@
+"""Verification stage."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .facts import AssemblyFacts
+
+
+@dataclass
+class VerifyReport:
+    matched: list[str] = field(default_factory=list)
+    omitted: list[str] = field(default_factory=list)
+    missing_routes: list[str] = field(default_factory=list)
+
+    @property
+    def ok(self) -> bool:
+        return not self.missing_routes
+
+    def render(self) -> str:
+        total = len(self.matched) + len(self.omitted)
+        lines = [f"coverage: {len(self.matched)}/{total}"]
+        if self.missing_routes:
+            lines.append("")
+            lines.append(f"missing ({len(self.missing_routes)}):")
+            lines += [f"  ! {r}" for r in self.missing_routes]
+        if self.omitted:
+            lines.append("")
+            lines.append(f"omitted ({len(self.omitted)}):")
+            lines += [f"  - {s!r}" for s in self.omitted]
+        lines.append("")
+        lines.append("OK" if self.ok else "FAIL")
+        return "\n".join(lines)
+
+
+class RecoveryVerifier:
+    def verify(self, facts: AssemblyFacts, python_source: str) -> VerifyReport:
+        report = VerifyReport()
+        for literal in facts.flat_strings():
+            if not literal.strip():
+                continue
+            bucket = report.matched if literal in python_source else report.omitted
+            bucket.append(literal)
+        report.missing_routes = [r for r in facts.routes if r not in python_source]
+        return report

tentod-0.1.0/tentod.egg-info/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: tentod
+Version: 0.1.0
+Summary: tentod
+Home-page: https://github.com/rijulg/tentod
+Author: Rijul Gupta
+Author-email: rijulg@gmail.com
+License: MIT
+Keywords: dotnet
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Utilities
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: class-argparse==0.1.4
+Requires-Dist: pythonnet==3.1.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# tentod
+
+```bash
+python -m tentod recover <assembly.dll>
+python -m tentod guide          # workflow for automated/LLM use
+```

tentod-0.1.0/tentod.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+README.md
+pyproject.toml
+setup.py
+tentod/GUIDE.md
+tentod/__init__.py
+tentod/__main__.py
+tentod/_runtime.py
+tentod/assembly.py
+tentod/decompiler.py
+tentod/deobfuscator.py
+tentod/facts.py
+tentod/pipeline.py
+tentod/verify.py
+tentod.egg-info/PKG-INFO
+tentod.egg-info/SOURCES.txt
+tentod.egg-info/dependency_links.txt
+tentod.egg-info/requires.txt
+tentod.egg-info/top_level.txt
+tests/test_assembly.py
+tests/test_decompiler.py
+tests/test_deobfuscator.py
+tests/test_facts.py
+tests/test_main.py
+tests/test_pipeline.py
+tests/test_verify.py

tentod-0.1.0/tentod.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tentod-0.1.0/tentod.egg-info/requires.txt

@@ -0,0 +1,2 @@
+class-argparse==0.1.4
+pythonnet==3.1.0

tentod-0.1.0/tentod.egg-info/top_level.txt

@@ -0,0 +1 @@
+tentod

tentod-0.1.0/tests/test_assembly.py

@@ -0,0 +1,109 @@
+import pytest
+
+from tentod.assembly import DotNetAssembly, NotManagedAssembly
+
+
+def _sample_types(clr):
+    return [
+        clr.Type("ns.Bank0", methods=[
+            clr.Method("m1", value="/x"),
+            clr.Method("m2", value="y"),
+            clr.Method("m3", raises=True),  # decryptor helper -> skipped
+        ]),
+        clr.Type("ns.AllRaise", methods=[
+            clr.Method("a", raises=True),
+            clr.Method("b", raises=True),
+            clr.Method("c", raises=True),
+        ]),
+        clr.Type("ns.<PrivateImplementationDetails>Z", name="Z"),
+        clr.Type("ns.EnumGood", enum=["A", "B"], kind="enum"),
+        clr.Type("ns.EnumRaise", enum="raise", kind="enum"),
+        clr.Type("ns.IFoo", kind="interface"),
+        clr.Type("ns.SBar", kind="struct"),
+        clr.Type("ns.CBaz", methods=[
+            clr.Method("M", static=False, ret="Void", params=("String", "Int32")),
+        ]),
+    ]
+
+
+def test_load_wraps_loadfrom(monkeypatch, clr):
+    sentinel = clr.Assembly([], fullname="Loaded, Version=9")
+
+    class Loader:
+        @staticmethod
+        def LoadFrom(path):
+            assert path == "x.dll"
+            return sentinel
+
+    monkeypatch.setattr("tentod.assembly.runtime", lambda: (Loader, None))
+    asm = DotNetAssembly.load("x.dll")
+    assert asm.full_name == "Loaded, Version=9"
+
+
+def test_load_skips_native(monkeypatch):
+    class BadImageFormatException(Exception):
+        pass
+
+    class Loader:
+        @staticmethod
+        def LoadFrom(path):
+            raise BadImageFormatException("native")
+
+    monkeypatch.setattr("tentod.assembly.runtime", lambda: (Loader, None))
+    with pytest.raises(NotManagedAssembly):
+        DotNetAssembly.load("native.dll")
+
+
+def test_load_reraises_other_errors(monkeypatch):
+    class Loader:
+        @staticmethod
+        def LoadFrom(path):
+            raise RuntimeError("disk on fire")
+
+    monkeypatch.setattr("tentod.assembly.runtime", lambda: (Loader, None))
+    with pytest.raises(RuntimeError):
+        DotNetAssembly.load("x.dll")
+
+
+def test_decrypt_strings(clr):
+    asm = DotNetAssembly(clr.Assembly(_sample_types(clr)))
+    banks = asm.decrypt_strings()
+    assert banks == {"Bank0": {"m1": "/x", "m2": "y"}}  # AllRaise dropped (empty)
+
+
+def test_enums(clr):
+    asm = DotNetAssembly(clr.Assembly(_sample_types(clr)))
+    assert asm.enums() == {"ns.EnumGood": ["A", "B"], "ns.EnumRaise": []}
+
+
+def test_types_default_skips_generated_and_covers_kinds(clr):
+    asm = DotNetAssembly(clr.Assembly(_sample_types(clr)))
+    by_name = {t.fullname: t for t in asm.types()}
+    assert "ns.Bank0" not in by_name  # string bank skipped
+    assert "ns.<PrivateImplementationDetails>Z" not in by_name
+    assert by_name["ns.EnumGood"].enum_members == ["A", "B"]
+    assert by_name["ns.EnumRaise"].enum_members == []  # GetEnumNames raised
+    assert by_name["ns.IFoo"].kind == "interface"
+    assert by_name["ns.SBar"].kind == "struct"
+    cbaz = by_name["ns.CBaz"]
+    assert cbaz.kind == "class"
+    assert cbaz.methods[0].params == ["String", "Int32"]
+
+
+def test_types_include_generated(clr):
+    asm = DotNetAssembly(clr.Assembly(_sample_types(clr)))
+    names = {t.fullname for t in asm.types(include_generated=True)}
+    assert "ns.Bank0" in names
+
+
+def test_types_recovers_from_partial_load(clr):
+    class Boom:
+        FullName = "Boom"
+
+        def GetTypes(self):
+            err = RuntimeError("partial")
+            err.Types = [clr.Type("ns.X")]
+            raise err
+
+    asm = DotNetAssembly(Boom())
+    assert [t.fullname for t in asm.types()] == ["ns.X"]

tentod-0.1.0/tests/test_decompiler.py

@@ -0,0 +1,86 @@
+import types
+
+import pytest
+
+from tentod.decompiler import IlspyDecompiler
+
+
+def _proc(returncode=0, stderr="", stdout=""):
+    return types.SimpleNamespace(returncode=returncode, stderr=stderr, stdout=stdout)
+
+
+def test_discover_via_which(monkeypatch):
+    monkeypatch.setattr(
+        "tentod.decompiler.shutil.which",
+        lambda c: "/usr/bin/ilspycmd" if c == "ilspycmd" else None,
+    )
+    d = IlspyDecompiler()
+    assert d._IlspyDecompiler__exe == "/usr/bin/ilspycmd"
+
+
+def test_discover_via_path(monkeypatch, tmp_path):
+    exe = tmp_path / "ilspycmd"
+    exe.write_text("")
+    monkeypatch.setattr("tentod.decompiler.shutil.which", lambda c: None)
+    monkeypatch.setattr(
+        IlspyDecompiler, "_IlspyDecompiler__TOOL_CANDIDATES", (str(exe),)
+    )
+    assert IlspyDecompiler()._IlspyDecompiler__exe == str(exe)
+
+
+def test_discover_not_found(monkeypatch):
+    monkeypatch.setattr("tentod.decompiler.shutil.which", lambda c: None)
+    monkeypatch.setattr(
+        IlspyDecompiler, "_IlspyDecompiler__TOOL_CANDIDATES", ("/nope/xyz",)
+    )
+    with pytest.raises(RuntimeError):
+        IlspyDecompiler()
+
+
+def test_decompile_idempotent(monkeypatch, tmp_path):
+    out = tmp_path / "out"
+    out.mkdir()
+    (out / "a.decompiled.cs").write_text("cached")
+    called = []
+    monkeypatch.setattr("tentod.decompiler.subprocess.run", lambda *a, **k: called.append(1))
+    result = IlspyDecompiler("ilspycmd").decompile(str(tmp_path / "a.dll"), str(out))
+    assert result == out / "a.decompiled.cs"
+    assert not called  # subprocess never invoked
+
+
+def test_decompile_success(monkeypatch, tmp_path):
+    out = tmp_path / "out"
+
+    def fake_run(cmd, env, capture_output, text):
+        (out / "a.decompiled.cs").write_text("cs")
+        return _proc()
+
+    monkeypatch.setattr("tentod.decompiler.subprocess.run", fake_run)
+    result = IlspyDecompiler("ilspycmd").decompile(str(tmp_path / "a.dll"), str(out))
+    assert result == out / "a.decompiled.cs"
+
+
+def test_decompile_nonzero_raises(monkeypatch, tmp_path):
+    monkeypatch.setattr(
+        "tentod.decompiler.subprocess.run", lambda *a, **k: _proc(1, stderr="boom")
+    )
+    with pytest.raises(RuntimeError, match="boom"):
+        IlspyDecompiler("ilspycmd").decompile(str(tmp_path / "a.dll"), str(tmp_path / "o"))
+
+
+def test_decompile_falls_back_to_glob(monkeypatch, tmp_path):
+    out = tmp_path / "out"
+
+    def fake_run(cmd, env, capture_output, text):
+        (out / "other.cs").write_text("cs")  # not the expected name
+        return _proc()
+
+    monkeypatch.setattr("tentod.decompiler.subprocess.run", fake_run)
+    result = IlspyDecompiler("ilspycmd").decompile(str(tmp_path / "a.dll"), str(out))
+    assert result == out / "other.cs"
+
+
+def test_decompile_no_output_raises(monkeypatch, tmp_path):
+    monkeypatch.setattr("tentod.decompiler.subprocess.run", lambda *a, **k: _proc())
+    with pytest.raises(RuntimeError, match="no .cs"):
+        IlspyDecompiler("ilspycmd").decompile(str(tmp_path / "a.dll"), str(tmp_path / "o"))

tentod-0.1.0/tests/test_deobfuscator.py

@@ -0,0 +1,46 @@
+from tentod.deobfuscator import StringDeobfuscator
+
+BANKS = {
+    "Bank0": {
+        "p": "/alpha",
+        "U": "keyname",
+        "u": "value",
+        "esc": 'a\\b"c\nd\re\tf',
+    }
+}
+
+
+def test_inlines_qualified_calls_only():
+    src = "x = A(z); y = Bank0.p(); d[Bank0.U()] = a;\n"
+    out, count = StringDeobfuscator(BANKS).deobfuscate_text(src)
+    assert count == 2
+    assert '"/alpha"' in out
+    assert '["keyname"] = a' in out
+    assert "A(z)" in out  # unqualified local call untouched
+
+
+def test_escapes_specials():
+    out, _ = StringDeobfuscator(BANKS).deobfuscate_text("Bank0.esc()")
+    assert out == '"a\\\\b\\"c\\nd\\re\\tf"'
+
+
+def test_unknown_accessor_untouched():
+    out, count = StringDeobfuscator(BANKS).deobfuscate_text("Bank0.zzz()")
+    assert count == 0
+    assert "Bank0.zzz()" in out
+
+
+def test_empty_bank_skipped():
+    out, count = StringDeobfuscator({"Empty": {}}).deobfuscate_text("Empty.p()")
+    assert count == 0
+    assert out == "Empty.p()"
+
+
+def test_deobfuscate_file_round_trip(tmp_path):
+    src = tmp_path / "in.cs"
+    src.write_text("v = Bank0.p();")
+    dst = tmp_path / "sub" / "out.cs"
+    out_path, count = StringDeobfuscator(BANKS).deobfuscate_file(str(src), str(dst))
+    assert out_path == dst
+    assert count == 1
+    assert dst.read_text() == 'v = "/alpha";'

tentod-0.1.0/tests/test_facts.py

@@ -0,0 +1,44 @@
+from tentod.facts import AssemblyFacts, FactsExtractor
+
+
+class FakeAsm:
+    full_name = "Fake, Version=1.0.0.0"
+
+    def decrypt_strings(self):
+        return {"bank": {"p": "/alpha", "k": "keyname", "n": "not-a-route"}}
+
+    def enums(self):
+        return {"E": ["A", "B"]}
+
+    def types(self):
+        return [type("T", (), {})()]
+
+
+def test_flat_strings_dedupes_and_preserves_order():
+    facts = AssemblyFacts(
+        assembly="Fake",
+        strings={"a": {"x": "one", "y": "two"}, "b": {"z": "two", "w": "three"}},
+    )
+    assert facts.flat_strings() == ["one", "two", "three"]
+
+
+def test_json_round_trip():
+    facts = AssemblyFacts(
+        assembly="Fake",
+        strings={"bank": {"p": "/alpha"}},
+        enums={"E": ["A", "B"]},
+        routes=["/alpha"],
+        types=[{"fullname": "X", "kind": "class", "methods": [], "enum_members": []}],
+    )
+    assert AssemblyFacts.from_json(facts.to_json()) == facts
+
+
+def test_extractor_collects_routes_and_surface(monkeypatch):
+    monkeypatch.setattr(
+        "tentod.facts.asdict", lambda t: {"fullname": "T"}
+    )
+    facts = FactsExtractor().extract(FakeAsm())
+    assert facts.assembly == "Fake, Version=1.0.0.0"
+    assert facts.routes == ["/alpha"]  # only the "/"-prefixed literal
+    assert facts.enums == {"E": ["A", "B"]}
+    assert facts.types == [{"fullname": "T"}]

tentod-0.1.0/tests/test_main.py

@@ -0,0 +1,115 @@
+import types
+
+import pytest
+
+import tentod.__main__ as M
+
+
+def _dll(tmp_path):
+    f = tmp_path / "a.dll"
+    f.write_text("")
+    return f
+
+
+def test_resolve_existing(tmp_path):
+    f = _dll(tmp_path)
+    assert M.Main()._Main__resolve(str(f)) == str(f)
+
+
+def test_resolve_adds_dll_suffix(tmp_path):
+    _dll(tmp_path)
+    assert M.Main()._Main__resolve(str(tmp_path / "a")) == str(tmp_path / "a.dll")
+
+
+def test_resolve_missing_raises():
+    with pytest.raises(SystemExit):
+        M.Main()._Main__resolve("/nope/x")  # no suffix -> tries .dll -> raises
+    with pytest.raises(SystemExit):
+        M.Main()._Main__resolve("/nope/x.dll")  # has suffix -> straight to raise
+
+
+def test_recover(monkeypatch, tmp_path, capsys):
+    facts = types.SimpleNamespace(
+        types=[1, 2], routes=["/x"], flat_strings=lambda: ["a", "b", "c"]
+    )
+    result = types.SimpleNamespace(
+        csharp="cs.cs", deobfuscated="d.cs", facts_path="f.json",
+        facts=facts, replacements=5,
+    )
+
+    class FakePipe:
+        def __init__(self, dll, out_dir):
+            pass
+
+        def recover(self, force):
+            return result
+
+    monkeypatch.setattr(M, "DotNetRecoveryPipeline", FakePipe)
+    M.Main().recover(str(_dll(tmp_path)))
+    out = capsys.readouterr().out
+    assert "types=2 strings=3 routes=1 inlined=5" in out
+
+
+def _pipe_with_report(ok):
+    report = types.SimpleNamespace(ok=ok, render=lambda: "REPORT")
+
+    class FakePipe:
+        def __init__(self, dll, out_dir):
+            pass
+
+        def verify(self, python):
+            return report
+
+    return FakePipe
+
+
+def test_verify_ok(monkeypatch, tmp_path):
+    monkeypatch.setattr(M, "DotNetRecoveryPipeline", _pipe_with_report(True))
+    M.Main().verify(str(_dll(tmp_path)), "gen.py")  # no SystemExit
+
+
+def test_verify_fail_exits(monkeypatch, tmp_path):
+    monkeypatch.setattr(M, "DotNetRecoveryPipeline", _pipe_with_report(False))
+    with pytest.raises(SystemExit):
+        M.Main().verify(str(_dll(tmp_path)), "gen.py")
+
+
+def test_guide(capsys):
+    M.Main().guide()
+    assert "tentod" in capsys.readouterr().out
+
+
+def test_recover_skips_native(monkeypatch, tmp_path, capsys):
+    class FakePipe:
+        def __init__(self, dll, out_dir):
+            pass
+
+        def recover(self, force):
+            raise M.NotManagedAssembly("native")
+
+    monkeypatch.setattr(M, "DotNetRecoveryPipeline", FakePipe)
+    M.Main().recover(str(_dll(tmp_path)))
+    assert "SKIP" in capsys.readouterr().out
+
+
+def test_strings_skips_native(monkeypatch, tmp_path, capsys):
+    def boom(path):
+        raise M.NotManagedAssembly("native")
+
+    monkeypatch.setattr(M, "DotNetAssembly", types.SimpleNamespace(load=boom))
+    M.Main().strings(str(_dll(tmp_path)))
+    assert "SKIP" in capsys.readouterr().out
+
+
+def test_strings(monkeypatch, tmp_path, capsys):
+    class FakeAsm:
+        def decrypt_strings(self):
+            return {"bank": {"m": "val"}}
+
+    monkeypatch.setattr(
+        M, "DotNetAssembly", types.SimpleNamespace(load=lambda p: FakeAsm())
+    )
+    M.Main().strings(str(_dll(tmp_path)))
+    out = capsys.readouterr().out
+    assert "### bank" in out
+    assert "m() = 'val'" in out

tentod-0.1.0/tests/test_pipeline.py

@@ -0,0 +1,94 @@
+from pathlib import Path
+
+from tentod.facts import AssemblyFacts
+import tentod.pipeline as P
+
+
+class _FakeAsm:
+    full_name = "Fake"
+
+    def decrypt_strings(self):
+        return {"b": {"p": "/x"}}
+
+
+class _FakeLoader:
+    @staticmethod
+    def load(path):
+        return _FakeAsm()
+
+
+class _FakeDeobf:
+    def __init__(self, banks):
+        self.banks = banks
+
+    def deobfuscate_file(self, cs_in, cs_out):
+        Path(cs_out).parent.mkdir(parents=True, exist_ok=True)
+        Path(cs_out).write_text("deobf")
+        return Path(cs_out), 7
+
+
+def test_paths():
+    pipe = P.DotNetRecoveryPipeline("dir/a.dll", "root")
+    assert pipe.root == Path("root/a")
+    assert pipe.facts_path == Path("root/a/facts.json")
+
+
+def test_recover(monkeypatch, tmp_path):
+    class FakeDec:
+        def decompile(self, dll, out_dir, force):
+            assert force is True
+            Path(out_dir).mkdir(parents=True, exist_ok=True)
+            f = Path(out_dir) / "a.decompiled.cs"
+            f.write_text("cs")
+            return f
+
+    facts = AssemblyFacts(assembly="Fake", routes=["/x"])
+
+    class FakeExtractor:
+        def extract(self, asm):
+            return facts
+
+    monkeypatch.setattr(P, "IlspyDecompiler", lambda: FakeDec())
+    monkeypatch.setattr(P, "DotNetAssembly", _FakeLoader)
+    monkeypatch.setattr(P, "StringDeobfuscator", _FakeDeobf)
+    monkeypatch.setattr(P, "FactsExtractor", FakeExtractor)
+
+    pipe = P.DotNetRecoveryPipeline(str(tmp_path / "a.dll"), str(tmp_path / "root"))
+    result = pipe.recover(force=True)
+    assert result.replacements == 7
+    assert result.facts is facts
+    assert result.deobfuscated.read_text() == "deobf"
+    assert pipe.facts_path.exists()
+
+
+def test_load_facts_from_disk(tmp_path):
+    pipe = P.DotNetRecoveryPipeline(str(tmp_path / "a.dll"), str(tmp_path / "root"))
+    pipe.facts_path.parent.mkdir(parents=True, exist_ok=True)
+    facts = AssemblyFacts(assembly="Fake", routes=["/x"])
+    pipe.facts_path.write_text(facts.to_json())
+    assert pipe.load_facts() == facts
+
+
+def test_load_facts_extracts_when_absent(monkeypatch, tmp_path):
+    facts = AssemblyFacts(assembly="Fake")
+
+    class FakeExtractor:
+        def extract(self, asm):
+            return facts
+
+    monkeypatch.setattr(P, "DotNetAssembly", _FakeLoader)
+    monkeypatch.setattr(P, "FactsExtractor", FakeExtractor)
+    pipe = P.DotNetRecoveryPipeline(str(tmp_path / "a.dll"), str(tmp_path / "root"))
+    assert pipe.load_facts() is facts
+
+
+def test_verify(tmp_path):
+    pipe = P.DotNetRecoveryPipeline(str(tmp_path / "a.dll"), str(tmp_path / "root"))
+    pipe.facts_path.parent.mkdir(parents=True, exist_ok=True)
+    pipe.facts_path.write_text(
+        AssemblyFacts(assembly="Fake", strings={"b": {"p": "/x"}}, routes=["/x"]).to_json()
+    )
+    py = tmp_path / "gen.py"
+    py.write_text('"/x"')
+    report = pipe.verify(str(py))
+    assert report.ok

tentod-0.1.0/tests/test_verify.py

@@ -0,0 +1,56 @@
+from tentod.facts import AssemblyFacts
+from tentod.verify import RecoveryVerifier
+
+
+def _facts():
+    return AssemblyFacts(
+        assembly="Fake",
+        strings={
+            "bank": {
+                "p": "/alpha",
+                "r": "/beta",
+                "U": "keyname",
+                "log": "chatty internal message",
+                "empty": "",
+            }
+        },
+        routes=["/alpha", "/beta"],
+    )
+
+
+def test_all_routes_present_is_ok():
+    py = 'BASE = "..."\n"/alpha"\n"/beta"\n{"keyname": x}\n'
+    report = RecoveryVerifier().verify(_facts(), py)
+    assert report.ok
+    assert not report.missing_routes
+    assert "chatty internal message" in report.omitted
+    assert "/alpha" in report.matched
+
+
+def test_missing_route_fails():
+    py = '"/alpha"\n{"keyname": x}\n'  # missing /beta
+    report = RecoveryVerifier().verify(_facts(), py)
+    assert not report.ok
+    assert report.missing_routes == ["/beta"]
+
+
+def test_empty_strings_ignored():
+    report = RecoveryVerifier().verify(_facts(), '"/alpha""/beta""keyname"')
+    assert "" not in report.matched
+    assert "" not in report.omitted
+
+
+def test_render_ok_verdict():
+    py = '"/alpha""/beta""keyname""chatty internal message"'
+    text = RecoveryVerifier().verify(_facts(), py).render()
+    assert text.endswith("OK")
+    assert "missing" not in text
+    assert "omitted" not in text  # nothing omitted when everything matched
+
+
+def test_render_fail_lists_missing_and_omitted():
+    text = RecoveryVerifier().verify(_facts(), "nothing here").render()
+    assert "missing (2):" in text
+    assert "  ! /alpha" in text
+    assert "omitted (4):" in text
+    assert text.endswith("FAIL")