Skip to content

Security model

A WAF that holds no private keys

The WAF enforces traffic policy and nothing else: no private keys, opaque certificate references, and no secrets on the event bus. Key custody and certificate lifecycle live behind their own boundaries.

The boundary

Enforcement and key custody are separate by design

A WAF is a traffic enforcement layer, not a key store. Keeping your most sensitive material out of the component in the request path means a smaller blast radius and a simpler design.

No private keys in the WAF

The enforcement layer stores no keys and no secret material — nothing sensitive to exfiltrate from the request path.

Opaque certificate references

The WAF stores certificate references verbatim. It never parses them or resolves them to keys.

Secrets never on the bus

The event bus carries certificate references and metadata only. Private keys never travel it.

Boundaries in context

Where each responsibility lives

Traffic is enforced at ArxLayer Edge before it reaches your origin, while key custody, certificate lifecycle, analytics, and billing stay independent. The boundary guarantee is visible in the architecture itself.

Architecture diagram. Traffic flows from the Internet to ArxLayer Edge, through Coraza with the OWASP Core Rule Set, then to your origin application. ArxLayer Trust, Certificates, Analytics, Billing, and IAM/NHI are separate platform components. No private keys traverse the event bus or config bus.

Request path
Internet
Untrusted client & machine traffic
ArxLayer Edge
TLS termination & request enforcement
Coraza + OWASP CRS
Inspection & anomaly scoring
Origin App
Your application or API
Platform components — separate from enforcement
ArxLayer Trust
Key custody & trust bundles
ArxLayer Certificates
Certificate lifecycle & certificate refs
ArxLayer Analytics
Event intelligence & reporting
ArxLayer Billing
Usage & commercial metering
ArxLayer IAM / NHI
User, service & machine identity

Boundary guarantee: ArxLayer Edge performs pure traffic enforcement. Certificate lifecycle, key custody, analytics, and billing are separate components — and no private keys ever traverse the event bus or config bus.

ArxLayer architecture: traffic is enforced at ArxLayer Edge using Coraza and the OWASP Core Rule Set before it reaches your origin, while certificate lifecycle (ArxLayer Certificates), key custody (ArxLayer Trust), analytics, billing, and identity (ArxLayer IAM / NHI) remain independent platform components.

Certificate references

The WAF references certificates — it never owns them

Certificate lifecycle belongs to ArxLayer Certificates; key custody and trust bundles belong to ArxLayer Trust. The enforcement layer only ever holds an opaque reference.

Config bus discipline

The event bus carries references, not secrets

ArxLayer distributes configuration as events. By design, that stream contains certificate references and policy metadata only — never private keys — so the transport itself can never become a path to your secrets.

References and metadata only

Policy, domain configuration, and opaque certificate references travel the bus. Secret material does not.

No secret on the wire

Keys are never published, so a consumer of the bus — or the bus itself — is never a route to private key material.

Auditable by construction

A config stream with no secrets is far easier to log, inspect, and reason about during review and audit.

Separation of duties

Each component owns exactly one responsibility

ArxLayer separates enforcement, certificate lifecycle, key custody, analytics, and billing into distinct boundaries — shrinking blast radius and keeping the WAF focused.

Why it matters

Bounded blast radius, simpler audit

When the component in the request path holds no secrets, a compromise there cannot leak private keys — and every boundary is easier to review on its own.

Smaller attack surface

The most exposed component is also the least sensitive — there are no secrets to steal.

Contained failures

Isolated boundaries keep an incident in one component from spreading across the platform.

Clearer ownership

One responsibility per component makes custody, lifecycle, enforcement, and reporting obvious.

Audit-friendly

Bounded scope and a secret-free config stream make each boundary straightforward to certify.

See the boundary in practice

No private keys in the request path, opaque certificate references, and separation of duties by design — see how it is wired, or talk it through with us.