In a default Kubernetes deployment of the Fastly Next-Gen WAF (formerly Signal Sciences) with the NGINX module and a sigsci-agent sidecar, a new pod can accept and forward traffic before the agent has loaded its rules. Until the agent opens its socket, the module fails open. Once the socket exists but no ruleset has loaded, the agent answers every request with “allow.” It stays that way for as long as the configuration cannot be loaded, while the pod reports Ready. This post covers the mechanism, lab test results on the current agent, how to check your own deployment, the opt-in mitigation Fastly shipped, and the CVE submission. The story of how I found it is in my April 12 post.
Summary
| Product | Fastly Next-Gen WAF agent (sigsci-agent) with the NGINX module, Kubernetes sidecar deployment |
| Component | Agent startup sequence and module/agent socket handoff |
| Weakness | CWE-636, Not Failing Securely (“Failing Open”); CWE-1188, Initialization of a Resource with an Insecure Default; CWE-696, Incorrect Behavior Order |
| Severity | Medium, CVSS 4.0 6.3 |
| Vector | CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:L/SA:N |
| CVE | {{requested from MITRE CNA-LR on 2026-09-29}} |
| Affected | All agent versions in default configuration, through at least 4.83.2 (tested 2026-11-12). Before 4.52.0 no mitigation existed; 4.52.0 and later are affected unless the startup probe is configured. Fastly states versions 4.52.0 and earlier are past its two-year support cycle. |
| Vendor mitigation | Startup probe options (startup-probe-listener, startup-probe-filepath), generally available in 4.52.0 (2024-03-14). Opt-in. |
| Default behavior | Fail-open until rules load. On 2026-10-29 Fastly stated it will not change the default. {{TODO: confirm status at publish time}} |
| Tested | Agent 4.83.2 and sigsci-nginx-ingress-controller 1.15.1-fastly1.4.0, deployed with Fastly’s published Helm values file, in a local kind cluster (see Lab testing) |
| Vendor position | “a deliberate, foundational design choice.” Fastly has said it may dispute through the CNA-LR. |
Scoring
| Metric | Value | Reason |
|---|---|---|
| Attack Vector | Network | Requests arrive over the network to the ingress. |
| Attack Complexity | Low | No defense needs to be defeated. A normal request is enough. |
| Attack Requirements | Present | Success depends on a pod running without a loaded ruleset, which the attacker does not control directly. Sustained traffic, or load that triggers autoscaling, will overlap those windows when they occur. |
| Privileges / User Interaction | None / None | Unauthenticated, no victim action. |
| Vulnerable system integrity | Low | The WAF’s enforcement and its request records are wrong for the duration of the window. |
| Subsequent system integrity | Low | Requests the operator’s rules would have blocked reach the protected application. What they can do there depends on the application, so this is held at Low. |
| Confidentiality / Availability | None | The bypass itself discloses nothing and degrades nothing. |
Configuring the probe removes the exposure for that deployment, but it does not change the base score. CVSS v4.0 §2.1 is explicit that “Specific configurations should not impact any attribute contributing to the CVSS Base metric assessment”; operator mitigations belong in Environmental scoring.
Root cause
The Next-Gen WAF consists of a module inside the web server and an agent that holds the rules and makes the allow or block decision. They talk over a Unix socket. In Kubernetes this is normally an ingress controller pod with the module built in, plus a sigsci-agent sidecar container that shares the socket path through a volume.
At pod start, both containers launch together:
- The NGINX container is ready to serve almost immediately.
- The agent authenticates to Fastly’s cloud, fetches the workspace rules, parses them, and loads them. This takes network round trips and time.
- Until the agent finishes its first configuration download attempt, it has not opened its RPC socket. The module cannot connect, logs an error, and passes the request through anyways.
- When that first attempt ends, the agent still opens the socket whether or not a ruleset was loaded. If none was, it answers every request with an allow decision and an
X-SigSci-Agent: disabledheader, and keeps doing so until a later download succeeds.
Kubernetes has no way to know about any of this. The pod reports ready because the container is running and NGINX answers, not because the WAF can enforce policy. Nothing in the default configuration ties pod readiness to rule load.
That makes the default posture fail-open at the moment the control is least able to protect: every rollout, every restart, every eviction, and every scale-out event under load.
Impact
For the duration of each startup window, the WAF provides no inspection to the traffic that pod receives. In an ingress deployment the WAF is usually the outermost control, so there may be nothing else in front of the application.
Two properties make it worse than a brief gap:
- It is mostly unflagged by default. The pod reports Ready throughout. While the socket is missing, NGINX logs an
[error] … cannot connect uds socketline per request at its default level. Once the agent answers “allow” with no ruleset, NGINX logs nothing at default level, and the agent never says it is disabled or that requests are passing uninspected. Its only default output is aConfig update failedline roughly every 30 seconds. Per-request evidence exists only with non-default options, such as the statsd countersigsci.agent.rpc.tx.dropped.engine_disabled. - It persists. The allow-everything state has no time limit. It lasts until a configuration download succeeds.
- It recurs on load. Horizontal autoscaling creates new pods exactly when traffic is highest, so the windows cluster at the times an attacker is most likely to be generating traffic anyway. How long a healthy start leaves the window open could not be measured without working credentials.
The practical result is a WAF bypass that is probabilistic and timing-dependent. It does not need credentials or a flaw in the application.
Check your deployment
- Find your agent container spec. Look in the pod or deployment manifests, Helm values, or the rendered output from your chart.
- Check for
SIGSCI_STARTUP_PROBE_LISTENERorSIGSCI_STARTUP_PROBE_FILEPATHin the agent container’s env, and for astartupProbeon the agent container that uses it. - If either is missing, the pods in that deployment start in the fail-open mode described above. The env var alone does nothing unless a
startupProbechecks it.
To find past occurrences without changing anything:
- Backend logs. When the agent answers without a ruleset, the module forwards
X-SigSci-Agent: disabledto your upstream. If your application or backend proxy logs request headers, search for it. - Agent logs. Look for
Config update failedlines from thesigsci-agentcontainer, particularly near pod starts. - Ingress controller logs. Look for
cannot connect uds socketerrors from the sigsci module.
Requests that passed while the socket was missing carry no X-SigSci-* header, so the backend header check alone will not find them.
Lab testing
Fastly did not answer my questions about what the agent does before rules load, so I tested it. I deployed agent 4.83.2 and sigsci-nginx-ingress-controller 1.15.1-fastly1.4.0, pulled by digest, using Fastly’s published sigsci-values.yaml layout in a local kind cluster. A generator sent about 20 requests per second, including SQLi, XSS and path traversal payloads, to an echo backend that logged every request header. Testing was black-box: logs, documented flags, the agent’s own documented RPC debug dump, and response headers. No Fastly credentials were available, so the agent could never load a ruleset. That limit is covered below.
What the agent returns before rules load. Two phases, in order:
| Phase | What happens | Default-level signal |
|---|---|---|
| Agent socket not yet created | Module cannot connect (errno=2) and passes the request through |
NGINX [error] … cannot connect uds socket per request |
| Socket created, no ruleset | Agent answers WAFResponse 200 with X-SigSci-Agent: disabled; request passes |
None in NGINX; agent logs only Config update failed about every 30 s |
The agent created its socket in the same millisecond its first configuration download attempt ended, whether or not it succeeded. I made that download fail four different ways, three runs each: dropped connections, rejected credentials (HTTP 403), DNS NXDOMAIN, and TCP reset. All four produced the same state, with 20,304 decoded agent responses and one distinct value: allow, marked disabled. A failure that has nothing to do with credentials, such as a DNS failure, leaves the agent in the same allow-everything state as a bad key.
How long it lasts. With slow failures (dropped connections) the socket appeared after about 60 seconds, and about 935 requests per run passed through the no-socket phase. With fast failures it appeared within about 1.7 seconds. In every case the disabled state then persisted, with retries every 30 seconds, for as long as configuration could not be loaded.
Mitigations.
- With the startup probe configured, the pod stayed out of the Service endpoints and zero requests reached the upstream, in all three runs.
- Fastly’s suggested alternative, a readiness probe with
initialDelaySecondsof 10, 30 or 60 seconds, let traffic through once each delay expired, including attack payloads. - I found no documented module or agent option that makes either fail closed. The experimental
debug-standalone=4setting removed the no-socket phase and thedisabledmarker, but still allowed every request.
The documented timeout path, for contrast. Freezing the agent process after its socket existed made the module fail open after about 320 ms per request, with nothing logged at default level. So silence at default level is not unique to the disabled state. The difference is that Fastly documents the timeout behavior, and documents nothing about an agent that answers with no ruleset loaded. Under load testing, the frozen agent also stalled NGINX workers and many client requests timed out. I infer, without having proven it, that the fail-open design does not fully protect availability either.
Limits. Without working credentials I could not observe a healthy start: whether, with a valid key, the socket ever opens before the first ruleset finishes loading, the startup probe’s 503 to 200 transition, or how these requests appear in Fastly’s console. The 60-second window is an artifact of how I blocked egress, not a typical duration. What the evidence supports is a finding about failure at startup: in every failure I tested, an agent that could not load its configuration allowed everything until it could, and the default deployment gave Kubernetes no readiness signal for it. The full report, manifests, scripts and raw evidence, with SHA-256 checksums, are at github.com/zaclohrenz/fastly-ngwaf-poc.
The vendor fix
Fastly added a startup probe options to the agent. They reached general availability in 4.52.0 on 2024-03-14, per the 4.52.0 changelog (archived). There are two options:
HTTP probe. Set SIGSCI_STARTUP_PROBE_LISTENER to an address. The agent serves an endpoint that returns 503 until rules are loaded and 200 afterward. Point a Kubernetes startupProbe at it. This is the simpler of the two: an httpGet probe needs nothing inside the agent image, while an exec probe needs a binary in the container to check for the file.
File probe. Set SIGSCI_STARTUP_PROBE_FILEPATH to a path. The agent creates the file once rules are loaded, and an exec probe checks for it.
Either way, Kubernetes holds the pod out of rotation until the agent can enforce policy. In my testing the probe kept the pod out of the Service endpoints in every run, with no requests reaching the upstream. Fastly’s Kubernetes startup probe guide documents the setup. An HTTP probe configuration looks like this:
containers:
- name: sigsci-agent
image: signalsciences/sigsci-agent:latest
ports:
- name: "startup-port"
containerPort: 2024
env:
- name: SIGSCI_STARTUP_PROBE_LISTENER
value: "0.0.0.0:2024"
startupProbe:
httpGet:
path: /startup
port: startup-port
failureThreshold: 90
periodSeconds: 2
The mechanism is correct and I have no objection to it. The problem is that it is optional. Fastly’s Kubernetes install guides on its documentation site didn’t include it until after my report in October 2026, and the Helm values files in Fastly’s own GitHub repository still don’t: sigsci-values.yaml and sigsci-nginxinc-values.yaml, as of commit 9794dfb on 2026-11-10, deploy the agent sidecar with no startup probe or readiness gate, and no version in the repository’s history has included one.
One cost is worth knowing. With the guide’s failureThreshold: 90 and periodSeconds: 2, a pod whose agent cannot load rules for three minutes is restarted by the kubelet. If Fastly’s cloud is unreachable that long, new pods never serve traffic. Pods that were already ready keep serving.
Why this is filed as a vulnerability
The probe exists but the default never changed. A deployment built from the standard manifests, or from documentation and examples that predate the probe, still starts fail-open. Whether a given operator is exposed depends on whether they found a feature briefly mentioned in a release note and opted in.
Fastly’s bizarre position
Fastly’s position came in several replies. On 2026-10-14 their product and security teams wrote that Fastly “does not classify this behavior as a vulnerability,” calling fail-open “a deliberate, foundational design choice in the Fastly NGWAF architecture designed to prioritize application availability and continuous traffic flow in the event of component unavailability, timeouts, or uninitialized states.” The same reply said they “entirely agree with your assessment of the security implications in a dynamically scaling Kubernetes environment.” On 2026-10-22 they acknowledged that “our install guides and suggested configs don’t include” the startup probe and held that a CVE is not the right fit “since the right default varies a lot by deployment type (fail-closed at startup is ideal for some and an outage for others).”
On 2026-10-29 Fastly’s Security Product Support manager sent a final position after review with Security, Engineering, and Product. In summary they argued:
- The behavior is not a vulnerability under the current CNA Operational Rules (v4.2.6), citing 4.1.3.4 released days after my report: “CNAs MAY determine consistently well-documented and widely known default configurations to not be Vulnerabilities.”
- CWE-1188 does not apply because fail-open “isn’t a placeholder intended to be changed; it’s the desired operating state for most of our customers.”
- Pod routing is a Kubernetes shared-responsibility matter, and operators can also use a readiness probe with
initialDelaySeconds. - WAFs “traditionally operate on a default-allow paradigm,” unlike network firewalls.
- “We won’t change the default fail-open behavior in situations where the agent is not available yet or is experiencing other issues.”
Fastly also updated its Kubernetes guides so the configuration snippets include the startup probe. On 2026-11-03 Fastly moved further discussion to the CNA-LR, reserved the right to dispute there, and noted that agent versions 4.52.0 and earlier are past its two-year support cycle.
How the CVE Program rules apply
The rules. CNA rule 4.1.3 says “CNAs SHOULD determine insecure default configuration settings to be vulnerabilities,” and acknowledges the determination “can be complicated” and “may be more subject to disputes than other determinations.” Rule 4.1.3.4, which Fastly relies on, is a MAY. Rule 4.1.3.2 is a SHOULD for defaults “that introduce un- or under-documented, surprising, or unexpected security behavior,” and 4.1.3.3 is a SHOULD for defaults “that enable direct exploitation.”
The documentation. Fastly’s agent reliability documentation covers two cases: the module failing open when the agent doesn’t respond within 100 to 200ms, and an agent that loses cloud connectivity continuing to “enforce existing blocking decisions.” Its startup section lists only the metadata addresses the agent queries to detect its environment. Nothing there says the agent handles requests before its rules have loaded, or that enforcement is absent during that window. The cloud-loss case assumes rules already exist and at startup, they don’t. Fastly’s own answer says the agent “still performs preliminary request handling” while loading its initial ruleset. That is the under-documented case 4.1.3.2 describes. Before 4.52.0 there was no option to avoid it, the Kubernetes install guides didn’t include the probe for more than two and a half years after it shipped, and Fastly’s GitHub Helm values still don’t. My testing found no documented option that makes the module or agent fail closed.
Informed preference. Fail-open being “the desired operating state for most of our customers” assumes customers knew about this window. A preference for a default operators weren’t told about isn’t an informed preference. I ran this agent in high-traffic production, I never chose to let rule-matching traffic through during startup, and I only learned the window existed by finding requests in my own telemetry that my rules should have blocked.
CWE-1188. For Kubernetes, Fastly’s own updated reference configuration now adds the probe. In the topology this report covers, the vendor’s reference configuration changes the default.
Default-allow. Default-allow describes traffic that matches no rule. Before rules load, nothing can match. That is absence of enforcement, not an allow policy. Some customers also use the WAF to restrict access, for example allowing only known sources to staging or development sites. For them the window lets through traffic that should be denied.
Kubernetes shared responsibility. Kubernetes can only gate traffic on a readiness signal the workload exposes. Before 4.52.0 the agent exposed none, so no manifest could gate on rule load. initialDelaySeconds delays traffic by a fixed time; it does not wait for rules, and rule-load time varies with network latency to Fastly’s cloud and the size of the ruleset. In testing, delays of 10, 30 and 60 seconds each let traffic through once they expired. A failing startupProbe keeps that one pod out of the Service endpoints while ready pods keep serving, which is ordinary rollout behavior, so the cited outage concern is more niche than Fastly attempts to state. The only case where it causes unavailability is when no pod is ready, which is the same case where fail-open passes every request uninspected.
End of support. The fail-open default persists in supported versions through at least 4.83.2, the version I tested. Under CNA rule 4.2.17.8, end-of-support versions belong in the same record as supported ones.
Fail-secure practice. NIST SP 800-53 control SC-7(18), Fail Secure, says to “Prevent systems from entering unsecure states in the event of an operational failure of a boundary protection device.” An organization can only make that decision for a failure mode it knows exists. For more than two years after the probe shipped, Fastly’s Kubernetes install guides and sample configs didn’t include it, so operators deploying from them had no prompt to make that decision.
My position is narrower than “fail-open is always wrong.” The product’s out-of-the-box behavior in the most common Kubernetes topology fails open, and the secure configuration is not the default. A vulnerability can also be by design. “Won’t fix, by design” is a legitimate disposition, and I actually proposed it to Fastly on 2026-10-18. A CVE is how downstream operators and scanners learn that a configuration they may have copied is exposed. I requested one CVE for the agent in its default configuration across versions, not one per release.
A vendor deciding whether its own product has a vulnerability has an obvious conflict of interest, which is why the CNA-LR process exists. Look at what Fastly chose at each step: it agreed with the security implications. It acknowledged its Kubernetes guides omitted the mitigation. It declined to change the default. It did not answer two questions that would help customers judge their exposure. It reserved the right to dispute the CVE. Each of those choices reduces what customers learn about this window. So who does keeping it out of the CVE record protect: Fastly’s customers, or Fastly?
Unanswered questions
On 2026-10-30 I asked Fastly two factual questions in writing, so this writeup could help operators judge their exposure: what the agent does with requests before its rules load, and how an operator can detect requests handled in that window. Fastly did not answer either. Its 2026-11-03 reply moved further discussion to the CNA-LR and reserved the right to dispute there. I answered them as far as I could by testing; see Lab testing.
If you have not configured the probe
- Add one of the two probe forms to every agent container, and confirm the pod stays out of rotation until the agent reports ready.
- Make probe configuration part of your chart or manifest template so new services inherit it, not something each team adds by hand.
- Set
failureThresholdandperiodSecondsto allow for the slowest realistic rule fetch (test it), including network latency to Fastly’s cloud. - Treat any other policy-enforcing sidecar the same way: Envoy or Linkerd proxies that load remote policy, OPA sidecars that fetch bundles, and similar agents. A running process and a process that can enforce are different readiness states, and
startupProbeexists to tell them apart.
Timeline
- Early 2024: reported to Fastly support, before the 4.52.0 release.
- 2024-03-14: agent 4.52.0 ships the startup probe options as generally available. The default is unchanged.
- 2026-04-12: I published an account of finding the issue and the fix.
- 2026-09-24: emailed Fastly’s security address asking whether Fastly classifies the behavior as a vulnerability and whether it would request or confirm a CVE. I gave a response date of 2026-10-24. No response was received.
- 2026-10-06: forwarded the report to Fastly support, noting the lack of acknowledgment. A case was opened and routed to Fastly’s security team the same day.
- 2026-10-07: Fastly support forwarded the remaining questions to its product team as a security report.
- 2026-10-14: Fastly’s product and security teams replied that they do not classify the behavior as a vulnerability, describing fail-open as a deliberate design choice, while agreeing with the assessment of its security implications in Kubernetes.
- 2026-10-18: I replied that a deliberate design choice and a vulnerability are not mutually exclusive, and asked whether Fastly would support a CVE with a “by design” disposition. Otherwise I would continue with MITRE.
- 2026-10-22: Fastly acknowledged that its install guides and sample configs omit the startup probe, said it was evaluating adding it, maintained that a CVE is not the right fit, and asked me to review the guide changes.
- 2026-10-22: I agreed to review the guide changes and set out the classification under CNA rule 4.1.4 (v4.1.0; superseded by v4.2.6 on 2026-10-20, where it is 4.1.3). I offered to hold publication until a fixed release, up to 2027-01-20, if Fastly changed the default, and asked for a decision by 2026-10-29. No response by that date would be treated as a decision not to fix. Fastly acknowledged and said it was relaying this to the team.
- 2026-10-29: Fastly’s Security Product Support manager sent a final position: not a vulnerability under CNA rules v4.2.6, the default will not change, and Kubernetes guides were updated to include the startup probe. Fastly found no 2024 support case matching my description and declined credit for the guide changes.
- 2026-10-30: I corrected my rule citation to v4.2.6, set out where I still disagreed, declined a call, and asked two factual questions in writing.
- 2026-11-03: Fastly moved further discussion to the CNA-LR, reserved the right to dispute there, and noted that agent versions 4.52.0 and earlier are past its two-year support cycle. It did not answer the two questions.
- 2026-11-12: I noted the unanswered questions and that I would publish once the CVE ID is assigned.
- 2026-11-12: lab testing of agent 4.83.2 with Fastly’s published Helm values, with dummy credentials.
- 2026-11-17: Fastly closed the case, stating the behavior is not a vulnerability under the CNA Operational Rules and that it had no further details to share. It said it would give its analysis directly to the CNA-LR if the CVE request proceeds.
- {{TODO: date}}: CVE ID assigned by MITRE CNA-LR.
- 2027-01-15: details published.
References
- Test evidence, scripts and manifests (fastly-ngwaf-poc)
- Fastly Next-Gen WAF agent 4.52.0 changelog
- Fastly Kubernetes startup probe guide
- Signal Sciences NGINX Ingress Controller
sigsci-values.yamlat commit 9794dfbsigsci-nginxinc-values.yamlat commit 9794dfb- Fastly Kubernetes Agent + Module guide
- Troubleshooting agent response codes
- CWE-636
- CWE-1188
- CWE-696
- CVE Program CNA Operational Rules v4.2.6
- Fastly agent reliability documentation
- Fastly agent end-of-support policy
- Fastly Next-Gen WAF agent 4.83.1 changelog
- CVSS 4.0 specification