module_conflict_check.py

#!/usr/bin/env python3
"""
module_conflict_check.py -- Detect LSPosed module conflicts
Analyzes hooked classes to find overlapping patches.
Usage: python3 module_conflict_check.py [--export csv]
"""
import subprocess, re, json, argparse, sys
from collections import defaultdict

def adb(cmd):
    r = subprocess.run(f"adb shell {cmd}", shell=True, capture_output=True, text=True)
    return r.stdout.strip()

def get_lsposed_modules():
    """List active LSPosed modules"""
    out = adb("pm dump | grep -A 20 'LSPosed'")
    # Parse module names from logcat or dumpsys
    modules = []
    for line in out.splitlines():
        if "module" in line.lower():
            m = re.search(r"package:([a-z0-9_.]+)", line)
            if m:
                modules.append(m.group(1))
    return modules

def analyze_hooks(module_pkg):
    """Extract hooked classes from module DEX"""
    # This is a simplified check — real analysis needs DEX parsing
    out = adb(f"pm dump {module_pkg} | grep -i hook")
    hooks = []
    for line in out.splitlines():
        m = re.search(r"(L[a-z0-9_/]+;)", line)
        if m:
            hooks.append(m.group(1))
    return hooks

def find_conflicts(modules_hooks):
    """Find overlapping hooks between modules"""
    conflicts = defaultdict(list)
    all_hooks = {}
    
    for mod, hooks in modules_hooks.items():
        for hook in hooks:
            if hook in all_hooks:
                conflicts[hook].append((all_hooks[hook], mod))
            else:
                all_hooks[hook] = mod
    
    return {h: mods for h, mods in conflicts.items() if len(mods) > 1}

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--export", help="Export to CSV or JSON")
    args = parser.parse_args()

    print("🔍 LSPosed Module Conflict Checker")
    print("=" * 50)
    
    modules = get_lsposed_modules()
    if not modules:
        print("No LSPosed modules found.")
        return

    print(f"Found {len(modules)} active modules\n")
    
    modules_hooks = {}
    for mod in modules:
        hooks = analyze_hooks(mod)
        modules_hooks[mod] = hooks
        print(f"  {mod.split('.')[-1]:<30} {len(hooks)} hooks")

    conflicts = find_conflicts(modules_hooks)
    
    if conflicts:
        print(f"\n⚠️  Found {len(conflicts)} potential conflicts:\n")
        for hook, hooked_by in conflicts.items():
            print(f"  {hook}")
            for mod1, mod2 in hooked_by:
                print(f"    ↔ {mod1} ↔ {mod2}")
        print("\n💡 Try disabling one module to see if conflicts resolve.")
    else:
        print("\n✅ No conflicts detected!")

    if args.export:
        data = {"total_modules": len(modules), "conflicts": conflicts}
        ext = args.export.split('.')[-1]
        with open(args.export, 'w') as f:
            json.dump(data, f, indent=2) if ext == 'json' else f.write(str(data))
        print(f"Exported to {args.export}")

if __name__ == "__main__":
    main()