coretrace-python-analyzer 0.6.0__tar.gz → 0.7.0__tar.gz

{coretrace_python_analyzer-0.6.0 → coretrace_python_analyzer-0.7.0}/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.7.0 (2026-09-25)
+
+### Precision
+
+- A dominating guard makes a flow a hotspot only when it examines what the sink receives. `if request.method == 'POST':` before `request.POST['cmd']` no longer lowers a vulnerability to a hotspot. A test of the value itself, of the same attribute, of a method called on it (`form.is_valid()`), or of any part of an object the flow passes whole still does. The regression snapshots record the verdict of each taint finding (#135).
+- The SSRF sinks of Requests and httpx read the destination only: the URL (the first argument, the second after the method for `request` and `stream`, or `url=`) or the prepared request `send` takes. Attacker data in the body, the JSON, the headers or the query parameters is no longer a server-side request forgery. `Sink` gains `keywords` next to `positions`, and function summaries keep the name of each keyword argument, so a project function forwarding `url=` still reaches the sink; the cache format is bumped (#128).
+- `render_to_string` escapes what it renders where the analyzer can establish it: on a directory check, it reads the project's Django templates, and a template escapes when neither it nor what it extends or includes marks output safe, uses a tag, filter or library beyond Django's own, or prints a variable where HTML escaping does not protect it, and no settings turn autoescaping off. Data reaching a response through such a template is no longer `xss`; any other template keeps the flow reported. `TemplateRender` declares such rendering calls, and the escaped templates are part of the cache key (#130).
+- Django's `csrf.get_token` returns a token of letters and digits whatever the request holds, and `reverse`/`reverse_lazy` build a local path that attacker data in their arguments or query cannot turn into another host: the first is no longer an injection, the second no longer an open redirect. `reverse` still carries other kinds, since it leaves `'` unquoted (#132).
+
 ## 0.6.0 (2026-09-24)
 
 ### Reports

{coretrace_python_analyzer-0.6.0 → coretrace_python_analyzer-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: coretrace-python-analyzer
-Version: 0.6.0
+Version: 0.7.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.6.0 → coretrace_python_analyzer-0.7.0}/docs/plugins.md

@@ -141,7 +141,7 @@ class BottleModels(ModelPlugin):
 | Model | Declares |
 |---|---|
 | `Source(symbol, label, kinds=ALL)` | A call or attribute whose value is attacker-controlled; `label` names it in messages (`http`, `stdin`, `argv`, `http-response`). `kinds` restricts what it can inject. |
-| `Sink(symbol, kinds, positions=())` | A call dangerous for `kinds`; `positions` limits a kind to given argument indexes, as SQL sinks read the statement only. |
+| `Sink(symbol, kinds, positions=(), keywords=())` | A call dangerous for `kinds`. `positions` limits a kind to the given argument indexes, and `keywords` to the given keyword names; a restricted kind reaches only the arguments listed there. SQL sinks read the statement only, and the SSRF sinks of HTTP clients read the URL, by position or as `url=`. A starred argument or `**kwargs` reaches no restricted kind. |
 | `Sanitizer(symbol, kinds)` | A call whose result is safe for `kinds`. |
 | `EntryPoint(symbol, label, kinds=ALL)` | A decorator or a class base whose functions receive their parameters as `label` input, such as `flask.Flask.route`. |
 | `TypedParameter(symbol, label, kinds=ALL)` | A class whose annotated parameters carry `label` input, such as Django's `HttpRequest`. |
@@ -149,11 +149,12 @@ class BottleModels(ModelPlugin):
 | `RouteRegistrar(symbol, argument, label, kinds=ALL, keyword=None)` | A call registering a view at argument `argument` (or `keyword`), such as Django's `path`; the view receives `label` input. |
 | `SuffixSink(suffix, kinds, positions=())` | A sink matched by the end of the symbol, for methods of any class such as `objects.raw`. |
 | `SafeArgument(symbol, argument, values, position=None, kinds=ALL)` | A call to the sink `symbol` whose `argument` (by keyword, or at `position`) denotes one of `values` is not a sink for `kinds`, such as `yaml.load` with `Loader=yaml.SafeLoader`. Values are written as the analyzer records arguments: a symbol by its canonical name, a constant as Python writes it (`True`). Only a value given explicitly makes the call safe. |
+| `TemplateRender(symbol, position=0, keyword="template_name")` | A call rendering, with autoescaping, the template named by its argument at `position` or `keyword`, such as `render_to_string`. What it returns carries no `HTML` when the name is written in the call and the project's template escapes everything it prints (see the usage guide). |
 | `Validator(symbol, kinds=ALL, argument=0)` | A callable whose truth proves its argument safe, such as `re.fullmatch`; a flow guarded by it is refuted. |
 | `AuthorizationGuard(symbol, label)` | A decorator or a condition restricting who reaches the code, such as `login_required`; a flow behind it is a hotspot. |
 
 Two plugins may describe the same symbol. An identical model is registered once; two
-`Sink` models merge their kinds and positions, so a plugin can add `SQL` to a sink
+`Sink` models merge their kinds, positions and keywords, so a plugin can add `SQL` to a sink
 another plugin declared for `COMMAND`; any other difference is a conflict that stops
 the analysis with a `ModelError` naming both plugins.
 

{coretrace_python_analyzer-0.6.0 → coretrace_python_analyzer-0.7.0}/docs/usage.md

@@ -108,8 +108,8 @@ a sanitizer for that kind of sink.
 | `command-injection` | Shell or process execution (`os.system`, `subprocess` with a string, …). |
 | `sql-injection` | A database statement (`cursor.execute`, SQLAlchemy `text`, Django `raw`, …). Parameters of a parameterised query are not statements. |
 | `path-traversal` | A file system path (`open`, `send_file`, `os.remove`, …). |
-| `ssrf` | The URL of an HTTP client request (Requests, httpx, `urllib`). |
-| `xss` | An HTTP response body built without escaping. |
+| `ssrf` | The URL of an HTTP client request (Requests, httpx, `urllib`), by position or as `url=`; the body, headers and query parameters are not the destination. |
+| `xss` | An HTTP response body built without escaping. A Django template rendered by `render_to_string` escapes, where the analyzer can establish it (below). |
 | `insecure-deserialization` | `pickle`, `marshal`, `dill`, `jsonpickle`, `shelve`, and the YAML loaders (`yaml.load`, `load_all`, `full_load`, `unsafe_load` and their several-document versions); `yaml.load` and `load_all` given a safe loader (`SafeLoader`, `BaseLoader`) are not. |
 | `open-redirect` | An HTTP redirect target. |
 | `plaintext-credential-storage` | A parameter named like a password stored in a database without hashing. Medium confidence, since a name is a hint. |
@@ -118,9 +118,42 @@ a sanitizer for that kind of sink.
 Each flow is judged before it is reported. A dominating guard that proves the value
 safe (`isdigit()`, membership in a constant collection, equality with a constant, a
 numeric value proven by `int()`, `len()` or bounded arithmetic, a validator such as
-`re.fullmatch`) refutes it and nothing is reported. A guard that only mentions the value,
-or an authorization decorator such as `login_required`, makes it a hotspot reported at
-medium confidence. The verdict and its evidence are in the finding's metadata.
+`re.fullmatch`) refutes it and nothing is reported. A hotspot is reported at medium
+confidence. Two things make a flow a hotspot:
+
+- A guard that examines the data without proving it safe. That covers a test of the value
+  itself (`if cmd:`, `len(cmd) < 10`), of the same attribute, or of a method called on
+  it (`form.is_valid()`).
+- An authorization decorator such as `login_required`.
+
+A guard that reads another attribute of the object the data comes from is no guard of
+that data. `if request.method == 'POST':` before `os.system(request.POST['cmd'])` leaves
+a vulnerability. When the flow passes the object whole, to the sink or to a function,
+a guard on any of its attributes still counts. The verdict and its evidence are in the
+finding's metadata.
+
+Django's `render_to_string(name, context)` returns HTML in which autoescaping escaped
+every variable, so data reaching a response through it is no `xss`, if the template really
+escapes. On a directory check, the analyzer reads the project's templates to decide it.
+
+It establishes escaping only when all of the following hold:
+
+- It finds every template of that name under a `templates` directory, by the path Django
+  uses (`app/page.html`), and everything those templates extend or include.
+- None of them marks output safe: `|safe`, `|safeseq` or `{% autoescape off %}`.
+- None of them uses a tag or filter beyond Django's own, or loads a library beyond its
+  built-ins (`static`, `i18n`, `l10n`, `tz`, `cache`, `humanize`).
+- None of them places a variable where HTML escaping does not protect it: a `<script>`
+  or `<style>` block, an event handler (`onclick="…"`), a `style` attribute, a URL
+  attribute not fixed by a relative or `http(s)://host/` prefix, an unquoted attribute,
+  or an attribute name.
+- No Python file of the project sets `autoescape` to `False`.
+
+The analyzer never assumes escaping where it cannot read the template. That covers a
+template named by an expression, a template found through a `DIRS` entry not named
+`templates`, one shipped by an installed package, one rendered through `get_template`,
+and Flask's Jinja2 templates. The flow is then reported as before. A single-file check
+reads no template.
 
 ### Dangerous API usage
 
@@ -202,7 +235,7 @@ the directory of the checked file; a path outside it is printed as it is.
 ```json
 {
   "schema_version": 1,
-  "tool": {"name": "coretrace-python-analyzer", "version": "0.6.0"},
+  "tool": {"name": "coretrace-python-analyzer", "version": "0.7.0"},
   "root": "/home/me/project",
   "findings": [
     {

{coretrace_python_analyzer-0.6.0 → coretrace_python_analyzer-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "coretrace-python-analyzer"
-version = "0.6.0"
+version = "0.7.0"
 description = "Static security analysis infrastructure for Python code"
 readme = "README.md"
 requires-python = ">=3.11"

{coretrace_python_analyzer-0.6.0 → coretrace_python_analyzer-0.7.0}/src/coretrace_python/__init__.py

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

{coretrace_python_analyzer-0.6.0 → coretrace_python_analyzer-0.7.0}/src/coretrace_python/bundled/models/django/django_models.py

@@ -23,6 +23,7 @@ from coretrace_python.taint import (
     Source,
     SuffixSink,
     TaintKind,
+    TemplateRender,
     TypedParameter,
 )
 
@@ -119,7 +120,15 @@ class DjangoModels(ModelPlugin):
         Sink(_sym("django.http.HttpResponseRedirect"), TaintKind.REDIRECT, _TARGET_ONLY),
         Sink(_sym("django.http.HttpResponsePermanentRedirect"), TaintKind.REDIRECT, _TARGET_ONLY),
         Sanitizer(_sym("django.utils.html.escape"), TaintKind.HTML),
+        TemplateRender(_sym("django.template.loader.render_to_string")),
         Sanitizer(_sym("django.utils.html.conditional_escape"), TaintKind.HTML),
+        # The masked CSRF secret: ASCII letters and digits only, a malformed cookie is
+        # replaced before it is used.
+        Sanitizer(_sym("django.middleware.csrf.get_token"), TaintKind.ALL),
+        # A path of the project's URL configuration, never scheme-relative: attacker data
+        # in its arguments or query reaches no other host through a redirect.
+        *(Sanitizer(_sym(f"django.urls.{name}"), TaintKind.REDIRECT) for name in ("reverse", "reverse_lazy")),
+        *(Sanitizer(_sym(f"django.urls.base.{name}"), TaintKind.REDIRECT) for name in ("reverse", "reverse_lazy")),
         *(AuthorizationGuard(_sym(decorator), label) for decorator, label in _AUTHORIZATION_DECORATORS),
         # ``urlpatterns = [path('login/', views.log_in)]``: the referenced view is an
         # entry point wherever it is defined; routers register viewsets.

coretrace_python_analyzer-0.7.0/src/coretrace_python/bundled/models/http_clients/http_client_models.py

@@ -0,0 +1,52 @@
+"""Requests and httpx models: every request function is a SSRF sink for the argument that
+chooses the destination, and what it returns is an ``http-response`` source, so data
+fetched from a remote server is untrusted. The destination is the URL — first, or second
+after the method, or ``url=`` — or the prepared request a ``send`` takes; the body, the
+headers and the query parameters do not choose the host."""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from coretrace_python.plugins import ModelPlugin
+from coretrace_python.semantic.symbols import SymbolId
+from coretrace_python.taint import Model, Sink, Source, TaintKind
+
+_METHODS = ("get", "post", "put", "patch", "delete", "head", "options", "request")
+
+_CALLERS = (
+    "requests",
+    "requests.Session",
+    "requests.api",
+    "httpx",
+    "httpx.Client",
+    "httpx.AsyncClient",
+)
+
+# Where each function takes its destination, by position (the receiver of a method
+# excluded) and by keyword, as its signature declares it.
+_DESTINATIONS = {
+    **{f"{caller}.{method}": (0, "url") for caller in _CALLERS for method in _METHODS if method != "request"},
+    **{f"{caller}.request": (1, "url") for caller in _CALLERS},
+    "httpx.stream": (1, "url"),
+    "httpx.Client.stream": (1, "url"),
+    "httpx.AsyncClient.stream": (1, "url"),
+    "requests.Session.send": (0, "request"),
+    "httpx.Client.send": (0, "request"),
+    "httpx.AsyncClient.send": (0, "request"),
+}
+
+
+def _sym(path: str) -> SymbolId:
+    return SymbolId(f"python.{path}")
+
+
+class HttpClientModels(ModelPlugin):
+    name: ClassVar[str] = "http-client-models"
+    models: ClassVar[tuple[Model, ...]] = (
+        *(
+            Sink(_sym(function), TaintKind.SSRF, ((TaintKind.SSRF, (position,)),), ((TaintKind.SSRF, (keyword,)),))
+            for function, (position, keyword) in _DESTINATIONS.items()
+        ),
+        *(Source(_sym(function), "http-response") for function in _DESTINATIONS),
+    )

{coretrace_python_analyzer-0.6.0 → coretrace_python_analyzer-0.7.0}/src/coretrace_python/cache.py

@@ -41,7 +41,7 @@ from coretrace_python.interprocedural import (
 from coretrace_python.semantic.symbols import SymbolId
 from coretrace_python.source import SourceId, SourceSpan
 
-CACHE_FORMAT = 8
+CACHE_FORMAT = 9
 
 
 @dataclass(frozen=True)
@@ -233,7 +233,7 @@ def _encode_call(call: ExternalCall) -> dict[str, Any]:
     return {
         "symbol": str(call.symbol),
         "arguments": [sorted(deps) for deps in call.argument_dependencies],
-        "keywords": sorted(call.keyword_dependencies),
+        "keywords": [[name, sorted(deps)] for name, deps in 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),
@@ -245,7 +245,7 @@ def _decode_call(data: Mapping[str, Any]) -> ExternalCall:
     return ExternalCall(
         SymbolId(_string(data["symbol"])),
         tuple(_indices(deps) for deps in data["arguments"]),
-        _indices(data["keywords"]),
+        tuple((None if name is None else _string(name), _indices(deps)) for name, deps in data["keywords"]),
         _decode_span(data["location"]),
         None if site is None else _decode_span(site),
         _decode_arguments(data["given"]),

{coretrace_python_analyzer-0.6.0 → coretrace_python_analyzer-0.7.0}/src/coretrace_python/engine.py

@@ -109,6 +109,7 @@ from coretrace_python.source import SourceFile, SourceId, SourceManager, SourceS
 from coretrace_python.taint import (
     EntryPoint,
     EntryPointAnalysis,
+    EscapedTemplates,
     ModelTable,
     RegisteredRoutes,
     Routes,
@@ -116,6 +117,7 @@ from coretrace_python.taint import (
     SecurityModelRegistry,
     TaintAnalysis,
     TaintKind,
+    escaped_templates,
     registered_routes,
 )
 
@@ -146,6 +148,7 @@ ALL_ANALYSES: tuple[AnyAnalysis, ...] = (
     RefutationAnalysis,
     DependencyAnalysis,
     RegisteredRoutes,
+    EscapedTemplates,
 )
 
 
@@ -178,7 +181,14 @@ class ResultsEvicted(TransformationPass):
 
     name: ClassVar[str] = "project.results-evicted"
     preserves: ClassVar[frozenset[AnyAnalysis]] = frozenset(
-        {*SEMANTIC_ANALYSES, SecurityModelAnalysis, ProjectSummaries, DependencyAnalysis, RegisteredRoutes}
+        {
+            *SEMANTIC_ANALYSES,
+            SecurityModelAnalysis,
+            ProjectSummaries,
+            DependencyAnalysis,
+            RegisteredRoutes,
+            EscapedTemplates,
+        }
     )
 
     @classmethod
@@ -397,10 +407,12 @@ def analyze_project(
     for name in sorted(analysable):
         for symbol, registered in _routes_of(analysable[name]).items():
             routes.setdefault(symbol, registered)
+    escaped = escaped_templates(root)
     for manager in analysable.values():
         manager.provide(RegisteredRoutes, routes)
+        manager.provide(EscapedTemplates, escaped)
 
-    configuration = _configuration_key(registry, plugins, models, advisories, dependencies, routes)
+    configuration = _configuration_key(registry, plugins, models, advisories, dependencies, routes, escaped)
     keys = module_keys(
         graph,
         {name: fingerprint(configuration, str(files[name].source_id), name, files[name].text) for name in analysable},
@@ -441,6 +453,7 @@ def analyze_project(
                             encode_index(_seed(results, graph, component)),
                             advisory_paths,
                             _encode_routes(routes),
+                            tuple(sorted(escaped)),
                         ),
                     )
                     for component in pending
@@ -588,6 +601,7 @@ class _Batch:
     seed: Mapping[str, Any]
     advisory_paths: tuple[Path, ...] = ()
     routes: tuple[tuple[str, str, str, int], ...] = ()
+    escaped: tuple[str, ...] = ()
 
 
 def _analyse_batch(batch: _Batch) -> dict[str, dict[str, Any]]:
@@ -612,6 +626,7 @@ def _analyse_batch(batch: _Batch) -> dict[str, dict[str, Any]]:
         manager.provide(SecurityModelAnalysis, models)
         manager.provide(DependencyAnalysis, dependencies)
         manager.provide(RegisteredRoutes, routes)
+        manager.provide(EscapedTemplates, frozenset(batch.escaped))
     module_plugins = tuple(p for p in all_plugins if not isinstance(p, ProjectPlugin))
     results = _analyse_managers(managers, decode_index(batch.seed), module_plugins, affected)
     return {name: encode(entry) for name, entry in results.items()}
@@ -639,6 +654,7 @@ def _configuration_key(
     advisories: tuple[Advisory, ...],
     dependencies: DependencyGraph,
     routes: Routes | None = None,
+    escaped: frozenset[str] = frozenset(),
 ) -> str:
     """Everything a module's results depend on besides the project sources (§11)."""
 
@@ -658,6 +674,7 @@ def _configuration_key(
         repr(dependencies.requirements),
         repr(dependencies.errors),
         repr(_encode_routes(routes or {})),
+        repr(sorted(escaped)),
     )
 
 

{coretrace_python_analyzer-0.6.0 → coretrace_python_analyzer-0.7.0}/src/coretrace_python/findings/refutation.py

@@ -8,10 +8,13 @@ and ``not`` combine as expected, a ``Validator`` model names a callable whose tr
 one of its arguments, a numeric value (``abstract.ranges``) cannot inject, and anything
 else that mentions the value is a guard that does not prove it. A proof counts for an
 origin when every dependence path from that origin to the sink argument goes through a
-proven value. A flow is refuted when every tainted origin is proven safe or the sink is
-unreachable, a hotspot when it sits behind an ``AuthorizationGuard`` (a decorator or a
-dominating condition) or when an unproven guard mentions it, and a vulnerability
-otherwise.
+proven value. A guard mentions an origin only when it examines what the sink receives:
+reading another attribute or item of an object the flow reads (``request.method`` next
+to ``request.POST``) examines nothing of it, while the same attribute, or a method called
+on the object (``form.is_valid()``), does. A flow is refuted when every tainted origin is
+proven safe or the sink is unreachable, a hotspot when it sits behind an
+``AuthorizationGuard`` (a decorator or a dominating condition) or when an unproven guard
+mentions it, and a vulnerability otherwise.
 """
 
 from __future__ import annotations
@@ -37,6 +40,7 @@ from coretrace_python.ir.model import (
     Constant,
     FunctionIR,
     GetAttr,
+    GetItem,
     Instruction,
     UnaryOp,
     Value,
@@ -267,6 +271,66 @@ class _Judge:
                         return tested, "equals a constant", definition.operator == "eq"
         return None
 
+    def examined(
+        self, condition: Value, mentioned: set[Value], argument: Value, chain: frozenset[Value]
+    ) -> set[Value]:
+        """What the guard examines of the values it mentions: everything its condition is
+        computed from, except an object it only reads another attribute or item of than
+        the flow reads (``request`` in ``request.method`` when the sink receives
+        ``request.POST['cmd']``). A method called on the object (``form.is_valid()``), the
+        same attribute or item, or any part of an object the flow takes whole (passes to
+        the sink or to a call), examines it."""
+
+        reads = {self.access(value) for value in chain} - {None}
+        whole = {argument} | {
+            operand
+            for value in chain
+            if (definition := self.defs.get(value)) is not None
+            for operand in definition.operands()
+            if not (isinstance(definition, GetAttr | GetItem) and definition.object == operand)
+        }
+        found: set[Value] = set()
+        called: set[Value] = set()
+        pending = [condition]
+        while pending:
+            value = pending.pop()
+            if value in found:
+                continue
+            found.add(value)
+            definition = self.defs.get(value)
+            if definition is None:
+                continue
+            if isinstance(definition, Call):
+                called.add(definition.callee)
+            access = None if value in called else self.access(value)
+            for operand in definition.operands():
+                if access is not None and access[0] == operand and operand not in whole and self.aside(access, reads):
+                    continue
+                pending.append(operand)
+        return found & mentioned
+
+    @staticmethod
+    def aside(access: tuple[Value, str, object], reads: set[tuple[Value, str, object] | None]) -> bool:
+        """Whether reading ``access`` reads beside what the flow reads of the same object;
+        an item under a key unknown on either side may be the same one."""
+
+        owner, kind, name = access
+        if kind == "item" and (name is None or (owner, "item", None) in reads):
+            return False
+        return access not in reads
+
+    def access(self, value: Value) -> tuple[Value, str, object] | None:
+        """``(object, "attribute" or "item", name or constant key)`` for a read of an
+        attribute or an item; ``None`` for any other value, and as the key when unknown."""
+
+        definition = self.defs.get(value)
+        if isinstance(definition, GetAttr):
+            return definition.object, "attribute", definition.attribute
+        if isinstance(definition, GetItem):
+            key = self.defs.get(definition.key)
+            return definition.object, "item", key.value if isinstance(key, Constant) else None
+        return None
+
     def is_constant_collection(self, value: Value) -> bool:
         definition = self.defs.get(value)
         if isinstance(definition, Constant):
@@ -326,8 +390,9 @@ class _Judge:
             for value, reason in found.items():
                 if value in chain:
                     proven.setdefault(value, reason)
+            examined = self.examined(guard.condition, mentioned, flow.argument, chain)
             for origin in origins:
-                if origin not in mentions and mentioned & (
+                if origin not in mentions and examined & (
                     {origin} | {w for w in chain if origin in self.closure(w)}
                 ):
                     mentions[origin] = guard.line

{coretrace_python_analyzer-0.6.0 → coretrace_python_analyzer-0.7.0}/src/coretrace_python/interprocedural/summaries.py

@@ -87,11 +87,13 @@ EMPTY = Dep()
 
 @dataclass(frozen=True)
 class ExternalCall:
-    """An external symbol reached from this function; dependencies are parameter indices."""
+    """An external symbol reached from this function; dependencies are parameter indices.
+    Keyword arguments keep their name, so a sink reading ``url=`` only can be decided;
+    ``*args`` and ``**kwargs`` have none."""
 
     symbol: SymbolId
     argument_dependencies: tuple[Dependencies, ...]
-    keyword_dependencies: Dependencies
+    keyword_dependencies: tuple[tuple[str | None, Dependencies], ...]
     location: SourceSpan
     call_site: SourceSpan | None
     # What the arguments of the call at ``location`` denote, where it is made.
@@ -313,9 +315,13 @@ class _DependenceProblem(DataflowProblem[State]):
 
     def call(self, call: Call, state: dict[Key, Dep]) -> Dep:
         arguments = tuple(self.deep(a, state) for a in call.arguments)
+        named = (
+            *((name, self.deep(value, state)) for name, value in call.keywords),
+            *((None, self.deep(value, state)) for value in call.starred),
+        )
         keywords = EMPTY
-        for value in (*call.starred, *(v for _, v in call.keywords)):
-            keywords |= self.deep(value, state)
+        for _, deps in named:
+            keywords |= deps
         everything = keywords
         for deps in arguments:
             everything |= deps
@@ -335,7 +341,7 @@ class _DependenceProblem(DataflowProblem[State]):
             self.record(
                 target.symbol,
                 tuple(a.parameters for a in arguments),
-                keywords.parameters,
+                tuple((name, deps.parameters) for name, deps in named),
                 call.location,
                 None,
                 self.graph.arguments_at(self.name, call.location),
@@ -418,7 +424,7 @@ class _DependenceProblem(DataflowProblem[State]):
             self.record(
                 reached.symbol,
                 tuple(mapped(d).parameters for d in reached.argument_dependencies),
-                mapped(reached.keyword_dependencies).parameters,
+                tuple((name, mapped(d).parameters) for name, d in reached.keyword_dependencies),
                 reached.location,
                 call.location,
                 reached.arguments,
@@ -435,7 +441,7 @@ class _DependenceProblem(DataflowProblem[State]):
         self,
         symbol: SymbolId,
         arguments: tuple[Dependencies, ...],
-        keywords: Dependencies,
+        keywords: tuple[tuple[str | None, Dependencies], ...],
         location: SourceSpan,
         call_site: SourceSpan | None,
         given: Arguments,
@@ -446,7 +452,11 @@ class _DependenceProblem(DataflowProblem[State]):
             arguments = tuple(
                 a | b for a, b in zip(previous.argument_dependencies, arguments, strict=False)
             )
-            keywords |= previous.keyword_dependencies
+            # The same call records the same keywords, in the same order.
+            keywords = tuple(
+                (name, deps | old)
+                for (name, deps), (_, old) in zip(keywords, previous.keyword_dependencies, strict=False)
+            )
         self.external[key] = ExternalCall(symbol, arguments, keywords, location, call_site, given)
 
 

{coretrace_python_analyzer-0.6.0 → coretrace_python_analyzer-0.7.0}/src/coretrace_python/taint/__init__.py

@@ -24,15 +24,18 @@ from coretrace_python.taint.models import (
     Source,
     SuffixSink,
     TaintKind,
+    TemplateRender,
     TypedParameter,
     Validator,
 )
 from coretrace_python.taint.routes import RegisteredRoutes, Routes, registered_routes
+from coretrace_python.taint.templates import EscapedTemplates, escaped_templates
 
 __all__ = [
     "AuthorizationGuard",
     "EntryPoint",
     "EntryPointAnalysis",
+    "EscapedTemplates",
     "Model",
     "ModelError",
     "ModelTable",
@@ -52,8 +55,10 @@ __all__ = [
     "TaintFacts",
     "TaintFlow",
     "TaintKind",
+    "TemplateRender",
     "TypedParameter",
     "Validator",
+    "escaped_templates",
     "propagate_taint",
     "registered_routes",
 ]