coretrace-python-analyzer 0.2.0__tar.gz → 0.3.0__tar.gz

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.3.0 (2026-09-22)
+
+### Plugins
+
+- Two plugins may declare the same symbol: an identical model is registered once and sinks merge their kinds and positions; a real conflict names both plugins instead of failing the run on the first duplicate (#92).
+- A plugin's entrypoint may be a package, `<module>/__init__.py`, so a plugin can split its tables across files and import them relatively (#93).
+- The cache key covers every file of a plugin directory, not only `.py` and `.toml`, so rules or advisories shipped as data invalidate cached results when they change (#94).
+
+### Analysis
+
+- New taint kinds: `NOSQL` in `TaintKind.ALL`; `LOG` and `PII` outside it, carried only by the values a model marks, so a NoSQL-injection, log-injection or personal-data detector no longer has to share a kind with another rule (#96).
+
+### Precision
+
+- A `Sanitizer` declared on a function of the analysed project takes precedence over the summary derived from its body, in the same file and across files, so a code base can declare its own validation layer (#95).
+
 ## 0.2.0 (2026-09-06)
 
 ### Adoption in an existing repository

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: coretrace-python-analyzer
-Version: 0.2.0
+Version: 0.3.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.2.0 → coretrace_python_analyzer-0.3.0}/docs/plugins.md

@@ -38,7 +38,12 @@ class = "SensitiveLoggingPlugin"
 | `plugin_api` | The range of plugin API versions the plugin supports. The current API is version 1. |
 | `requires` | Capabilities the plugin needs; a mismatch with the class's `requires` is a manifest error. |
 | `provides` | Capabilities the plugin offers, for documentation and conflict detection. |
-| `entrypoint` | The module file (without `.py`, next to the manifest) and the class in it. |
+| `entrypoint` | The module (without `.py`, next to the manifest) and the class in it. |
+
+The entrypoint module may be a package, `<module>/__init__.py`, when a plugin grows past
+one file: its submodules are reached through relative imports (`from .tables import
+celery`). Two plugins may use the same module name; each is imported under a name derived
+from its path.
 
 ## Symbols
 
@@ -101,10 +106,14 @@ class CommandInjectionPlugin(TaintDetector):
 ```
 
 `confidence` defaults to high; a hotspot, a flow behind a guard that mentions the value
-or an authorization decorator, is reported at medium. The taint kinds are `SQL`,
-`COMMAND`, `HTML`, `PATH`, `SSRF`, `CODE`, `DESERIALIZATION`, `REDIRECT`, `ADVISORY`
-(APIs affected by advisories) and `CREDENTIAL`, which only credential-named parameters
-carry so that ordinary input reaching a database write is not a plaintext credential.
+or an authorization decorator, is reported at medium. The taint kinds every source
+carries by default (`TaintKind.ALL`) are `SQL`, `NOSQL`, `COMMAND`, `HTML`, `PATH`,
+`SSRF`, `CODE`, `DESERIALIZATION`, `REDIRECT` and `ADVISORY` (APIs affected by
+advisories). Three kinds are outside `ALL`, so only a value a model marks with them
+reaches their sinks: `CREDENTIAL`, which credential-named parameters carry so that
+ordinary input reaching a database write is not a plaintext credential; `LOG`, for
+values that must not be written to a log as they are; and `PII`, for personal data
+that must not leave the application through a log, a third party or plain storage.
 
 ### Security models: `ModelPlugin`
 
@@ -142,6 +151,11 @@ class BottleModels(ModelPlugin):
 | `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
+another plugin declared for `COMMAND`; any other difference is a conflict that stops
+the analysis with a `ModelError` naming both plugins.
+
 A model plugin may also carry `advisories`, a tuple of `Advisory` values
 (`coretrace_python.dependency`) with the package, the vulnerable range and the affected
 symbols, as the shipped `sample-advisories` plugin does. Requirements matching them are

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/docs/usage.md

@@ -198,7 +198,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.2.0"},
+  "tool": {"name": "coretrace-python-analyzer", "version": "0.3.0"},
   "root": "/home/me/project",
   "findings": [
     {
@@ -283,8 +283,9 @@ coretrace-python-analyzer --check src/ --sbom sbom.json --policy security/policy
 ## Large projects
 
 `--cache DIR` keeps the results of a directory check on disk, one entry per module,
-keyed by the module's source, the tool and plugin versions, the security models, the
-advisories, the dependency graph and the modules it imports. On the next run an unchanged
+keyed by the module's source, the tool version, every file of every plugin directory
+(code, manifest and data alike), the security models, the advisories, the dependency
+graph and the modules it imports. On the next run an unchanged
 module is served from the cache, so editing one file re-analyses that file and its
 importers only. Entries are plain data; an unreadable entry is recomputed.
 
@@ -335,6 +336,29 @@ coretrace-python-analyzer --check src/ --plugins ./coretrace-plugins
 coretrace-python-analyzer --check src/ --no-bundled-plugins --plugins ./coretrace-plugins
 ```
 
+### Your own validation layer
+
+A code base that already validates its input has functions the analyzer cannot know are
+safe: a `clean()` that returns its argument looks, from its body, like a function that
+passes taint through. Declare them in a model plugin by their project symbol,
+`python.<module>.<function>`, and the analyzer takes your word over what it derived:
+
+```python
+from coretrace_python.plugins import ModelPlugin
+from coretrace_python.semantic.symbols import SymbolId
+from coretrace_python.taint import Sanitizer, TaintKind, Validator
+
+
+class HouseModels(ModelPlugin):
+    name = "house-models"
+    models = (
+        # the result of app.validation.clean is safe for commands, whatever the body does
+        Sanitizer(SymbolId("python.app.validation.clean"), TaintKind.COMMAND),
+        # a flow behind ``if app.validation.is_slug(value):`` is refuted
+        Validator(SymbolId("python.app.validation.is_slug")),
+    )
+```
+
 ## Continuous integration
 
 The exit status gates the job and the SARIF report feeds code scanning. On GitHub

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/pyproject.toml

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

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/src/coretrace_python/__init__.py

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

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/src/coretrace_python/cache.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 import hashlib
 import json
 import os
-from collections.abc import Iterable, Mapping
+from collections.abc import Mapping
 from dataclasses import dataclass
 from pathlib import Path
 from types import MappingProxyType
@@ -64,15 +64,18 @@ def fingerprint(*parts: str) -> str:
     return digest.hexdigest()
 
 
-def directory_fingerprint(directory: Path, suffixes: Iterable[str] = (".py", ".toml")) -> str:
-    """A digest of the source files under ``directory``, so edited plugin code misses."""
+def directory_fingerprint(directory: Path) -> str:
+    """A digest of every file under ``directory``, so an edited plugin misses: its code,
+    its manifest and the rule or advisory data it ships in any format. Bytecode and
+    hidden files are not part of what the plugin does."""
 
-    wanted = tuple(suffixes)
     parts: list[str] = []
     for path in sorted(directory.rglob("*")):
-        if path.is_file() and path.suffix in wanted:
-            parts.append(str(path.relative_to(directory)))
-            parts.append(path.read_text(encoding="utf-8", errors="replace"))
+        relative = path.relative_to(directory)
+        if not path.is_file() or any(p == "__pycache__" or p.startswith(".") for p in relative.parts):
+            continue
+        parts.append(str(relative))
+        parts.append(path.read_bytes().hex())
     return fingerprint(*parts)
 
 

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/src/coretrace_python/engine.py

@@ -257,7 +257,7 @@ def load_plugins(plugin_roots: Sequence[Path], manager: AnalysisManager) -> Plug
 def plugin_models(plugins: Iterable[Plugin]) -> ModelTable:
     models = SecurityModelRegistry()
     for plugin in plugins:
-        models.register(*plugin.models)
+        models.register(*plugin.models, origin=plugin.name)
     return models.freeze()
 
 

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/src/coretrace_python/plugins/loader.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import hashlib
 import importlib.util
+import sys
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -63,16 +64,31 @@ def discover_plugins(root: Path, manager: AnalysisManager) -> tuple[LoadedPlugin
 
 
 def _import_entrypoint(directory: Path, manifest: PluginManifest) -> type[Plugin]:
-    module_path = directory / f"{manifest.entrypoint.module}.py"
+    """Import the entrypoint, a module ``<name>.py`` or a package ``<name>/__init__.py``.
+
+    The module name derives from the path, so two plugins may both call their module
+    ``models``; a package is registered in ``sys.modules`` under that name before it
+    runs, which is what its relative imports resolve through."""
+
+    package_path = directory / manifest.entrypoint.module / "__init__.py"
+    is_package = package_path.is_file()
+    module_path = package_path if is_package else directory / f"{manifest.entrypoint.module}.py"
     if not module_path.is_file():
         raise ManifestError(
             f"{directory / MANIFEST_FILENAME}: entrypoint module"
             f" {manifest.entrypoint.module!r} not found"
         )
     unique = hashlib.sha1(str(module_path.resolve()).encode()).hexdigest()[:12]
-    spec = importlib.util.spec_from_file_location(f"coretrace_plugin_{unique}", module_path)
+    name = f"coretrace_plugin_{unique}"
+    spec = importlib.util.spec_from_file_location(
+        name,
+        module_path,
+        submodule_search_locations=[str(module_path.parent)] if is_package else None,
+    )
     assert spec is not None and spec.loader is not None
     module = importlib.util.module_from_spec(spec)
+    if is_package:
+        sys.modules[name] = module
     spec.loader.exec_module(module)
 
     candidate = getattr(module, manifest.entrypoint.class_name, None)

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/src/coretrace_python/taint/engine.py

@@ -147,8 +147,10 @@ class _TaintProblem(DataflowProblem[State]):
         project: SummaryIndex | None = None,
         heap: HeapFacts | None = None,
         seeds: Mapping[HeapLocation, Taint] | None = None,
+        module: str = "",
     ) -> None:
         self.name = name
+        self.module = module
         self.function = function
         self.models = models
         self.graph = graph
@@ -294,9 +296,10 @@ class _TaintProblem(DataflowProblem[State]):
                 through = target.symbol.canonical_name.removeprefix("python.")
                 bound = () if project.static else self.receiver(call, project.name)
                 arguments = (*(self.deep(r, state) for r in bound), *arguments)
-                return self.known(
+                result = self.known(
                     project, through, arguments, keywords, everything, call, flows, state, (), bound
                 )
+                return self.declared_clean(target.symbol, result)
             symbol = target.symbol
             if not self.modelled(symbol):
                 # ``get_conn().execute`` derived ``app.database.get_conn.execute``; what
@@ -312,9 +315,10 @@ class _TaintProblem(DataflowProblem[State]):
                 *arguments,
                 *(self.deep(value, state) for value in captured),
             )
-            return self.known(
+            result = self.known(
                 summary, target.name, arguments, keywords, everything, call, flows, state, captured, bound
             )
+            return self.declared_clean(project_symbol(self.module, target.name), result)
         returned = self.returned_symbol(call)
         if returned is not None:
             return self.external(returned, everything, call, state, flows)
@@ -369,6 +373,13 @@ class _TaintProblem(DataflowProblem[State]):
         made = self.defs.get(call.callee)
         return made.captured if isinstance(made, MakeFunction) else ()
 
+    def declared_clean(self, symbol: SymbolId, result: Taint) -> Taint:
+        """A ``Sanitizer`` declared on a project function is the project's own knowledge
+        of what its result carries; it wins over what the summary derived from the body."""
+
+        sanitizer = self.models.sanitizer(symbol)
+        return result if sanitizer is None else result.without(sanitizer.kinds)
+
     def modelled(self, symbol: SymbolId) -> bool:
         return (
             self.models.sink(symbol) is not None
@@ -730,8 +741,9 @@ def propagate_taint(
     project: SummaryIndex | None = None,
     heap: HeapFacts | None = None,
     seeds: Mapping[HeapLocation, Taint] | None = None,
+    module: str = "",
 ) -> TaintFacts:
-    problem = _TaintProblem(name, function, models, graph, summaries, parameters, project, heap, seeds)
+    problem = _TaintProblem(name, function, models, graph, summaries, parameters, project, heap, seeds, module)
     solution = solve(problem, cfg)
     taints: dict[Key, Taint] = {}
     flows: list[TaintFlow] = []
@@ -794,6 +806,7 @@ class TaintAnalysis(FunctionAnalysis[TaintFacts]):
             ctx.get(ProjectSummaries),
             heap,
             seeds,
+            ctx.module.name,
         )
 
 

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/src/coretrace_python/taint/models.py

@@ -30,10 +30,14 @@ class TaintKind(Flag):
     ADVISORY = auto()
     DESERIALIZATION = auto()
     REDIRECT = auto()
-    ALL = SQL | COMMAND | HTML | PATH | SSRF | CODE | ADVISORY | DESERIALIZATION | REDIRECT
-    # Outside ALL on purpose: only credential-named parameters carry it, so a database
-    # write reached by ordinary input is not a plaintext credential.
+    NOSQL = auto()
+    ALL = SQL | COMMAND | HTML | PATH | SSRF | CODE | ADVISORY | DESERIALIZATION | REDIRECT | NOSQL
+    # Outside ALL on purpose: only the values a model marks carry them, so a database
+    # write reached by ordinary input is not a plaintext credential, and ordinary input
+    # reaching a logger is neither log forging nor a personal-data leak.
     CREDENTIAL = auto()
+    LOG = auto()
+    PII = auto()
 
 
 class ModelError(Exception):
@@ -69,6 +73,11 @@ class Sink:
                 kinds &= ~restricted
         return kinds
 
+    def merged(self, other: Sink) -> Sink:
+        """This sink with ``other``'s kinds and positions added."""
+
+        return Sink(self.symbol, self.kinds | other.kinds, self.positions + other.positions)
+
 
 @dataclass(frozen=True)
 class Sanitizer:
@@ -251,11 +260,7 @@ class ModelTable:
         merged = {sink.symbol: sink for sink in self.sinks}
         for sink in sinks:
             current = merged.get(sink.symbol)
-            merged[sink.symbol] = (
-                Sink(sink.symbol, current.kinds | sink.kinds, current.positions + sink.positions)
-                if current is not None
-                else sink
-            )
+            merged[sink.symbol] = sink if current is None else current.merged(sink)
         return ModelTable(
             self.sources,
             tuple(merged.values()),
@@ -279,15 +284,31 @@ class SecurityModelRegistry:
 
     def __init__(self) -> None:
         self._models: dict[tuple[type[Model], SymbolId], Model] = {}
+        self._origins: dict[tuple[type[Model], SymbolId], str | None] = {}
+
+    def register(self, *models: Model, origin: str | None = None) -> None:
+        """Add models; ``origin`` names the plugin so a conflict can name both sides.
+
+        Two plugins may describe the same symbol: an identical model is ignored, sinks
+        merge their kinds and positions, any other difference is a conflict."""
 
-    def register(self, *models: Model) -> None:
         for model in models:
             key = (type(model), model.symbol)
-            if key in self._models:
+            current = self._models.get(key)
+            if current is None:
+                self._models[key] = model
+                self._origins[key] = origin
+            elif current == model:
+                continue
+            elif isinstance(model, Sink) and isinstance(current, Sink):
+                self._models[key] = current.merged(model)
+            else:
+                registered = self._origins[key]
+                sides = f" by {registered!r} and {origin!r}" if registered and origin else ""
                 raise ModelError(
-                    f"{type(model).__name__.lower()} model for {model.symbol} is already registered"
+                    f"{type(model).__name__.lower()} model for {model.symbol}"
+                    f" is registered twice{sides} with different values"
                 )
-            self._models[key] = model
 
     def freeze(self) -> ModelTable:
         models = list(self._models.values())

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/tests/test_cache.py

@@ -13,6 +13,7 @@ Expected to remain red until ``coretrace_python.cache`` and the ``--cache`` opti
 from __future__ import annotations
 
 import json
+import shutil
 from pathlib import Path
 
 import pytest
@@ -119,6 +120,25 @@ def test_keys_depend_on_dependency_files(tmp_path: Path) -> None:
     assert all(after[name] != before[name] for name in before)
 
 
+def test_keys_depend_on_every_plugin_file(tmp_path: Path) -> None:
+    root = standard(tmp_path)
+    plugins = tmp_path / "plugins"
+    shutil.copytree(
+        PLUGINS / "syntax" / "dangerous_eval",
+        plugins / "dangerous_eval",
+        ignore=shutil.ignore_patterns("__pycache__"),
+    )
+    before = engine.analyze_project(root, [plugins]).keys
+    (plugins / "dangerous_eval" / "rules.json").write_text('{"v": 1}', encoding="utf-8")
+    after = engine.analyze_project(root, [plugins]).keys
+    (plugins / "dangerous_eval" / "__pycache__").mkdir(exist_ok=True)
+    (plugins / "dangerous_eval" / "__pycache__" / "x.pyc").write_bytes(b"\0")
+    with_bytecode = engine.analyze_project(root, [plugins]).keys
+
+    assert all(after[name] != before[name] for name in before)
+    assert with_bytecode == after
+
+
 # --------------------------------------------------------------------------- reuse
 
 

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/tests/test_interprocedural_taint.py

@@ -50,12 +50,12 @@ def require_interprocedural_taint() -> None:
         pytest.fail("TaintAnalysis does not consume the call graph and summaries yet")
 
 
-def facts(source_text: str, name: str = "run") -> TaintFacts:
+def facts(source_text: str, name: str = "run", *extra: Sanitizer) -> TaintFacts:
     module = build_hir(SourceManager().add_source("ip.py", source_text))
     manager = AnalysisManager(module)
     manager.register(*engine.ALL_ANALYSES)
     registry = SecurityModelRegistry()
-    registry.register(*MODELS)
+    registry.register(*MODELS, *extra)
     manager.provide(SecurityModelAnalysis, registry.freeze())
     function = next(s for s in module.body if isinstance(s, nodes.Function) and s.name == name)
     return manager.get(TaintAnalysis, function)
@@ -130,6 +130,17 @@ def test_sanitizing_before_the_call_removes_the_flow() -> None:
     assert result.flows == ()
 
 
+def test_a_sanitizer_declared_on_a_project_function_overrides_its_summary() -> None:
+    source = (
+        "import os\n\n"
+        "def clean(value):\n    return value\n\n"
+        "def run():\n    os.system(clean(input()))\n"
+    )
+
+    assert lines(facts(source)) == [7]
+    assert facts(source, "run", Sanitizer(SymbolId("python.ip.clean"), TaintKind.COMMAND)).flows == ()
+
+
 def test_keyword_arguments_flow_through_summaries() -> None:
     result = facts(
         "import subprocess\n\n"

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/tests/test_plugins.py

@@ -357,6 +357,51 @@ def test_discovers_plugins_recursively_in_sorted_order(tmp_path: Path) -> None:
     assert [plugin.manifest.name for plugin in loaded] == ["first", "second"]
 
 
+def write_package(directory: Path, label: str) -> None:
+    package = directory / "sample"
+    (package / "tables").mkdir(parents=True)
+    (package / "__init__.py").write_text(
+        "from typing import ClassVar\n\n"
+        "from coretrace_python.plugins import ModelPlugin\n\n"
+        "from .tables.celery import MODELS\n\n\n"
+        "class SamplePlugin(ModelPlugin):\n"
+        '    name: ClassVar[str] = "sample"\n'
+        "    models = MODELS\n",
+        encoding="utf-8",
+    )
+    (package / "tables" / "__init__.py").write_text("", encoding="utf-8")
+    (package / "tables" / "celery.py").write_text(
+        "from coretrace_python.semantic.symbols import SymbolId\n"
+        "from coretrace_python.taint import EntryPoint\n\n"
+        f'MODELS = (EntryPoint(SymbolId("python.celery.{label}"), "{label}"),)\n',
+        encoding="utf-8",
+    )
+
+
+def test_loads_a_plugin_package_with_relative_imports(tmp_path: Path) -> None:
+    write_manifest(tmp_path)
+    write_package(tmp_path, "task")
+
+    loaded = load_plugin(tmp_path, manager_for(""))
+
+    assert [m.symbol for m in loaded.plugin.models] == [SymbolId("python.celery.task")]
+
+
+def test_plugin_packages_with_the_same_module_name_do_not_collide(tmp_path: Path) -> None:
+    for name in ("a", "b"):
+        directory = tmp_path / name
+        directory.mkdir()
+        write_manifest(directory, name=name)
+        write_package(directory, name)
+
+    loaded = discover_plugins(tmp_path, manager_for(""))
+
+    assert [m.symbol for p in loaded for m in p.plugin.models] == [
+        SymbolId("python.celery.a"),
+        SymbolId("python.celery.b"),
+    ]
+
+
 # --------------------------------------------------------------------------- registry
 
 

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/tests/test_project.py

@@ -136,6 +136,38 @@ def test_taint_flows_into_a_function_defined_in_another_file(tmp_path: Path) ->
     assert findings[0].metadata["sink_line"] == "4"
 
 
+def test_a_sanitizer_declared_on_a_function_of_another_file_refutes_the_flow(tmp_path: Path) -> None:
+    root = project(
+        tmp_path / "src",
+        {
+            "app/__init__.py": "",
+            "app/validation.py": "def clean(value):\n    return value\n",
+            "app/main.py": "import os\nfrom app.validation import clean\n\ndef run():\n    os.system(clean(input()))\n",
+        },
+    )
+    models = project(
+        tmp_path / "models",
+        {
+            "plugin.toml": (
+                'name = "house-models"\nversion = "1.0.0"\nplugin_api = ">=1,<2"\n'
+                'requires = []\nprovides = ["models.house"]\n\n'
+                '[entrypoint]\nmodule = "house"\nclass = "HouseModels"\n'
+            ),
+            "house.py": (
+                "from coretrace_python.plugins import ModelPlugin\n"
+                "from coretrace_python.semantic.symbols import SymbolId\n"
+                "from coretrace_python.taint import Sanitizer, TaintKind\n\n\n"
+                "class HouseModels(ModelPlugin):\n"
+                '    name = "house-models"\n'
+                '    models = (Sanitizer(SymbolId("python.app.validation.clean"), TaintKind.COMMAND),)\n'
+            ),
+        },
+    )
+
+    assert rules(engine.analyze_project(root, [PLUGINS]).findings) == [("main.py", "command-injection", 5)]
+    assert rules(engine.analyze_project(root, [PLUGINS, models]).findings) == []
+
+
 def test_module_attribute_calls_resolve_too(tmp_path: Path) -> None:
     root = project(
         tmp_path,

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/tests/test_release.py

@@ -30,7 +30,7 @@ def require_changelog() -> None:
 def test_the_version_is_declared_once_and_mirrored() -> None:
     project = tomllib.loads((REPO / "pyproject.toml").read_text(encoding="utf-8"))["project"]
 
-    assert project["version"] == coretrace_python.__version__ == "0.2.0"
+    assert project["version"] == coretrace_python.__version__ == "0.3.0"
 
 
 def test_the_changelog_starts_with_the_current_version() -> None:

{coretrace_python_analyzer-0.2.0 → coretrace_python_analyzer-0.3.0}/tests/test_taint.py

@@ -101,6 +101,38 @@ def test_taint_kinds_form_a_bitset() -> None:
     assert {TaintKind.SQL, TaintKind.COMMAND, TaintKind.HTML, TaintKind.PATH, TaintKind.SSRF} <= set(TaintKind)
 
 
+def test_nosql_is_ordinary_input_while_log_and_pii_are_opt_in() -> None:
+    assert TaintKind.NOSQL in TaintKind.ALL
+    assert TaintKind.LOG not in TaintKind.ALL
+    assert TaintKind.PII not in TaintKind.ALL
+    assert TaintKind.CREDENTIAL not in TaintKind.ALL
+
+
+def test_ordinary_input_reaches_a_nosql_sink_but_not_a_log_sink() -> None:
+    registry = SecurityModelRegistry()
+    registry.register(
+        Source(sym("python.flask.request.args"), HTTP),
+        Source(sym("python.app.record"), "record", TaintKind.LOG),
+        Sink(sym("python.db.find"), TaintKind.NOSQL),
+        Sink(sym("python.logging.info"), TaintKind.LOG),
+    )
+    _, facts = analyze(
+        "from flask import request\n"
+        "import db, logging\n"
+        "from app import record\n\n"
+        "def run():\n"
+        "    db.find(request.args['q'])\n"
+        "    logging.info(request.args['q'])\n"
+        "    logging.info(record())\n",
+        registry.freeze(),
+    )
+
+    assert [(f.sink.symbol, f.kinds) for f in facts.flows] == [
+        (sym("python.db.find"), TaintKind.NOSQL),
+        (sym("python.logging.info"), TaintKind.LOG),
+    ]
+
+
 def test_taint_joins_with_or() -> None:
     a = Taint(TaintKind.SQL, frozenset({Source(sym("python.a"), "a")}))
     b = Taint(TaintKind.HTML, frozenset({Source(sym("python.b"), "b")}))
@@ -131,10 +163,44 @@ def test_registry_indexes_models_by_symbol() -> None:
 
 def test_registry_rejects_conflicting_models() -> None:
     registry = SecurityModelRegistry()
-    registry.register(Sink(sym("python.os.system"), TaintKind.COMMAND))
+    registry.register(Source(sym("python.flask.request.args"), "http"))
+
+    with pytest.raises(ModelError, match="python.flask.request.args"):
+        registry.register(Source(sym("python.flask.request.args"), "cli"))
+
+
+def test_registry_ignores_an_identical_model() -> None:
+    registry = SecurityModelRegistry()
+    registry.register(Sanitizer(sym("python.html.escape"), TaintKind.HTML))
+    registry.register(Sanitizer(sym("python.html.escape"), TaintKind.HTML))
+
+    assert registry.freeze().sanitizers == (Sanitizer(sym("python.html.escape"), TaintKind.HTML),)
+
+
+def test_registry_merges_sinks_on_one_symbol() -> None:
+    registry = SecurityModelRegistry()
+    registry.register(Sink(sym("python.os.system"), TaintKind.COMMAND, ((TaintKind.COMMAND, (0,)),)))
+    registry.register(Sink(sym("python.os.system"), TaintKind.SQL))
+
+    sink = registry.freeze().sink(sym("python.os.system"))
+    assert sink == Sink(
+        sym("python.os.system"), TaintKind.COMMAND | TaintKind.SQL, ((TaintKind.COMMAND, (0,)),)
+    )
+
+
+def test_plugin_models_names_both_plugins_of_a_conflict() -> None:
+    from coretrace_python.plugins import ModelPlugin
+
+    class First(ModelPlugin):
+        name = "first-models"
+        models = (Source(sym("python.flask.request.args"), "http"),)
+
+    class Second(ModelPlugin):
+        name = "second-models"
+        models = (Source(sym("python.flask.request.args"), "cli"),)
 
-    with pytest.raises(ModelError, match="python.os.system"):
-        registry.register(Sink(sym("python.os.system"), TaintKind.SQL))
+    with pytest.raises(ModelError, match="'first-models' and 'second-models'"):
+        engine.plugin_models([First(), Second()])
 
 
 def test_models_and_tables_are_immutable() -> None: