adl-toolkit 0.0.0-stage → 0.1.1

package/adl_drift/lang/java/scopes.py

@@ -0,0 +1,69 @@
+"""Lexical visibility ranges for Java type declarations."""
+
+from __future__ import annotations
+
+from typing import Dict, Iterator, List, Tuple
+
+from tree_sitter import Node
+
+TYPE_DECLARATIONS = {
+    "class_declaration", "interface_declaration", "enum_declaration",
+    "record_declaration", "annotation_type_declaration",
+}
+# Body node types tree-sitter-java pairs with each `TYPE_DECLARATIONS` entry —
+# *not* uniformly `class_body`: `interface_declaration` → `interface_body`,
+# `enum_declaration` → `enum_body`, `annotation_type_declaration` →
+# `annotation_type_body` (`class_declaration`/`record_declaration` are the
+# only two that actually use `class_body`). Any CST walk that must stop at a
+# nested type's boundary (a local/anonymous type's own scope, separately
+# analyzed) needs *all four*, not just `class_body` — a caller that checks
+# only `class_body` will walk straight through a local enum/interface/
+# `@interface`'s body and misattribute its statements to the enclosing
+# method (PROBLEMS.md P4.6).
+TYPE_BODIES = {"class_body", "interface_body", "enum_body", "annotation_type_body"}
+TypeScopes = Dict[str, List[Tuple[int, int]]]
+
+
+def _walk(node: Node) -> Iterator[Node]:
+    yield node
+    for child in node.children:
+        yield from _walk(child)
+
+
+def declaration_scope(node: Node, root: Node) -> Tuple[int, int]:
+    """Lexical visibility range for a type declaration `node`: from its own
+    start (a local class isn't visible before its declaration point) to the
+    end of whichever encloses it — the nearest `block` for a local class, the
+    nearest enclosing type's body for a member class, or `root` for a
+    top-level class. Shared by `declared_type_scopes` (below) and
+    `type_provenance.local_supertypes_of`, so a class's variable-declaration
+    scope and its extends/implements scope always agree (PROBLEMS.md P4.6
+    F-02: two local classes of the same simple name in sibling methods each
+    get their own scope instead of colliding in a single name-keyed table)."""
+    parent = node.parent
+    while parent is not None and parent is not root:
+        if parent.type == "block":
+            return (node.start_byte, parent.end_byte)
+        if parent.type in TYPE_DECLARATIONS:
+            body = parent.child_by_field_name("body")
+            scope = body if body is not None else parent
+            return (scope.start_byte, scope.end_byte)
+        parent = parent.parent
+    return (root.start_byte, root.end_byte)
+
+
+def declared_type_scopes(root: Node, source: bytes) -> TypeScopes:
+    scopes: TypeScopes = {}
+    for node in _walk(root):
+        if node.type not in TYPE_DECLARATIONS:
+            continue
+        name_node = node.child_by_field_name("name")
+        if name_node is None:
+            continue
+        name = source[name_node.start_byte:name_node.end_byte].decode("utf-8")
+        scopes.setdefault(name, []).append(declaration_scope(node, root))
+    return scopes
+
+
+def type_declared_at(scopes: TypeScopes, name: str, at_byte: int) -> bool:
+    return any(start <= at_byte < end for start, end in scopes.get(name, ()))

package/adl_drift/lang/java/taint.py

@@ -0,0 +1,500 @@
+"""Java intra-function taint mechanics (P4.6, PROBLEMS.md).
+
+`JavaTaintStrategy` is `detectors.taint.TaintStrategy`'s Java implementation
+— the CST-coupled half of P2.19's taint tracking, mirroring `lang/python/
+taint.py::PythonTaintStrategy`'s shape but driven by Java's own source/sink
+tables (`lang/java/cfg.py`) and grammar.
+
+The one genuinely Java-specific addition beyond a grammar port: a formal
+parameter carrying a request-binding annotation (`@RequestParam` et al.,
+`CFGConfig.taint_source_param_annotations`) is tainted *unconditionally* at
+function entry — not merely "could be tainted, caller decides" the way an
+ordinary parameter is. This is what makes codegraph-java-deep-dive.md
+§10.5's example work: `UserController.search(@RequestParam String q)` is
+itself the taint's origin, with no caller needed to seed it.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional, Set, Tuple
+
+from tree_sitter import Node
+
+from adl_drift.detectors.taint import TaintPath, TaintStrategy, _OutCall
+from adl_drift.lang.base import CFGConfig
+from adl_drift.lang.java.cfg import (
+    SINK_CONSTRUCTOR_ARGUMENTS,
+    SINK_CONSTRUCTOR_OWNERS,
+    SINK_METHOD_ARGUMENTS,
+    SINK_METHOD_EXTERNAL_SUBTYPE_FALLBACKS,
+    SINK_METHOD_OWNERS,
+    SinkArgumentPolicy,
+    TAINT_SOURCE_PARAM_ANNOTATION_OWNERS,
+    _annotation_owner_verdict,
+    _annotations_of,
+    _collect_uses,
+    _constructed_receiver_type,
+    _enclosing_type_name,
+    _erased_type_name,
+    _method_parameters,
+    _owner_provenance,
+    _receiver_type_candidates,
+    _source_match_for,
+    _text,
+)
+from adl_drift.lang.java.scopes import TYPE_BODIES
+from adl_drift.lang.java.type_provenance import JavaTypeContext, build_type_context
+from adl_drift.utils.types import SourcePosition
+
+__all__ = ["JavaTaintStrategy", "default_java_taint_strategy"]
+
+# Node types marking a *different* function/type's own scope — walks over a
+# method body must not descend past one of these (mirrors `lang.java.
+# resolution.constants._NESTED_SCOPE_BOUNDARY`'s intent, but correct for
+# every nested-type body tree-sitter-java produces, not just `class_body`;
+# see `scopes.TYPE_BODIES`'s docstring — PROBLEMS.md P4.6).
+_NESTED_SCOPE_BOUNDARY = (
+    "method_declaration", "constructor_declaration",
+    "compact_constructor_declaration", "lambda_expression", *TYPE_BODIES,
+)
+
+
+def _pos(node: Node) -> SourcePosition:
+    return SourcePosition(
+        line=node.start_point[0] + 1,
+        column=node.start_point[1],
+        end_line=node.end_point[0] + 1,
+        end_column=node.end_point[1],
+    )
+
+
+def _ids_in(node: Optional[Node], source: bytes) -> Set[str]:
+    """Identifier *reads* under *node* — reuses `lang.java.cfg`'s use-walker
+    (already skips method/field names, type positions, annotations, and
+    lambda bodies) rather than duplicating that logic."""
+    out: Set[str] = set()
+    if node is None:
+        return out
+    events: List = []
+    _collect_uses(node, events)
+    return {e.name for e in events}
+
+
+def _this_field_name(node: Optional[Node], source: bytes) -> str:
+    if node is None or node.type != "field_access":
+        return ""
+    obj = node.child_by_field_name("object")
+    field = node.child_by_field_name("field")
+    if obj is None or field is None or obj.type != "this":
+        return ""
+    return _text(field, source)
+
+
+def _taint_ids_in(node: Optional[Node], source: bytes) -> Set[str]:
+    """Binding reads for taint propagation, including `this.field` aliases."""
+    out = _ids_in(node, source)
+    if node is None:
+        return out
+    stack = [node]
+    while stack:
+        cur = stack.pop()
+        name = _this_field_name(cur, source)
+        if name:
+            out.add(name)
+            continue
+        stack.extend(cur.children)
+    return out
+
+
+def _target_names(node: Optional[Node], source: bytes) -> List[str]:
+    if node is None:
+        return []
+    if node.type == "identifier":
+        name = _text(node, source)
+        return [name] if name else []
+    name = _this_field_name(node, source)
+    return [name] if name else []
+
+
+def _positional_args(call: Node) -> List[Node]:
+    args = call.child_by_field_name("arguments")
+    if args is None:
+        return []
+    return [c for c in args.children if c.is_named]
+
+
+def _sink_args(call: Node, policy: SinkArgumentPolicy) -> List[Node]:
+    if policy == "receiver":
+        # Zero-argument sink (`in.readObject()`) — the node to check for
+        # taint is the receiver expression itself, not a positional
+        # argument. Reusing the same "list of nodes checked for taint"
+        # contract as the argument-index policies below lets the caller's
+        # generic sink-taint check (`analyze_one`) handle this case with no
+        # extra branching.
+        obj = call.child_by_field_name("object")
+        return [obj] if obj is not None else []
+    pos_args = _positional_args(call)
+    if policy == "all":
+        return pos_args
+    return [pos_args[idx] for idx in policy if 0 <= idx < len(pos_args)]
+
+
+def _param_names(func_node: Node, source: bytes) -> List[str]:
+    params_node = _method_parameters(func_node)
+    if params_node is None:
+        return []
+    names: List[str] = []
+    for child in params_node.children:
+        if child.type not in ("formal_parameter", "spread_parameter"):
+            continue
+        name_node = child.child_by_field_name("name")
+        if name_node is not None:
+            names.append(_text(name_node, source))
+    return names
+
+
+def _annotation_seeds(
+    func_node: Node, source: bytes, config: CFGConfig, ctx: Optional[JavaTypeContext],
+) -> Dict[str, Tuple[str, bool]]:
+    """`{param_name: (source_label, confirmed)}` for every formal parameter
+    carrying a request-binding annotation (`@RequestParam` et al.).
+    `confirmed` is `False` for an annotation that couldn't be positively
+    matched against `TAINT_SOURCE_PARAM_ANNOTATION_OWNERS` via import (F-04,
+    PROBLEMS.md P4.6) — still seeded, at reduced downstream confidence,
+    unless the annotation is *provably* a different, same-named one (a
+    local `@interface` declaration, or a conflicting import), in which case
+    it's skipped entirely."""
+    params_node = _method_parameters(func_node)
+    if params_node is None:
+        return {}
+    seeds: Dict[str, Tuple[str, bool]] = {}
+    for child in params_node.children:
+        if child.type not in ("formal_parameter", "spread_parameter"):
+            continue
+        name_node = child.child_by_field_name("name")
+        if name_node is None:
+            continue
+        for raw_name, at_byte in _annotations_of(child, source):
+            simple = raw_name.rsplit(".", 1)[-1]
+            label = config.taint_source_param_annotations.get(simple)
+            if not label:
+                continue
+            verdict = _annotation_owner_verdict(
+                raw_name, at_byte, TAINT_SOURCE_PARAM_ANNOTATION_OWNERS.get(simple), ctx,
+            )
+            if verdict == "rejected":
+                continue
+            seeds[_text(name_node, source)] = (label, verdict == "confirmed")
+            break
+    return seeds
+
+
+class JavaTaintStrategy(TaintStrategy):
+    """Java's `TaintStrategy` (P4.6)."""
+
+    def __init__(self, config: CFGConfig) -> None:
+        super().__init__(config)
+        # Per-file import/declared-type provenance (F-04, PROBLEMS.md P4.6),
+        # computed once per file and reused for every function `analyze_one`
+        # is called on within it — safe to cache for the lifetime of this
+        # strategy instance, which is itself scoped to one `CallGraphBuilder`
+        # (one scan snapshot; see `CallGraphBuilder._get_taint_strategy`).
+        self._type_ctx_cache: Dict[str, JavaTypeContext] = {}
+
+    def param_names(self, func_node: Node, source: bytes) -> List[str]:
+        return _param_names(func_node, source)
+
+    def _type_context(self, func_node: Node, source: bytes, file_path: str) -> JavaTypeContext:
+        ctx = self._type_ctx_cache.get(file_path)
+        if ctx is None:
+            root = func_node
+            while root.parent is not None:
+                root = root.parent
+            ctx = build_type_context(root, source)
+            self._type_ctx_cache[file_path] = ctx
+        return ctx
+
+    def _source_match(
+        self, node: Optional[Node], source: bytes, ctx: Optional[JavaTypeContext],
+    ) -> Optional[Tuple[str, bool]]:
+        return _source_match_for(node, self.config, source, ctx)
+
+    def _sink_info(
+        self, call: Node, is_new: bool, source: bytes, ctx: Optional[JavaTypeContext],
+    ) -> Optional[Tuple[str, str, List[Node], bool]]:
+        """Returns ``(callable_text, category, pos_args, confirmed)`` — *all*
+        positional args, not just the first: Java varargs sinks (`new
+        ProcessBuilder(String...)`, `.command(String...)`) spread the
+        attacker-controlled data across multiple sibling argument nodes,
+        unlike Python's sinks (`eval`, `os.system`) which are always
+        single-argument. ``confirmed`` is `False` when the sink name matched
+        but its declaring type couldn't be positively confirmed via imports
+        (F-04, PROBLEMS.md P4.6) — a business method named `execute`/
+        `invoke`/`exec` on a project-owned, unrelated class returns `None`
+        entirely (its type is *confirmed* to be something else), not a
+        low-confidence match."""
+        if is_new:
+            type_node = call.child_by_field_name("type")
+            if type_node is None:
+                return None
+            simple = _erased_type_name(_text(type_node, source))
+            sink_key = simple if simple in self.config.sink_constructors else None
+            if sink_key is None:
+                # Fully-qualified constructed type (`new java.lang.
+                # ProcessBuilder(...)`), not just the short `ProcessBuilder`
+                # form `_erased_type_name` above catches — same FQN gap as
+                # `_source_match_for`'s (PROBLEMS.md P4.6 F-04): `simple`
+                # above never equals the short `sink_constructors` key for
+                # an FQN-spelled type, so it fell through unmatched. Only
+                # trusted when `simple` equals the *entire* owner FQN, not a
+                # suffix of it, mirroring the source-side fix.
+                for cand_key, owner_fqns in SINK_CONSTRUCTOR_OWNERS.items():
+                    if cand_key in self.config.sink_constructors and simple in owner_fqns:
+                        sink_key = cand_key
+                        break
+            category = self.config.sink_constructors.get(sink_key) if sink_key else None
+            if category is None:
+                return None
+            pos_args = _sink_args(call, SINK_CONSTRUCTOR_ARGUMENTS.get(sink_key, "all"))
+            if not pos_args:
+                return None
+            verdict = _owner_provenance(
+                (simple,), call.start_byte, SINK_CONSTRUCTOR_OWNERS.get(sink_key), ctx,
+            )
+            if verdict == "rejected":
+                return None
+            return f"new {sink_key}", category, pos_args, verdict == "confirmed"
+
+        name_node = call.child_by_field_name("name")
+        if name_node is None:
+            return None
+        method_name = _text(name_node, source)
+        category = self.config.sink_methods.get(method_name)
+        if category is None:
+            return None
+        pos_args = _sink_args(call, SINK_METHOD_ARGUMENTS.get(method_name, "all"))
+        if not pos_args:
+            return None
+        obj = call.child_by_field_name("object")
+        receiver = _text(obj, source) if obj is not None else ""
+        verdict = _owner_provenance(
+            _receiver_type_candidates(
+                receiver, ctx, call.start_byte, _constructed_receiver_type(obj, source),
+                _enclosing_type_name(call, source) if obj is None else "",
+            ),
+            call.start_byte, SINK_METHOD_OWNERS.get(method_name), ctx,
+            allow_external_subtype_fallback=method_name in SINK_METHOD_EXTERNAL_SUBTYPE_FALLBACKS,
+        )
+        if verdict == "rejected":
+            return None
+        callable_text = f"{receiver}.{method_name}" if obj is not None else method_name
+        return callable_text, category, pos_args, verdict == "confirmed"
+
+    @staticmethod
+    def _collect_call_sites(body: Node) -> List[Tuple[Node, bool]]:
+        """`(call_node, is_object_creation)` for every `method_invocation`/
+        `object_creation_expression` in `body`, not descending into a nested
+        method/constructor/class body or a lambda (each has its own,
+        separately-analyzed scope)."""
+        out: List[Tuple[Node, bool]] = []
+        stack = [body]
+        while stack:
+            node = stack.pop()
+            if node.type == "method_invocation":
+                out.append((node, False))
+            elif node.type == "object_creation_expression":
+                out.append((node, True))
+            if node is not body and node.type in _NESTED_SCOPE_BOUNDARY:
+                continue
+            stack.extend(node.children)
+        return out
+
+    def analyze_one(
+        self,
+        func_node: Node,
+        source: bytes,
+        function_id: str,
+        file_path: str,
+        seed_params: Set[str],
+    ) -> Tuple[Set[str], List[TaintPath], List[_OutCall]]:
+        body = func_node.child_by_field_name("body")
+        if body is None:
+            return set(), [], []
+
+        ctx = self._type_context(func_node, source, file_path)
+
+        tainted: Set[str] = set(seed_params)
+        source_of: Dict[str, str] = {p: "parameter" for p in seed_params}
+        # Whether each binding's taint origin was FQN-confirmed (F-04,
+        # PROBLEMS.md P4.6) rather than an unresolved simple-name fallback —
+        # cross-function seeds have no source/sink match of their own to
+        # confirm, so they default to confirmed (their confidence is already
+        # governed by the existing cross-function 0.7-vs-0.85 split below).
+        confirmed_of: Dict[str, bool] = {p: True for p in seed_params}
+
+        # Request-binding annotations are an unconditional source, regardless
+        # of caller — see module docstring.
+        for name, (label, confirmed) in _annotation_seeds(func_node, source, self.config, ctx).items():
+            tainted.add(name)
+            source_of[name] = label
+            confirmed_of[name] = confirmed
+
+        # ── collect assignment records ──────────────────────────────────
+        # `(names, rhs_ids, direct_label, direct_confirmed)` — `direct_label`
+        # is set only when the RHS itself is a recognized source expression.
+        assigns: List[Tuple[List[str], Set[str], Optional[str], bool]] = []
+
+        def _record(target_node: Optional[Node], value: Optional[Node]) -> None:
+            names = _target_names(target_node, source)
+            if not names or value is None:
+                return
+            match = self._source_match(value, source, ctx)
+            label, confirmed = match if match else (None, True)
+            assigns.append((names, _taint_ids_in(value, source), label, confirmed))
+
+        stack = [body]
+        while stack:
+            node = stack.pop()
+            t = node.type
+            if node is not body and t in _NESTED_SCOPE_BOUNDARY:
+                continue
+            if t == "local_variable_declaration":
+                for i, child in enumerate(node.children):
+                    if node.field_name_for_child(i) != "declarator":
+                        continue
+                    _record(child.child_by_field_name("name"), child.child_by_field_name("value"))
+            elif t == "assignment_expression":
+                lhs = node.child_by_field_name("left")
+                op = node.child_by_field_name("operator")
+                rhs = node.child_by_field_name("right")
+                op_text = _text(op, source) if op is not None else "="
+                names = _target_names(lhs, source)
+                if names and rhs is not None:
+                    if op_text == "=":
+                        _record(lhs, rhs)
+                    else:
+                        rhs_ids = _taint_ids_in(rhs, source) | set(names)
+                        match = self._source_match(rhs, source, ctx)
+                        label, confirmed = match if match else (None, True)
+                        assigns.append((names, rhs_ids, label, confirmed))
+            elif t == "enhanced_for_statement":
+                _record(node.child_by_field_name("name"), node.child_by_field_name("value"))
+            elif t == "resource":
+                _record(node.child_by_field_name("name"), node.child_by_field_name("value"))
+            stack.extend(node.children)
+
+        # ── propagate to fixpoint ─────────────────────────────────────────
+        changed = True
+        while changed:
+            changed = False
+            for names, rhs_ids, lbl, lbl_confirmed in assigns:
+                tainted_rhs = lbl or any(i in tainted for i in rhs_ids)
+                if not tainted_rhs:
+                    continue
+                if lbl:
+                    label, confirmed = lbl, lbl_confirmed
+                else:
+                    hit = next((i for i in rhs_ids if i in tainted), None)
+                    label = source_of.get(hit)
+                    confirmed = confirmed_of.get(hit, True)
+                for n in names:
+                    if n not in tainted:
+                        tainted.add(n)
+                        source_of[n] = label or "tainted"
+                        confirmed_of[n] = confirmed
+                        changed = True
+
+        # ── sink detection ────────────────────────────────────────────────
+        paths: List[TaintPath] = []
+        seen_sites: Set[Tuple[int, int]] = set()
+        for call, is_new in self._collect_call_sites(body):
+            info = self._sink_info(call, is_new, source, ctx)
+            if info is None:
+                continue
+            callable_text, category, arg_nodes, sink_confirmed = info
+            site = _pos(call)
+            site_key = (site.line, site.column)
+
+            direct: Optional[str] = None
+            direct_confirmed = True
+            binding: Optional[str] = None
+            for arg_node in arg_nodes:
+                match = self._source_match(arg_node, source, ctx)
+                if match:
+                    direct, direct_confirmed = match
+                    break
+                arg_ids = _taint_ids_in(arg_node, source)
+                hit = next((i for i in arg_ids if i in tainted), None)
+                if hit is not None:
+                    binding = hit
+                    break
+            if direct is None and binding is None:
+                continue
+
+            if direct:
+                label = direct
+                cross = False
+                source_confirmed = direct_confirmed
+            else:
+                label = source_of.get(binding, "tainted")
+                cross = label == "parameter"
+                source_confirmed = confirmed_of.get(binding, True)
+
+            if site_key in seen_sites:
+                continue
+            seen_sites.add(site_key)
+
+            chain = [label]
+            if binding:
+                chain.append(binding)
+            chain.append(callable_text)
+            # Confidence combines the existing same-function/cross-function
+            # split with whether *both* the source and sink API were
+            # FQN-confirmed (F-04, PROBLEMS.md P4.6) — an unresolved simple-
+            # name match on either side is still reported (recall), just at
+            # a markedly lower confidence than a fully-confirmed one.
+            confirmed = source_confirmed and sink_confirmed
+            if confirmed:
+                confidence = 0.7 if cross else 0.85
+            else:
+                confidence = 0.35 if cross else 0.5
+            paths.append(TaintPath(
+                function_id=function_id,
+                file_path=file_path,
+                sink=callable_text,
+                sink_category=category,
+                source_label=label,
+                binding_name=binding,
+                sink_site=site,
+                chain=chain,
+                confidence=confidence,
+                cross_function=cross,
+            ))
+
+        # ── outgoing tainted calls (for cross-function propagation) ────────
+        out_calls: List[_OutCall] = []
+        for call, is_new in self._collect_call_sites(body):
+            if is_new:
+                continue  # constructor targets aren't looked up by-name (P4.4 precedent)
+            name_node = call.child_by_field_name("name")
+            if name_node is None:
+                continue
+            callee = _text(name_node, source)
+            if not callee:
+                continue
+            pos_t: Set[int] = set()
+            for idx, arg in enumerate(_positional_args(call)):
+                if self._source_match(arg, source, ctx) or (_taint_ids_in(arg, source) & tainted):
+                    pos_t.add(idx)
+            if pos_t:
+                out_calls.append(_OutCall(
+                    callee, pos_t, set(),
+                    site_line=call.start_point[0] + 1,
+                    site_column=call.start_point[1],
+                ))
+
+        return tainted, paths, out_calls
+
+
+def default_java_taint_strategy(config: CFGConfig) -> JavaTaintStrategy:
+    return JavaTaintStrategy(config)