coretrace-python-analyzer 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

coretrace_python/__init__.py

@@ -1,4 +1,4 @@
 """CoreTrace's Python static analysis frontend."""
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 

coretrace_python/bundled/dependency/reachable_vulnerability/reachable_vulnerability.py

@@ -7,7 +7,7 @@ from typing import ClassVar
 
 from coretrace_python.analysis import AnyAnalysis
 from coretrace_python.dependency import DependencyAnalysis
-from coretrace_python.dependency.correlation import affected_symbols, evidence
+from coretrace_python.dependency.correlation import affected_symbols, check_conditions, evidence
 from coretrace_python.findings import Confidence, Finding
 from coretrace_python.interprocedural import CallGraphAnalysis, ExternalSymbol
 from coretrace_python.plugins import ProjectContext, ProjectPlugin
@@ -29,6 +29,9 @@ class ReachableVulnerabilityPlugin(ProjectPlugin):
                     if not isinstance(site.target, ExternalSymbol):
                         continue
                     for advisory in affected.get(site.target.symbol, ()):
+                        check = check_conditions(advisory.entry_point(site.target.symbol), site.arguments)
+                        if check.contradicted is not None:
+                            continue
                         findings.append(
                             Finding(
                                 rule_id="reachable-vulnerability",
@@ -40,7 +43,7 @@ class ReachableVulnerabilityPlugin(ProjectPlugin):
                                 confidence=Confidence.HIGH,
                                 span=site.location,
                                 function=function,
-                                metadata=evidence(advisory, site.target.symbol, "reachable"),
+                                metadata=evidence(advisory, site.target.symbol, "reachable", check),
                             )
                         )
         return findings

coretrace_python/bundled/dependency/vulnerable_dependency/plugin.toml

@@ -1,7 +1,7 @@
 name = "vulnerable-dependency"
 version = "1.0.0"
 plugin_api = ">=1,<2"
-requires = ["dependency.graph"]
+requires = ["dependency.graph", "interprocedural.callgraph"]
 provides = ["vulnerability.vulnerable-dependency"]
 
 [entrypoint]

coretrace_python/bundled/dependency/vulnerable_dependency/vulnerable_dependency.py

@@ -7,23 +7,34 @@ from typing import ClassVar
 
 from coretrace_python.analysis import AnyAnalysis
 from coretrace_python.dependency import DependencyAnalysis
+from coretrace_python.dependency.correlation import affected_symbols, check_conditions, ruled_out
 from coretrace_python.findings import Confidence, Finding
+from coretrace_python.interprocedural import CallGraphAnalysis, ExternalSymbol
 from coretrace_python.plugins import ProjectContext, ProjectPlugin
 
 
 class VulnerableDependencyPlugin(ProjectPlugin):
     name: ClassVar[str] = "vulnerable-dependency"
-    requires: ClassVar[frozenset[AnyAnalysis]] = frozenset({DependencyAnalysis})
+    requires: ClassVar[frozenset[AnyAnalysis]] = frozenset({DependencyAnalysis, CallGraphAnalysis})
 
     def analyze_project(self, ctx: ProjectContext) -> Sequence[Finding]:
         findings: list[Finding] = []
         imported = [s for module in ctx.modules for s in ctx.imports(module).all_symbols()]
+        excluded = _ruled_out(ctx)
         for requirement in ctx.dependencies.requirements:
             for advisory in ctx.advisories:
                 if not advisory.affects(requirement):
                     continue
                 pinned = requirement.pinned is not None
                 level = "imported" if advisory.imported_by(imported) else "declared"
+                metadata = {
+                    "advisory": advisory.id,
+                    "package": advisory.package,
+                    "specifier": requirement.specifier,
+                    "level": level,
+                }
+                if excluded.get(advisory.id):
+                    metadata["ruled_out"] = "; ".join(excluded[advisory.id])
                 findings.append(
                     Finding(
                         rule_id="vulnerable-dependency",
@@ -35,12 +46,26 @@ class VulnerableDependencyPlugin(ProjectPlugin):
                         severity=advisory.severity,
                         confidence=Confidence.HIGH if pinned else Confidence.MEDIUM,
                         span=requirement.span,
-                        metadata={
-                            "advisory": advisory.id,
-                            "package": advisory.package,
-                            "specifier": requirement.specifier,
-                            "level": level,
-                        },
+                        metadata=metadata,
                     )
                 )
         return findings
+
+
+def _ruled_out(ctx: ProjectContext) -> dict[str, list[str]]:
+    """By advisory, the calls to its entry points whose arguments contradict one of its
+    conditions: the evidence that the requirement, imported, is not reached there."""
+
+    affected = affected_symbols(ctx.dependencies, ctx.advisories)
+    excluded: dict[str, list[str]] = {}
+    for module in sorted(ctx.modules):
+        graph = ctx.call_graph(module)
+        for function in graph.functions:
+            for site in graph.sites(function):
+                if not isinstance(site.target, ExternalSymbol):
+                    continue
+                for advisory in affected.get(site.target.symbol, ()):
+                    check = check_conditions(advisory.entry_point(site.target.symbol), site.arguments)
+                    if check.contradicted is not None:
+                        excluded.setdefault(advisory.id, []).append(ruled_out(module, site, check))
+    return excluded

coretrace_python/cache.py

@@ -22,11 +22,13 @@ from typing import Any
 
 from coretrace_python.findings import Confidence, Finding, Severity
 from coretrace_python.interprocedural import (
+    Arguments,
     CallSite,
     ExternalCall,
     ExternalSymbol,
     FunctionSummary,
     KnownFunction,
+    ModuleFunction,
     ModuleGraph,
     Mutation,
     NonlocalWrite,
@@ -37,14 +39,14 @@ from coretrace_python.interprocedural import (
 from coretrace_python.semantic.symbols import SymbolId
 from coretrace_python.source import SourceId, SourceSpan
 
-CACHE_FORMAT = 5
+CACHE_FORMAT = 7
 
 
 @dataclass(frozen=True)
 class CachedModule:
     """Everything a later run needs from one module without lowering it again."""
 
-    functions: tuple[str, ...]
+    functions: tuple[ModuleFunction, ...]
     summaries: Mapping[str, FunctionSummary]
     sites: tuple[CallSite, ...]
     findings: tuple[Finding, ...]
@@ -128,7 +130,7 @@ class ProjectCache:
 def encode(module: CachedModule) -> dict[str, Any]:
     return {
         "format": CACHE_FORMAT,
-        "functions": list(module.functions),
+        "functions": [[f.name, _encode_span(f.span), f.entry_point] for f in module.functions],
         "summaries": {name: _encode_summary(s) for name, s in module.summaries.items()},
         "sites": [_encode_site(site) for site in module.sites],
         "findings": [_encode_finding(finding) for finding in module.findings],
@@ -139,7 +141,7 @@ def decode(data: Mapping[str, Any]) -> CachedModule:
     if data["format"] != CACHE_FORMAT:
         raise ValueError(f"unsupported cache format {data['format']!r}")
     return CachedModule(
-        tuple(_string(name) for name in data["functions"]),
+        tuple(_decode_function(function) for function in data["functions"]),
         {_string(name): _decode_summary(s) for name, s in data["summaries"].items()},
         tuple(_decode_site(site) for site in data["sites"]),
         tuple(_decode_finding(finding) for finding in data["findings"]),
@@ -187,6 +189,11 @@ def _decode_span(data: Any) -> SourceSpan:
     )
 
 
+def _decode_function(data: Any) -> ModuleFunction:
+    name, span, entry_point = data
+    return ModuleFunction(_string(name), _decode_span(span), None if entry_point is None else _string(entry_point))
+
+
 def _encode_finding(finding: Finding) -> dict[str, Any]:
     return {
         "rule": finding.rule_id,
@@ -219,6 +226,7 @@ def _encode_call(call: ExternalCall) -> dict[str, Any]:
         "keywords": sorted(call.keyword_dependencies),
         "location": _encode_span(call.location),
         "call_site": None if call.call_site is None else _encode_span(call.call_site),
+        "given": _encode_arguments(call.arguments),
     }
 
 
@@ -230,6 +238,7 @@ def _decode_call(data: Mapping[str, Any]) -> ExternalCall:
         _indices(data["keywords"]),
         _decode_span(data["location"]),
         None if site is None else _decode_span(site),
+        _decode_arguments(data["given"]),
     )
 
 
@@ -311,8 +320,7 @@ def _encode_site(site: CallSite) -> dict[str, Any]:
         "caller": site.caller,
         "location": _encode_span(site.location),
         "target": _encode_target(site.target),
-        "arguments": site.arguments,
-        "keywords": site.keywords,
+        "arguments": _encode_arguments(site.arguments),
     }
 
 
@@ -321,6 +329,27 @@ def _decode_site(data: Mapping[str, Any]) -> CallSite:
         _string(data["caller"]),
         _decode_span(data["location"]),
         _decode_target(data["target"]),
-        _integer(data["arguments"]),
-        _integer(data["keywords"]),
+        _decode_arguments(data["arguments"]),
+    )
+
+
+def _encode_arguments(arguments: Arguments) -> dict[str, Any]:
+    return {
+        "positional": list(arguments.positional),
+        "keywords": [[name, value] for name, value in arguments.keywords],
+        "unpacked": arguments.unpacked,
+    }
+
+
+def _decode_arguments(data: Mapping[str, Any]) -> Arguments:
+    def denoted(value: Any) -> str | None:
+        return None if value is None else _string(value)
+
+    unpacked = data["unpacked"]
+    if not isinstance(unpacked, bool):
+        raise TypeError(f"expected a boolean, got {unpacked!r}")
+    return Arguments(
+        tuple(denoted(value) for value in data["positional"]),
+        tuple((_string(name), denoted(value)) for name, value in data["keywords"]),
+        unpacked,
     )

coretrace_python/dependency/advisories.py

@@ -160,6 +160,10 @@ def _condition_entry(condition: Condition) -> dict[str, Any]:
         entry["argument"] = condition.argument
     if condition.values:
         entry["values"] = list(condition.values)
+    if condition.position is not None:
+        entry["position"] = condition.position
+    if condition.default:
+        entry["default"] = True
     return entry
 
 
@@ -193,13 +197,22 @@ def _entry_point(entry: Mapping[str, Any]) -> AdvisoryEntryPoint:
     return AdvisoryEntryPoint(
         SymbolId(str(entry["symbol"])),
         str(entry["justification"]),
-        tuple(
-            Condition(
-                str(c["kind"]),
-                str(c["text"]),
-                None if c.get("argument") is None else str(c["argument"]),
-                tuple(str(v) for v in c.get("values") or []),
-            )
-            for c in entry.get("conditions") or []
-        ),
+        tuple(_condition(c) for c in entry.get("conditions") or []),
+    )
+
+
+def _condition(entry: Mapping[str, Any]) -> Condition:
+    position = entry.get("position")
+    if position is not None and (not isinstance(position, int) or isinstance(position, bool) or position < 0):
+        raise TypeError(f"condition position must be a non-negative integer, got {position!r}")
+    default = entry.get("default", False)
+    if not isinstance(default, bool):
+        raise TypeError(f"condition default must be true or false, got {default!r}")
+    return Condition(
+        str(entry["kind"]),
+        str(entry["text"]),
+        None if entry.get("argument") is None else str(entry["argument"]),
+        tuple(str(v) for v in entry.get("values") or []),
+        position,
+        default,
     )

coretrace_python/dependency/correlation.py

@@ -10,10 +10,18 @@ are correlated here into one high-confidence ``exploitable-vulnerability`` findi
 from __future__ import annotations
 
 from collections.abc import Iterable, Mapping
-
-from coretrace_python.dependency.graph import DIRECT, Advisory, DependencyGraph
+from dataclasses import dataclass
+
+from coretrace_python.dependency.graph import (
+    DIRECT,
+    Advisory,
+    AdvisoryEntryPoint,
+    Condition,
+    DependencyGraph,
+)
 from coretrace_python.findings import Confidence, Finding, Severity
 from coretrace_python.findings.refutation import Status, Verdict, Verdicts
+from coretrace_python.interprocedural import Arguments, CallSite, ExternalSymbol
 from coretrace_python.semantic.symbols import SymbolId
 from coretrace_python.taint import Sink, TaintFlow, TaintKind
 
@@ -40,10 +48,68 @@ def advisory_sinks(affected: Affected) -> tuple[Sink, ...]:
     return tuple(Sink(symbol, TaintKind.ADVISORY) for symbol in affected)
 
 
-def evidence(advisory: Advisory, symbol: SymbolId, level: str) -> dict[str, str]:
+@dataclass(frozen=True)
+class ConditionCheck:
+    """What one call tells of an entry point's conditions: those it meets, those left to
+    review (every semantic one, and every argument one the call does not decide), and
+    the argument condition it contradicts with what it passes instead (None: absent),
+    in which case the call does not reach the vulnerability."""
+
+    met: tuple[Condition, ...] = ()
+    pending: tuple[Condition, ...] = ()
+    contradicted: Condition | None = None
+    passed: str | None = None
+
+
+def check_conditions(entry: AdvisoryEntryPoint | None, arguments: Arguments | None) -> ConditionCheck:
+    """Decide ``entry``'s conditions against what the call's ``arguments`` denote."""
+
+    if entry is None:
+        return ConditionCheck()
+    met: list[Condition] = []
+    pending: list[Condition] = []
+    for condition in entry.conditions:
+        given = _given(condition, arguments) if condition.checkable and arguments is not None else None
+        if given is None:
+            pending.append(condition)
+            continue
+        explicit, value = given
+        if explicit and value is None:
+            pending.append(condition)
+            continue
+        affected = value in condition.values if explicit else condition.default
+        if not affected:
+            return ConditionCheck(tuple(met), tuple(pending), condition, value)
+        met.append(condition)
+    return ConditionCheck(tuple(met), tuple(pending))
+
+
+def _given(condition: Condition, arguments: Arguments) -> tuple[bool, str | None] | None:
+    """Whether the call gives the condition's argument, and what it denotes: ``(True,
+    value)`` when given, ``(False, None)`` when surely absent, None when it cannot tell."""
+
+    for name, value in arguments.keywords:
+        if name == condition.argument:
+            return True, value
+    if condition.position is not None and condition.position < len(arguments.positional):
+        return True, arguments.positional[condition.position]
+    return None if arguments.unpacked else (False, None)
+
+
+def ruled_out(module: str, site: CallSite, check: ConditionCheck) -> str:
+    """Which call a contradicted condition rules out, and why: ``app:12
+    python.yaml.load(Loader=python.yaml.SafeLoader)``."""
+
+    assert check.contradicted is not None and isinstance(site.target, ExternalSymbol)
+    argument = check.contradicted.argument or f"#{check.contradicted.position}"
+    passed = f"{argument} absent" if check.passed is None else f"{argument}={check.passed}"
+    return f"{module}:{site.location.start_line} {site.target.symbol}({passed})"
+
+
+def evidence(advisory: Advisory, symbol: SymbolId, level: str, check: ConditionCheck) -> dict[str, str]:
     """What a finding keeps of the advisory for ``symbol``: the level of evidence
-    established, how the symbol relates to the vulnerability and under which
-    conditions, the ones the engine could not check listed as pending review."""
+    established, how the symbol relates to the vulnerability, and its conditions — those
+    the call meets and those left to review."""
 
     metadata = {"advisory": advisory.id, "package": advisory.package, "symbol": str(symbol), "level": level}
     entry = advisory.entry_point(symbol)
@@ -54,9 +120,10 @@ def evidence(advisory: Advisory, symbol: SymbolId, level: str) -> dict[str, str]
     metadata["justification"] = entry.justification
     if entry.conditions:
         metadata["conditions"] = "; ".join(c.text for c in entry.conditions)
-        # ponytail: no condition is checked yet, so every one awaits review; argument
-        # conditions get checked at the call site once call sites carry argument symbols.
-        metadata["conditions_pending_review"] = "; ".join(c.text for c in entry.conditions)
+    if check.met:
+        metadata["conditions_met"] = "; ".join(c.text for c in check.met)
+    if check.pending:
+        metadata["conditions_pending_review"] = "; ".join(c.text for c in check.pending)
     return metadata
 
 
@@ -77,21 +144,22 @@ def correlate(
         if verdict is not None and verdict.status is Status.REFUTED:
             continue
         hotspot = verdict is not None and verdict.status is Status.HOTSPOT
-        findings.extend(
-            _exploitable(function, flow, advisory, verdict, hotspot) for advisory in affected.get(flow.sink.symbol, ())
-        )
+        for advisory in affected.get(flow.sink.symbol, ()):
+            check = check_conditions(advisory.entry_point(flow.sink.symbol), flow.sink_arguments)
+            if check.contradicted is None:
+                findings.append(_exploitable(function, flow, advisory, verdict, hotspot, check))
     return tuple(findings)
 
 
 def _exploitable(
-    function: str, flow: TaintFlow, advisory: Advisory, verdict: Verdict | None, hotspot: bool
+    function: str, flow: TaintFlow, advisory: Advisory, verdict: Verdict | None, hotspot: bool, check: ConditionCheck
 ) -> Finding:
     message = (
         f"{advisory.id}: {flow.source.label} input reaches {flow.sink.symbol}, affected in "
         f"the required {advisory.package} {advisory.vulnerable}: {advisory.summary}"
     )
     metadata = {
-        **evidence(advisory, flow.sink.symbol, "exploitable"),
+        **evidence(advisory, flow.sink.symbol, "exploitable", check),
         "source": str(flow.source.symbol),
         "source_label": flow.source.label,
         "verdict": "hotspot" if hotspot else "vulnerability",

coretrace_python/dependency/graph.py

@@ -147,13 +147,18 @@ class Condition:
     """What must hold for an entry point to reach, or exploit, the affected code: the
     value of an argument, the loader or algorithm used, the format decoded, the kind of
     input, a configuration. ``kind`` says whether the engine can check it: an
-    ``argument`` condition names the argument and the values that satisfy it; a
-    ``semantic`` condition cannot be checked yet and is reported as pending review."""
+    ``argument`` condition names the argument by keyword, and by ``position`` when it may
+    be passed positionally, and lists the ``values`` that satisfy it — symbols
+    (``python.yaml.FullLoader``) or constants as Python writes them (``True``);
+    ``default`` says an absent argument means a vulnerable value. A ``semantic``
+    condition cannot be checked and is reported as pending review."""
 
     kind: str
     text: str
     argument: str | None = None
     values: tuple[str, ...] = ()
+    position: int | None = None
+    default: bool = False
 
     @property
     def checkable(self) -> bool:

coretrace_python/engine.py

@@ -71,6 +71,7 @@ from coretrace_python.interprocedural import (
     CallGraphAnalysis,
     CallSite,
     FunctionSummary,
+    ModuleFunction,
     ModuleGraph,
     ProjectSummaries,
     SummaryAnalysis,
@@ -106,6 +107,7 @@ from coretrace_python.semantic.symbols import SymbolAnalysis, SymbolId
 from coretrace_python.source import SourceFile, SourceId, SourceManager, SourceSpan, decode_text
 from coretrace_python.taint import (
     EntryPoint,
+    EntryPointAnalysis,
     ModelTable,
     RegisteredRoutes,
     Routes,
@@ -139,6 +141,7 @@ ALL_ANALYSES: tuple[AnyAnalysis, ...] = (
     ProjectSummaries,
     SecurityModelAnalysis,
     TaintAnalysis,
+    EntryPointAnalysis,
     RefutationAnalysis,
     DependencyAnalysis,
     RegisteredRoutes,
@@ -147,7 +150,7 @@ ALL_ANALYSES: tuple[AnyAnalysis, ...] = (
 
 # Named so the set stays right whichever analyses a build registers.
 _PROJECT_DEPENDANT_NAMES = frozenset(
-    {"interprocedural.project", "interprocedural.summaries", "taint.flows", "findings.refutation"}
+    {"interprocedural.project", "interprocedural.summaries", "taint.flows", "taint.entry_points", "findings.refutation"}
 )
 _PROJECT_DEPENDANTS: frozenset[AnyAnalysis] = frozenset(
     a for a in ALL_ANALYSES if a.name in _PROJECT_DEPENDANT_NAMES
@@ -451,6 +454,7 @@ def analyze_project(
 
     index = _seed(results, graph, frozenset())
     call_graphs: dict[str, CallGraph] = {}
+    functions: dict[str, tuple[ModuleFunction, ...]] = {}
     for name in sorted(analysable):
         entry = results[name]
         findings.extend(entry.findings)
@@ -458,11 +462,12 @@ def analyze_project(
         coverage.append(
             FileCoverage(str(files[name].source_id), "analysed", len(entry.functions), len(entry.functions) - unsupported)
         )
-        sites: dict[str, list[CallSite]] = {function: [] for function in entry.functions}
+        functions[name] = entry.functions
+        sites: dict[str, list[CallSite]] = {function.name: [] for function in entry.functions}
         for site in entry.sites:
             sites.setdefault(site.caller, []).append(site)
         call_graphs[name] = CallGraph({}, {f: tuple(s) for f, s in sites.items()}, frozenset())
-    context = ProjectContext(graph, dependencies, advisories, analysable, call_graphs, policy, root)
+    context = ProjectContext(graph, dependencies, advisories, analysable, call_graphs, policy, root, functions)
     for plugin in all_plugins:
         if isinstance(plugin, ProjectPlugin):
             findings.extend(plugin.analyze_project(context))
@@ -662,7 +667,7 @@ def _analyse_module(
                 )
             )
     return CachedModule(
-        graph.functions,
+        manager.get(EntryPointAnalysis),
         _summaries_of(manager),
         tuple(site for function in graph.functions for site in graph.sites(function)),
         (*findings, *correlated),

coretrace_python/interprocedural/__init__.py

@@ -1,11 +1,13 @@
 """Call graph and function summaries (architecture §19, §20)."""
 
 from coretrace_python.interprocedural.callgraph import (
+    Arguments,
     CallGraph,
     CallGraphAnalysis,
     CallSite,
     ExternalSymbol,
     KnownFunction,
+    ModuleFunction,
     Target,
     UnknownTarget,
 )
@@ -28,6 +30,7 @@ from coretrace_python.interprocedural.summaries import (
 )
 
 __all__ = [
+    "Arguments",
     "CallGraph",
     "CallGraphAnalysis",
     "CallSite",
@@ -35,6 +38,7 @@ __all__ = [
     "ExternalSymbol",
     "FunctionSummary",
     "KnownFunction",
+    "ModuleFunction",
     "ModuleGraph",
     "Mutation",
     "NonlocalWrite",

coretrace_python/interprocedural/callgraph.py

@@ -9,7 +9,7 @@ and framework models narrow it down.
 from __future__ import annotations
 
 from collections.abc import Mapping
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from types import MappingProxyType
 from typing import ClassVar
 
@@ -25,10 +25,12 @@ from coretrace_python.ir.lowering import (
 from coretrace_python.ir.model import (
     Await,
     Call,
+    Constant,
     FunctionIR,
     GetAttr,
     GetItem,
     Global,
+    Instruction,
     MakeFunction,
     Symbol,
     Value,
@@ -58,13 +60,36 @@ class UnknownTarget:
 Target = KnownFunction | ExternalSymbol | UnknownTarget
 
 
+@dataclass(frozen=True)
+class Arguments:
+    """What the arguments of a call denote: a symbol's canonical name
+    (``python.yaml.FullLoader``), a constant as Python writes it (``True``, ``'/static'``),
+    or None for anything else (a parameter, an expression). ``unpacked`` says the call
+    unpacks ``*args`` or ``**kwargs``, so an argument it does not give explicitly may
+    still be given; after ``*args`` no position is known, and ``positional`` is empty."""
+
+    positional: tuple[str | None, ...] = ()
+    keywords: tuple[tuple[str, str | None], ...] = ()
+    unpacked: bool = False
+
+
 @dataclass(frozen=True)
 class CallSite:
     caller: str
     location: SourceSpan
     target: Target
-    arguments: int
-    keywords: int
+    arguments: Arguments = field(default_factory=Arguments)
+
+
+@dataclass(frozen=True)
+class ModuleFunction:
+    """One function of a module as a project plugin sees it: the name the call graph
+    gives it (``Class.method``, ``outer.inner``, ``<module>``), where it is, and the label
+    of the entry point it is (``http`` for a route, ``argv`` for a command), if any."""
+
+    name: str
+    span: SourceSpan
+    entry_point: str | None = None
 
 
 class CallGraph:
@@ -82,9 +107,7 @@ class CallGraph:
         self._names = {function.span: name for name, function in definitions.items()}
         self.unsupported = unsupported
         self._sites = MappingProxyType(dict(sites))
-        self._targets = {
-            (site.caller, site.location): site.target for found in sites.values() for site in found
-        }
+        self._at = {(site.caller, site.location): site for found in sites.values() for site in found}
         callers: dict[str, set[str]] = {name: set() for name in definitions}
         for found in sites.values():
             for site in found:
@@ -104,7 +127,14 @@ class CallGraph:
         return self._sites.get(caller, ())
 
     def target_at(self, caller: str, location: SourceSpan) -> Target:
-        return self._targets.get((caller, location), UnknownTarget())
+        site = self._at.get((caller, location))
+        return site.target if site is not None else UnknownTarget()
+
+    def arguments_at(self, caller: str, location: SourceSpan) -> Arguments:
+        """What the arguments of the call at ``location`` in ``caller`` denote."""
+
+        site = self._at.get((caller, location))
+        return site.arguments if site is not None else Arguments()
 
     def callees(self, caller: str) -> frozenset[str]:
         return frozenset(
@@ -154,6 +184,29 @@ def derive_symbols(
     return symbols
 
 
+# Conditions name short constants (``True``, ``None``, a mode); a log message or a query
+# passed as an argument is not recorded, so call sites stay small in the cache.
+MAX_CONSTANT_LENGTH = 64
+
+
+def _arguments(call: Call, symbols: Mapping[Value, SymbolId], defs: Mapping[Value, Instruction]) -> Arguments:
+    def denoted(value: Value) -> str | None:
+        symbol = symbols.get(value)
+        if symbol is not None:
+            return str(symbol)
+        made = defs.get(value)
+        if not isinstance(made, Constant):
+            return None
+        written = repr(made.value)
+        return written if len(written) <= MAX_CONSTANT_LENGTH else None
+
+    return Arguments(
+        () if call.starred else tuple(denoted(value) for value in call.arguments),
+        tuple((name, denoted(value)) for name, value in call.keywords if name is not None),
+        bool(call.starred) or any(name is None for name, _ in call.keywords),
+    )
+
+
 def resolve_targets(
     function: FunctionIR,
     scopes: ScopeTable,
@@ -328,6 +381,7 @@ class CallGraphAnalysis(Analysis[CallGraph]):
                 _typed_with_module_classes(function, ssa, classes),
                 bases,
             )
+            defs = {i.result: i for block in ssa.blocks for i in block.instructions if i.result is not None}
             found: list[CallSite] = []
             for block in ssa.blocks:
                 for instruction in block.instructions:
@@ -337,8 +391,7 @@ class CallGraphAnalysis(Analysis[CallGraph]):
                                 name,
                                 instruction.location,
                                 targets.get(instruction.callee, UnknownTarget()),
-                                len(instruction.arguments),
-                                len(instruction.keywords),
+                                _arguments(instruction, symbols[name], defs),
                             )
                         )
             sites[name] = tuple(found)

coretrace_python/interprocedural/summaries.py

@@ -9,6 +9,7 @@ security knowledge: the taint engine decides which external symbols matter.
 
 from __future__ import annotations
 
+import dataclasses
 from collections.abc import Mapping
 from dataclasses import dataclass
 from types import MappingProxyType
@@ -26,6 +27,7 @@ from coretrace_python.analysis import Analysis, AnalysisContext, AnyAnalysis
 from coretrace_python.cfg import CFG, BlockId, CFGAnalysis
 from coretrace_python.dataflow import DataflowProblem, Direction, solve
 from coretrace_python.interprocedural.callgraph import (
+    Arguments,
     CallGraph,
     CallGraphAnalysis,
     ExternalSymbol,
@@ -92,6 +94,8 @@ class ExternalCall:
     keyword_dependencies: Dependencies
     location: SourceSpan
     call_site: SourceSpan | None
+    # What the arguments of the call at ``location`` denote, where it is made.
+    arguments: Arguments = dataclasses.field(default_factory=Arguments)
 
 
 @dataclass(frozen=True)
@@ -334,6 +338,7 @@ class _DependenceProblem(DataflowProblem[State]):
                 keywords.parameters,
                 call.location,
                 None,
+                self.graph.arguments_at(self.name, call.location),
             )
             return everything | Dep(externals=frozenset({target.symbol}))
         if isinstance(target, KnownFunction):
@@ -416,6 +421,7 @@ class _DependenceProblem(DataflowProblem[State]):
                 mapped(reached.keyword_dependencies).parameters,
                 reached.location,
                 call.location,
+                reached.arguments,
             )
         made = self.defs.get(call.callee)
         values = (*receiver, *call.arguments, *(made.captured if isinstance(made, MakeFunction) else ()))
@@ -432,6 +438,7 @@ class _DependenceProblem(DataflowProblem[State]):
         keywords: Dependencies,
         location: SourceSpan,
         call_site: SourceSpan | None,
+        given: Arguments,
     ) -> None:
         key = (symbol, location, call_site)
         previous = self.external.get(key)
@@ -440,7 +447,7 @@ class _DependenceProblem(DataflowProblem[State]):
                 a | b for a, b in zip(previous.argument_dependencies, arguments, strict=False)
             )
             keywords |= previous.keyword_dependencies
-        self.external[key] = ExternalCall(symbol, arguments, keywords, location, call_site)
+        self.external[key] = ExternalCall(symbol, arguments, keywords, location, call_site, given)
 
 
 def summarize(

coretrace_python/plugins/api.py

@@ -25,10 +25,15 @@ from coretrace_python.analysis.provider import R
 from coretrace_python.dependency import Advisory, DependencyGraph, Policy
 from coretrace_python.findings import Finding
 from coretrace_python.hir import nodes
-from coretrace_python.interprocedural import CallGraph, CallGraphAnalysis, ModuleGraph
+from coretrace_python.interprocedural import (
+    CallGraph,
+    CallGraphAnalysis,
+    ModuleFunction,
+    ModuleGraph,
+)
 from coretrace_python.ir.lowering import analyzable_functions
 from coretrace_python.semantic.imports import ImportAnalysis, ImportTable
-from coretrace_python.taint import Model
+from coretrace_python.taint import EntryPointAnalysis, Model
 
 PLUGIN_API_VERSION = 1
 
@@ -57,8 +62,8 @@ class ModelPlugin(Plugin):
 class ProjectContext:
     """What a project-scoped plugin sees: the module graph, the dependency graph, the
     advisories every plugin and advisory file contributed, the dependency policy, and
-    each module's imports and call graph. The engine passes the call graphs of modules
-    it served from its cache."""
+    each module's imports, call graph and functions. The engine passes the call graphs
+    and functions of modules it served from its cache."""
 
     def __init__(
         self,
@@ -69,6 +74,7 @@ class ProjectContext:
         call_graphs: Mapping[str, CallGraph] | None = None,
         policy: Policy | None = None,
         root: Path | None = None,
+        functions: Mapping[str, tuple[ModuleFunction, ...]] | None = None,
     ) -> None:
         self.root = root
         self.graph = graph
@@ -77,6 +83,7 @@ class ProjectContext:
         self.policy = policy or Policy()
         self._managers = managers
         self._call_graphs = dict(call_graphs or {})
+        self._functions = dict(functions or {})
 
     @property
     def modules(self) -> tuple[str, ...]:
@@ -89,6 +96,13 @@ class ProjectContext:
         cached = self._call_graphs.get(module)
         return cached if cached is not None else self._managers[module].get(CallGraphAnalysis)
 
+    def functions(self, module: str) -> tuple[ModuleFunction, ...]:
+        """The module's functions as its call graph names them, each with its span, so a
+        finding can be placed in one, and the label of the entry point it is, if any."""
+
+        cached = self._functions.get(module)
+        return cached if cached is not None else self._managers[module].get(EntryPointAnalysis)
+
 
 class ProjectPlugin(Plugin):
     """A plugin that runs once per project rather than once per module (§26)."""

coretrace_python/taint/__init__.py

@@ -1,6 +1,7 @@
 """Security models and the global multi-kind taint engine (architecture §16, §17)."""
 
 from coretrace_python.taint.engine import (
+    EntryPointAnalysis,
     Taint,
     TaintAnalysis,
     TaintFacts,
@@ -30,6 +31,7 @@ from coretrace_python.taint.routes import RegisteredRoutes, Routes, registered_r
 __all__ = [
     "AuthorizationGuard",
     "EntryPoint",
+    "EntryPointAnalysis",
     "Model",
     "ModelError",
     "ModelTable",

coretrace_python/taint/engine.py

@@ -22,16 +22,18 @@ from coretrace_python.abstract import (
     HeapLocation,
     mutated_by,
 )
-from coretrace_python.analysis import AnalysisContext, AnyAnalysis, FunctionAnalysis
+from coretrace_python.analysis import Analysis, AnalysisContext, AnyAnalysis, FunctionAnalysis
 from coretrace_python.cfg import CFG, BlockId, CFGAnalysis
 from coretrace_python.dataflow import DataflowProblem, Direction, solve
 from coretrace_python.hir import nodes
 from coretrace_python.interprocedural import (
+    Arguments,
     CallGraph,
     CallGraphAnalysis,
     ExternalSymbol,
     FunctionSummary,
     KnownFunction,
+    ModuleFunction,
     ProjectSummaries,
     SummaryAnalysis,
     SummaryIndex,
@@ -111,6 +113,8 @@ class TaintFlow:
     location: SourceSpan
     through: str | None = None
     sink_location: SourceSpan | None = None
+    # What the arguments of the sink call denote, to decide the conditions on them.
+    sink_arguments: Arguments | None = None
 
 
 Key = Value | HeapLocation
@@ -394,10 +398,11 @@ class _TaintProblem(DataflowProblem[State]):
 
         sink = self.models.sink(symbol)
         if sink is not None:
+            given = self.graph.arguments_at(self.name, call.location)
             for position, argument in enumerate(call.arguments):
-                self.report(flows, sink, self.rendered(argument, state), argument, call, None, None, position)
+                self.report(flows, sink, self.rendered(argument, state), argument, call, None, None, position, given)
             for argument in (*call.starred, *(value for _, value in call.keywords)):
-                self.report(flows, sink, self.rendered(argument, state), argument, call, None, None, None)
+                self.report(flows, sink, self.rendered(argument, state), argument, call, None, None, None, given)
         sanitizer = self.models.sanitizer(symbol)
         if sanitizer is not None:
             return everything.without(sanitizer.kinds)
@@ -483,7 +488,7 @@ class _TaintProblem(DataflowProblem[State]):
             for position, deps in zip(positions, (*reached.argument_dependencies, reached.keyword_dependencies), strict=True):
                 taint, witness = mapped(deps)
                 if witness is not None:
-                    self.report(flows, sink, taint, witness, call, through, reached.location, position)
+                    self.report(flows, sink, taint, witness, call, through, reached.location, position, reached.arguments)
         for mutation in summary.mutations:
             if mutation.parameter < len(values):
                 stored = mapped(mutation.dependencies)[0]
@@ -509,6 +514,7 @@ class _TaintProblem(DataflowProblem[State]):
         through: str | None,
         sink_location: SourceSpan | None,
         position: int | None = None,
+        arguments: Arguments | None = None,
     ) -> None:
         reaching = taint.kinds & sink.kinds_at(position)
         if not reaching:
@@ -523,6 +529,7 @@ class _TaintProblem(DataflowProblem[State]):
                     call.location,
                     through,
                     call.location if sink_location is None else sink_location,
+                    arguments,
                 )
             )
 
@@ -684,7 +691,7 @@ def entry_point_of(
     return None
 
 
-def parameter_sources(
+def function_entry_point(
     function: nodes.Function,
     module: nodes.Module,
     models: ModelTable,
@@ -692,16 +699,11 @@ def parameter_sources(
     symbols: SymbolTable,
     instances: Instances | None = None,
     routes: Routes | None = None,
-) -> Mapping[int, Source]:
-    """The attacker-controlled parameters of ``function``, by index: every parameter of an
-    entry point (``self`` excepted for a method), including one registered elsewhere
-    (``routes``), and every parameter annotated with a typed-parameter symbol."""
+) -> EntryPoint | None:
+    """The entry point ``function`` is: one of its decorators or, for a method, one of its
+    class's bases matching an entry-point model, or a registration elsewhere (``routes``)."""
 
-    owner = next(
-        (s for s in module.body if isinstance(s, nodes.Class) and any(f is function for f in s.body)),
-        None,
-    )
-    sources: dict[int, Source] = {}
+    owner = _owner(module, function)
     enclosing_function = _enclosing(module, function)
     if enclosing_function is not None:
         # ``app = Flask(__name__)`` inside ``create_app``: routes defined there resolve.
@@ -712,6 +714,34 @@ def parameter_sources(
         entry = routes.get(project_symbol(module.name, qualified))
         if entry is None and owner is not None:
             entry = routes.get(project_symbol(module.name, owner.name))
+    return entry
+
+
+def _owner(module: nodes.Module, function: nodes.Function) -> nodes.Class | None:
+    """The top-level class ``function`` is a method of, if any."""
+
+    return next(
+        (s for s in module.body if isinstance(s, nodes.Class) and any(f is function for f in s.body)),
+        None,
+    )
+
+
+def parameter_sources(
+    function: nodes.Function,
+    module: nodes.Module,
+    models: ModelTable,
+    scopes: ScopeTable,
+    symbols: SymbolTable,
+    instances: Instances | None = None,
+    routes: Routes | None = None,
+) -> Mapping[int, Source]:
+    """The attacker-controlled parameters of ``function``, by index: every parameter of an
+    entry point (``self`` excepted for a method), including one registered elsewhere
+    (``routes``), and every parameter annotated with a typed-parameter symbol."""
+
+    owner = _owner(module, function)
+    sources: dict[int, Source] = {}
+    entry = function_entry_point(function, module, models, scopes, symbols, instances, routes)
     if entry is not None:
         first = 1 if owner is not None else 0
         for index in range(first, len(function.parameters)):
@@ -817,6 +847,38 @@ class TaintAnalysis(FunctionAnalysis[TaintFacts]):
         )
 
 
+class EntryPointAnalysis(Analysis[tuple[ModuleFunction, ...]]):
+    """The module's functions as the call graph names them, each with its span and the
+    label of the entry point it is, decided as the taint engine decides which parameters
+    are attacker-controlled. What a project plugin sees of a module, cached with it."""
+
+    name: ClassVar[str] = "taint.entry_points"
+    requires: ClassVar[frozenset[AnyAnalysis]] = frozenset(
+        {
+            CallGraphAnalysis,
+            SecurityModelAnalysis,
+            ScopeAnalysis,
+            SymbolAnalysis,
+            SummaryAnalysis,
+            ProjectSummaries,
+            RegisteredRoutes,
+        }
+    )
+
+    @classmethod
+    def compute(cls, ctx: AnalysisContext) -> tuple[ModuleFunction, ...]:
+        graph = ctx.get(CallGraphAnalysis)
+        models = ctx.get(SecurityModelAnalysis)
+        scopes, symbols = ctx.get(ScopeAnalysis), ctx.get(SymbolAnalysis)
+        instances = factory_instances(ctx.module, scopes, symbols, ctx.get(SummaryAnalysis), ctx.get(ProjectSummaries))
+        routes = ctx.get(RegisteredRoutes)
+        functions: list[ModuleFunction] = []
+        for name, function in graph.definitions.items():
+            entry = function_entry_point(function, ctx.module, models, scopes, symbols, instances, routes)
+            functions.append(ModuleFunction(name, function.span, entry.label if entry is not None else None))
+        return tuple(functions)
+
+
 def self_seeds(
     function: nodes.Function,
     module: nodes.Module,

{coretrace_python_analyzer-0.4.0.dist-info → coretrace_python_analyzer-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: coretrace-python-analyzer
-Version: 0.4.0
+Version: 0.5.0
 Summary: Static security analysis infrastructure for Python code
 Project-URL: Homepage, https://github.com/CoreTrace/coretrace-python-analyzer
 Project-URL: Repository, https://github.com/CoreTrace/coretrace-python-analyzer

{coretrace_python_analyzer-0.4.0.dist-info → coretrace_python_analyzer-0.5.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-coretrace_python/__init__.py,sha256=uJFWBDpap961PWbZ01zYoAZ0LTF4lnI0UH11pEl6GEw,75
+coretrace_python/__init__.py,sha256=utnxu8MbeZzYTN5zz5v2YJUPEiq63GzimvSef3LaKIo,75
 coretrace_python/__main__.py,sha256=V8DnYtRboISK2VCKm7DGHLREKvqLbqApyWlKBOs26wU,65
-coretrace_python/cache.py,sha256=Aj6o-PvOHoTjLRuD-rJqYZv-fnPnp7NmbNFmfWssOvk,11316
+coretrace_python/cache.py,sha256=D14p9uzdise9HtkIEJVLZXICt5jUPcDYUMxo2iuh9g0,12427
 coretrace_python/cli.py,sha256=ZE6F8wqNcE-ogfldii-UgUq4nOcEMnHuMCzz0l--yuw,9792
-coretrace_python/engine.py,sha256=FGMR22fXmBnt_iafkM7-xSh9vYhw15OPKGvTTJu-xiQ,27403
+coretrace_python/engine.py,sha256=ZXEPnio1cRSMme9HP2kmHJaYpychCRDYpZSyFosEZx0,27625
 coretrace_python/abstract/__init__.py,sha256=n5FNkV8Z4LmwG0r06KWdLj4N2CPSgAKwY3896tdmRgM,999
 coretrace_python/abstract/constants.py,sha256=z4-e7IzysxzGi58wFFff1MlEoV8l7AZsB9EL-q6b7vY,9071
 coretrace_python/abstract/heap.py,sha256=OaESXFGC0qzyhAr76xrCu4skeDVzZM4wlenQqfMTkdk,9642
@@ -14,11 +14,11 @@ coretrace_python/analysis/provider.py,sha256=Q_OlEcoLzBAsNdAGWijbj_n3E2Ep5UQ4Z8_
 coretrace_python/bundled/dependency/dependency_policy/dependency_policy.py,sha256=_CJYHijv4DTgfdumcCqAVV5_MPWjfZOadxeM5pQdw_k,1845
 coretrace_python/bundled/dependency/dependency_policy/plugin.toml,sha256=4w1TA-UKsa82WTnd1xy4bJuU3_G2RNCAWNICLPcZLMk,210
 coretrace_python/bundled/dependency/reachable_vulnerability/plugin.toml,sha256=LuF9jQqZfplN_GBky69Xjq2pksaX1Fs8PYEir-7-vY8,275
-coretrace_python/bundled/dependency/reachable_vulnerability/reachable_vulnerability.py,sha256=nPwOlbebAhMNmk4BHldNe-UMrsK6qUUs1bL4z8fObvY,2186
+coretrace_python/bundled/dependency/reachable_vulnerability/reachable_vulnerability.py,sha256=FwEqdDbkyYOUzF2piVteFfSzEm75tCnk2qRe8RvRNxA,2414
 coretrace_python/bundled/dependency/sample_advisories/plugin.toml,sha256=cME4pSFzkFsxmIJGGBSrmXqynAd0dg34X-rgEoZ_u6E,184
 coretrace_python/bundled/dependency/sample_advisories/sample_advisories.py,sha256=jw98GK6hh5RAx05t8QPcUzsFMfGigAL8418vZLprKlc,3710
-coretrace_python/bundled/dependency/vulnerable_dependency/plugin.toml,sha256=FbmiXLEqtPUZEsDc5q_UqCzn6AecL5HCSdGVy7_2dy0,238
-coretrace_python/bundled/dependency/vulnerable_dependency/vulnerable_dependency.py,sha256=ruwruejQ_NqYy7osxfaiPFRlus1DsMEluJ2obhxATkM,2092
+coretrace_python/bundled/dependency/vulnerable_dependency/plugin.toml,sha256=4-OnbEb3lYVAoTfuz8mDPH4L9fHOPQ2KW1dDFAbClFk,267
+coretrace_python/bundled/dependency/vulnerable_dependency/vulnerable_dependency.py,sha256=THXqpuffQZ8nuv1b8zQrgkA7eTI1PxhODATMzqhWeyY,3393
 coretrace_python/bundled/models/aiohttp/aiohttp_models.py,sha256=EraiXpZih8yPRk5t0OKe2TMJO9iATv4Kj_lKLp_KpfA,2946
 coretrace_python/bundled/models/aiohttp/plugin.toml,sha256=YvU60RUBexYBtIxbXdmUhO83BoijmOe3MeQKwY8QDaM,220
 coretrace_python/bundled/models/bottle/bottle_models.py,sha256=0yt8-7g-Pxtas3qQcIdORkWLiqJu4O3JzCrSnhzbgHs,1885
@@ -89,9 +89,9 @@ coretrace_python/dataflow/__init__.py,sha256=N5uY8VTNjEk6-ARCgDkxr6uGqQIz2NbF-U9
 coretrace_python/dataflow/lattice.py,sha256=HgYGVcKVUlexvEc0yT47aQCudLxU_SWLpHhr17igkiE,1929
 coretrace_python/dataflow/solver.py,sha256=iDsW0wujhM2DXplu2JMKC46BRsroXlNETHPEoikPeG4,3475
 coretrace_python/dependency/__init__.py,sha256=sZdigKRbM4NkV0Dr86FDF3rFRQz35pICVX6obgO2Rxo,1065
-coretrace_python/dependency/advisories.py,sha256=RMEQ_9bvZ7OThjBncM5CbKzsmySPvQYuNMZqQVcrVnc,7765
-coretrace_python/dependency/correlation.py,sha256=nyysSoXPz9jg_X8zeweybDpJRXLmj4eH0Z0_WQw5rd0,4916
-coretrace_python/dependency/graph.py,sha256=Z0_u4v0hAYMCAyXEWMh7NwcG2FesIHsXUd3Fl8C1MF8,13617
+coretrace_python/dependency/advisories.py,sha256=9g9teb2bzkHmnR9tB86AmtLLlVPhfedP8wITFwmXEXI,8381
+coretrace_python/dependency/correlation.py,sha256=7a-i-1HbemzIfHFvdx0GcVuZ7gyI0o-NOT7-6uYoR_w,7797
+coretrace_python/dependency/graph.py,sha256=0w6bWq7YNb_qcF7H-S-YGClhjS7JsK9Fh1i-w1ONpBQ,13910
 coretrace_python/dependency/policy.py,sha256=u6nUw2nX-kTuqmw_vooxN8eXZoC31ZMoMaxC9pCcwec,2317
 coretrace_python/dependency/sbom.py,sha256=h4K3Gb9O_D6uZyfpwpC5rPcNjH_Ib-3uvFxix6OKlfs,2520
 coretrace_python/findings/__init__.py,sha256=gnJI-uB2CkgZ8I5aFYP_N5yZb7FGNIy7LirVDh4NLwo,372
@@ -106,10 +106,10 @@ coretrace_python/frontend/parser.py,sha256=6-CG7rWxUYeOGeDP206SJWy4BMQUP9Mr6Jf-t
 coretrace_python/hir/__init__.py,sha256=xMpvj-RSp6bd78a_hhkqbe99-snjERkH-_Lv5o9ASbw,180
 coretrace_python/hir/nodes.py,sha256=4BI0f3UhKbnz9ZIxMoKXM7ujav0BmRpD0OXaoblRxIk,12364
 coretrace_python/hir/visitors.py,sha256=JFnX09hK6trLyRcWgZ5ehOG2ywX3VvkqQ1h82nahYNg,885
-coretrace_python/interprocedural/__init__.py,sha256=57nLUicdsnX0uIub--EUcLt3TRazzZxy2LQ8TRwlOS0,1054
-coretrace_python/interprocedural/callgraph.py,sha256=5YJ3W5JsKf-uSHkwDvSPBRS1X1ZTyjPaz-wJ8aJV3zE,15232
+coretrace_python/interprocedural/__init__.py,sha256=TCX98DRbO0rXFcohwixpDZUVo_9Mdnkbn8wtlBeiu7Q,1128
+coretrace_python/interprocedural/callgraph.py,sha256=NuXogZcdcJwRB_UYiGHGsIss0REjfiQueel7Tfo_4fI,17565
 coretrace_python/interprocedural/modulegraph.py,sha256=4sB7OKjBYfxtm7aMtHm2jRlqFVUNUsdnLhnv9UZ1BWA,8846
-coretrace_python/interprocedural/summaries.py,sha256=6JFrTaMkG34g_nLhfmckjxKWvexCGvXuXozLliw6xQ8,20427
+coretrace_python/interprocedural/summaries.py,sha256=q--xpp1euaf5utxbK4CZtS8CSyLJ6p3MLel5Iu80X3w,20747
 coretrace_python/ir/__init__.py,sha256=ShBPYYqoQFePP-mgBjGezQ2acel0-ReOHF9vCC-G_4Q,232
 coretrace_python/ir/defuse.py,sha256=CZEPnlgntRp4MqwR7kLldd2ZlIlBnr-V9VJAxXxwm0c,2616
 coretrace_python/ir/lowering.py,sha256=V7r_4tEOi801NBOsPdG6pwrRHZIeVTahygYENneLQ4U,31428
@@ -117,7 +117,7 @@ coretrace_python/ir/model.py,sha256=i7LvHEnl5pmWYUcSui17ZGS1rdPVavMpnjt7Tog7P4c,
 coretrace_python/ir/printer.py,sha256=otBIhZUvB_UfB68gid_FbPcSjBUSmxH3v7vBMZZQVkg,9125
 coretrace_python/ir/ssa.py,sha256=cIYbcv90PI6AOeMrw2ZWp88fy7E2ZO4P3tqjtPHra7g,11116
 coretrace_python/plugins/__init__.py,sha256=xRKqkvkvQMmfQACHHoBioYhIyyK4HoMAVogy6EZG8tg,1398
-coretrace_python/plugins/api.py,sha256=Fjjy3FjnkS9OoQ55eLQZ-YJgykd4TgKNAYXySb0uSXY,7588
+coretrace_python/plugins/api.py,sha256=NjeDRRwy2K6esSEkg1Ofmv09mqa0El6MlTmRDCWiOmQ,8182
 coretrace_python/plugins/detectors.py,sha256=ej5Z_MS0CBqrR4b9xycjTVUIo5arpArpdbr7nL732iI,5700
 coretrace_python/plugins/loader.py,sha256=Use-lHTL4-IJYQBZmODC89zhJbYKGvDSLZHWjZa5NaI,3885
 coretrace_python/plugins/manifest.py,sha256=F24pgQSwApRUL6ZihRSLv9wL_M03A_pZjrj9Zi4Ku3Q,3438
@@ -136,13 +136,13 @@ coretrace_python/semantic/symbols.py,sha256=3JptnnX5_KBlSd00L_wcGlYZQdnmBvSBAhfi
 coretrace_python/source/__init__.py,sha256=0Y8fvtbkETnNCJR9Zq7RS5TSgF9c22pz3SSk1KdAXF0,301
 coretrace_python/source/manager.py,sha256=JRmMOcWfS1nocbVrdcvfQTqEfIkmnb5JP857TpGywN4,2736
 coretrace_python/source/model.py,sha256=FZnN5mlir3tzbIpWoxnn6YtRi9UcJ_y0sZM60tKr8U4,1727
-coretrace_python/taint/__init__.py,sha256=D-NH3kx9wKTNeWASewawGAx7ChOkGMGhmjf-E4crHl0,1111
-coretrace_python/taint/engine.py,sha256=tj28lfqWZSyddXsJ2c0Q7zbVSmk8ceZ-FccZDoBuhd4,35605
+coretrace_python/taint/__init__.py,sha256=BuZVlVE4h7Kr873dW3PZ7miBfHQvlRRcqvEaJVvJAas,1161
+coretrace_python/taint/engine.py,sha256=4IFD5uFXG6QhPRBM9lY87hVCpfPLTAd7oTJZbveY5ZI,38180
 coretrace_python/taint/models.py,sha256=H-Q_nChzwqm-MEGfbfw5jMegpXlIfwUIunFiRXbE90I,12005
 coretrace_python/taint/routes.py,sha256=UAJKXcw_sM9shf58FfDroxVO9bNSm4qrQdZknwUB0lo,6110
-coretrace_python_analyzer-0.4.0.dist-info/METADATA,sha256=4CTPKMus5dgilu4I3lpROK-gLTL9HiQC5P75aZu8Kj8,3216
-coretrace_python_analyzer-0.4.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-coretrace_python_analyzer-0.4.0.dist-info/entry_points.txt,sha256=wdozemiraOkbt65g_Y_zgspuZpoLxJdaCVMJt1Ft3c0,72
-coretrace_python_analyzer-0.4.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-coretrace_python_analyzer-0.4.0.dist-info/licenses/NOTICE,sha256=s3VHj5ngV0ozjW_kZJpg_35ne6JwoBK0ysOjbqVtA0w,113
-coretrace_python_analyzer-0.4.0.dist-info/RECORD,,
+coretrace_python_analyzer-0.5.0.dist-info/METADATA,sha256=v8A0jSjku33W6bQ9nd7aWtBRxGh0GQziPYycy8G4Igc,3216
+coretrace_python_analyzer-0.5.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+coretrace_python_analyzer-0.5.0.dist-info/entry_points.txt,sha256=wdozemiraOkbt65g_Y_zgspuZpoLxJdaCVMJt1Ft3c0,72
+coretrace_python_analyzer-0.5.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+coretrace_python_analyzer-0.5.0.dist-info/licenses/NOTICE,sha256=s3VHj5ngV0ozjW_kZJpg_35ne6JwoBK0ysOjbqVtA0w,113
+coretrace_python_analyzer-0.5.0.dist-info/RECORD,,