coretrace-python-analyzer 0.1.0__py3-none-any.whl

coretrace_python/bundled/dependency/reachable_vulnerability/reachable_vulnerability.py

@@ -0,0 +1,56 @@
+"""Calls, anywhere in the project, to an API affected by a vulnerable requirement."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import ClassVar
+
+from coretrace_python.analysis import AnyAnalysis
+from coretrace_python.dependency import DependencyAnalysis
+from coretrace_python.findings import Confidence, Finding
+from coretrace_python.interprocedural import CallGraphAnalysis, ExternalSymbol
+from coretrace_python.plugins import ProjectContext, ProjectPlugin
+
+
+class ReachableVulnerabilityPlugin(ProjectPlugin):
+    name: ClassVar[str] = "reachable-vulnerability"
+    requires: ClassVar[frozenset[AnyAnalysis]] = frozenset({DependencyAnalysis, CallGraphAnalysis})
+
+    def analyze_project(self, ctx: ProjectContext) -> Sequence[Finding]:
+        affected = {}
+        for requirement in ctx.dependencies.requirements:
+            for advisory in ctx.advisories:
+                if advisory.affects(requirement):
+                    for symbol in advisory.affected_symbols:
+                        affected.setdefault(symbol, advisory)
+        if not affected:
+            return ()
+        findings: list[Finding] = []
+        for module in ctx.modules:
+            graph = ctx.call_graph(module)
+            for function in graph.functions:
+                for site in graph.sites(function):
+                    if not isinstance(site.target, ExternalSymbol):
+                        continue
+                    advisory = affected.get(site.target.symbol)
+                    if advisory is None:
+                        continue
+                    findings.append(
+                        Finding(
+                            rule_id="reachable-vulnerability",
+                            message=(
+                                f"{advisory.id}: {site.target.symbol} is affected in the required "
+                                f"{advisory.package} {advisory.vulnerable}: {advisory.summary}"
+                            ),
+                            severity=advisory.severity,
+                            confidence=Confidence.HIGH,
+                            span=site.location,
+                            function=function,
+                            metadata={
+                                "advisory": advisory.id,
+                                "package": advisory.package,
+                                "symbol": str(site.target.symbol),
+                            },
+                        )
+                    )
+        return findings

coretrace_python/bundled/dependency/sample_advisories/plugin.toml

@@ -0,0 +1,9 @@
+name = "sample-advisories"
+version = "1.0.0"
+plugin_api = ">=1,<2"
+requires = []
+provides = ["advisories.sample"]
+
+[entrypoint]
+module = "sample_advisories"
+class = "SampleAdvisories"

coretrace_python/bundled/dependency/sample_advisories/sample_advisories.py

@@ -0,0 +1,109 @@
+"""A small, offline sample of published advisories (architecture §26).
+
+This is a demonstration database: a handful of well-known CVEs with the APIs they
+affect. A live OSV or GHSA feed belongs to a dedicated plugin.
+"""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from coretrace_python.dependency import Advisory
+from coretrace_python.findings import Severity
+from coretrace_python.plugins import ModelPlugin
+from coretrace_python.semantic.symbols import SymbolId
+
+
+def _sym(path: str) -> SymbolId:
+    return SymbolId(f"python.{path}")
+
+
+class SampleAdvisories(ModelPlugin):
+    name: ClassVar[str] = "sample-advisories"
+    advisories: ClassVar[tuple[Advisory, ...]] = (
+        Advisory(
+            "CVE-2020-1747",
+            "pyyaml",
+            "<5.4",
+            "yaml.load and full_load can execute arbitrary code from untrusted documents",
+            Severity.CRITICAL,
+            (_sym("yaml.load"), _sym("yaml.full_load"), _sym("yaml.unsafe_load")),
+        ),
+        Advisory(
+            "CVE-2018-18074",
+            "requests",
+            "<2.20.0",
+            "Authorization header is leaked on redirects to another host",
+            Severity.HIGH,
+            (_sym("requests.get"), _sym("requests.post"), _sym("requests.request"), _sym("requests.Session")),
+        ),
+        Advisory(
+            "CVE-2020-28493",
+            "jinja2",
+            "<2.11.3",
+            "regular expression denial of service in the urlize filter",
+            Severity.MEDIUM,
+            (_sym("jinja2.Environment"), _sym("jinja2.Template")),
+        ),
+        Advisory(
+            "CVE-2021-33503",
+            "urllib3",
+            "<1.26.5",
+            "regular expression denial of service when parsing authority in URLs",
+            Severity.HIGH,
+            (_sym("urllib3.PoolManager"), _sym("urllib3.request")),
+        ),
+        Advisory(
+            "CVE-2023-30861",
+            "flask",
+            "<2.2.5",
+            "session cookie may be leaked through caching proxies",
+            Severity.HIGH,
+            (_sym("flask.Flask"),),
+        ),
+        Advisory(
+            "CVE-2024-1135",
+            "gunicorn",
+            "<22.0.0",
+            "HTTP request smuggling through improper Transfer-Encoding validation",
+            Severity.HIGH,
+            (),
+            ("GHSA-w3h3-4rj7-4ph4",),
+        ),
+        Advisory(
+            "CVE-2023-4863",
+            "opencv-python",
+            "<4.8.1.78",
+            "heap buffer overflow in the bundled libwebp when decoding a crafted WebP image",
+            Severity.CRITICAL,
+            (_sym("cv2.imread"), _sym("cv2.imdecode"), _sym("cv2.imreadmulti")),
+            ("GHSA-qr4w-53vh-m672",),
+        ),
+        Advisory(
+            "CVE-2024-34069",
+            "werkzeug",
+            "<3.0.3",
+            "the debugger can be tricked into executing code through a crafted domain",
+            Severity.HIGH,
+            (_sym("werkzeug.debug.DebuggedApplication"),),
+            ("GHSA-2g68-c3qc-8985",),
+        ),
+        Advisory(
+            "CVE-2023-46136",
+            "werkzeug",
+            "<3.0.1",
+            "a crafted multipart body exhausts CPU and memory in the form parser",
+            Severity.HIGH,
+            (_sym("werkzeug.formparser.MultiPartParser"),),
+            ("GHSA-hrfv-mqp8-q5rw",),
+        ),
+        Advisory(
+            "CVE-2026-25990",
+            "pillow",
+            "<=11.2.1",
+            "out-of-bounds write when loading a crafted PSD image",
+            Severity.HIGH,
+            (_sym("PIL.Image.open"),),
+            ("GHSA-cfh3-3jmp-rvhc",),
+        ),
+    )

coretrace_python/bundled/dependency/vulnerable_dependency/plugin.toml

@@ -0,0 +1,9 @@
+name = "vulnerable-dependency"
+version = "1.0.0"
+plugin_api = ">=1,<2"
+requires = ["dependency.graph"]
+provides = ["vulnerability.vulnerable-dependency"]
+
+[entrypoint]
+module = "vulnerable_dependency"
+class = "VulnerableDependencyPlugin"

coretrace_python/bundled/dependency/vulnerable_dependency/vulnerable_dependency.py

@@ -0,0 +1,43 @@
+"""Requirements that allow a version an advisory marks as vulnerable."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import ClassVar
+
+from coretrace_python.analysis import AnyAnalysis
+from coretrace_python.dependency import DependencyAnalysis
+from coretrace_python.findings import Confidence, Finding
+from coretrace_python.plugins import ProjectContext, ProjectPlugin
+
+
+class VulnerableDependencyPlugin(ProjectPlugin):
+    name: ClassVar[str] = "vulnerable-dependency"
+    requires: ClassVar[frozenset[AnyAnalysis]] = frozenset({DependencyAnalysis})
+
+    def analyze_project(self, ctx: ProjectContext) -> Sequence[Finding]:
+        findings: list[Finding] = []
+        for requirement in ctx.dependencies.requirements:
+            for advisory in ctx.advisories:
+                if not advisory.affects(requirement):
+                    continue
+                pinned = requirement.pinned is not None
+                findings.append(
+                    Finding(
+                        rule_id="vulnerable-dependency",
+                        message=(
+                            f"{advisory.id}: {advisory.package} {advisory.vulnerable} is "
+                            f"{'required' if pinned else 'allowed'} by {requirement.name}"
+                            f"{requirement.specifier or ''}: {advisory.summary}"
+                        ),
+                        severity=advisory.severity,
+                        confidence=Confidence.HIGH if pinned else Confidence.MEDIUM,
+                        span=requirement.span,
+                        metadata={
+                            "advisory": advisory.id,
+                            "package": advisory.package,
+                            "specifier": requirement.specifier,
+                        },
+                    )
+                )
+        return findings

coretrace_python/bundled/models/cli/cli_models.py

@@ -0,0 +1,35 @@
+"""Command-line entry points: the parameters of click and Typer commands are argv input."""
+
+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 EntryPoint, Model, TaintKind
+
+# A command-line tool is expected to open the paths it is given: argv input carries every
+# kind but PATH.
+ARGV_KINDS = TaintKind.ALL & ~TaintKind.PATH
+
+_COMMANDS = (
+    "click.command",
+    "click.group",
+    "click.command.command",
+    "click.group.command",
+    "click.group.group",
+    "click.Group.command",
+    "typer.Typer.command",
+    "typer.Typer.callback",
+)
+
+
+def _sym(path: str) -> SymbolId:
+    return SymbolId(f"python.{path}")
+
+
+class CliModels(ModelPlugin):
+    name: ClassVar[str] = "cli-models"
+    models: ClassVar[tuple[Model, ...]] = tuple(
+        EntryPoint(_sym(command), "argv", ARGV_KINDS) for command in _COMMANDS
+    )

coretrace_python/bundled/models/cli/plugin.toml

@@ -0,0 +1,9 @@
+name = "cli-models"
+version = "1.0.0"
+plugin_api = ">=1,<2"
+requires = []
+provides = ["model.cli-sources"]
+
+[entrypoint]
+module = "cli_models"
+class = "CliModels"

coretrace_python/bundled/models/credentials/credential_models.py

@@ -0,0 +1,43 @@
+"""Credential models: password-named parameters are credentials, password hashing clears
+them, and the database write sinks of the other model plugins also carry the
+``CREDENTIAL`` kind, so a credential stored unhashed is a flow."""
+
+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, NamedParameter, Sanitizer, TaintKind
+
+_HASHERS = (
+    "hashlib.pbkdf2_hmac",
+    "hashlib.scrypt",
+    "hashlib.sha256",
+    "hashlib.sha512",
+    "hashlib.sha3_256",
+    "hashlib.blake2b",
+    "hashlib.new",
+    "bcrypt.hashpw",
+    "bcrypt.kdf",
+    "argon2.PasswordHasher.hash",
+    "argon2.low_level.hash_secret",
+    "werkzeug.security.generate_password_hash",
+    "passlib.hash.pbkdf2_sha256.hash",
+    "passlib.hash.bcrypt.hash",
+    "passlib.hash.argon2.hash",
+    "passlib.context.CryptContext.hash",
+    "django.contrib.auth.hashers.make_password",
+)
+
+
+def _sym(path: str) -> SymbolId:
+    return SymbolId(f"python.{path}")
+
+
+class CredentialModels(ModelPlugin):
+    name: ClassVar[str] = "credential-models"
+    models: ClassVar[tuple[Model, ...]] = (
+        NamedParameter(r"(?i)^(password|passwd|pwd|new_password|plain_password|secret)$", "credential", TaintKind.CREDENTIAL),
+        *(Sanitizer(_sym(hasher), TaintKind.CREDENTIAL) for hasher in _HASHERS),
+    )

coretrace_python/bundled/models/credentials/plugin.toml

@@ -0,0 +1,9 @@
+name = "credential-models"
+version = "1.0.0"
+plugin_api = ">=1,<2"
+requires = []
+provides = ["model.credential-sources", "model.credential-sinks"]
+
+[entrypoint]
+module = "credential_models"
+class = "CredentialModels"

coretrace_python/bundled/models/django/django_models.py

@@ -0,0 +1,123 @@
+"""Django security models: typed requests, views, decorators, ORM and HTML sinks.
+
+Django views are undecorated, so HTTP input comes from three generic mechanisms: a
+parameter annotated with a request class, a method of a class-based view, or a view
+decorated by one of Django's or Django REST framework's view decorators. A view with a
+bare ``request`` parameter and none of these is not recognised; URL configurations are
+not read.
+"""
+
+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 (
+    AuthorizationGuard,
+    EntryPoint,
+    Model,
+    RouteRegistrar,
+    Sanitizer,
+    Sink,
+    SuffixSink,
+    TaintKind,
+    TypedParameter,
+)
+
+_REQUEST_CLASSES = (
+    "django.http.HttpRequest",
+    "django.http.request.HttpRequest",
+    "django.core.handlers.wsgi.WSGIRequest",
+    "django.core.handlers.asgi.ASGIRequest",
+    "rest_framework.request.Request",
+)
+
+_VIEW_BASES = (
+    "django.views.View",
+    "django.views.generic.View",
+    "django.views.generic.base.View",
+    "django.views.generic.TemplateView",
+    "django.views.generic.RedirectView",
+    "django.views.generic.ListView",
+    "django.views.generic.DetailView",
+    "django.views.generic.FormView",
+    "django.views.generic.CreateView",
+    "django.views.generic.UpdateView",
+    "django.views.generic.DeleteView",
+    "rest_framework.views.APIView",
+    "rest_framework.generics.GenericAPIView",
+    "rest_framework.viewsets.ViewSet",
+    "rest_framework.viewsets.GenericViewSet",
+    "rest_framework.viewsets.ModelViewSet",
+    "rest_framework.viewsets.ReadOnlyModelViewSet",
+)
+
+_VIEW_DECORATORS = (
+    "django.views.decorators.csrf.csrf_exempt",
+    "django.views.decorators.csrf.csrf_protect",
+    "django.views.decorators.http.require_http_methods",
+    "django.views.decorators.http.require_GET",
+    "django.views.decorators.http.require_POST",
+    "django.views.decorators.http.require_safe",
+    "django.views.decorators.cache.never_cache",
+    "django.views.decorators.cache.cache_page",
+    "django.contrib.auth.decorators.login_required",
+    "django.contrib.auth.decorators.permission_required",
+    "django.contrib.auth.decorators.user_passes_test",
+    "rest_framework.decorators.api_view",
+    "rest_framework.decorators.action",
+)
+
+_ROUTE_REGISTRARS = (
+    "django.urls.path",
+    "django.urls.re_path",
+    "django.conf.urls.url",
+    "rest_framework.routers.DefaultRouter.register",
+    "rest_framework.routers.SimpleRouter.register",
+)
+
+_AUTHORIZATION_DECORATORS = (
+    ("django.contrib.auth.decorators.login_required", "login"),
+    ("django.contrib.auth.decorators.permission_required", "permission"),
+    ("django.contrib.auth.decorators.user_passes_test", "test"),
+    ("django.contrib.admin.views.decorators.staff_member_required", "staff"),
+    ("rest_framework.decorators.permission_classes", "permission"),
+)
+
+
+def _sym(path: str) -> SymbolId:
+    return SymbolId(f"python.{path}")
+
+
+class DjangoModels(ModelPlugin):
+    name: ClassVar[str] = "django-models"
+    models: ClassVar[tuple[Model, ...]] = (
+        *(TypedParameter(_sym(cls), "http") for cls in _REQUEST_CLASSES),
+        *(EntryPoint(_sym(base), "http") for base in _VIEW_BASES),
+        *(EntryPoint(_sym(decorator), "http") for decorator in _VIEW_DECORATORS),
+        Sink(_sym("django.db.connection.cursor.execute"), TaintKind.SQL | TaintKind.CREDENTIAL, ((TaintKind.SQL, (0,)),)),
+        Sink(_sym("django.db.connection.cursor.executemany"), TaintKind.SQL | TaintKind.CREDENTIAL, ((TaintKind.SQL, (0,)),)),
+        Sink(_sym("django.db.models.expressions.RawSQL"), TaintKind.SQL | TaintKind.CREDENTIAL),
+        Sink(_sym("django.db.models.Manager.raw"), TaintKind.SQL | TaintKind.CREDENTIAL),
+        Sink(_sym("django.db.models.QuerySet.raw"), TaintKind.SQL | TaintKind.CREDENTIAL),
+        Sink(_sym("django.db.models.QuerySet.extra"), TaintKind.SQL | TaintKind.CREDENTIAL),
+        Sink(_sym("django.utils.safestring.mark_safe"), TaintKind.HTML),
+        Sink(_sym("django.http.HttpResponse"), TaintKind.HTML),
+        Sink(_sym("django.http.response.HttpResponse"), TaintKind.HTML),
+        Sink(_sym("django.template.Template"), TaintKind.HTML),
+        Sink(_sym("django.http.FileResponse"), TaintKind.PATH),
+        Sink(_sym("django.shortcuts.redirect"), TaintKind.REDIRECT),
+        Sink(_sym("django.http.HttpResponseRedirect"), TaintKind.REDIRECT),
+        Sink(_sym("django.http.HttpResponsePermanentRedirect"), TaintKind.REDIRECT),
+        Sanitizer(_sym("django.utils.html.escape"), TaintKind.HTML),
+        Sanitizer(_sym("django.utils.html.conditional_escape"), TaintKind.HTML),
+        *(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.
+        *(RouteRegistrar(_sym(registrar), 1, "http") for registrar in _ROUTE_REGISTRARS),
+        # ``Model.objects.raw(sql)`` for any model class: the statement is the first
+        # argument, its parameters are not.
+        SuffixSink("objects.raw", TaintKind.SQL, ((TaintKind.SQL, (0,)),)),
+        SuffixSink("objects.extra", TaintKind.SQL),
+    )

coretrace_python/bundled/models/django/plugin.toml

@@ -0,0 +1,9 @@
+name = "django-models"
+version = "1.0.0"
+plugin_api = ">=1,<2"
+requires = []
+provides = ["model.http-sources", "model.django-views", "model.sql-sinks"]
+
+[entrypoint]
+module = "django_models"
+class = "DjangoModels"

coretrace_python/bundled/models/fastapi/fastapi_models.py

@@ -0,0 +1,29 @@
+"""FastAPI security models: route handlers and response sinks."""
+
+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 EntryPoint, Model, RouteRegistrar, Sink, TaintKind
+
+_METHODS = ("get", "post", "put", "delete", "patch", "options", "head", "api_route", "websocket")
+
+
+def _sym(path: str) -> SymbolId:
+    return SymbolId(f"python.{path}")
+
+
+class FastApiModels(ModelPlugin):
+    name: ClassVar[str] = "fastapi-models"
+    models: ClassVar[tuple[Model, ...]] = (
+        *(EntryPoint(_sym(f"fastapi.FastAPI.{method}"), "http") for method in _METHODS),
+        *(EntryPoint(_sym(f"fastapi.APIRouter.{method}"), "http") for method in _METHODS),
+        RouteRegistrar(_sym("fastapi.FastAPI.add_api_route"), 1, "http"),
+        RouteRegistrar(_sym("fastapi.APIRouter.add_api_route"), 1, "http"),
+        Sink(_sym("fastapi.responses.HTMLResponse"), TaintKind.HTML),
+        Sink(_sym("fastapi.responses.FileResponse"), TaintKind.PATH),
+        Sink(_sym("fastapi.responses.RedirectResponse"), TaintKind.REDIRECT),
+        Sink(_sym("starlette.responses.RedirectResponse"), TaintKind.REDIRECT),
+    )

coretrace_python/bundled/models/fastapi/plugin.toml

@@ -0,0 +1,9 @@
+name = "fastapi-models"
+version = "1.0.0"
+plugin_api = ">=1,<2"
+requires = []
+provides = ["model.http-sources", "model.fastapi-routes"]
+
+[entrypoint]
+module = "fastapi_models"
+class = "FastApiModels"

coretrace_python/bundled/models/flask/flask_models.py

@@ -0,0 +1,53 @@
+"""Flask security models: HTTP sources, route handlers, HTML sinks and escaping."""
+
+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 (
+    AuthorizationGuard,
+    EntryPoint,
+    Model,
+    RouteRegistrar,
+    Sanitizer,
+    Sink,
+    Source,
+    TaintKind,
+)
+
+_REQUEST_ATTRIBUTES = (
+    "args", "form", "values", "json", "data", "cookies", "headers", "files",
+    "get_json", "get_data", "url", "full_path", "path", "query_string", "stream",
+)
+
+
+def _sym(path: str) -> SymbolId:
+    return SymbolId(f"python.{path}")
+
+
+class FlaskModels(ModelPlugin):
+    name: ClassVar[str] = "flask-models"
+    models: ClassVar[tuple[Model, ...]] = (
+        *(Source(_sym(f"flask.request.{attribute}"), "http") for attribute in _REQUEST_ATTRIBUTES),
+        EntryPoint(_sym("flask.Flask.route"), "http"),
+        EntryPoint(_sym("flask.Blueprint.route"), "http"),
+        RouteRegistrar(_sym("flask.Flask.add_url_rule"), 2, "http", keyword="view_func"),
+        RouteRegistrar(_sym("flask.Blueprint.add_url_rule"), 2, "http", keyword="view_func"),
+        Sink(_sym("flask.render_template_string"), TaintKind.HTML),
+        Sink(_sym("flask.make_response"), TaintKind.HTML),
+        Sink(_sym("flask.Response"), TaintKind.HTML),
+        Sink(_sym("flask.Markup"), TaintKind.HTML),
+        Sink(_sym("flask.send_file"), TaintKind.PATH),
+        Sink(_sym("flask.redirect"), TaintKind.REDIRECT),
+        Sink(_sym("werkzeug.utils.redirect"), TaintKind.REDIRECT),
+        Sink(_sym("flask.request.files.save"), TaintKind.PATH),
+        Sanitizer(_sym("werkzeug.utils.secure_filename"), TaintKind.PATH),
+        Sanitizer(_sym("flask.escape"), TaintKind.HTML),
+        Sanitizer(_sym("markupsafe.escape"), TaintKind.HTML),
+        AuthorizationGuard(_sym("flask_login.login_required"), "login"),
+        AuthorizationGuard(_sym("flask_login.fresh_login_required"), "login"),
+        AuthorizationGuard(_sym("flask_login.current_user.is_authenticated"), "login"),
+        AuthorizationGuard(_sym("flask.session"), "session"),
+    )

coretrace_python/bundled/models/flask/plugin.toml

@@ -0,0 +1,9 @@
+name = "flask-models"
+version = "1.0.0"
+plugin_api = ">=1,<2"
+requires = []
+provides = ["model.http-sources", "model.flask-routes"]
+
+[entrypoint]
+module = "flask_models"
+class = "FlaskModels"

coretrace_python/bundled/models/http_clients/http_client_models.py

@@ -0,0 +1,43 @@
+"""Requests and httpx models: every request function is a SSRF sink, and what it returns
+is an ``http-response`` source, so data fetched from a remote server is untrusted."""
+
+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",
+)
+
+_REQUEST_FUNCTIONS = (
+    *(f"{caller}.{method}" for caller in _CALLERS for method in _METHODS),
+    "requests.Session.send",
+    "httpx.stream",
+    "httpx.Client.stream",
+    "httpx.AsyncClient.stream",
+    "httpx.Client.send",
+    "httpx.AsyncClient.send",
+)
+
+
+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) for function in _REQUEST_FUNCTIONS),
+        *(Source(_sym(function), "http-response") for function in _REQUEST_FUNCTIONS),
+    )

coretrace_python/bundled/models/http_clients/plugin.toml

@@ -0,0 +1,9 @@
+name = "http-client-models"
+version = "1.0.0"
+plugin_api = ">=1,<2"
+requires = []
+provides = ["model.ssrf-sinks", "model.http-response-sources"]
+
+[entrypoint]
+module = "http_client_models"
+class = "HttpClientModels"

coretrace_python/bundled/models/python_stdlib/plugin.toml

@@ -0,0 +1,9 @@
+name = "python-stdlib-models"
+version = "1.0.0"
+plugin_api = ">=1,<2"
+requires = []
+provides = ["model.python-stdlib"]
+
+[entrypoint]
+module = "python_stdlib"
+class = "PythonStdlibModels"