PyPI 上的 agent-framework 1.26.1–1.26.2 含 .pth 憑證竊取程式,需隔離受影響環境
PyPI agent-framework 1.26.1–1.26.2 .pth credential stealer creates startup risk; audit and isolate affected environments.
PyPI 上的 agent-framework 1.26.1 和 1.26.2 被植入 .pth 憑證竊取程式,Python 啟動時即會執行,無須匯入套件。1.26.2 在 1.26.1 下架後 33 分鐘重新上架,並以改名檔案承載相同 payload;1.26.0 是最後已知乾淨版本。
Executive Overview and the 33-Minute Compromise Timeline
Two consecutive PyPI releases of agent-framework—versions 1.26.1 and 1.26.2—shipped a credential stealer embedded in a .pth file, turning routine package installation into an immediate execution event with no import required. Version 1.26.0 remains the last known clean release. After 1.26.1 was pulled, 1.26.2 appeared on PyPI just 33 minutes later carrying the same malicious payload under renamed files. For teams running automated CI/CD builds or agentic AI workers that resolve floating dependencies, a 33-minute turnaround is wide enough to pull poisoned artifacts into build runners, container layers, and live runtime environments before human operators even notice a yank.
Traditional supply-chain defenses assume a two-stage barrier: first a package must be installed, and second application code must actually import and call it. A .pth file inside site-packages collapses those two stages into one. When Python initializes its interpreter, its startup path-configuration machinery (site.py) scans .pth files in site-packages directories. Any line starting with import is parsed and passed directly to exec() during interpreter boot. In practical terms, the moment a CI job runs pip install and a subsequent step invokes python—even python -m pytest, a health check, or a container entrypoint that never touches agent-framework—the interpreter evaluates that startup hook in memory, reads environment variables, cloud metadata, and local secrets from the process address space and filesystem, and transmits them outbound.
Rapid re-compromise within 33 minutes points directly to an uncontained publisher identity or build pipeline rather than a one-off account slip. When a maintainer token, Trusted Publisher workflow, or build host is compromised, rotating only a password or deleting a single release leaves the underlying signing or upload path intact. Attackers simply re-trigger the build or upload pipeline with altered internal file names to evade signature or filename checks while keeping the payload behavior identical. Every minute that credential remains valid inside a compromised build or release flow expands the blast radius: every downstream build that resolves 1.26.1 or 1.26.2 pulls the stealer, exfiltrates runner secrets, and compounds regulatory, contractual, and incident-response exposure across every customer environment that ingests the artifact.
Edge cases matter here because naive cleanup misses lingering execution paths. Even if a team blocks 1.26.1 and 1.26.2 in PyPI mirrors, pre-built container images, cached wheel layers, virtual environments created during the 33-minute window, and agentic sandboxes that install tools on the fly still hold the written .pth file on disk. Conversely, if a build pipeline only installs dependencies and exits before invoking Python—for example, a multi-stage Docker build where pip install runs in a builder stage and only copied artifacts move forward—the .pth code does not execute during that pip call itself, though any later Python invocation inside that environment will trigger it.
| Stage / Window | Event & Mechanism | Operational & Governance Consequence |
| Baseline (1.26.0) | Last clean release prior to the compromise chain; standard site-packages layout with no malicious .pth hook. |
Safe pinning target for emergency containment while provenance is verified. |
| Release 1.26.1 & Yank | Malicious .pth payload published, then pulled; CI/CD runners and local caches that already fetched 1.26.1 retain the file on disk. |
Pulling a version removes new downloads, not already-materialized environments or active runner secrets. |
| +33 Minutes (1.26.2) | Same credential-stealing payload re-uploaded under different file names; floating or unpinned resolvers pull the new release automatically. | Proves active upstream/release control or token exposure; shortens detection-to-infection window to minutes. |
| Interpreter Startup |
site.py reads .pth during Python initialization and executes import ... lines via exec() before app code runs. |
Bypasses import-gating and static code review focused on application modules; exposes runner credentials immediately. |
To contain this class of incident, organizations have three primary levers: (1) immediate environment isolation plus hard pinning to 1.26.0 with hash/artifact verification, (2) relying solely on PyPI version yanks or package blocklists, or (3) waiting for upstream maintainer remediation before touching affected runners. Hard pinning to 1.26.0 combined with isolating and rotating credentials on any environment that touched 1.26.1 or 1.26.2 is the optimal choice because it immediately breaks floating-dependency re-infection while treating already-executed builds as compromised. Relying on PyPI yanks fails whenever builds use local caches, mirrors, or pre-built images, and waiting for upstream fixes fails because the 33-minute re-compromise window shows the attacker can ship new versions faster than manual review cycles.
A common mistake is assuming that because no code imports agent-framework, the package cannot run during a build or test step. In Python, site.py loads .pth files unconditionally during standard interpreter startup (unless disabled via -S or isolated flags), so any test runner, linter written in Python, or helper script executes the hook automatically. Another frequent error is rotating only the PyPI or deployment token without rotating the runtime secrets—CI cloud roles, API keys, and SSH/signing keys—that sat in environment variables or disk when 1.26.1 or 1.26.2 ran. Use this rule to choose your response: if a build, container, or host installed or ran agent-framework 1.26.1 or 1.26.2, isolate the environment and rotate exposed credentials first; if you are building or deploying downstream, pin strictly to 1.26.0 and verify artifact hashes before allowing Python to start.
Technical Anatomy of the .pth Credential Stealer and Blast Radius
When a Python package like agent-framework ships a malicious .pth file in 1.26.1 and 1.26.2 (after clean release 1.26.0), the compromise collapses the traditional two-stage boundary between installation and execution. Standard supply-chain reviews assume code inside a dependency runs only when application code executes an explicit import. A .pth hook breaks that assumption by turning interpreter initialization itself into an execution trigger.
Interpreter Boot Mechanics and Stage Collapse
During standard Python startup, the standard library's site module initializes import paths and scans site-packages directories for files ending in .pth. In normal operation, site.py reads each non-comment line and appends valid filesystem paths to sys.path. However, when a line begins with import (such as import agent_framework_meta in 1.26.1 or import af_runtime_diag in 1.26.2), site.py passes that line directly to exec() during interpreter bootstrap.
That single design behavior creates a direct causal chain from installation to payload execution:
- Impact: A wheel containing a .pth startup hook is unpacked into site-packages during pip install or dependency resolution.
- Internal process: On the very next Python process launch, site.py parses the .pth file before user application modules load, executing the import statement via exec(), which loads the attacker's module into memory and spawns a detached child process or background thread (guarded by a sentinel environment check such as _AF_TEL to avoid re-entrant loops).
- Observable effect: Running python, pytest, linters, or even administrative commands like pip list inside that environment triggers credential collection and outbound HTTPS POST exfiltration even if no file in the repository ever imports agent-framework.
Edge cases determine whether a build or container actually fires the hook. A multi-stage container build that installs packages in a builder stage and copies only selected artifacts into a runtime image that never invokes Python inside the tainted layer does not execute the hook during the copy step itself. Conversely, any build step, test runner, pre-commit hook, or health check that boots Python inside an environment containing the .pth file—or runs pip uninstall before removing the .pth file—triggers interpreter initialization and executes the payload.
Targeted Secrets and Environment Data
Because the payload runs inside the live security context of whatever host, container, or runner boots Python, it harvests credentials across four overlapping layers rather than a single config file:
- Process and sibling environment variables: The collector scans current environment variables matching secret and cloud patterns (such as tokens, keys, secrets, passwords, and provider prefixes) and also reads /proc/[pid]/environ across up to 300 accessible processes, allowing a single compromised process on a shared or long-lived runner to read secrets belonging to concurrent or neighboring jobs.
- On-disk credential and configuration stores: It reads small credential and config files (such as files under 256 KB, capped in count) across developer and agent paths—including Azure CLI state, package-manager and Git credential files, Docker configs, .env files, and CI agent credential files—giving attackers persistent or long-lived keys.
- Cloud instance and managed identity endpoints: By querying local metadata and identity endpoints (such as Azure IMDS), the hook extracts short-lived cloud access tokens bound to the underlying compute role.
- CI/CD OIDC and pipeline tokens: Inside build agents (such as Azure DevOps pipelines and GitHub Actions runners), the stealer leverages pipeline identity endpoints and tokens to request or capture OIDC and build tokens, turning a build step into cloud control-plane access.
Collected fields are serialized into JSON, compressed, Base64-encoded, and transmitted over HTTPS to an external webhook endpoint. Because the metapackage still pulls in the legitimate core dependency (such as agent-framework-core), normal framework functionality continues working, masking the theft behind routine build and runtime logs.
Blast Radius Across Developers, CI/CD, and Enterprises
The blast radius widens sharply when 1.26.1 is pulled, yanked, and followed 33 minutes later by 1.26.2 with renamed files. Automated CI/CD jobs, floating version constraints, and autonomous agentic workflows that install or refresh packages on the fly can pull a compromised release within minutes of publication—before human triage or signature blocklists catch up.
In enterprise environments, a single infected CI runner or shared build VM acts as a credential concentrator. That single host frequently holds deployment keys, cloud OIDC privileges, registry credentials, and environment secrets for multiple repositories or teams at once. Once those tokens leave the network via outbound HTTPS, the risk shifts from a localized package bug to unauthorized cloud API calls, lateral movement across environments, data exposure, contractual breach notifications, and regulatory reporting obligations.
Containment Dominance and Decision Rules
Comparing containment options by effectiveness shows why passive or partial measures fail against a 33-minute re-compromise window:
- Waiting for upstream package removal or relying on filename/hash blocklists: Ineffective as a primary defense because attackers can re-publish under new version numbers or renamed modules in minutes, and blocklists fail once a wheel is already cached in local mirrors, pip caches, or container layers.
- Rotating only PyPI or repository deploy credentials: Insufficient because the stealer harvests runtime environment secrets, cloud metadata/OIDC tokens, and local credential files—leaving cloud IAM roles, API keys, and service principals active even after publisher access is cut.
- Isolating touched environments, rotating all exposed credentials, and pinning to 1.26.0 with verified hashes: This is the optimal strategy because it severs active attacker use of stolen runtime/CI secrets, eliminates re-execution from cached artifacts, and locks builds to a known-clean baseline.
Even the optimal containment strategy breaks down under two conditions: if teams inspect or uninstall inside a suspect environment by invoking Python or pip before isolating the host or removing the .pth file (which triggers the startup hook again), or if organizations fail to audit cloud and OIDC logs for tokens already minted and exfiltrated during the active window.
Decision rule: If a host, container, or CI runner installed or ran agent-framework 1.26.1 or 1.26.2, isolate the environment and rotate every secret and cloud/OIDC credential accessible to it first; if an environment has not touched either version, pin downstream builds to 1.26.0 with strict hash verification before executing Python.
Five Exposure Scenarios: Legal, Regulatory, Contractual, and Incident-Response Impacts
When agent-framework 1.26.1 shipped a credential stealer inside a .pth file, got pulled, and reappeared 33 minutes later as 1.26.2 with renamed internal modules after clean release 1.26.0, the failure mode shifted from a routine package bug to an active supply-chain breach. Because Python's site.py reads .pth files during interpreter startup and passes lines starting with import directly to exec(), any build step, test runner, or agentic worker that boots Python in a tainted site-packages directory runs the payload before application code ever loads. The mechanism of risk is straightforward: automated installers and floating dependency resolvers pull the new wheel into runner or host storage, the next interpreter launch reads /proc/[pid]/environ, local credential files, or cloud metadata/OIDC tokens, serializes and compresses them into Base64, and posts them over HTTPS while normal functionality continues via core dependencies.
Relying on PyPI yanks or filename blocklists fails here because re-publishing took 33 minutes and local caches, mirrors, and container layers already hold tainted artifacts; rotating only PyPI or deploy tokens fails because stolen runtime environment variables, cloud identity tokens, and local secrets remain valid until rotated. The optimal response is to isolate suspect hosts, runners, and containers before invoking Python, rotate every exposed runtime, CI, and cloud credential, and pin downstream builds to 1.26.0 with verified hashes. This strategy stops working if an operator runs Python or pip inside the tainted environment prior to isolation (which re-triggers site.py) or skips cloud and OIDC audit logs (which leaves already-minted tokens unrevoked). A common choice error is assuming an unimported package is inert: running pytest, linters, or pip uninstall boots the interpreter and executes the hook. Decision rule: if an environment installed or executed 1.26.1 or 1.26.2, isolate it first and rotate all accessible credentials; if untouched, pin downstream builds to 1.26.0 with hash verification before launching Python.
1. Open-Source and Package Maintainers: Compromised Release Pipeline and Attribution
A maintainer or release team discovers that two consecutive releases, 1.26.1 and 1.26.2, went out within 33 minutes carrying the same stealer under different module names while 1.26.0 was clean. Because a second upload happened so fast after a yank, the causal chain points to an active publisher token, Trusted Publisher workflow, or build host compromise rather than an isolated typo: the attacker retained valid upload credentials or runner access, modified or injected the .pth hook during packaging, and pushed a fresh artifact that bypassed filename checks.
- Compliance and governance duties: If the package is stewarded under a corporate entity or commercial support program, internal security governance and vulnerability disclosure commitments require rapid integrity verification of the build pipeline, audit logging of CI/OIDC identity exchanges, and transparent advisory notices identifying 1.26.1 and 1.26.2 as compromised and 1.26.0 as the last clean baseline.
- Breach notification obligations: Direct notification duties depend on contractual and statutory relationships; where the maintainer operates under commercial terms or handles regulated telemetry/customer data on build infrastructure, compromised build credentials that exposed secrets or signed artifacts can trigger customer and regulator notice duties under applicable breach laws.
- SLA and contractual liabilities: Commercial support agreements, enterprise indemnification clauses, or co-maintained ecosystem SLAs face friction when an upstream release introduces malware, especially if release signing keys or build runners were exposed and allowed downstream consumers to pull trojanized wheels.
- Containment priorities: Freeze automated publishing pipelines, revoke and rotate all PyPI tokens, OIDC trust relationships, SSH/signing keys, and build-host secrets, audit build logs for unauthorized pushes, and warn consumers not to rely solely on yanks or module names.
2. Downstream Consumers Using Floating Dependencies and CI/CD
An engineering team uses unpinned or range constraints in pyproject.toml or requirements files so CI/CD runners resolve fresh packages on every pull request or nightly build. During the active window, a runner resolves 1.26.1 or 1.26.2, unpacks the .pth into site-packages, and then runs python -m pytest or a build script: site.py executes the hook at interpreter startup, reading runner environment variables, /proc environments across accessible PIDs, and local config files and posting them outbound over HTTPS.
- Compliance duties: Software supply-chain controls and audit frameworks (such as SOC 2, ISO 27001, or internal SDLC policies) require evidence that third-party dependencies are verified, pinned or lock-controlled, and audited when a known malicious release enters the build chain.
- Breach notification obligations: If runner secrets included production database credentials, cloud keys, or customer data access tokens that were exfiltrated, the organization may face statutory data-breach notification timelines and customer notice obligations once unauthorized access to regulated data is confirmed or reasonably likely.
- SLA and contractual liabilities: Downstream SaaS or software vendors that ship or run compromised builds risk breaching customer security addenda, uptime/security SLAs, or data-protection warranties if stolen CI credentials allow lateral access into production environments.
- Containment priorities: Immediately isolate affected CI runners and build caches, rotate every secret, token, SSH key, and cloud credential exposed to those runners, purge tainted wheels/caches, and pin builds to 1.26.0 with hash checks before running any Python command.
3. Shared Build Runners: Cross-Repository Secret Concentration
Multiple repositories, teams, and deployment pipelines share persistent or long-lived CI/CD build runners. When one job pulls 1.26.1 or 1.26.2 and boots Python, the .pth payload scans accessible process environments and on-disk credential files on that runner: shared or lingering secrets from neighboring jobs, cached tokens, or host-level credentials get bundled into the compressed Base64 HTTPS payload, turning a single package pull into a multi-project exposure.
- Compliance duties: Segregation-of-duties and environment-isolation controls are directly tested when multi-tenant or shared runners leak cross-project secrets; auditors will examine whether runner ephemeralization, secret scoping, and log retention failed to contain blast radius.
- Breach notification obligations: Because shared runners aggregate secrets across business units or client workloads, exposure of another team's or customer's credentials expands the scope of forensic assessment and potential downstream or regulatory breach notifications.
- SLA and contractual liabilities: Internal chargeback agreements and external client contracts tied to dedicated or isolated build environments can be breached if shared runner state allowed cross-tenant secret exposure.
- Containment priorities: Take shared runner pools offline, destroy and rebuild runner images rather than cleaning in place, rotate all secrets across every repository and environment that ever touched those runners, and audit cloud API and OIDC logs for anomalous calls during the compromise window.
4. Agentic AI and Dynamic Tool-Installation Workflows
An autonomous agent or dynamic tool-runner installs or upgrades packages on demand inside a live runtime environment and immediately executes Python code to run tools or health checks. Because the stealer lives in a .pth file rather than an imported module, the agent never has to import agent-framework; the very next Python launch triggers site.py to run the hook in memory or via a detached worker/thread (guarded by a sentinel environment variable like _AF_TEL to avoid re-entrant loops), harvesting environment variables, local credential files, and cloud metadata/IMDS tokens.
- Compliance duties: AI governance, runtime security policies, and regulated industry controls require strict boundaries on autonomous code/package execution and credential access; dynamic unvetted package installation with live cloud metadata access creates clear compliance gaps.
- Breach notification obligations: Cloud metadata/IMDS tokens and agent credentials frequently carry broad cloud permissions; if an attacker uses stolen short-lived or long-lived credentials to access sensitive data stores, breach notification obligations under privacy and sector regulations can be triggered.
- SLA and contractual liabilities: Enterprises offering agentic workflows under service contracts face liability if autonomous tool installation compromises customer data, violates data-residency/security commitments, or causes service disruption during emergency isolation.
- Containment priorities: Quarantine live agent sandboxes and compute instances immediately, revoke cloud IAM/IMDS sessions and rotate all accessible agent/environment credentials, block dynamic unpinned package installs in runtime sandboxes, and pin approved environments to 1.26.0 with verified hashes.
5. Enterprise Production and Container Fleets: Edge Cases and Lateral Risk
An enterprise operates multi-stage container builds and production Python services alongside developer and operator workstations. A multi-stage Docker build that installs 1.26.1 or 1.26.2 in a builder stage and copies artifacts without running Python in that tainted layer avoids firing the hook during the copy step—but any subsequent Python invocation inside an environment holding the .pth file (including health checks, diagnostic scripts, or even running pip uninstall before deleting the .pth file) triggers site.py and can exfiltrate cloud metadata, OIDC tokens, and local files.
- Compliance duties: Enterprise risk management, regulatory reporting, and audit trails require documenting affected container images, runtime environments, and rotated credentials, as well as proving that residual .pth files and cached layers were removed without triggering execution.
- Breach notification obligations: Production environments carry the highest likelihood of touching customer records, regulated data, or core infrastructure keys; confirmed exfiltration of production or cloud control-plane credentials requires rapid legal and security evaluation for regulatory and customer notifications.
- SLA and contractual liabilities: Production incidents directly implicate availability SLAs, security commitments, and enterprise customer agreements, requiring coordinated incident response, forensic preservation, and customer communications where data exposure occurred.
- Containment priorities: Isolate affected containers, VMs, and developer/operator endpoints, rotate all runtime, cloud IMDS/OIDC, and local credentials, remove tainted images and caches so Python is not launched inside unisolated tainted layers, and deploy clean builds pinned to 1.26.0 with verified hashes while reviewing cloud and OIDC audit logs.
Remediation Playbook and Supply-Chain Hardening Priorities
When a package like agent-framework ships a malicious .pth file in consecutive releases (1.26.1 and 1.26.2) within 33 minutes of clean version 1.26.0, standard post-mortem habits break down. A .pth file placed inside site-packages is processed by Python's site module during interpreter initialization before application code runs. Even if no module ever imports agent-framework, starting a Python interpreter process—such as a test runner, linter, health probe, or agent worker—triggers site.py to read and execute embedded lines or exec() calls, reading environment variables, /proc/[pid]/environ where accessible, local credential files, or cloud metadata and OIDC tokens, encoding them into Base64, and sending them over HTTPS.
The 33-minute re-upload window with renamed files turns reactive defenses into dead ends. If a CI/CD pipeline or autonomous agent has floating version constraints and pulls 1.26.1 or 1.26.2 before a registry yank propagates—or pulls 1.26.2 right after 1.26.1 is yanked—the malicious artifact lands on disk, inside build caches, or in container layers. Every subsequent interpreter launch in that environment executes the payload, turning routine automation into silent credential theft and creating acute contractual, statutory breach-notification, and SLA exposure across engineering, security, and legal teams.
Immediate Triage, Isolation, and Revocation
The primary failure mode during early response is invoking Python inside a suspected environment to inspect state or clean up packages. Launching python, pytest, linters, or even pip uninstall inside an unisolated site-packages directory causes site.py to load the .pth file first, firing the credential stealer again and potentially using a sentinel variable (such as _AF_TEL) only to avoid re-entrant loops within the same process tree while still exfiltrating secrets. Similarly, rotating only PyPI or deployment tokens fails because runtime secrets, cloud/OIDC tokens, and local files already read by the process remain valid until revoked or expired.
- Quarantine before execution: Sever network egress and freeze or snapshot suspect CI runners, ephemeral sandboxes, containers, VMs, and developer workstations without running Python binaries inside them. For shared build runners, take the pool offline immediately because persistent or long-lived runners aggregate secrets across repositories and jobs, allowing a single interpreter boot to bundle cross-project credentials into one HTTPS exfiltration call.
- Clean or rebuild without booting Python: In multi-stage Docker builds, installing 1.26.1 or 1.26.2 in a builder stage and copying files without running Python avoids triggering the hook during the copy step, but any later Python invocation in a tainted layer fires site.py. Destroy and rebuild tainted container images and runner images from clean bases rather than cleaning in place, and purge local wheel caches, mirrors, and layer caches using non-Python tooling.
- Rotate broad credentials and audit logs: Revoke and rotate all accessible runtime secrets, CI/CD variables, SSH keys, local config secrets, cloud IAM/IMDS sessions, and OIDC trust/token exchanges. For package maintainers, freeze automated publishing and rotate PyPI tokens, OIDC publishers, signing keys, and build-host secrets because a 33-minute re-upload with renamed files points to an active publisher token, OIDC workflow, or build-host compromise. Audit cloud API and OIDC logs across the exposure window to detect token abuse and assess statutory or contractual breach-notification duties.
- Establish clean baselines: Where 1.26.1 or 1.26.2 was never installed or executed, pin 1.26.0 with verified hashes and clear tainted caches before launching Python.
Decision Rule for Immediate Containment
If 1.26.1 or 1.26.2 was installed or executed: isolate the host, runner, container, or sandbox first without running Python, rotate all accessible runtime, CI, cloud, OIDC, SSH, and local credentials, and audit cloud/OIDC logs for unauthorized calls. If untouched: pin downstream builds to 1.26.0 with verified hashes and purge or bypass tainted caches before starting Python.
Longer-Term PyPI and CI/CD Hardening Priorities
Preventing repeat exposure requires closing the gap between upstream package publication and downstream interpreter execution. Relying on registry yanks, filename blocklists, or module-name denylists fails mechanically: yanks do not remove artifacts already cached in CI runners, mirrors, or container layers, and attackers rename modules across rapid re-uploads while keeping the .pth startup trigger intact.
Comparing Defense Controls by Effectiveness
- Cryptographic hash pinning plus ephemeral, isolated execution: Cryptographic hashes bind exact artifact bytes to lockfiles so neither a yanked version nor a 33-minute re-upload with different file names can substitute for 1.26.0. Pairing hash-pinned installs with ephemeral runners, network-restricted agent sandboxes, and short-lived scoped credentials limits what an unexpected startup hook can read or reach even if a future compromised release slips through. This is the optimal solution because it blocks unverified artifact substitution at install time and shrinks credential blast radius at runtime. It stops working when teams bypass lockfiles for emergency hotfixes, use mutable or unpinned ranges in dynamic agent tool-installers, or grant runtime sandboxes broad IMDS/OIDC permissions and persistent state.
- Registry yanks and filename/module blocklists: Yanks stop new uncached pulls from PyPI after discovery, and blocklists catch known names, but both fail under rapid re-publication and naming churn. A 33-minute turnaround outpaces manual or reactive blocklists, and local caches or already-built images bypass the registry completely.
- In-place cleanup scripts (such as running pip uninstall or Python audits): Invoking Python to uninstall or inspect a suspect environment executes site.py before cleanup completes, turning remediation itself into another execution event.
Governance and Engineering Alignment
Engineering leads should enforce strict hash pinning and lockfile verification in CI/CD, eliminate floating dependency upgrades in live agentic runtimes, and replace persistent shared build runners with short-lived, isolated runners where secrets are scoped strictly to the active job. Security teams should pair OIDC/IMDS log monitoring with automated artifact-hash checks and pre-flight static inspection of .pth entries inside wheels before promotion. Legal and compliance stakeholders should align incident-response playbooks with these technical controls—documenting pin enforcement, runner isolation, image rebuilds, credential rotations, and OIDC/cloud audit findings—so evidence is ready to evaluate regulatory reporting, customer notice obligations, SLA commitments, and indemnification terms without delay.
來源:DEV Community · dev.to
