Improving the Security of Containerized Workloads using Transparency and Traceability Services

A cryptographically verified approach to secure Docker container updates in CI/CD pipelines

A secure CI/CD update workflow that combines keyless Cosign signing (OIDC/Fulcio), immutable SHA-256 digest–based image addressing, mandatory pre-deployment signature verification, and freshness controls against rollback attacks is presented, while permitting controlled rollback only to previously verified versions.

Hardware Keystores for AI Agent Signing Workflows: A Zero-Trust MCP Enforcement Architecture

AI agents performing cryptographic operations (signing Git commits, authenticating API calls, issuing certificates) currently store private keys in software-accessible locations: plaintext files, environment variables, or container memory. Any process with sufficient read privileges can extract the raw key material. A recent production incident demonstrated the practical severity: private keys were exfiltrated from a widely deployed framework via email injection in under five minutes. We aim to enforce both key confidentiality and content-aware authorisation for key use. To that end, we replace software-resident keys with hardware-confined keys accessible through a vendor-neutral PKCS#11 interface. A hardware keystore (HSM, TPM, smart card) executes cryptographic operations on-device; the host receives only the result via opaque handles. Hardware confinement is the primary contribution; it is enabled by a surrounding five-layer Zero-Trust enforcement stack comprising session identity (SAGA), scope bounds (Smax), semantic validation (RAV), taint tracking, and the hardware execution boundary. We evaluate against 12 injection scenarios derived from AgentDojo's ImportantInstructionsAttack template (Debenedetti et al., arXiv:2406.13352). We run four LLM models; three follow injections in baseline mode (gpt-oss-120b, Qwen2.5-72B, DeepSeek-V4-Flash, n=192 combined). Baseline Attack Success Rate (ASR): 19.3% [14.3%, 25.4%]; protected ASR: 0% (Wilson 95% CI upper bound 2.0%). Zero false positives across four benign task scenarios.

GuixChain: Enforcing Reproducible Builds and Provenance Integrity for Secure Automotive OTA Pipelines

Ensuring the integrity of automotive software, from source code to deployed binaries, has become critical as vehicles increasingly rely on over-the-air (OTA) updates and complex supply chains. The Uptane framework secures OTA update delivery for automotive systems but does not enforce integrity within the upstream software supply chain, leaving the gap between source commits and deployed artifacts unverified. We present GuixChain, a blockchain-backed reproducible build layer that enforces multi-party consensus before artifacts enter OTA pipelines. GuixChain combines deterministic GNU Guix builds, cryptographic SBOM binding, and Hyperledger Fabric smart contracts. Together, these components ensure that only independently verified, bit-identical binaries are deployed. Evaluation across a consortium representing OEMs, suppliers, and auditors demonstrated reliable reproducibility over 30 build cycles. Fault injection experiments covering four threat categories were fully detected with low latency (1.8–2.4 seconds). The system maintained modest overheads (15–19% CPU, 1.4–3.5.GB memory, 41–60MB disk), with blockchain consensus adding only 2–3 seconds to build verification. Multi-node consensus yielding total build-to-verification time of 30–38 seconds per validator. By enforcing consensus-based reproducibility upstream of Uptane, GuixChain provides a scalable and verifiable supply chain integrity layer, bridging the gap between source-level trust and safe deployment, while remaining compatible with existing automotive OTA infrastructure.

Bit-for-Bit How we built a Sovereign, Reproducible Container Supply Chain for DevGuard

Slice & Dice: Privacy-Preserving Layered Attestation via Active Memory Introspection

: The rapid adoption of dynamic Payload Managers enables portable, platform-agnostic execution across the cloud/edge continuum. However, these complex execution layers, even when embedded within a Trusted Ex-ecution Environment (TEE), significantly expand the attack surface of the Trusted Computing Base (TCB). Existing layered attestation schemes typically combat this using static, load-time measurements of payloads. Yet, recent vulnerabilities demonstrate that static checks are insufficient to prevent attackers from gaining privileged execution rights while avoiding detection. Slice and Dice proposes a layered attestation architecture for 3-layer systems, in which a minimal and highly privileged programmable firmware layer (Layer 0) continuously performs dynamic memory introspection on the untrusted Payload Manager layer (Layer 1). By inspecting ELF segments during execution, the firmware can detect code modifications in real-time. To complete the cycle of Remote Attestation (RA) and provide evidence to an external verifier in a privacy-preserving manner, we couple the introspection mechanism with Zero-Knowledge Proofs (ZKP) utilizing BBS anonymous credentials.

Securing Filesystems for Confidential Computing

Confidential computing protects applications inside Trusted Execution Environments (TEEs), but it leaves storage vulnerable. Even with disk encryption, a malicious cloud provider can roll back, replay, fork, or tamper with disk state, breaking the integrity and freshness guarantees required by stateful applications. Existing solutions either assume trusted storage, incur high overheads, or push integrity logic into applications. We present ShieldFS, a POSIX-compliant filesystem that provides end-to-end integrity and freshness for persistent storage in the confidential-computing threat model without requiring application changes. ShieldFS represents permissible filesystem states using succinct cryptographic commitments, maintained inside TEEs and replicated in a lightweight trusted registry. On-disk data structures, including a write-ahead log and a storage pool, are authenticated using hash chains and an embedded Merkle tree. ShieldFS utilizes transactions and copy-on-write to update persistent filesystem state and commitments atomically. The commitments are verified during reads, ensuring that rollback, replay, and equivocation attacks are detected even when the entire I/O stack is untrusted. We implement the design by extending ZFS, yielding ShieldZFS. Evaluation with standard filesystem benchmarks and real-world workloads shows that ShieldZFS provides strong integrity and freshness guarantees with performance comparable to state-of-the-art filesystems.