Android 17 のローカルネットワーク権限 — LAN に触る箇所を機械で洗い出してから、エージェントに直させる

#!/usr/bin/env python3
"""lan_scan.py — ローカルネットワーク権限が要る呼び出し箇所を洗い出す。"""
import json
import re
import sys
from pathlib import Path
 
PRIVATE_V4 = (
    r"(?:10\.(?:\d{1,3}\.){2}\d{1,3}"
    r"|192\.168\.\d{1,3}\.\d{1,3}"
    r"|172\.(?:1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}"
    r"|169\.254\.\d{1,3}\.\d{1,3})"
)
 
# (確度, 規則名, 正規表現, なぜ LAN へ出るか)
RULES = [
    ("certain", "private-ipv4-literal", rf"(?<![\d.]){PRIVATE_V4}(?![\d.])",
     "プライベート/リンクローカルのIPリテラル"),
    ("certain", "mdns-local-host", r"[A-Za-z0-9_-]+\.local(?![A-Za-z0-9_-])",
     "mDNS の .local ホスト名"),
    ("certain", "broadcast-address", r"255\.255\.255\.255", "UDPブロードキャスト"),
    ("certain", "nsd-discovery",
     r"\bNsdManager\b|\bdiscoverServices\s*\(|\bresolveService\s*\(",
     "NSD/mDNS によるサービス探索"),
    ("certain", "multicast-lock",
     r"\bcreateMulticastLock\s*\(|CHANGE_WIFI_MULTICAST_STATE",
     "マルチキャストの受信"),
    ("certain", "media-router-scan",
     r"\bCastContext\b|CALLBACK_FLAG_PERFORM_ACTIVE_SCAN"
     r"|\bMediaRouter\b\s*\.\s*addCallback",
     "Cast/MediaRouter の能動スキャン"),
    ("likely", "raw-socket",
     r"\b(?:Socket|DatagramSocket|ServerSocket|MulticastSocket)\s*\(",
     "ホストが実行時に決まる生ソケット"),
    ("likely", "inet-resolve",
     r"InetAddress\s*\.\s*(?:getByName|getAllByName)\s*\(",
     "実行時解決。LAN 宛になり得る"),
    ("likely", "configurable-base-url",
     r"\b(?:baseUrl|BASE_URL|host|HOST|endpoint|ENDPOINT|serverUrl|SERVER_URL)\b\s*[:=]",
     "設定画面やリモート設定で差し替わるホスト"),
    ("likely", "emulator-host", r"(?<![\d.])10\.0\.2\.2(?![\d.])",
     "エミュレータのホストループバック"),
    ("likely", "webview-load", r"\bloadUrl\s*\(|\bloadDataWithBaseURL\s*\(",
     "WebView が LAN の URL を読む可能性"),
    ("review", "cleartext-domain-config",
     r"cleartextTrafficPermitted\s*=\s*[\"']true[\"']",
     "平文許可。LAN 宛の名残であることが多い"),
]
 
SKIP_DIRS = {"build", ".git", ".gradle", "node_modules"}
EXTS = {".kt", ".java", ".xml", ".json", ".properties"}
 
# コメント除去は「URL の // を食う」事故が起きやすいので、
# スキームの直後だけは除去対象から外す。
_LINE_COMMENT = re.compile(r"(?<![:/])//.*$|<!--.*?(?:-->|$)|(?<!\S)#.*$")
 
def strip_comment(line: str) -> str:
    return _LINE_COMMENT.sub("", line)
 
def is_import(line: str) -> bool:
    return bool(re.match(r"\s*import\s", line))
 
def scan(root: Path):
    hits = {}  # (file, line) -> finding
    for path in sorted(root.rglob("*")):
        if not path.is_file() or path.suffix not in EXTS:
            continue
        if SKIP_DIRS & set(path.parts):
            continue
        rel = str(path.relative_to(root))
        for lineno, raw in enumerate(path.read_text(errors="replace").splitlines(), 1):
            if is_import(raw):
                continue
            line = strip_comment(raw)
            if not line.strip():
                continue
            matched = [(c, n, w) for c, n, pat, w in RULES if re.search(pat, line)]
            if not matched:
                continue
            # 1行に複数当たったら、最も強い確度で1件に畳む
            order = {"certain": 0, "likely": 1, "review": 2}
            matched.sort(key=lambda m: order[m[0]])
            hits[(rel, lineno)] = {
                "file": rel,
                "line": lineno,
                "confidence": matched[0][0],
                "rules": [m[1] for m in matched],
                "why": matched[0][2],
                "text": raw.strip()[:100],
            }
    return [hits[k] for k in sorted(hits)]
 
def manifest_has_permission(root: Path) -> bool:
    return any(
        "android.permission.LOCAL_NETWORK_ACCESS" in m.read_text(errors="replace")
        for m in root.rglob("AndroidManifest.xml")
    )
 
def main():
    root = Path(sys.argv[1] if len(sys.argv) > 1 else ".").resolve()
    findings = scan(root)
    counts = {"certain": 0, "likely": 0, "review": 0}
    for f in findings:
        counts[f["confidence"]] += 1
    report = {
        "root": str(root),
        "declared_permission": manifest_has_permission(root),
        "counts": counts,
        "total": len(findings),
        "files_touched": len({f["file"] for f in findings}),
        "findings": findings,
    }
    print(json.dumps(report, ensure_ascii=False, indent=2))
    # 権限未宣言なのに certain がある = 出荷後に無反応として現れる
    if counts["certain"] and not report["declared_permission"]:
        print(f"\nFAIL: certain {counts['certain']} 件に対し "
              "LOCAL_NETWORK_ACCESS が未宣言です", file=sys.stderr)
        return 1
    return 0
 
if __name__ == "__main__":
    sys.exit(main())

def strip_comment(line: str) -> str:  # ← 最初の版。これは壊れています
    for marker in ("//", "<!--", "#"):
        i = line.find(marker)
        if i >= 0:
            line = line[:i]
    return line

const val OLLAMA_FALLBACK = "http://192.168.11.8:11434"

_LINE_COMMENT = re.compile(r"(?<![:/])//.*$|<!--.*?(?:-->|$)|(?<!\S)#.*$")

#!/usr/bin/env python3
"""lan_tasks.py — lan_scan.py の JSON を、エージェントに渡せる作業単位へ畳む。"""
import json
import sys
 
QUESTION = {
    "private-ipv4-literal": "この宛先は同一 LAN 上か。ループバック/エミュレータなら権限は不要",
    "emulator-host": "デバッグビルド限定か。リリースに残るなら本番の宛先を確認",
    "mdns-local-host": "名前解決が mDNS 経由なら、探索そのものに権限が要る",
    "broadcast-address": "ブロードキャストは権限なしで無反応になる。縮退表示を用意",
    "nsd-discovery": "探索が0件で返る。ユーザーに理由を出せているか",
    "multicast-lock": "ロック取得は通るが受信が来ない。タイムアウトの扱いを確認",
    "media-router-scan": "Cast 端末が一覧に出ない。空リストの文言を用意",
    "raw-socket": "接続先が LAN になり得るか。なるなら失敗時の例外を握り潰していないか",
    "inet-resolve": "解決結果が私的アドレスになり得るか",
    "configurable-base-url": "ユーザーが LAN のホストを入れられる導線があるか",
    "webview-load": "読み込む URL が LAN を指し得るか。エラーページを出せるか",
    "cleartext-domain-config": "平文許可の対象が LAN 宛か。不要なら削除",
}
RANK = {"certain": 0, "likely": 1, "review": 2}
 
def main():
    report = json.load(open(sys.argv[1]))
    per_file = {}
    for f in report["findings"]:
        e = per_file.setdefault(
            f["file"], {"lines": [], "rules": set(), "confidence": "review"}
        )
        e["lines"].append(f["line"])
        e["rules"].update(f["rules"])
        if RANK[f["confidence"]] < RANK[e["confidence"]]:
            e["confidence"] = f["confidence"]
 
    tasks = []
    for path in sorted(per_file, key=lambda p: (RANK[per_file[p]["confidence"]], p)):
        e = per_file[path]
        tasks.append({
            "file": path,
            "lines": sorted(set(e["lines"])),
            "confidence": e["confidence"],
            "checks": sorted({QUESTION[r] for r in e["rules"] if r in QUESTION}),
            "status": "todo",
        })
 
    print(json.dumps(
        {"permission_declared": report["declared_permission"], "tasks": tasks},
        ensure_ascii=False, indent=2,
    ))
    # 人が読む形は stderr へ。パイプの邪魔をしない
    for t in tasks:
        marks = ",".join(str(x) for x in t["lines"])
        print(f"\n[{t['confidence']}] {t['file']}  (L{marks})", file=sys.stderr)
        for q in t["checks"]:
            print(f"    - [ ] {q}", file=sys.stderr)
 
if __name__ == "__main__":
    main()

sealed interface DiscoveryOutcome {
    data class Found(val services: List<NsdServiceInfo>) : DiscoveryOutcome
    /** 権限がないため探索そのものが成立していない */
    data object BlockedByPermission : DiscoveryOutcome
    /** 権限はあるが本当に見つからなかった */
    data object EmptyNetwork : DiscoveryOutcome
}
 
class DiscoveryReporter(private val context: Context) {
 
    private fun hasLocalNetworkAccess(): Boolean =
        ContextCompat.checkSelfPermission(context, LOCAL_NETWORK_ACCESS) ==
            PackageManager.PERMISSION_GRANTED
 
    /**
     * 0 件は「見つからなかった」と「探せなかった」の両方を意味する。
     * 権限の状態で分岐しないと、ユーザーは無関係な場所を疑い続けることになる。
     */
    fun classify(services: List<NsdServiceInfo>): DiscoveryOutcome = when {
        services.isNotEmpty() -> DiscoveryOutcome.Found(services)
        !hasLocalNetworkAccess() -> DiscoveryOutcome.BlockedByPermission
        else -> DiscoveryOutcome.EmptyNetwork
    }
 
    companion object {
        // 名称はプラットフォームの世代で変わり得るため、参照は1箇所に寄せる
        const val LOCAL_NETWORK_ACCESS = "android.permission.LOCAL_NETWORK_ACCESS"
    }
}