coretrace-python-analyzer 0.15.0__tar.gz → 0.17.0__tar.gz

{coretrace_python_analyzer-0.15.0 → coretrace_python_analyzer-0.17.0}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.17.0 (2026-09-28)
+
+### Plugins
+
+- `BasePattern(pattern, label, parameters, kinds)` makes the methods of a class whose base's canonical symbol matches a regular expression entry points, for bases generated per project such as a gRPC servicer's, whatever the module's prefix and however the base is imported. Each parameter after `self` is, by position, either input of the model's kinds or an object of a class the model names, which the sources on that class taint without the object being input: a `Source` on `ServicerContext.invocation_metadata` gives the client's metadata, and `peer()` gives nothing. When the project holds the base, only the methods the base defines are entry points, so a servicer's utility methods are not; otherwise every method with the listed number of parameters is. `async` methods and the messages of an iterated parameter are covered (#176).
+
+## 0.16.0 (2026-09-27)
+
+### Advisories
+
+- A filter of Django's own libraries that a project template applies is a call to the function behind it, at the template's line: `{{ bio|striptags }}` calls `django.template.defaultfilters.striptags`, and so do filters in tag arguments and `{% filter %}` blocks. An advisory entry point naming that function is reachable there, whether or not a Python call names the template, since a class-based view renders its `template_name` inside Django. A template the analyzer cannot read may apply any filter: when the project names one by an expression, or by a name found under no `templates` directory, in `render`, `render_to_string`, `TemplateResponse`, `{% include %}` or `{% extends %}`, an advisory whose entry points include a template filter stays `under_investigation` in the VEX document, and the notes say where. `render`, `TemplateResponse` and `SimpleTemplateResponse` are now template renders like `render_to_string` (#146).
+- Attacker input in a render context reaching a template filter makes an advisory entry point naming that filter exploitable at the render call. The analyzer links them only where it is certain of the value: a dict literal with constant keys that the render call alone uses, and a filter the rendered template applies to a context variable, directly or through `{% for %}`, `{% with %}`, constant `{% include %}` and `{% extends %}`, earlier filter arguments and `{% filter %}` blocks, in the blocks that render. A name a tag binds shadows the context, and `{% include ... only %}` passes none of it. The filter's value is its first argument, the filter's own argument its second. A project function rendering what it receives carries it the same way (#146).
+- The request the `request` context processor adds reaches a template's filters too, as `{{ request.GET.q|striptags }}`, only where the analyzer is certain of it: every Django template engine the settings assign to `TEMPLATES`, as literals no other code names, lists the processor; the render call passes the request (`render`, `TemplateResponse`, `render_to_string` given `request`) with a certain context, absent or a dict literal; nothing shadows `request`; and the template reads a text attribute of the request object, such as `GET`, `POST`, `COOKIES` or `headers`. Otherwise the filter stays reachable (#146).
+
 ## 0.15.0 (2026-09-26)
 
 ### Precision

{coretrace_python_analyzer-0.15.0 → coretrace_python_analyzer-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: coretrace-python-analyzer
-Version: 0.15.0
+Version: 0.17.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.15.0 → coretrace_python_analyzer-0.17.0}/docs/plugins.md

@@ -154,10 +154,11 @@ class BottleModels(ModelPlugin):
 | `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`. |
 | `NamedParameter(pattern, label, kinds)` | A regular expression on parameter names; matching parameters carry `kinds`, as `password` carries `CREDENTIAL`. |
+| `BasePattern(pattern, label, parameters=(None,), kinds=ALL)` | A regular expression on the canonical symbol of a class's base, for bases generated per project such as a gRPC servicer's (`(?:^|\.)\w+_pb2_grpc\.\w+Servicer$`), whatever the module's prefix and however the base is imported. The methods taking the parameters listed, by position after `self`, are entry points: a position left `None` is `label` input carrying `kinds`; one holding a class symbol denotes an object of that class, which the sources on the class taint, as `invocation_metadata()` on a `ServicerContext`, without the object itself being input. When the project holds the base, only the methods the base defines count; otherwise every method with that number of parameters. Inheritance identifies a potential service, not its registration on a server. |
 | `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). |
+| `TemplateRender(symbol, position=0, keyword="template_name", context=1, request=None)` | A call rendering, with autoescaping, the template named by its argument at `position` or `keyword`, such as `render_to_string`, with the variables of its argument at `context` or `context=` and the request at `request` or `request=` (None: the call takes none); it makes the filter calls the template applies, fed from that context and, with the `request` context processor, that request (see the usage guide). 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). A name the analyzer cannot read keeps an advisory a template filter reaches under investigation in the VEX document. |
 | `Validator(symbol, kinds=ALL, argument=0)` | A callable whose truth proves its argument safe for `kinds`, such as `re.fullmatch`. A flow guarded by it is refuted when it carries no other kind into the sink, and is a hotspot otherwise: a redirect validator does not make a shell command safe. `symbol` may be a function of the project, by its project symbol (`python.hc.accounts.views._allow_redirect`), which then counts wherever it is called, in its own module too. |
 | `RequestObject(symbol, text=())` | The inputs from `symbol`, an entry point, a route registrar, a typed parameter or a source, are request objects. A view receives the request first (after `self`), then URL parameters, which are text. Reading one of the request's `text` attributes gives text, as Django's `GET` or aiohttp's `query`; its body and files keep the request's kinds. An attribute read counts only when every source of the value is such a request. |
 | `AuthorizationGuard(symbol, label)` | A decorator or a condition restricting who reaches the code, such as `login_required`; a flow behind it is a hotspot. |
@@ -258,6 +259,10 @@ one, and the label of the entry point it is (`http` for a route, `argv` for a co
 when the models make it one. `ctx.call_graph(module)` gives each function's call sites
 (`sites(function)`) and the symbols it reads, called or not (`reads(function)`: reading
 `request.form['name']` reads `python.flask.request.form`), each where it first reads it.
+`ctx.templates` gives the templates found under the project's `templates` directories:
+their `names`, the filters they apply as `calls` (each a `FilterCall(symbol, span)`, the
+function behind the filter and where the template applies it), and where they name a
+template the analyzer cannot read (`unread`).
 The shipped `vulnerable-dependency`, `reachable-vulnerability` and `dependency-policy`
 plugins are of this kind.
 

{coretrace_python_analyzer-0.15.0 → coretrace_python_analyzer-0.17.0}/docs/usage.md

@@ -241,7 +241,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.15.0"},
+  "tool": {"name": "coretrace-python-analyzer", "version": "0.17.0"},
   "root": "/home/me/project",
   "findings": [
     {
@@ -273,7 +273,7 @@ bytes. A single-file check lists no components.
 
 ```json
 "tool": {
-  "name": "coretrace-python-analyzer", "version": "0.15.0",
+  "name": "coretrace-python-analyzer", "version": "0.17.0",
   "components": [
     {"kind": "plugin", "name": "curated-advisories", "version": "2026.09.25", "digest": "sha256:…"},
     {"kind": "advisories", "name": "advisories.json", "digest": "sha256:…"}
@@ -362,6 +362,57 @@ it is reachable, called or not — `request.form['name']`, `for key in request.f
 `request.form.get('name')` all read it. A function reading it several times is reported
 once, where it first reads it.
 
+A filter of Django's own libraries that a project template applies is a call to the
+function behind it, placed at the template's line: `{{ bio|striptags }}` calls
+`python.django.template.defaultfilters.striptags`, and so do filters in tag arguments
+(`{% if bio|striptags %}`) and `{% filter %}` blocks. A template counts whether or not a
+Python call names it, since a class-based view renders its `template_name` inside
+Django. Most filters are functions of the same name in `django.template.defaultfilters`;
+`escape`, `escapejs`, `linebreaks`, `phone2numeric`, `slice`, `timesince` and `timeuntil`
+are `<name>_filter` there, and the filters of `i18n`, `l10n`, `tz` and `humanize` are in
+their library's module (`timezone` is `django.templatetags.tz.do_timezone`).
+
+Attacker input in the render context makes the filter exploitable at the render call:
+`render(request, "app/profile.html", {"bio": request.POST["bio"]})` with
+`{{ bio|striptags }}`. The analyzer links a context value to a filter only where it is
+certain of it:
+
+- The context is a dict literal with constant keys, used by the render call and
+  nothing else, written in the call or through a variable. A dict mutated or passed
+  elsewhere, one unpacking another (`**extra`), or a context built any other way leaves
+  the filter reachable.
+- The filter's value is a context variable, directly or through `{% for %}` and
+  `{% with %}`, the templates the template includes or extends by a constant name, the
+  arguments of the filters before it, or the output of a `{% filter %}` block. A name a
+  tag binds shadows the context, and `{% include ... only %}` passes none of it.
+- The filter renders: a template extending another renders only its blocks, which
+  replace the blocks of that name in what it extends.
+- One file has the template's name; of two files of the same name, which one renders
+  depends on the loaders.
+
+The filter's value is its first argument and its argument (`cut:bio`) its second, so an
+entry point naming only the value in `attacker_arguments` is not exploitable through
+the argument. A project function rendering the values it receives carries them the same
+way.
+
+With the `django.template.context_processors.request` context processor, a template
+rendered with the request reads it as `request`: `{{ request.GET.q|striptags }}` is
+exploitable at the render call too. The analyzer counts it only where all of these hold:
+
+- The project's settings assign `TEMPLATES` a literal list, every `DjangoTemplates`
+  engine of it lists the processor in a literal `context_processors`, and no other code
+  of the project names `TEMPLATES`. A mere mention of the processor proves nothing.
+- The render call passes the request: `render` and `TemplateResponse` always do,
+  `render_to_string` when given `request`, `SimpleTemplateResponse` never.
+- The render's context is certain, absent or a dict literal as above, so it cannot hide
+  a `request` entry. An entry of that name, a name a tag binds or `{% include ... only %}`
+  shadows the processor's request.
+- The template reads text the user controls: an attribute the request object lists
+  among its text attributes, such as `GET`, `POST`, `COOKIES` or `headers`; not `user` or
+  `session`.
+
+Through a project function, only the context entries are followed.
+
 Most vulnerabilities need attacker input in one argument: the path `send_from_directory`
 serves, not its `download_name`; the URL `requests.get` fetches, not its body. An entry
 point may name them in `attacker_arguments`, by keyword `argument` and, when it may be
@@ -444,16 +495,25 @@ check, including findings the policy accepts or a comment suppresses:
 | Status | When |
 |---|---|
 | `affected` | The project's code reaches the vulnerable code. The notes give each place and its level, `reachable` or `exploitable`. |
-| `not_affected` | Justified as `vulnerable_code_not_in_execute_path`, only when all of these hold: the advisory names entry points, no code of the project reaches them, every file and function was analysed, and a lock file (`uv.lock` or `poetry.lock`) shows that no other package requires the vulnerable one. The impact statement names the entry points and any calls ruled out by their arguments. |
+| `not_affected` | Justified as `vulnerable_code_not_in_execute_path`, only when all of these hold: the advisory names entry points, no code of the project reaches them, every file and function was analysed, every template the project names was read if a template filter is among them, and a lock file (`uv.lock` or `poetry.lock`) shows that no other package requires the vulnerable one. The impact statement names the entry points and any calls ruled out by their arguments. |
 | `under_investigation` | Anything else. The notes say which condition failed. |
 
+A template the analyzer cannot read may apply any filter. The project names one when
+`render`, `render_to_string`, `TemplateResponse`, an `{% include %}` or an `{% extends %}`
+names a template by an expression, or by a name found under no `templates` directory,
+including one an installed package ships; a template file that cannot be read counts
+too. An advisory whose entry points include a template filter then stays
+`under_investigation`, and the notes list where the project names each such template
+(`app.views:12 names a template by an expression`). A template named elsewhere, such as
+a class-based view's `template_name`, is not checked.
+
 `not_affected` needs the lock-file check because the analyzer reads the project's code,
 not the code of installed packages. A framework calling the vulnerable function on the
 project's behalf would go unseen. Without a lock file, a package is never
 `not_affected`. The document's `@id` derives from its statements, so two runs with the
 same result share it; its `author` is `Unknown Author`, as OpenVEX tools write when they
 cannot know it. Its `tooling` names the analyzer and each component with its digest
-(`coretrace-python-analyzer 0.15.0; curated-advisories 2026.09.25 (sha256:…)`), so the
+(`coretrace-python-analyzer 0.17.0; curated-advisories 2026.09.25 (sha256:…)`), so the
 `@id` changes with the advisory data a statement was decided with.
 
 ## Large projects

{coretrace_python_analyzer-0.15.0 → coretrace_python_analyzer-0.17.0}/pyproject.toml

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

{coretrace_python_analyzer-0.15.0 → coretrace_python_analyzer-0.17.0}/src/coretrace_python/__init__.py

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

{coretrace_python_analyzer-0.15.0 → coretrace_python_analyzer-0.17.0}/src/coretrace_python/bundled/dependency/reachable_vulnerability/reachable_vulnerability.py

@@ -1,5 +1,6 @@
 """Calls, anywhere in the project, to an API affected by a vulnerable requirement, and
-reads of an affected attribute whose getter runs the vulnerable code."""
+reads of an affected attribute whose getter runs the vulnerable code. A filter a project
+template applies is a call to the function behind it, at the template's line."""
 
 from __future__ import annotations
 
@@ -56,6 +57,10 @@ class ReachableVulnerabilityPlugin(ProjectPlugin):
                             reported.add((advisory, symbol))
                             check = check_conditions(entry, None)
                             findings.append(_reached(advisory, symbol, read.location, function, check))
+        for call in ctx.templates.calls:
+            for advisory in affected.get(call.symbol, ()):
+                check = check_conditions(advisory.entry_point(call.symbol), None)
+                findings.append(_reached(advisory, call.symbol, call.span, None, check))
         return findings
 
 
@@ -67,7 +72,9 @@ def _read_through(symbol: SymbolId) -> Iterator[SymbolId]:
         yield SymbolId(".".join(components[:end]))
 
 
-def _reached(advisory: Advisory, symbol: SymbolId, span: SourceSpan, function: str, check: ConditionCheck) -> Finding:
+def _reached(
+    advisory: Advisory, symbol: SymbolId, span: SourceSpan, function: str | None, check: ConditionCheck
+) -> Finding:
     return Finding(
         rule_id="reachable-vulnerability",
         message=(

{coretrace_python_analyzer-0.15.0 → coretrace_python_analyzer-0.17.0}/src/coretrace_python/bundled/models/django/django_models.py

@@ -139,7 +139,10 @@ 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")),
+        TemplateRender(_sym("django.template.loader.render_to_string"), request=2),
+        TemplateRender(_sym("django.shortcuts.render"), 1, context=2, request=0),
+        TemplateRender(_sym("django.template.response.TemplateResponse"), 1, "template", 2, 0),
+        TemplateRender(_sym("django.template.response.SimpleTemplateResponse"), 0, "template"),
         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.

{coretrace_python_analyzer-0.15.0 → coretrace_python_analyzer-0.17.0}/src/coretrace_python/dependency/vex.py

@@ -7,7 +7,8 @@ subcomponent of the project:
   exploitable finding, whatever the policy or a suppression did with it;
 - ``not_affected``, as ``vulnerable_code_not_in_execute_path``, only when the advisory is
   curated (it names entry points), no code of the project reaches them, every file and
-  function was analysed, and a lock file shows that no other package requires the
+  function was analysed, every template the project names was read when a template
+  filter can reach them, and a lock file shows that no other package requires the
   vulnerable one, since the code of installed packages is not analysed;
 - ``under_investigation`` otherwise, with the reason in its notes.
 """
@@ -25,6 +26,7 @@ from coretrace_python.dependency.graph import Advisory, DependencyGraph, Require
 from coretrace_python.dependency.sbom import purl
 from coretrace_python.findings import Component, Finding
 from coretrace_python.findings.coverage import Coverage
+from coretrace_python.taint import FILTER_FUNCTIONS
 
 CONTEXT = "https://openvex.dev/ns/v0.2.0"
 # OpenVEX's shared namespace for documents without an IRI of their own, and the author
@@ -33,6 +35,8 @@ NAMESPACE = "https://openvex.dev/docs/public/vex-"
 AUTHOR = "Unknown Author"
 # Evidence levels that put the vulnerable code in the project's execution path, lowest first.
 REACHED = ("reachable", "exploitable")
+# What a template calls: a template the engine cannot read may reach these.
+_TEMPLATE_CALLS = frozenset(FILTER_FUNCTIONS.values())
 
 
 def render_vex(
@@ -140,6 +144,11 @@ def _status(
             f"No analysed code reaches {entries}, but {', '.join(partial)} could not be fully "
             f"analysed.{ruled}"
         )
+    if coverage.unread_templates and _TEMPLATE_CALLS.intersection(advisory.reachable_symbols):
+        return _investigating(
+            f"No analysed code reaches {entries}, but a template can reach them, and the engine could "
+            f"not read every template the project names: {'; '.join(coverage.unread_templates)}.{ruled}"
+        )
     required_by = dependencies.required_by(package)
     if required_by is None:
         return _investigating(

{coretrace_python_analyzer-0.15.0 → coretrace_python_analyzer-0.17.0}/src/coretrace_python/engine.py

@@ -80,9 +80,12 @@ from coretrace_python.interprocedural import (
     ModuleFunction,
     ModuleGraph,
     ProjectSummaries,
+    SignaturesAnalysis,
     SummaryAnalysis,
     SummaryIndex,
     SymbolRead,
+    TemplateCalls,
+    TemplateCallsAnalysis,
     build_module_graph,
     discover_sources,
     project_symbol,
@@ -124,7 +127,10 @@ from coretrace_python.taint import (
     TaintAnalysis,
     TaintKind,
     escaped_templates,
+    project_templates,
     registered_routes,
+    request_processor,
+    unread_renders,
 )
 from coretrace_python.taint.urls import flow_url
 
@@ -158,6 +164,8 @@ ALL_ANALYSES: tuple[AnyAnalysis, ...] = (
     RegisteredRoutes,
     EscapedTemplates,
     ClearingAnalysis,
+    TemplateCallsAnalysis,
+    SignaturesAnalysis,
 )
 
 
@@ -198,6 +206,8 @@ class ResultsEvicted(TransformationPass):
             RegisteredRoutes,
             EscapedTemplates,
             ClearingAnalysis,
+            TemplateCallsAnalysis,
+            SignaturesAnalysis,
         }
     )
 
@@ -261,6 +271,7 @@ def build_manager(
     table = (models or SecurityModelRegistry()).freeze()
     manager.provide(SecurityModelAnalysis, table)
     manager.provide(MembersAnalysis, table.members_by_class())
+    manager.provide(SignaturesAnalysis, table.signatures())
     manager.provide(ClearingAnalysis, table.clearing())
     manager.provide(ProjectSummaries, SummaryIndex())
     manager.provide(RegisteredRoutes, _routes_of(manager))
@@ -316,6 +327,7 @@ def analyze_file(source: SourceFile, plugin_roots: Sequence[Path]) -> FileAnalys
     table = plugin_models(loaded.plugin for loaded in registry)
     manager.provide(SecurityModelAnalysis, table)
     manager.provide(MembersAnalysis, table.members_by_class())
+    manager.provide(SignaturesAnalysis, table.signatures())
     manager.provide(ClearingAnalysis, table.clearing())
     manager.provide(ProjectSummaries, SummaryIndex())
     manager.provide(RegisteredRoutes, _routes_of(manager))
@@ -411,6 +423,7 @@ def analyze_project(
     for manager in managers.values():
         manager.provide(SecurityModelAnalysis, models)
         manager.provide(MembersAnalysis, members)
+        manager.provide(SignaturesAnalysis, models.signatures())
         manager.provide(DependencyAnalysis, dependencies)
 
     imports: dict[str, ImportTable] = {}
@@ -431,13 +444,20 @@ def analyze_project(
         for symbol, registered in _routes_of(analysable[name]).items():
             routes.setdefault(symbol, registered)
     escaped = escaped_templates(root)
+    templates = project_templates(root)
     clearing = models.clearing(escaped)
+    template_calls = models.template_calls(
+        templates.filters, request_processor(modules[name] for name in sorted(analysable))
+    )
     for manager in analysable.values():
         manager.provide(RegisteredRoutes, routes)
         manager.provide(EscapedTemplates, escaped)
         manager.provide(ClearingAnalysis, clearing)
+        manager.provide(TemplateCallsAnalysis, template_calls)
 
-    configuration = _configuration_key(components, plugins, models, advisories, dependencies, routes, escaped)
+    configuration = _configuration_key(
+        components, plugins, models, advisories, dependencies, routes, escaped, template_calls
+    )
     keys = module_keys(
         graph,
         {name: fingerprint(configuration, str(files[name].source_id), name, files[name].text) for name in analysable},
@@ -479,6 +499,7 @@ def analyze_project(
                             advisory_paths,
                             _encode_routes(routes),
                             tuple(sorted(escaped)),
+                            template_calls,
                         ),
                     )
                     for component in pending
@@ -516,7 +537,9 @@ def analyze_project(
             frozenset(),
             reads={f: tuple(r) for f, r in reads.items()},
         )
-    context = ProjectContext(graph, dependencies, advisories, analysable, call_graphs, policy, root, functions)
+    context = ProjectContext(
+        graph, dependencies, advisories, analysable, call_graphs, policy, root, functions, templates
+    )
     for plugin in all_plugins:
         if isinstance(plugin, ProjectPlugin):
             findings.extend(plugin.analyze_project(context))
@@ -526,6 +549,9 @@ def analyze_project(
     findings = [_sourced(finding, origins) for finding in findings]
     accepted = tuple(f for f in findings if policy.accepts(f))
     kept, suppressed = partition(apply_policy(policy, findings), _text_of(sources))
+    unread = list(templates.unread)
+    for name in sorted(call_graphs):
+        unread.extend(unread_renders(name, call_graphs[name], models, templates.names))
     return ProjectAnalysis(
         graph,
         index,
@@ -534,7 +560,7 @@ def analyze_project(
         MappingProxyType(keys),
         reused,
         advisories,
-        Coverage(tuple(sorted(coverage, key=lambda c: c.path))),
+        Coverage(tuple(sorted(coverage, key=lambda c: c.path)), tuple(unread)),
         suppressed,
         accepted,
         components,
@@ -686,6 +712,7 @@ class _Batch:
     advisory_paths: tuple[Path, ...] = ()
     routes: tuple[tuple[str, str, str, int], ...] = ()
     escaped: tuple[str, ...] = ()
+    template_calls: TemplateCalls = field(default_factory=TemplateCalls)
 
 
 def _analyse_batch(batch: _Batch) -> dict[str, dict[str, Any]]:
@@ -709,10 +736,12 @@ def _analyse_batch(batch: _Batch) -> dict[str, dict[str, Any]]:
     for manager in managers.values():
         manager.provide(SecurityModelAnalysis, models)
         manager.provide(MembersAnalysis, members)
+        manager.provide(SignaturesAnalysis, models.signatures())
         manager.provide(DependencyAnalysis, dependencies)
         manager.provide(RegisteredRoutes, routes)
         manager.provide(EscapedTemplates, escaped)
         manager.provide(ClearingAnalysis, models.clearing(escaped))
+        manager.provide(TemplateCallsAnalysis, batch.template_calls)
     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()}
@@ -741,6 +770,7 @@ def _configuration_key(
     dependencies: DependencyGraph,
     routes: Routes | None = None,
     escaped: frozenset[str] = frozenset(),
+    template_calls: TemplateCalls | None = None,
 ) -> str:
     """Everything a module's results depend on besides the project sources (§11)."""
 
@@ -758,6 +788,7 @@ def _configuration_key(
         repr(dependencies.errors),
         repr(_encode_routes(routes or {})),
         repr(sorted(escaped)),
+        repr(template_calls),
     )
 
 

{coretrace_python_analyzer-0.15.0 → coretrace_python_analyzer-0.17.0}/src/coretrace_python/findings/coverage.py

@@ -2,7 +2,9 @@
 
 "No findings" only means something when the reader knows what was analysed. Each file
 is ``analysed``, a ``syntax-error`` (the frontend rejected it) or ``unreadable`` (it could
-not be decoded); analysed files count their functions and how many lowered.
+not be decoded); analysed files count their functions and how many lowered. The
+templates the project names but the run could not read are listed, each where the
+project names it: they may call any template filter.
 """
 
 from __future__ import annotations
@@ -21,6 +23,7 @@ class FileCoverage:
 @dataclass(frozen=True)
 class Coverage:
     details: tuple[FileCoverage, ...] = ()
+    unread_templates: tuple[str, ...] = ()
 
     @property
     def files(self) -> int:

{coretrace_python_analyzer-0.15.0 → coretrace_python_analyzer-0.17.0}/src/coretrace_python/interprocedural/__init__.py

@@ -8,6 +8,8 @@ from coretrace_python.interprocedural.callgraph import (
     ExternalSymbol,
     KnownFunction,
     ModuleFunction,
+    Signature,
+    SignaturesAnalysis,
     SymbolRead,
     Target,
     UnknownTarget,
@@ -20,6 +22,7 @@ from coretrace_python.interprocedural.modulegraph import (
     project_symbol,
 )
 from coretrace_python.interprocedural.summaries import (
+    FILTER_ARGUMENTS,
     Cleared,
     Clearing,
     ClearingAnalysis,
@@ -31,10 +34,14 @@ from coretrace_python.interprocedural.summaries import (
     SummaryAnalysis,
     SummaryIndex,
     SummaryTable,
+    TemplateCalls,
+    TemplateCallsAnalysis,
+    TemplateFilter,
     cleared_by,
 )
 
 __all__ = [
+    "FILTER_ARGUMENTS",
     "Arguments",
     "CallGraph",
     "CallGraphAnalysis",
@@ -51,11 +58,16 @@ __all__ = [
     "Mutation",
     "NonlocalWrite",
     "ProjectSummaries",
+    "Signature",
+    "SignaturesAnalysis",
     "SummaryAnalysis",
     "SummaryIndex",
     "SummaryTable",
     "SymbolRead",
     "Target",
+    "TemplateCalls",
+    "TemplateCallsAnalysis",
+    "TemplateFilter",
     "UnknownTarget",
     "build_module_graph",
     "cleared_by",

{coretrace_python_analyzer-0.15.0 → coretrace_python_analyzer-0.17.0}/src/coretrace_python/interprocedural/callgraph.py

@@ -9,6 +9,7 @@ reads, called or not: reading ``request.form`` runs its getter.
 
 from __future__ import annotations
 
+import re
 from collections.abc import Mapping
 from dataclasses import dataclass, field
 from types import MappingProxyType
@@ -104,6 +105,30 @@ class SymbolRead:
     symbol: SymbolId
 
 
+@dataclass(frozen=True)
+class Signature:
+    """What the parameters of the methods of a class denote when the canonical symbol
+    of its base matches ``pattern``, by position after ``self``: a class symbol, or None
+    for a parameter denoting none. A method taking another number of parameters has
+    none. The engine derives signatures from the security models (§16)."""
+
+    pattern: str
+    parameters: tuple[SymbolId | None, ...]
+
+    def matches(self, base: SymbolId) -> bool:
+        return re.search(self.pattern, base.canonical_name) is not None
+
+
+class SignaturesAnalysis(Analysis[tuple[Signature, ...]]):
+    """The signatures the models declare, provided by the engine; none on its own."""
+
+    name: ClassVar[str] = "interprocedural.signatures"
+
+    @classmethod
+    def compute(cls, ctx: AnalysisContext) -> tuple[Signature, ...]:
+        return ()
+
+
 @dataclass(frozen=True)
 class ModuleFunction:
     """One function of a module as a project plugin sees it: the name the call graph
@@ -357,6 +382,20 @@ def _annotated(
     return found
 
 
+def _declared(
+    function: nodes.Function, ssa: FunctionIR, bases: tuple[SymbolId, ...], signatures: tuple[Signature, ...]
+) -> dict[Value, SymbolId]:
+    """Parameters a signature types by their position, for a method of a class one of
+    whose ``bases`` matches the signature and which takes the parameters it lists."""
+
+    given = function.parameters[1:]
+    for signature in signatures:
+        if any(signature.matches(base) for base in bases) and len(given) == len(signature.parameters):
+            typed = zip(ssa.parameters[1:], signature.parameters, strict=False)
+            return {value: symbol for value, symbol in typed if symbol is not None}
+    return {}
+
+
 def _typed_with_module_classes(
     function: nodes.Function, ssa: FunctionIR, classes: Mapping[str, frozenset[str]]
 ) -> dict[Value, str]:
@@ -372,12 +411,15 @@ def _typed_with_module_classes(
 
 class CallGraphAnalysis(Analysis[CallGraph]):
     name: ClassVar[str] = "interprocedural.callgraph"
-    requires: ClassVar[frozenset[AnyAnalysis]] = frozenset({SSAAnalysis, ScopeAnalysis, SymbolAnalysis})
+    requires: ClassVar[frozenset[AnyAnalysis]] = frozenset(
+        {SSAAnalysis, ScopeAnalysis, SymbolAnalysis, SignaturesAnalysis}
+    )
 
     @classmethod
     def compute(cls, ctx: AnalysisContext) -> CallGraph:
         scopes = ctx.get(ScopeAnalysis)
         table = ctx.get(SymbolAnalysis)
+        signatures = ctx.get(SignaturesAnalysis)
         definitions: dict[str, nodes.Function] = {}
         for function in analyzable_functions(ctx.module):
             # A property and its setter, or a redefinition, share a qualified name; each
@@ -396,14 +438,15 @@ class CallGraphAnalysis(Analysis[CallGraph]):
             for statement in ctx.module.body
             if isinstance(statement, nodes.Class)
         }
+        # Inheritance follows the first base that resolves; a signature may match any.
         bases: dict[str, SymbolId] = {}
+        ancestry: dict[str, tuple[SymbolId, ...]] = {}
         for statement in ctx.module.body:
             if isinstance(statement, nodes.Class):
-                for base_expression in statement.bases:
-                    symbol = table.resolve_expression(scopes.module_scope.id, base_expression)
-                    if symbol is not None:
-                        bases[statement.name] = symbol
-                        break
+                resolved = [table.resolve_expression(scopes.module_scope.id, base) for base in statement.bases]
+                ancestry[statement.name] = tuple(symbol for symbol in resolved if symbol is not None)
+                if ancestry[statement.name]:
+                    bases[statement.name] = ancestry[statement.name][0]
         sites: dict[str, tuple[CallSite, ...]] = {}
         symbols: dict[str, Mapping[Value, SymbolId]] = {}
         reads: dict[str, tuple[SymbolRead, ...]] = {}
@@ -418,11 +461,13 @@ class CallGraphAnalysis(Analysis[CallGraph]):
             owner = name.rsplit(".", 1)[0] if "." in name and name.rsplit(".", 1)[0] in classes else None
             if owner is not None and _is_staticmethod(function):
                 owner = None  # a static method has no receiver
+            # A signature types parameters by their position; an annotation says more.
+            declared = _declared(function, ssa, ancestry.get(owner, ()) if owner is not None else (), signatures)
             targets, symbols[name] = resolve_targets(
                 ssa,
                 scopes,
                 known,
-                _annotated(function, ssa, scopes, table),
+                {**declared, **_annotated(function, ssa, scopes, table)},
                 frozenset(definitions),
                 classes,
                 owner,