WEBVTT

00:00:14.890 --> 00:00:23.021
<v Host>Today we’re looking at how cloud access outages can throw a wrench into software supply chains and why that matters for every business that builds and ships software.

00:00:23.284 --> 00:00:35.401
<v Analyst>When a cloud region goes down or a DNS resolver fails, the controls that rely on cloud-held policy or hosted scanning suddenly disappear, and the pipeline still has to move.

00:00:35.747 --> 00:00:39.668
<v Host>So the first question is, what exactly gets broken when the cloud is unreachable?

00:00:40.042 --> 00:00:54.005
<v Analyst>There are three key failure modes that cascade across the supply chain: identity and authorization, artifact scanning and vulnerability intelligence, and dependency retrieval combined with build reproducibility.

00:00:54.279 --> 00:01:04.233
<v Host>Let’s start with identity. Most teams rely on an identity provider to mint tokens for build runners, pull private packages, and ask a policy engine what’s allowed.

00:01:04.545 --> 00:01:16.628
<v Analyst>When that provider is unreachable, the runner can’t authenticate to the artifact registry, the package feed, or the signing service, and the whole chain loses its ability to prove who is doing what.

00:01:16.957 --> 00:01:28.094
<v Host>And because Zero Trust treats every actor as untrusted until proven otherwise, losing that identity check isn’t a simple fallback; it’s a hard stop unless you have a local credential.

00:01:28.377 --> 00:01:37.501
<v Analyst>Exactly. The article stresses that you need a fallback approach that doesn’t turn identity into local trust by default, because that would weaken the model.

00:01:37.774 --> 00:01:43.869
<v Host>Moving on to scanning, many teams run vulnerability scans as hosted services that pull data from the cloud.

00:01:44.165 --> 00:01:52.724
<v Analyst>If the scanner can’t reach its data sources, it either stops altogether or falls back to an outdated signature that the pipeline can’t trust.

00:01:53.032 --> 00:02:03.871
<v Host>But Zero Trust doesn’t treat the absence of a scan as a pass-it requires evidence that the scan was performed, or a clear policy that says the artifact may be promoted with stale evidence.

00:02:04.166 --> 00:02:13.981
<v Analyst>That means the pipeline must mark the artifact accordingly, indicating whether it was scanned and what data was used, so later steps can enforce the policy.

00:02:14.279 --> 00:02:22.582
<v Host>Now dependency fetching is a real pain point. When the cloud registry is down, teams might be tempted to use a cached copy without verifying freshness.

00:02:22.858 --> 00:02:31.114
<v Analyst>The article warns that this temptation can turn an outage into an integrity incident, because a cached dependency might have been tampered with.

00:02:31.375 --> 00:02:39.072
<v Host>So the recommended practice is to treat every cached package as a potential threat unless it matches a pre-approved digest pinned in a lockfile.

00:02:39.419 --> 00:02:50.149
<v Analyst>And if the lockfile only specifies a version number without the exact hash, the safe option is to fail the build until the mirror is updated or connectivity returns.

00:02:50.436 --> 00:03:01.341
<v Host>All of these scenarios point to the same principle: verification and authorization must work with what’s available locally, and degradation must be explicit, not silent.

00:03:01.643 --> 00:03:11.485
<v Analyst>That’s why the article proposes keeping trust data in a local mirror and updating it whenever you can, so the pipeline never relies on a single point of failure.

00:03:11.754 --> 00:03:21.343
<v Host>Let’s talk about the practical controls that can survive an outage. First, signed allowlists for base images, build tools, and internal artifacts.

00:03:21.661 --> 00:03:31.064
<v Analyst>Those allowlists are stored locally, and you update them periodically when the cloud is reachable; they serve as the baseline that the pipeline uses for every build.

00:03:31.405 --> 00:03:39.805
<v Host>Second, known-good dependency digests pinned in lockfiles. The pipeline verifies each dependency against the expected hash before proceeding.

00:03:40.072 --> 00:03:47.873
<v Analyst>If a dependency can’t be verified, the build fails fast, preventing a malicious or corrupted package from slipping through.

00:03:48.220 --> 00:03:57.261
<v Host>Third, local vulnerability metadata snapshots. Even if the scanner is offline, you can still check artifacts against the most recent known results that you’ve cached.

00:03:57.603 --> 00:04:06.642
<v Analyst>The article stresses that you need an explicit 'as of' timestamp and a policy that decides what release actions are allowed when evidence is stale.

00:04:06.964 --> 00:04:16.757
<v Host>For signing, the article suggests using offline-capable key management, like an HSM-attested device that remains available even when the cloud signing service is down.

00:04:17.045 --> 00:04:26.421
<v Analyst>When a key is used, the pipeline records the key version, so later promotion steps can verify that the signature comes from an approved key set stored locally.

00:04:26.747 --> 00:04:39.220
<v Host>Attestations are another core element. Instead of depending on a remote attestation service, you generate a build attestation locally that captures inputs, environment claims, and artifact digests.

00:04:39.535 --> 00:04:50.460
<v Analyst>That attestation is signed with a key that stays available offline, and it becomes part of the artifact’s metadata, so any downstream step can verify it before promotion.

00:04:50.722 --> 00:04:59.648
<v Host>The article also points out the common mistake of treating scanning and verification as build-time only. Promotion should re-verify what it’s about to deploy.

00:04:59.953 --> 00:05:12.326
<v Analyst>In a staging promotion step, for example, you require that the artifact digest matches the manifest, the signature is valid under an approved public key list, and the build attestation’s signature is valid.

00:05:12.630 --> 00:05:21.072
<v Host>You also need to check that the attestation contains the required claims for that release tier, such as whether it was scanned or whether it’s a staged or production build.

00:05:21.323 --> 00:05:34.434
<v Analyst>The policy can allow different tiers of evidence. During an outage, you might permit promotion to staging if the vulnerability evidence is present but labeled as stale, while requiring fresh evidence for production.

00:05:34.693 --> 00:05:47.062
<v Host>That brings us to the concept of release tiers-Tier 0 for emergency fixes, Tier 1 for staging with labeled evidence freshness limits, and Tier 2 for production that requires fresh evidence or explicit exceptions.

00:05:47.370 --> 00:05:57.330
<v Analyst>By defining these tiers ahead of an outage, teams avoid ad-hoc decisions and keep the trust model consistent even when parts of the cloud degrade differently.

00:05:57.634 --> 00:06:03.152
<v Host>The article also mentions that you can distribute policy as signed documents to the build and release environment.

00:06:03.458 --> 00:06:13.987
<v Analyst>Those signed policy artifacts include rules that map identities to allowed operations, approved build templates, and required evidence types for each promotion step.

00:06:14.271 --> 00:06:23.466
<v Host>The local authorization engine verifies the policy signature before using it, so if the policy distribution is compromised, the offline enforcement remains trustworthy.

00:06:23.785 --> 00:06:34.948
<v Analyst>And if the policy expires and the cloud cannot renew it, the system should default to safer behavior, like disabling production promotion rather than continuing with weaker checks.

00:06:35.262 --> 00:06:41.706
<v Host>Another key point is that evidence must be stored with the artifact so that later stages can retrieve and verify it deterministically.

00:06:41.977 --> 00:06:54.418
<v Analyst>The article lists three types of evidence: signed build attestations, signed SBOMs or dependency manifests, and approval records that link an artifact version to an authorization decision.

00:06:54.714 --> 00:07:04.694
<v Host>When something fails, the pipeline logs a clear audit trail showing which evidence was missing, which signature verification failed, or which policy requirement blocked promotion.

00:07:04.982 --> 00:07:13.080
<v Analyst>That auditability is critical because it allows you to investigate why a build was blocked during an outage and to prove compliance later.

00:07:13.395 --> 00:07:20.028
<v Host>The article also warns that outages create behavioral pressure, and teams may drift toward shortcuts if deadlines loom.

00:07:20.283 --> 00:07:30.408
<v Analyst>That’s why operational safeguards are as important as technical controls. You need to practice tabletop exercises that include evidence verification steps.

00:07:30.699 --> 00:07:41.692
<v Host>In those drills, you simulate a token minting failure, a scanner outage, or a missing dependency mirror, and you walk through the offline verification process, documenting where checks block promotion.

00:07:41.969 --> 00:07:48.375
<v Analyst>The goal is to confirm that the control plane works under stress, not just that the pipeline still runs.

00:07:48.715 --> 00:07:56.033
<v Host>The article also suggests using time-bound exceptions with auditable approvals when evidence truly cannot be gathered during an outage.

00:07:56.318 --> 00:08:07.731
<v Analyst>For example, you might allow a promotion with a missing scanner result if you document the reason, set an expiration time, and require re-verification when cloud access returns.

00:08:08.036 --> 00:08:18.416
<v Host>To sum up the first half, the article lays out the failure modes, the evidence types, and the policy mechanisms that keep a supply chain trustworthy even when connectivity is lost.

00:08:18.673 --> 00:08:28.945
<v Analyst>And it emphasizes that the key is to keep trust data local, maintain signed policy artifacts, and enforce evidence requirements consistently across all stages.

00:08:29.245 --> 00:08:36.723
<v Host>Now that we’ve covered the what and why, the next step is to discuss how organizations should build these controls into their pipelines.

00:08:36.998 --> 00:08:47.819
<v Analyst>First, inventory your current evidence sources-do you have local caches of base images, signed policy documents, and offline attestation templates?

00:08:48.268 --> 00:08:55.054
<v Host>Next, implement a local key management solution that can generate and verify signatures without reaching out to a cloud service.

00:08:55.366 --> 00:09:05.352
<v Analyst>An HSM or a dedicated signing enclave on the build server can serve that purpose, and you must keep the key rotation schedule in sync with your policy updates.

00:09:05.693 --> 00:09:13.932
<v Host>Then, build an attestation generator into your CI job that captures the builder identity, the exact inputs, and the resulting artifact digest.

00:09:14.192 --> 00:09:23.172
<v Analyst>Make sure the attestation is signed with the offline key and stored alongside the artifact in your registry, so any promotion step can retrieve it.

00:09:23.520 --> 00:09:31.173
<v Host>You should also configure your policy engine to accept signed policy documents and to reject any unsigned or tampered ones automatically.

00:09:31.427 --> 00:09:40.844
<v Analyst>In addition, set up a local vulnerability database snapshot that the scanner can query offline, and define a freshness threshold for each release tier.

00:09:41.153 --> 00:09:50.246
<v Host>Finally, document a clear exception policy that specifies which evidence gaps can be tolerated, the duration of the exception, and the audit trail required to close it.

00:09:50.518 --> 00:10:00.730
<v Analyst>With those pieces in place, your pipeline can continue to enforce Zero Trust even when the cloud is unreachable, and you’ll have an auditable record of every decision.

00:10:01.011 --> 00:10:07.391
<v Host>Remember that every change to the policy or to the key set must be signed and versioned, so you can roll back if something breaks.

00:10:07.690 --> 00:10:16.614
<v Analyst>Also, schedule regular tabletop drills that simulate different outage scenarios, so your team stays comfortable with the offline verification workflow.

00:10:16.957 --> 00:10:24.055
<v Host>And monitor the health of your local mirrors and signing infrastructure, because an outage in those systems would still threaten the pipeline’s integrity.

00:10:24.351 --> 00:10:32.858
<v Analyst>Make sure you have a fallback path for key recovery-an out-of-band key backup that can be restored if the HSM fails during an outage.

00:10:33.157 --> 00:10:41.783
<v Host>When you’re ready to deploy, run a test promotion that uses only local evidence, and verify that the policy engine enforces the correct tier rules.

00:10:42.074 --> 00:10:51.537
<v Analyst>After that, you can gradually shift more controls to the cloud as connectivity improves, but the offline foundation will keep you safe during the transition.

00:10:51.794 --> 00:10:56.415
<v Host>So, what should organizations do next to prepare for these kinds of cloud-access failures?

00:10:56.553 --> 00:11:02.694
<v Host>To start, organizations should inventory all cloud-dependent controls and map them to local alternatives.

00:11:03.019 --> 00:11:12.004
<v Analyst>That inventory includes identity providers, artifact registries, vulnerability scanners, and policy engines that might fail.

00:11:12.322 --> 00:11:16.834
<v Host>Once you have that map, you can begin to define which evidence must be kept in-house.

00:11:17.175 --> 00:11:23.852
<v Analyst>The core evidence is the signed attestation, the artifact digest, and the policy version identifier.

00:11:24.134 --> 00:11:30.952
<v Host>You should also guarantee that the signing keys themselves are available offline, perhaps via an HSM on premises.

00:11:31.209 --> 00:11:36.499
<v Analyst>If the HSM goes down, you need an out-of-band key backup that can be restored quickly.

00:11:36.777 --> 00:11:41.860
<v Host>Another practical step is to mirror policy documents and vulnerability data locally and version them.

00:11:42.197 --> 00:11:48.731
<v Analyst>When you mirror a policy, sign it with your internal CA and include a clear expiration window.

00:11:49.026 --> 00:11:55.339
<v Host>If the expiration passes and the cloud can’t update the policy, the local engine should default to the safest rule set.

00:11:55.626 --> 00:12:04.332
<v Analyst>That safest set usually blocks production promotion and allows only staging or emergency releases with strict evidence.

00:12:04.662 --> 00:12:09.942
<v Host>Remember, the policy engine must reject any unsigned or tampered policy document automatically.

00:12:10.274 --> 00:12:16.508
<v Analyst>In addition, you need to build a local vulnerability snapshot that the scanner can query offline.

00:12:16.774 --> 00:12:22.990
<v Host>This snapshot should be refreshed regularly when connectivity is available, but you must record the refresh timestamp.

00:12:23.267 --> 00:12:30.703
<v Analyst>During an outage, the scanner can still match artifact hashes against that snapshot and flag any known CVEs.

00:12:31.005 --> 00:12:36.939
<v Host>If the snapshot is too old, the policy can require the artifact to be rejected or to go to a higher tier.

00:12:37.203 --> 00:12:45.629
<v Analyst>That brings us to the concept of tiered releases-emergency, staging, and production-each with its own evidence threshold.

00:12:45.929 --> 00:12:51.887
<v Host>An emergency tier might allow a build that only has a signed attestation but no fresh vulnerability scan.

00:12:52.210 --> 00:12:59.672
<v Analyst>Staging could accept a stale scan, provided the attestation is recent and the artifact hash matches the local cache.

00:12:59.942 --> 00:13:05.853
<v Host>Production, however, should only proceed when all evidence is fresh and the policy is still valid.

00:13:06.182 --> 00:13:13.022
<v Analyst>If any of those conditions fail, the promotion step must fail and log the missing evidence for later review.

00:13:13.287 --> 00:13:18.987
<v Host>That audit trail is critical because it lets you trace back why a particular artifact was allowed during an outage.

00:13:19.277 --> 00:13:29.381
<v Analyst>Common mistakes organizations make include ignoring the need for signed policies, relying on default cloud credentials, and skipping local cache pinning.

00:13:29.639 --> 00:13:36.117
<v Host>Another frequent error is assuming that a cached dependency is always safe without verifying its digest against a lockfile.

00:13:36.387 --> 00:13:42.362
<v Analyst>Because the lockfile might not have been updated during the outage, you risk pulling a compromised package.

00:13:42.621 --> 00:13:47.774
<v Host>Listeners often ask whether they can rely on a backup cloud provider to avoid outages altogether.

00:13:48.066 --> 00:13:54.754
<v Analyst>A backup provider can help, but it introduces another point of failure; you still need local controls.

00:13:55.096 --> 00:13:59.973
<v Host>The key is to treat any provider as another service that may go down and design for that scenario.

00:14:00.278 --> 00:14:05.349
<v Analyst>Another question is how to handle signing when the cloud signing service is unavailable.

00:14:05.675 --> 00:14:11.174
<v Host>The answer is to have an on-prem signing enclave that holds the same keys the cloud service uses.

00:14:11.461 --> 00:14:17.908
<v Analyst>That enclave should be hardened, backed up, and isolated from the build environment to prevent key theft.

00:14:18.178 --> 00:14:24.471
<v Host>In practice, many teams deploy a small HSM or a TPM-based signing device in the build pod.

00:14:24.758 --> 00:14:31.157
<v Analyst>When you sign locally, you must also sign the policy documents so that the promotion engine can verify them.

00:14:31.447 --> 00:14:36.258
<v Host>That brings us to the importance of a signed build chain, where each step signs the next.

00:14:36.524 --> 00:14:43.966
<v Analyst>If a step cannot sign because the key is missing, the entire chain is broken and the artifact must be rejected.

00:14:44.274 --> 00:14:48.776
<v Host>Listeners also wonder about the best way to store the signed attestations for later audit.

00:14:49.041 --> 00:14:55.041
<v Analyst>Store them in the same registry as the artifact, using a metadata field that the policy engine can read.

00:14:55.390 --> 00:15:01.159
<v Host>That way, when you promote, the engine pulls the artifact and its attestation in a single transaction.

00:15:01.506 --> 00:15:08.432
<v Analyst>If the attestation is missing or invalid, the promotion fails immediately, preventing a blind deployment.

00:15:08.771 --> 00:15:14.164
<v Host>Another common mistake is to treat a missing scan as a pass; zero trust says otherwise.

00:15:14.485 --> 00:15:19.863
<v Analyst>A missing scan should be treated as a required evidence category, not an optional one.

00:15:20.138 --> 00:15:25.662
<v Host>When you design your policy, explicitly list the evidence types that are mandatory for each tier.

00:15:25.925 --> 00:15:33.854
<v Analyst>For example, the policy might require a signed attestation, a published SBOM, and a vulnerability scan for production.

00:15:34.133 --> 00:15:39.905
<v Host>If any of those items is missing, the promotion engine should log the missing evidence and block the promotion.

00:15:40.249 --> 00:15:46.328
<v Analyst>That logging must be tamper-proof so that you can audit it later even if the system is compromised.

00:15:46.661 --> 00:15:50.627
<v Host>Another question from listeners is how to handle policy updates during an outage.

00:15:50.925 --> 00:15:56.343
<v Analyst>You should treat policy updates as a signed artifact with a version and an expiration date.

00:15:56.596 --> 00:16:03.037
<v Host>If the update cannot be fetched, the system should continue to use the last known good policy until it can be refreshed.

00:16:03.311 --> 00:16:07.655
<v Analyst>That approach ensures you never downgrade to a weaker policy during a failure.

00:16:07.995 --> 00:16:12.578
<v Host>Some organizations also ask whether they should enforce the same controls on the deployment step.

00:16:12.911 --> 00:16:19.518
<v Analyst>Yes, the deployment step should also verify the artifact against the local cache and check the attestation.

00:16:19.792 --> 00:16:25.741
<v Host>That means the deployment environment must have the same signed policy and local vulnerability snapshot.

00:16:26.062 --> 00:16:32.350
<v Analyst>If the deployment environment is in a different network segment, you need to replicate those artifacts there as well.

00:16:32.693 --> 00:16:38.481
<v Host>Turning to operational practices, teams should schedule regular tabletop exercises that mimic a cloud outage.

00:16:38.783 --> 00:16:45.214
<v Analyst>During those drills, test the promotion logic with only local evidence and observe the audit logs.

00:16:45.473 --> 00:16:50.577
<v Host>If the logs show any missing evidence, that’s a signal that your policy needs tightening.

00:16:50.878 --> 00:16:56.969
<v Analyst>Another drill scenario is to simulate a corrupted local cache; see how the pipeline reacts.

00:16:57.224 --> 00:17:02.590
<v Host>If the build system rejects the artifact due to checksum mismatch, you’ve built the right security posture.

00:17:02.936 --> 00:17:08.020
<v Analyst>In contrast, if it proceeds, you’ve likely misconfigured the verification step.

00:17:08.361 --> 00:17:13.035
<v Host>Listeners also ask about the cost of maintaining local mirrors and HSMs.

00:17:13.342 --> 00:17:20.154
<v Analyst>The cost is largely upfront for hardware and ongoing for storage, but it’s a trade-off against downtime.

00:17:20.409 --> 00:17:25.412
<v Host>Many organizations find that the value of a fail-safe pipeline outweighs those costs.

00:17:25.756 --> 00:17:33.268
<v Analyst>Additionally, the audit trail you build now can reduce compliance audit time and improve trust with regulators.

00:17:33.577 --> 00:17:38.423
<v Host>One more common question: can we still use the cloud for scanning when it’s partially available?

00:17:38.825 --> 00:17:47.276
<v Analyst>Yes, if the scanner can reach the vulnerability database but not the policy engine, you can still run the scan and store the results locally.

00:17:47.559 --> 00:17:53.586
<v Host>The key is to tag those results with a timestamp and a flag indicating that the policy was applied locally.

00:17:53.877 --> 00:17:58.968
<v Analyst>That metadata lets you later reconcile the results once the cloud services are back online.

00:17:59.268 --> 00:18:04.649
<v Host>In summary, the goal is to make every verification step independent of external connectivity.

00:18:04.948 --> 00:18:14.433
<v Analyst>By keeping signed attestations, local policy, and vulnerability data in the same environment, you preserve Zero Trust even when the cloud is down.

00:18:14.751 --> 00:18:21.520
<v Host>That means you can keep the pipeline running safely, audit every decision, and avoid the temptation to bypass controls.

00:18:21.829 --> 00:18:31.994
<v Analyst>The last piece of advice is to document everything-policy versions, key rotations, and exception approvals-so you can prove compliance later.

00:18:32.252 --> 00:18:37.430
<v Host>That completes the practical roadmap for handling cloud-access failures in a Zero Trust supply chain.

00:18:37.699 --> 00:18:44.587
<v Analyst>I hope this gives you a clear path to build resilient pipelines that stay secure even when the cloud is out.

00:18:44.837 --> 00:18:47.441
<v Host>Thank you for sharing these insights with us today, analyst.

00:18:47.769 --> 00:18:53.485
<v Analyst>You’re welcome, and I encourage you to start evaluating your own pipeline for these controls right away.

00:18:53.787 --> 00:19:01.670
<v Host>Remember, the key is to keep evidence, policy, and keys local and signed, so you’re never dependent on a single cloud service.

00:19:01.978 --> 00:19:09.393
<v Analyst>And if you need help, reach out to a trusted security partner who can audit your current setup and recommend improvements.

00:19:09.734 --> 00:19:12.543
<v Host>Thanks again for your time and expertise, analyst.
