Feature

Ze Features

Ze is an open-source configuration and protocol engine written in Go. The network operating system built on it runs on any Linux or as a gokrazy appliance.

Status values: Supported means every completion criterion its kind requires holds, including a current recorded green run of each real-path test and of each counted interop scenario; Experimental means implemented and reachable through its real entry point, without the evidence Supported requires; Stub-backed means implemented, with the evidence for its external dependency coming only from a stub harness; (partial) after a level means the named scope gaps are not implemented or not proven; Future means planned but not shipped; Rejected means unsupported by design.

Protocols

Feature Status Description
AIGP (RFC 7311) Experimental (partial) Accumulated IGP Metric path attribute: wire encoding and decoding, receive validation, structured JSON exposure with RFC 4271 attribute flags, per-session enablement (internal sessions on, external sessions off unless configured), configured origination, next-hop-self accumulation, and best-path selection after LOCAL_PREF and before AS_PATH (RFC 7311 Section 4.1). AIGP is an attribute, not a capability, so capability { aigp } is refused. Next-hop-self source-cost propagation is not yet established end to end, and automatic origination is not enabled. Scope gaps: next-hop-self source-cost propagation end to end; automatic origination.
AS112 Anycast DNS Experimental (partial) Authoritative sink for misdirected RFC 1918 / link-local reverse-DNS queries (RFC 7534) and the EMPTY.AS112.ARPA DNAME-redirection zone (RFC 7535). Four fixed anycast host addresses (never operator-typed), registered against the iface address-ownership registry and bound via IP_FREEBIND. Optional allow-from client-source access list (loopback always permitted). BGP integration composes existing healthcheck/watchdog/update-block mechanisms: the anycast route announces only once a probe against a real anycast service address confirms the DNS service is healthy, with an operator-chosen community and optional AS112-origin AS_PATH override. show as112, as112 health [target <ip>], ze_as112_* metrics. The four covering prefixes can also be BGP-originated directly through the redistribute path (redistribute { destination bgp { import as112 } }) with a configurable origin ASN (asn, default 112) and community, health-gated by the watchdog serving-state check (RFC 7534 Section 3.3). Compile-out-able with the ze_as112 build tag: default-on in ZE_FEATURES, dropped from ze-stripped / bare ze_core builds, with its config block rejected as unknown. Scope gaps: RFC 7858 and RFC 8484 MUST gaps for DoT and DoH; RFC 7535 is not proven; no DNS interop.
Authoritative DNS Answer Policy Experimental One harness serves as112 and geodns, so both answer a malformed or out-of-scope query the same way. A name outside every served zone gets REFUSED with the AA bit CLEAR, because RFC 1035 Section 4.1.1 gives AA one meaning and a responder that keeps it set on a Refused reply asserts an authority it does not have. A name inside a served zone that the zone does not own gets NXDOMAIN. A name that exists with no record of the requested type gets NOERROR with an empty Answer. Both negative answers carry the zone SOA in the Authority section, which RFC 2308 Section 3 requires so a resolver can cache them. A non-query opcode gets NOTIMP. A UDP reply is bounded to 512 octets (RFC 1035 Sections 2.3.4 and 4.2.1) or to the larger buffer the requestor advertised in an OPT record (RFC 6891 Section 6.2.3), with TC set; an advertisement below 512 does not lower the bound. TCP, DoT and DoH are unbounded.
BFD Liveness Detection Experimental (partial) RFC 5880 Bidirectional Forwarding Detection plugin: pinned single-hop (UDP 3784) and multi-hop (UDP 4784) sessions, profile-driven timer bundles, GTSM enforcement (IP_TTL=255 outbound / IP_RECVTTL ingress gate), multi-hop min-TTL floor, RFC 5880 §6.8.7 TX jitter (0-25%, clamped to [10%, 25%) when detect-multiplier=1), SO_BINDTODEVICE for single-hop interface and multi-VRF binding, BGP peer opt-in with RFC 9384 Cease subcode 10 teardown, BFD strict mode (draft-ietf-idr-bgp-bfd-strict-mode: capability 74 negotiated in OPEN, the BFD session opened before the BGP FSM starts, the BGP session held in OpenSent until BFD is Up, the BfdHoldTimer for a negotiated hold time of zero, and FSM events 30 to 35), show bfd sessions/session/profile commands, ze_bfd_* Prometheus metrics, RFC 5880 §6.7 Keyed SHA1/MD5 (meticulous variants included) authentication with file-backed sequence-number persistence, and RFC 5880 §6.4 Echo mode config/wire advertisement (transport half tracked as spec-bfd-6b-echo-transport). Compile-out-able with the ze_bfd build tag (default-on in ZE_FEATURES): a stripped build drops the engine, session, transport, auth, and command surface and rejects a bfd {} block, while the nil-able client seam (bfd/api, with the bfd/packet State/Diag types) stays always-on so BGP, OSPF, and static route monitors run without BFD by their existing warn-and-degrade path. Scope gaps: RFC 5880 and RFC 5881 obligations the ledger marks Partial; Echo mode transport half (spec-bfd-6b-echo-transport).
BGP Protocol Experimental (partial) 23 address families, 14 capabilities, 15 path attributes. bgp update-delay max-delay <seconds> holds the first advertisement of a speaker that has just started until every configured peer has sent its End-of-RIB marker, until an optional establish-wait expires, or until max-delay expires, so a neighbor receives one settled route set instead of an initial set followed by corrections; RFC 4724 Section 4.1 prescribes the same deferral for a restarting speaker and requires the configurable upper bound. show bgp update-delay reports whether the speaker is holding and what it waits for. The whole BGP subsystem is compile-out-able with the ze_bgp build tag. The default feature list includes it, while bare ze_core builds drop internal/component/bgp entirely -- engine, wire codec, RIB, and every BGP plugin -- plus flowspec-firewall, which translates BGP-delivered flowspec routes and is meaningless without it. Both composition roots are gated (the generated all_ze_bgp.go, and the package main root, which splits into for the CLI registration under ze_core && ze_bgp and for the always-on seams under ze_bgp alone), and a bgp {} config block is rejected as an unknown field rather than silently ignored. A BGP-less daemon still runs OSPF, IS-IS, static routes, the FIB, MRT recording, and flow export: the route-action vocabulary, the BGP message-type codes, and the best-path-change event contract those consumers share live in always-on internal/core/bgp/* leaves, and the places always-on code used to call into the engine are inversion-of-control seams the engine fills from its own init: internal/component/config/infra carries four of them (ze config dump/diff/validate resolution, BGP peer validation, roleless-peer reporting, and the graceful-restart marker), and the MRT RIB dump provider is a fifth. le chaos run and le perf drive an in-process reactor and force ze_bgp on. Within a ze_bgp build the BMP monitoring plugin (RFC 7854/8671/9069) is independently compile-out-able with the ze_bmp build tag: it is a dependent gate. BMP imports the engine, so all_ze_bmp.go is generated with //go:build ze_bgp && ze_bmp, and a ze_bmp-without-ze_bgp build links neither BMP nor the engine. Scope gaps: RFC 4271 iBGP MED re-advertisement (plan/release/fixes/spec-rfc4271-med-ibgp-readvertisement.md); RFC 4724 RFC 6793 and RFC 8654 obligations the ledger marks Partial; RFC 7606 gap row in rfc/short/rfc7606.md. cmd/ze/dispatch_bgp.gocmd/ze/infra_bgp.go
BMP Delivery (RFC 7854) Experimental (partial) Each collector session owns a bounded FIFO transmit queue, drained by its own goroutine off the producer's, so a slow collector never blocks the BGP path. The bound is 256 MiB of queued-but-unwritten bytes per session, sized to absorb a full Loc-RIB dump (about 1M IPv4 best paths at roughly 120 bytes of Route Monitoring each is about 120 MB). Reaching it resets the session rather than dropping a message, because RFC 7854 has no back-pressure signal. The byte bound is NOT the defense against a wedged collector: one that stops reading entirely is caught seconds earlier by the per-write deadline. It bites for the other shape, a collector that keeps reading but steadily slower than Ze produces, where every write succeeds and the backlog is what grows. A Loc-RIB dump closes every family it owes, including one with nothing to send. Those End-of-RIB markers are sent once the dump request is queued, usually before bgp-rib has sent a route, so a collector cannot yet read a marker as the end of the dump. Scope gaps: RFC 7854 obligations the ledger marks Partial.
DHCP Server Named Ranges Experimental (partial) Multiple named address ranges per subnet for segmented allocation. Each range has an independent bitmap pool. Compile-out-able with the ze_dhcpserver build tag: default-on in ZE_FEATURES, dropped from ze-stripped / bare ze_core builds, with its config block rejected as unknown. Scope gaps: several ranges per subnet are proven by unit tests only; no interop against a real DHCP client.
DHCP Server Shared Segment Experimental (partial) Several IPv4 subnets served on one LAN segment. The subnets of one shared-network share a segment; a request is served from the segment its listen interface is addressed in, or the one holding the relay's giaddr. A static reservation for the client's MAC in any subnet of the segment wins over every pool, then the home subnet's pool is used, then the others in configuration order. Option 54 is the interface's address in the chosen subnet, or the subnet's optional server-identifier while the interface holds it, and a SELECTING request naming any of the server's addresses on the segment is accepted (RFC 2131 Section 4.1). Scope gaps: option 82 relay agent information; its link-selection sub-option (RFC 3527) and the server identifier override (RFC 5107) are not read; so a relayed request selects its segment by giaddr alone.
DNS Resolver Experimental Built-in cached DNS resolver for all components. Asks the router's servers in order, passing a query to the next server when one gives no answer or answers a server failure. With no system dns-source written, those servers are the configured system.name-server list when it has an entry, else the servers learned from DHCPv4, DHCPv6 and PPPoE leases and router advertisement RDNSS, or the host's while none of them lists a server; system dns-source sets the classes, their mode and the interfaces received reads, and show system dns prints the learned records and the selection. It follows every lease change and reload, and fails closed with no DNS server configured when no source supplies a server. It does not silently fall back to public recursive resolvers. Cache management: show dns cache list/record, clear dns cache all/record/stats (flush/selective delete/stats reset). /etc/resolv.conf
Egress attribute conformance (RFC 4271 Section 5) Experimental (partial) Each rule is enforced at one site and applies on every rail that writes an UPDATE (announce, forward, route server): LOCAL_PREF is never sent on an external session (5.1.5); a received MULTI_EXIT_DISC is not relayed to another neighboring AS (5.1.4), with the route-server client exempt per RFC 7947 Section 2.2.3; no peer is sent its own address as NEXT_HOP (5.1.3); the Partial bit is set on an unrecognized transitive optional attribute (Sections 5 and 9); withdrawals are applied before announces (4.3); a relayed withdrawal creates no attribute (4.3 and 6.3); and attributes are inserted by ascending type code with MP_UNREACH first. The final session writer also clears the four unused low-order bits of every Attribute Flags octet (4.3) and drops a repeated LARGE_COMMUNITY value whichever producer added it (RFC 8092 Section 3), on the raw rail too. Scope gaps: RFC 4271 iBGP MED re-advertisement (plan/release/fixes/spec-rfc4271-med-ibgp-readvertisement.md).
Flow Export Experimental Interface counter and per-flow record export over UDP via sFlow v5, NetFlow v9 (RFC 3954), and IPFIX (RFC 7011). Per-collector polling interval and template refresh. Packet sampling (tc sample + psample) exported as sFlow flow samples with configurable 1-in-N rate, header truncation, and psample group. Conntrack-based per-flow records (periodic table dumps) for NetFlow v9 and IPFIX. Optional BGP next-hop enrichment from the RIB best-change event. show flow export [<collector>] reports per-collector datagrams-sent, bytes-sent, errors, sequence, and last-export-time. show flow recent [dst <prefix>] returns recent conntrack flow records (5-tuple + TCP state) from a bounded drop-oldest ring (recent-flow-ring, default 4096 records, allocated only when conntrack export is on) that feeds on-box DDoS characterization. Prometheus metrics: ze_flowexport_datagrams_total, ze_flowexport_bytes_total, ze_flowexport_errors_total, ze_flowexport_samples_total, ze_flowexport_flows_total, ze_flowexport_flows_active, ze_flowexport_recent_ring_drops. Per-flow records cover IPv4 and IPv6 (separate templates); BGP enrichment currently fills next-hop only; sampling needs Linux with CAP_NET_ADMIN and kernel psample. Compile-out-able with the ze_flowexport build tag: default-on in ZE_FEATURES, dropped from ze-stripped / bare ze_core builds, with its config block rejected as unknown.
GeoDNS Experimental Authoritative DNS server that selects the answer from the client's source IP, taken from the EDNS0 client-subnet option (RFC 7871) or the connecting address. Zones, host sets, per-source selection, and a configurable SOA (contact, serial mode, refresh, retry, expire, minimum) with the serial recomputed per generation. Optional DoT (RFC 7858) and DoH (RFC 8484), whose certificate is either a cert-file/key-file pair or a tls { certificate <name> } reference into the pki {} store; the two forms are mutually exclusive. Shares the answer-policy harness described below with as112.
gNMI Experimental Industry-standard gRPC Network Management Interface for YANG-modeled config. Capabilities, Get, Set (via segment-based paths preserving IP list keys), Subscribe ONCE and STREAM modes. Bearer token auth with constant-time comparison, optional TLS. YANG config schema under environment { gnmi {} }, show gnmi CLI command, Prometheus counters (ze_gnmi_requests_total, ze_gnmi_subscribe_active, ze_gnmi_errors_total). External config commits (web, CLI, managed) notify STREAM subscribers. Env-var gated (ze.gnmi.enabled), default port 9339. The service is default-on but compile-out-able with the ze_gnmi build tag: normal and appliance builds include it, while ze-stripped and bare ze_core builds drop internal/component/gnmi, its schema, and its show gnmi RPC.
IKEv2 Engine Experimental Full IKE FSM for both initiator and responder roles (connection-type initiate/respond): IKE_SA_INIT, IKE_AUTH, CREATE_CHILD_SA, INFORMATIONAL exchanges. PSK and X.509 certificate authentication; as responder Ze also acts as the EAP authenticator (EAP-MSCHAPv2, EAP-TLS and MD5-Challenge server). Child SA creation with traffic selectors and ESP proposals. A respond peer bound to a remote-access pool is leased a virtual IP through the Configuration Payload in IKE_AUTH (RFC 7296 Section 2.19), and every Child SA of that IKE SA, a rekey included, names only that address for the peer's side. IKE SA and Child SA rekeying (initiate and respond) with collision handling. DPD (Dead Peer Detection) via INFORMATIONAL exchange with configurable interval and timeout. XFRM policy and state programming via netlink. Reconciliation on config reload. An IKE SA whose first Child SA the peer refuses stays up with no Child SA (RFC 7296 Section 2.21.2), in both roles; the IKE SA initiator then asks for the Child SA through CREATE_CHILD_SA on a retry schedule, and either role creates one when the peer asks. A site-to-site peer can add one RFC 4739 authentication round in each direction (authentication second-round), by pre-shared secret or X.509, in both roles; an unconfigured, missing or third round is refused with AUTHENTICATION_FAILED. An initiate peer accepts a reauthentication its gateway starts with a fresh IKE_SA_INIT from the established SA's address (RFC 7296 Section 2.8.3), unless it authenticates with EAP; on either connection type a re-initiated IKE SA replaces the old one only once its Child SA is installed, and one held without a Child SA answers the peer's CREATE_CHILD_SA, liveness probe and Delete. When that reauthentication crosses Ze's own IKE SA rekey or reconnect, the successor the peer started wins in either completion order and Ze deletes its own replacement. A peer whose local address comes from an interface follows that interface's address: when it changes, as a PPPoE redial changes ppp0's, the peers it served stop and the peers the new address serves start, and an interface that is deleted holds no address, so its peers wait for it to return. The mgmt-tunnel and mgmt-tunnel-ed25519 topology scenarios run Ze as initiator from a CPE behind PPPoE against strongSwan, authenticating with a P-256 and an Ed25519 certificate: the IKE SA comes up only once DNS answers, the Child SA is narrowed to ::/0 on both sides, and an IPv6 ping crosses vti0 with each direction's ESP byte counters advancing. SK crypto, key derivation, AUTH octets, and ESP key roles are parameterized by SA role. Compile-out-able with the ze_ike build tag (default-on in ZE_FEATURES): a stripped build drops the engine, IPsec config plumbing, EAP, wire codec, and command surface and rejects a vpn { ipsec {} } block. Two packages stay always-on: ike/dataplane (the XFRM programming seam OSPF's RFC 4552 authentication also uses) and ike/crypto (the IKEv2 transform registry show mtu reads to size the IPsec tunnels the kernel holds).
IPsec EAP Authentication Experimental (partial) EAP-MSCHAPv2 (type 26), EAP-TLS (type 13) and EAP MD5-Challenge (type 4) authentication for road warrior VPN clients inside IKEv2 IKE_AUTH exchange. authentication { mode eap-md5 } selects type 4, and it is never a default. Its AUTH payloads come from SK_pi and SK_pr, because the method derives no MSK. Adopting it writes one warning quoting the RFC 7296 Section 2.16 sentence against a method that establishes no shared key. MS-CHAPv2 crypto (NtPasswordHash, ChallengeResponse, MPPE key derivation), TLS handshake in EAP with fragmentation, MSK derivation feeding IKEv2 AUTH payload. Virtual IP pool with dual-stack allocation (IPv4 + IPv6), DNS push via Configuration Payload: a respond peer with virtual-ip-pool, whatever its authentication method, sends a CFG_REQUEST in IKE_AUTH and is leased an inner address no other live peer holds (RFC 7296 Section 2.19, RFC 3948 Section 5.1), every Child SA of that IKE SA names only the lease for the peer's side, and show vpn ipsec sa lists it under virtual-ip. As the EAP peer, Ze negotiates the method instead of failing: a Request for an authentication type it does not run draws an RFC 3748 Section 5.3.1 legacy Nak (type 3) naming the configured method, and a Notification Request (type 2) draws a Notification Response with its message in the daemon log. On EAP-TLS the peer sends an anonymous Network Access Identifier rather than its local-id, because RFC 9190 Section 2.1.8 forbids a permanent identifier in the cleartext Identity Response: the realm is kept and the username omitted (@realm), and an identity carrying no realm the RFC 7542 Section 2.2 grammar accepts becomes the fixed anonymous. On EAP-TLS 1.3 the authenticator answers a Certificate Status Request with the OCSP response configured on the certificate it presents (pki certificate <name> ocsp-response), which RFC 9190 Section 5.4 makes mandatory; the peer refuses a chain whose stapled status is missing, expired, about another certificate or not good once certificate-status-request is set, and it re-checks the authenticator's certificate against that certificate's own OCSP responder over https as soon as the Child SA gives it a network, closing the SA when the responder reports a revocation. Scope gaps: the RFC 5216 3DES cipher-suite MUST is not met; the RFC 5216 Section 5.3 SHOULD to retrieve missing intermediate certificates is not met (no Authority Information Access fetch; the intermediate-certificate list pre-configures them instead); RFC 3748 is Partial in the ledger with open defects in spec-ike-eap-rfc-defects.
IPsec MOBIKE Experimental (partial) RFC 4555 MOBIKE for IPv4 tunnel-mode peers, as initiator or responder: address updates, UDP 4500 source selection, COOKIE2 return-routability checks, NO_NATS_ALLOWED under the per-peer nat-traversal policy, and live XFRM state migration that keeps the sequence number and replay window. A peer advertises MOBIKE only when the kernel provides Linux 7.2's XFRM_MSG_MIGRATE_STATE API and CONFIG_XFRM_MIGRATE; other kernels, other backends and transport-mode peers do not. The mgmt-tunnel and mgmt-tunnel-ed25519 topology scenarios check that strongSwan holds Ze's IKE SA on UDP 4500 with no NAT on the path, which only MOBIKE's move explains (RFC 4555 Section 3.3). These two and the mobike-initiator and mobike-responder interop scenarios have no run recorded for this feature, and the RFC 4555 ledger entry is Partial. Scope gaps: IPv6 and transport-mode peers do not advertise MOBIKE; kernels without XFRM_MSG_MIGRATE_STATE and CONFIG_XFRM_MIGRATE do not advertise it; the RFC 4555 ledger entry is Partial.
IPsec NAT Traversal Experimental (partial) NAT detection via SHA-1 hash notify payloads in IKE_SA_INIT (RFC 7296 Section 2.23). Port 4500 with non-ESP marker for IKE, UDP encapsulation for ESP (RFC 3948). NAT keepalive (0xFF byte, 20s interval). XFRM SA UDP encap attribute set when NAT detected. Transport mode works across an address-translating NAT on both roles: RFC 7296 Section 2.23.1's selector substitution replaces the addresses the peer named with the addresses this node observed, so the SA the kernel programs matches the packets it really sees. The SA records which side each translation is on, and show vpn ipsec sa reports it as behind-nat and peer-behind-nat beside nat-detected. A peer whose remote-address is a DNS name runs the same detection over the address the name resolved to on that connect cycle, and a peer with no local-address hashes over the address it sends from: the interface address under vpn ipsec interface, else the source the routing table picks toward the peer. Scope gaps: RFC 3948 Section 5.1 ESP port behind NAT is an open defect; NAT transport mode is not proven on the appliance kernel.
IPv6 Router Advertisements Experimental Ze sends IPv6 Router Advertisements on a LAN interface unit (RFC 4861). This is the job radvd does on other systems. Hosts build addresses by stateless address autoconfiguration (SLAAC), learn a default router, and learn DNS resolvers (RFC 8106 RDNSS, up to 8 servers). The router-advertisement container sits in the per-unit ipv6 container. It carries the M and O flags, the per-prefix L and A flags, four timers, a prefix list, and the resolver block. The container is Linux only and netlink only. A backend vpp tree rejects it at config verify. Config verify applies the cross-leaf rules a YANG range cannot express. minimum-interval is at most 0.75 x maximum-interval, and preferred-lifetime is at most valid-lifetime. A prefix with host bits is rejected rather than masked, and so is the link-local prefix. Two zero values are legal input. router-lifetime 0 advertises prefixes and resolvers while Ze is not a default router. rdnss lifetime 0 tells hosts to stop using the resolvers. The iface-ra plugin owns the socket and the timers. Every advertisement leaves with Hop Limit 255. The sender joins for Router Solicitations and sends to. Each unsolicited interval is random between the two configured bounds, and a solicited answer is rate limited. A sender that stops sends one advertisement with a Router Lifetime of 0. Counters are ze_iface_ra_sent_total{interface} and ze_iface_ra_solicited_total{interface}. ze doctor reports doctor-iface-ra-forwarding when an advertising interface has IPv6 forwarding off, on the device or in the kernel's global switch. A unit that names a WAN with ipv6 delegated-prefix <wan> is in the CE role (RFC 7084). Each advertisement it sends carries the unit's /64 from the delegation in a Prefix Information option with the L and A flags, and one Route Information option (RFC 4191) for the whole delegated prefix. Both carry the lifetimes that remain of the delegation at the moment of the send, so they never outlive it (RFC 9915 Section 6.3). A /64 whose delegation ended, or that the unit stopped numbering from, is advertised once with zero lifetimes and then dropped. The Router Lifetime follows two inputs: W, whether the main table holds an IPv6 default route through a WAN device the unit names, and P, whether the unit advertises a prefix (an operator prefix entry, or a delegated /64 still valid). With W and P both true it is the configured router-lifetime; otherwise it is 0, and the PIO and RIO are still sent while the delegation holds (RFC 7084 G-4, L-4, L-3). When the Router Lifetime crosses zero in either direction, or a /64 is retired, the next advertisement leaves at once instead of at the next periodic interval, within the 3 second spacing RFC 4861 Section 6.2.6 sets (RFC 7084 G-5). A unit with no delegated-prefix keeps the configured Router Lifetime whatever the WAN does. A WAN name Ze cannot resolve counts as holding no default route, logged once at WARN when it starts failing and once at INFO when it resolves. The pppoe-dhcpv6-pd-ze-client topology scenario proves the RIO route on a dhcpcd host, the configured Router Lifetime while the session is up, and Router Lifetime 0 once the access concentrator ends the session. . ff02::2ff02::1
IS-IS Experimental (partial) Native IS-IS link-state IGP (ISO/IEC 10589, RFC 1195/5305/5301/5303/5308) running directly over Layer 2: L1+L2 levels, broadcast + point-to-point circuits with DIS election and pseudo-nodes, adjacency FSM, link-state database with flooding (CSNP/PSNP sync), SPF, and FIB install via the shared Loc-RIB. Authentication (RFC 5304 HMAC-MD5, RFC 5310 generic crypto / HMAC-SHA, and cleartext) is configured as named key-chains with $9$-encoded secrets: per-interface chains authenticate Hellos (IIH), per-level chains (area key L1 / domain key L2) authenticate LSPs and CSNP/PSNP; the Authentication TLV is emitted first, LSP digests zero the Authentication Value + Checksum + Remaining Lifetime before signing (Fletcher checksum computed after), purges are authenticated, key rotation is hitless via send/accept lifetimes, and every digest compare is constant-time. Auth-failure rejections increment ze_isis_auth_failures_total{level,interface}. Redistribution meshes IS-IS with BGP in both directions through the protocol-agnostic redistribute framework: a single source isis exports SPF routes (redistribute { destination bgp { import isis } }), and an isis consumer imports connected/static/BGP prefixes into IS-IS LSPs as Extended IP Reachability (TLV 135, redistribute { destination isis { import connected/static/bgp } }); enabled and passive interface prefixes are also advertised. TLV 135 carries no external bit (RFC 5305 sec 4); the up/down bit is set only on a down-level leak (RFC 2966). Redistribution counters are ze_isis_redist_injected_total{source,afi}, ze_isis_redist_withdrawn_total{source,afi}, ze_isis_redist_inject_failures_total{source}, and ze_isis_lsp_reoriginations_total{level}. Dual-stack IPv6 (RFC 5308) runs over the same instance under single-topology: per-interface address-family ipv6-unicast advertises NLPID 0x8E (TLV 129), carries the link-local address in the Hello (TLV 232) and non-link-local addresses in the LSP, originates IPv6 prefixes as IPv6 Reachability (TLV 236, link-local prefixes excluded per RFC 5308 sec 2), runs IPv6 route extraction over the shared SPF tree (a TLV 236 metric above MAX_V6_PATH_METRIC 0xFE000000 is ignored), and installs IPv6 routes via the same Loc-RIB path (show isis route ipv6); IPv6 redistribution works both ways under the single isis source with an afi=ipv6 counter label. Non-congruent IPv4/IPv6 topologies are not supported, because RFC 5120 Multi-Topology is not implemented. LSDB operations: every show isis database row carries an own boolean, so an operator sees at a glance which LSPs this node originated. A received claim on one of this node's own LSP IDs, a purge included, is never overwritten: the node raises its origination sequence floor above the claimed number, re-originates, and floods, which is ISO/IEC 10589 clause 7.3.16.4 c) deferring to clause 7.3.16.1. The dynamic hostname is refused at config time outside 7-bit ASCII, and bounded per label and in total, per RFC 5301 Section 3 and RFC 2181 Section 11, so an unencodable value fails the commit rather than the wire. Live adjacency, flooding, SPF, dual-stack, and FRR interop run as QEMU integration / interop tests. The IS-IS plugin is compile-out-able with the ze_isis build tag: the default-on feature set includes it in normal and appliance builds, while ze-stripped and bare ze_core builds drop internal/plugins/isis (engine, codec, transport, cli, schema) from both composition roots and reject the isis {} config block as unknown. Scope gaps: non-congruent IPv4 and IPv6 topologies (RFC 5120 Multi-Topology); SPF and LSP timers (plan/post-release/features/spec-isis-spf-lsp-timers.md).
IXP Route Server Dynamic Peers Experimental (partial) Route server (bgp-rs) supports dynamic peers for IXP deployments. Peers connect dynamically and inherit configuration from a peer group template. RS-client role and per-peer community filtering. RFC 7947 Section 2.1 is not met: an UPDATE that an ingress filter denies never reaches the Adj-RIB-In, so show bgp adj-rib-in holds the post-policy routes. Scope gaps: RFC 7947 Section 2.1 Adj-RIB-In holds post-policy routes (plan/release/fixes/spec-rfc7947-adj-rib-in-accepts-filtered-updates.md).
L2TPv2 BNG Experimental (partial) New-session PPP policy includes mru (68..1500, default 1500) and the ordered authentication/allow set. IPv6CP defaults enabled and requires an MRU of at least 1280. Disable IPv6CP to configure 68 through 1279 for IPv4-only service. MRU and authentication policy hot-apply to new sessions; established sessions retain their policy. show l2tp config reports the effective values. Native L2TP interop proves the 1492 transmit cap with omitted peer MRU and accepted proxy MRUs of 1500 and 9000. Those IPv4 sessions authenticate, carry traffic and release their interfaces. The refusal scenario verifies required authentication closes before LCP opens. The topology scenarios prove the LAC relay data path with Ze in every PPP role: a Ze CPE dials with no Service-Name, a Ze LAC relays it (relay "") over L2TP to a Ze LNS, and the LNS checks CHAP against FreeRADIUS. access-up asserts the Framed-IP-Address on the CPE, MRU 1492 and CHAP-MD5 on the LNS session, and a ping across the LAC's kernel channel bridge; access-pool asserts the pool fallback, and access-accounting the Start, Interim-Update and Stop records with the session's octets. Each goes red when its producer is broken. The LNS policy for a LAC's proxy LCP (RFC 2661 Section 4.4.5) is the proxy-lcp leaf: accept, the default, opens LCP on valid proxy LCP; renegotiate ignores it and negotiates LCP with the subscriber afresh, then authenticates with the configured method. show l2tp session id <id> names the outcome (accepted, renegotiated, none). Unit and wiring tests prove it; the pppd interop scenario l2tp-lns-lcp-renegotiate-pppd is not yet run. As a LAC, Ze can choose the LNS from the realm of the subscriber's PPP username, the way a wholesale access network does: an l2tp relay-realm <realm> { remote <name>; } binding names a declared remote. The realm is the text after the last @ of the username, matched exactly once case is ignored, so cpe@Example.NET matches example.net and cpe@x.example.net does not. For a matched realm the LAC runs LCP and starts authentication with the subscriber itself, then places an incoming call to the bound remote whose ICCN carries the RFC 2661 Section 4.4.5 proxy AVPs: the three LCP Configure-Requests (AVPs 26 to 28) and the proxy authentication type, name, challenge, Identifier and response (AVPs 29 to 33), each with M=0. A PAP password travels only hidden, so with no shared-secret on the remote a PAP subscriber's proxy authentication is left out and the LNS restarts it. Once the session is up the LAC bridges the subscriber's PPP channel to it and the LNS carries on the PPP session. A username with no realm, or whose realm names no binding, is authenticated locally as for any PPPoE session, and a Service-Name relay that matched at discovery wins over the realm. A matched realm whose call cannot start, and an MS-CHAPv2 subscriber of a matched realm, are refused, never authenticated locally. show l2tp session id <id> on the LAC adds relay-realm, relay-remote, proxy-lcp-sent, proxy-auth-sent and, when no proxy authentication was sent, proxy-auth-reason. The access-wholesale topology scenario proves the relay with a Ze LNS; the accel-ppp and xl2tpd LNS scenarios are written and not yet run. The PPP engine's IPv6CP boundary tests negotiate at MRU 1280 with a test address provider. Shipped subscriber service remains IPv4-only: the static pool declines IPv6 requests. Subscriber IPv6 traffic and prefix delegation belong to the post-release IPv6 subscriber spec under the owner's existing release decision. RFC 2661 L2TPv2 LNS/LAC with full BNG stack: tunnel lifecycle (SCCRQ/SCCRP/SCCCN, CHAP-MD5 challenge, HELLO keepalive, StopCCN teardown, tie-breaker), configurable dead-peer detection (hello-retries x hello-interval ACK-driven keepalive timeout, separate from the ~31s reliable-transport retransmit exhaustion, so a peer that dies without StopCCN is torn down fast while an idle-but-alive peer that only ZLB-ACKs HELLOs is not falsely dropped) , reliable delivery with sliding window and congestion avoidance, PPP negotiation (LCP 10-state FSM, PAP/CHAP-MD5/MS-CHAPv2 auth, IPCP/IPv6CP address assignment, proxy LCP), kernel data plane via l2tp_ppp netlink and PPPoL2TP sockets. Four plugins: auth-local (static users), auth-radius (RADIUS auth/acct/CoA/DM with failover, real per-subscriber traffic counters in Interim/Stop including RFC 2869 Gigawords), pool (bitmap-backed IPv4 ranges from Ze config), shaper (TC TBF/HTB on pppN interfaces with configured defaults and CoA rate updates). Subscriber route redistribution via redistribute { import l2tp }: the real RouteObserver emits add/remove route-change batches, and BGP announce/withdraw plumbing is covered with a synthetic producer. CQM monitoring (100s echo RTT/loss buckets, per-login sample rings, 24h retention). Web UI at /l2tp with session list, detail page, uPlot CQM graph with SSE live updates, event timeline, and disconnect with audit trail. ze_l2tp_* Prometheus metrics (session/tunnel gauges, per-session byte/packet counters, CQM echo RTT histogram, loss ratio, bucket state). ze_radius_* metrics (auth/acct/interim counters, server reachability). RADIUS Access-Accept subscriber profile attributes are consumed: Framed-IP-Address bypasses pool (direct IP assignment), Framed-Pool selects a named pool, Session-Timeout/Idle-Timeout enforce session lifetime, Filter-Id sets initial shaping rate at session establishment, Vendor-Specific attributes (RFC 2865 S5.26) extract CoS profiles from Cisco-AVPair/Juniper ERX/Nokia/Huawei VSAs and shaper rates from MikroTik Mikrotik-Rate-Limit (Ze "cos:" Filter-Id takes priority; unknown vendors silently ignored), Acct-Interim-Interval sets the per-session accounting interval for a deployment that left acct-interval unset, because RFC 2869 Section 2.1 gives a locally configured value precedence over the Access-Accept, and Framed-Route/Framed-IPv6-Route (RFC 2865 Section 5.22, RFC 6911 Section 3.2) inject per-subscriber static routes into BGP alongside the subscriber /32 or /128. Named pools are configured via YANG named-pool list under l2tp > pool. PPP auth now defaults to mandatory CHAP-MD5 with finite tunnel/session caps; no-auth requires explicit opt-in, hidden mandatory AVPs are rejected fail-closed. Every Accounting-Request carries Framed-IP-Address, the address IPCP actually assigned (RFC 2866 Section 4.1), and a NAS-Port-Id composed once per session from a {nas-id} / {tunnel-id} / {session-id} template (nas-port-id-format, RFC 2869 Section 5.17), so an LNS with no physical port still joins its accounting records. An SCCRQ whose Assigned Tunnel ID AVP carries 0 is a protocol error under RFC 2661 Section 4.4.3: Ze answers it with a StopCCN sent outside any tunnel, allocates no tunnel, and bounds the reply to one per source-address slot per second so a spoofed flood costs nothing. Docker-backed xl2tpd evidence covers external LAC control tunnel and incoming-call session setup. A peer-isolated Docker lab (./le test deployment docker-l2tp-ppp) proves full PPP LCP/IPCP, kernel pppN creation, dataplane ping, and BGP route redistribution from a live PPP session with Ze LNS, real xl2tpd/pppd LAC, and FRR in separate containers; requires host kernel PPPoL2TP support. Compile-out-able with the ze_l2tp build tag (default-on in ZE_FEATURES): a stripped build drops the whole BNG subtree (L2TP, PPPoE, subscriber management, local-auth/pool/shaper plugins) and rejects l2tp {} and pppoe {} blocks; the hub builds the subsystems through the gated bngRegister seam, the web session pages and diag l2tp captures answer not-in-this-build, and the cos dynamic RADIUS-CoS handler drops with it. Scope gaps: RFC 2661 MUST gaps open in the ledger; BGP announce and withdraw for subscriber routes are proven only with a synthetic producer; subscriber IPv6 remains a post-release extension.
LAN DNS Resolver Experimental (partial) Caching LAN DNS resolver (service dns-resolver) for the hosts behind Ze. It answers recursive queries on the listener addresses the operator names (UDP and TCP, wildcard addresses refused), only from allow-from source prefixes, and resolves by forwarding, with failover, TCP retry on truncation and RFC 5452 reply matching, to the upstreams its forward dns-source list selects. In that list configured is the ordered forward server list and received the resolvers Ze learned from DHCPv4, DHCPv6, IPCP and RA RDNSS, narrowed by received-interface; two sources combine first-usable or merge, and self and radius are refused. With no list written it asks forward server when one is set, else the learned resolvers, and it follows each lease change without rebinding its listeners or emptying its caches. Answer and negative caches with TTL caps, trust ranking and bailiwick checks; bounds on outstanding resolutions, per-client rate and per-query work. show dns resolver, clear dns resolver cache all, its selection in show system dns, two ze doctor checks of its own and the doctor-dns-source-* warnings over its list, and ze_dns_resolver_* metrics. It does not recurse from the root and does not validate DNSSEC. Scope gaps: forwarding only: no recursion from the root (spec-dns-resolver-recursion); no DNSSEC validation (spec-dns-resolver-dnssec-validation); no DoT or DoH listener.
MCP Integration Experimental AI-assisted BGP operations through Model Context Protocol. The transport is stateless Streamable HTTP, revision 2026-07-28: per-request _meta, standard request headers, per-request authentication, and server/discover. Ze is an OAuth 2.1 resource server. Background tasks are server-directed through the extension: the daemon reads each command's ze:task-support annotation and decides whether to return a task handle. The client polls a task, and the server never pushes one. MCP Apps UI resources carry embedded panels, and Ze gates them on the extension. Cacheable results carry ttlMs and a private cacheScope on server/discover, tools/list, resources/list and resources/read. Elicitation runs as a Multi Round-Trip Request. The server RETURNS resultType: "input_required" with an inputRequests map, in form mode. Ze sends this result only when the client declares form-mode support. The client then retries the original call with inputResponses, because the revision forbids a server to send an independent request on any stream. Ze mints no requestState, so Ze holds nothing between the two requests. The service is default-on and compile-out-able with the ze_mcp build tag. normal and appliance builds include it, and ze-stripped and bare ze_core builds drop internal/component/mcp and its schema. An omitted MCP exposes no endpoint, and Ze rejects its environment { mcp {} } config block as unknown. . io.modelcontextprotocol/tasksio.modelcontextprotocol/ui
MPLS / LDP / RSVP-TE Experimental (partial) Kernel MPLS forwarding: BGP labeled-unicast routes programmed into the Linux MPLS FIB (label push via netlink lwtunnel), 20-bit label / 16-deep stack validation, net.mpls.platform_labels + per-interface mpls { enable } (net.mpls.conf.<iface>.input) sysctls, ze doctor kernel-module check, ze_fibkernel_mpls_* metrics, show mpls forwarding (reads the kernel AF_MPLS table). LDP (RFC 5036): UDP multicast discovery, TCP session FSM, label information base. RSVP-TE (RFC 3209/2205): control plane over raw IP (protocol 46) -- PATH/RESV signaling for ingress/transit/egress, ERO-based explicit routing, per-interface bandwidth admission control with PathErr on oversubscription, soft-state refresh, PathTear teardown, and make-before-break reroute (SE style). Fast Reroute (RFC 4090): facility backup -- a tunnel fast-reroute request adds FAST_REROUTE/SESSION_ATTRIBUTE protection flags to PATH; a transit Point of Local Repair arms a configured bypass, and on a link failure redirects the LSP onto it with a 2-label stack (the bypass label over the protected label), sends a PathErr Notify (code 25/3) toward the head-end without tearing the LSP down, and the head-end re-optimizes make-before-break; node protection merges at the next-next hop using RRO label recording. Dataplane: RSVP-TE/LDP emit push/swap/pop forwarding entries on the mpls-fib event bus and fib-kernel programs them (IP route + label for push, AF_MPLS routes for swap/pop, including the 2-label facility-backup stack), keeping fib-kernel the single kernel-FIB owner. ze-to-ze FRR is covered by the in-memory fabric interop. Cross-vendor RSVP-TE interop runs against freeRouter, built by, in the Docker suite ./le test integration interop-rsvpte: a Ze transit expands a loose ERO hop, forwards a strict hop and refuses an outside strict hop with PathErr 24/2, and freeRouter parses and relays the PATH, PathErr, ResvErr and ResvTear Ze originates to another Ze node. freeRouter does not enforce strict hops itself, so the strict scenarios prove it relays what Ze sends, not that it agrees on strict-hop validation. TestRSVPFreeRouterInterop (freeRouter ingress, Ze egress) is a manual guest procedure in the RSVP-TE guide with no recorded pass. LDP and RSVP-TE are independently compile-out-able with the ze_ldp and ze_rsvpte build tags (default-on in ZE_FEATURES; dropped from ze-stripped / bare ze_core, with their ldp {} / rsvp-te {} config blocks rejected as unknown); the MPLS operational surface (show mpls forwarding and the show mpls command schema, internal/component/mpls + internal/plugins/mpls-cmd) is compile-out-able with ze_mpls, while kernel MPLS forwarding itself (fib/kernel) stays always-on. Scope gaps: RSVP message validation (plan/release/validation/spec-rsvp-message-validation.md); RFC 4090 one-to-one backup (plan/post-release/features/spec-mpls-9-rsvp-te-one-to-one-backup.md); RFC 2205 gap rows in rfc/short/rfc2205.md; interop with RSVP-TE implementations other than freeRouter. test/interop-rsvpte/Dockerfile.freertr
OSPF Experimental (partial) Native OSPF engine with one ospf config root for OSPFv2 IPv4 and OSPFv3 IPv6 (address-family ipv6): raw protocol 89 transports, interface and neighbor state machines, LSDB flooding/aging, intra-area SPF, ABR summary origination, inter-area route calculation with area ranges, ASBR external origination and redistribution, OSPFv3 Link-LSAs and Intra-Area-Prefix-LSAs, stub / totally-stubby / NSSA areas (RFC 3101: Type 7/NSSA origination, Highest-Router-ID translator election with a stability-interval grace so a transient flap opens no Type 5 gap, Type 7 to Type 5 translation, §2.5 preference; Section 2.4's border-router default is originated into every directly attached NSSA with no operator gate, in BOTH address families, as a P-clear Type 7 into a regular NSSA (the OSPFv3 NSSA-LSA 0x2007, whose P-bit rides in the prefix options) and a Type 3 at default-cost into a no-summary one (::/0 as an Inter-Area-Prefix-LSA for OSPFv3), which leaves default-originate meaning only an internal router's P-set Type 7 default, itself conditional on a usable non-zero forwarding address and inert in a no-summary NSSA per §1.3; a border router refuses a received Type 7 default whose P-bit is clear and every Type 7 default while it suppresses summary import, and an internal router installs both), virtual links through a transit area (RFC 2328 §15 / RFC 5340 §4.2: config-validated transit-area/ABR/self rules, transit-area-SPF-computed cost, backbone Router-LSA virtual record + transit-area V-bit, §16.3 transit pass, routed transport), the RFC 5250 opaque-LSA carrier with RFC 3630/5392 Traffic Engineering and the RFC 7770 Router Information LSA (OSPFv2 Opaque type 4, OSPFv3 function code 12, informational capability bits, a consumer-neutral TLV hook), the RFC 7684 Extended Prefix/Link Opaque LSAs (Opaque type 7/8, prefix/link attribute containers with a generic sub-TLV registration hook for Segment Routing), Graceful Restart (RFC 3623 IPv4 + RFC 5187 IPv6, one shared restarter + helper control plane: the IPv4 Grace-LSA rides the opaque carrier as Opaque type 3, the IPv6 Grace-LSA is a native link-scope LS type 0x000B, non-stop forwarding via the RTPROT_ZE FIB retention, an NVS restart fact, and a family-neutral graceful-restart config), Segment Routing over the MPLS data plane (RFC 8665 IPv4 + RFC 8666 IPv6, one shared control plane: SRGB/SRLB label ranges, the multi-range index-to-label arithmetic, the NP/E/M push/swap/PHP truth table, node Prefix-SIDs and SRLB-allocated Adjacency-SIDs, install through the shared mpls-fib bus as the third producer alongside LDP and RSVP-TE; the IPv4 family rides RFC 7770/7684 opaque LSAs and the IPv6 family the RFC 8362 Extended LSAs), LFA / TI-LFA fast reroute (RFC 5286: per-neighbour SPFs and the strict loop-free / node-protecting / downstream inequalities select a pre-computed backup next-hop per primary, with a TI-LFA post-convergence Segment-Routing repair list where no directly-connected LFA exists, the §6.3 multi-area suppression rules, carried to the FIB writer through a generic carry-through field on locrib.Path, with a gap: the kernel route holds the primary path only, so the backup is not used on a primary link failure; IPv4 carries SR repair labels, OSPFv3 gets base-LFA next-hop selection through the address-family seam), per-interface OSPFv2 authentication with key chains and replay protection, ECMP, and FIB install through the shared Loc-RIB -> sysrib -> fibkernel path. show ospf exposes process, neighbor, interface, database (including opaque, te-database, and router-information views), route, SPF, and border-router views. The OSPF plugin is compile-out-able with the ze_ospf build tag: the default-on feature set includes it in normal and appliance builds, while ze-stripped and bare ze_core builds drop internal/plugins/ospf (engine, codec, transport, v3, cli, schema) from both composition roots and reject the ospf {} config block as unknown. Scope gaps: RFC 3101 NSSA single ABR default producer and its interop scenarios (plan/release/fixes/spec-ospf-nssa-single-abr-producer.md); RFC 2328 and RFC 5340 obligations the ledger marks Partial.
Path Identifier regeneration (RFC 7911) Experimental Ze generates its own Path Identifier for every route it re-advertises rather than relaying the one the source chose. The identifier is keyed on the ingress path, and how much of the path the key holds follows what the SOURCE framed. A source that negotiated no ADD-PATH names a path by its prefix alone, so ze holds one identifier for that source's whole session and releases it when the peer is removed. A source that negotiated ADD-PATH names a path by (prefix, identifier), so ze holds one entry per family, received identifier and prefix, and frees it once it has relayed that pair's withdraw. Either way the same path always gets the same value, and two route-server clients that happened to pick the same identifier no longer collide at a third. A received identifier of 0 is a value and not an absence: RFC 7911 Section 3 makes it legal, and a source that negotiated no ADD-PATH sends every path under it. The table tracks every identifier currently assigned, so a wrapped counter cannot hand a live path's identifier to a second path.
PATHS-LIMIT (draft-abraitis-idr-addpath-paths-limit-04) Experimental Receiver-requested ADD-PATH limit per family and prefix. Ze enforces the peer's negotiated limit across batches on each destination connection, including route-server fast-path forwarding. When a better path arrives for a route already at the peer's limit, Ze asks the bgp-rib plugin's election which paths rank first, withdraws the demoted path, then announces the better one; without the RIB the first admitted paths keep their slots and a warning names the cause. Replacements remain permitted, withdrawals free slots, and a new connection resets the count. Local capability { add-path { limit { receive N; } } } advertises a receive limit, with per-family overrides, and Ze enforces it on received paths: an excess path is dropped, the rest of its UPDATE installs, and each refusal is counted. See ADD-PATH and PATHS-LIMIT.
PPPoE Access Experimental (partial) RFC 2516 PPPoE access concentrator: discovery state machine (PADI/PADO/PADR/PADS/PADT), HMAC-SHA256 AC-Cookie for DoS protection, per-interface session tables with bitmap SID allocation (1-65535), per-source-MAC PADI rate limiting, Service-Name filtering, kernel PPPoE sessions via AF_PPPOX + PX_PROTO_OE, and integration with the transport-agnostic PPP Driver (same auth/pool/shaper plugins as L2TP). Subscriber authentication is per-AC: auth-method selects none, pap, chap-md5 (the default) or ms-chap-v2, and the AC advertises it in its own LCP Configure-Request; allow-no-auth is the explicit opt-in that auth-method none requires, so an unauthenticated concentrator is never the default. The credential is verified by the same l2tp-auth-local or l2tp-auth-radius handler L2TP uses. YANG config (pppoe {}) with per-interface settings. CLI commands: show pppoe, show pppoe sessions, show pppoe statistics, show pppoe interfaces. Runs concurrently with L2TP on the same daemon. Functional tests (./le test qemu pppoe) drive a real client over a veth pair inside a per-test network namespace on ze's runtime kernel: PADI to PADO carrying AC-Name and AC-Cookie, PADR to PADS with a kernel AF_PPPOX session and a non-zero session id, a forged AC-Cookie earning no PADS, the same exchange on an 802.1Q sub-interface, and an L2TP SCCRP answered while the AC is bound. Both roles are now interop-tested in: scenario 01 runs Ze as a client against accel-ppp, and scenario 02 runs Ze as the access concentrator with pppd 2.5.1 and the rp-pppoe plugin as the client, asserting discovery, LCP, CHAP-MD5 accept and reject, IPCP address assignment from the pool, ICMP across the session, and a PADT teardown that empties Ze's session table read over its own REST API. Partial because PADI rate limiting and Service-Name filtering still have unit coverage only. The access-reconnect topology scenario redials through Ze's AC on a LAC that relays the PPPoE session to an L2TP LNS: once the LNS clears the session, the CPE's fresh discovery is answered and the CPE comes back with the new address RADIUS hands out. PPPoE ships inside the ze_l2tp build tag (the BNG gate); a stripped build rejects a pppoe {} block as unknown. Subscriber PPP policy uses the flat ordered-set leaf pppoe authentication-allow. Absent or empty lists derive [chap-md5] for auth-method chap-md5, [ms-chap-v2] for ms-chap-v2, [chap-md5 pap] for pap, and no methods for none. Explicit lists must contain auth-method and cannot contain none or accompany auth-method none. CHAP variants precede PAP; the configured CHAP variant precedes the remaining variants in written order. Startup and reload share the policy parser; reload changes only new sessions. Configurations relying on implicit PAP fallback must explicitly include PAP. The PPPoE MRU ceiling remains 1492. On a LAC with an l2tp relay-realm binding, the PPPoE AC records each new session's LCP exchange and, when the subscriber authenticates, asks the L2TP subsystem to relay it by the realm of its username (the text after the last @, matched exactly once case is ignored) before any auth handler sees the credential. A matched realm is relayed: the AC has run LCP and started CHAP or PAP per authentication-allow, and L2TP places an incoming call whose ICCN carries the subscriber's LCP and authentication as proxy AVPs, then the PPPoE channel is bridged to the L2TP session. A username with no realm, or whose realm names no binding, is authenticated locally by the configured auth handler; a matched realm whose call cannot start, and an MS-CHAPv2 subscriber of a matched realm, are refused with an authentication failure and an LCP Terminate-Request, never authenticated locally. The L2TPv2 BNG feature carries the L2TP half and the show l2tp session keys. Scope gaps: PADI rate limiting and Service-Name filtering have unit coverage only. test/pppoe/test/interop-pppoe/
RADIUS admin AAA Experimental (partial) RFC 2865 RADIUS authentication for operator/admin login (SSH, web, MCP), distinct from the L2TP subscriber RADIUS path. PAP (User-Password hidden per §5.2), CHAP (CHAP-Password §5.3 with a 16-octet CHAP-Challenge §5.40, both generated per login from crypto/rand), or EAP with MD5-Challenge or MS-CHAPv2 carried in EAP-Message attributes (RFC 3579 §3.1), selected by the auth-method leaf and defaulting to pap; RFC 2865 §4.1 and RFC 3579 §3.3 Note 1 permit one credential type and never two, so exactly one is sent and the socket refuses a request carrying two, and §2.2 makes chap and eap-md5 usable only against a server holding the password in cleartext while eap-mschapv2 needs the NT hash. Ordered server failover with per-server timeout and retries, Access-Accept reply-attribute-to-profile mapping (configurable, default Filter-Id §5.11, or Class §5.25) with a default-profile fallback, an Accept resolving to no profile rejected rather than authorized (an authenticated login always names at least one profile), and explicit-reject vs unreachable distinction so a wrong-password Access-Reject does NOT fall through to local bcrypt while an unreachable server does. Runs as a pluggable aaa.Authenticator at chain priority 50 (ahead of TACACS+ 100 and local 200); local bcrypt remains the fallback. ze doctor probes reachability (doctor-radius-admin-unreachable) and names a server that answers only unsigned (doctor-radius-admin-unsigned-response). Reuses the L2TP RADIUS client, so retransmit, failover, and Response-Authenticator verification behave identically. For the two EAP methods ze is the EAP PEER itself, answering with the password the operator typed rather than relaying frames, so no login transport changes: it splits one EAP packet across consecutive EAP-Message attributes at 253 octets, signs every Access-Request with a Message-Authenticator placed first (the RFC 3579 §3.2 HMAC-MD5, which draft-ietf-radext-deprecating-radius-10 §4.2 extends from EAP to PAP, CHAP and MS-CHAP as the BlastRADIUS CVE-2024-3596 defence), discards an answer that carries no Message-Authenticator before its Response Authenticator is checked unless that server row sets require-message-authenticator false (§4.6, counted on ze_radius_unsigned_response_discards_total{server}), silently DISCARDS a reply whose Message-Authenticator does not verify so a forged packet cannot stop the AAA chain, and answers each Access-Challenge with the State attribute copied byte for byte and never read (RFC 2865 §5.24). The conversation is bounded by the peer's 20-round cap and the login time budget, neither of which a server can raise. EAP-TLS is implemented in the peer and not offered here: it needs an operator certificate and key. Admin-session accounting is not implemented. Compile-out-able with the ze_radius build tag (default-on in ZE_FEATURES); the l2tp RADIUS auth plugin is the dependent piece, generated behind ze_l2tp && ze_radius, so a radius-less BNG build links zero RADIUS symbols and a bng-less build keeps RADIUS system authentication. Scope gaps: admin-session accounting is not implemented; EAP-TLS is not offered; RFC 3579 MUSTs are not all proven.
RFC 1997 well-known community suppression Experimental NO_EXPORT, NO_ADVERTISE and NO_EXPORT_SUBCONFED are honored on egress automatically, on both forward rails, with no configuration and no switch. The scan runs once per UPDATE over the SOURCE payload the peer sent, never over a policy chain's wire override, so an export policy that strips NO_EXPORT does not license the leak: the route arrived carrying it. A destination the gate refuses is sent the withdrawal of every route that UPDATE names rather than nothing (RFC 7606 Section 2 treat-as-withdraw), so a route already advertised is taken back. This is the ordering that separates Ze from FRR and BIRD, which apply the route-map first, where stripping the community there restores advertisement.
RFC 7999 BLACKHOLE Experimental Per-session honoring of the BLACKHOLE community, off by default. The peer names the community it uses (blackhole communities, the well-known 65535:666 or its own) and the prefixes it is authorized to blackhole within (blackhole prefixes); RFC 7999 Section 3.3 states both conditions, so a peer with a community and no covering prefix blackholes nothing. A honored route becomes a discard route directly: a Linux FIB blackhole or a VPP drop, with no next-hop to allocate and no static route to pre-create. The same list governs the send side, which is RFC 7999 Section 3.1's requirement that the two networks agree before the community is advertised: send bgp <sel> blackhole and send bgp <sel> unicast <prefix> community 65535:666 reach only the sessions that agreed, and a session that named its own value alone is left out rather than sent the prefix untagged. A relayed route carrying BLACKHOLE follows the same agreement: it reaches an eBGP neighbor only when that session agreed, iBGP sessions and route-server clients are not refused, and a reload that removes the agreement withdraws the route from that neighbor. The leaves are augmented at the bgp, group and peer levels.
RFC 9774 AS_SET and AS_CONFED_SET deprecation Experimental (partial) Ze never advertises an AS_SET or AS_CONFED_SET, and by default does not accept one. A received UPDATE whose AS_PATH or AS4_PATH holds either segment type is treat-as-withdraw (RFC 7606), whatever the AS width, so the route is never installed and a route the peer announced earlier is withdrawn. The one exception is a peer whose session as-set the operator set to accept (the default is withdraw), the operator configuration RFC 9774 Section 3 allows; ze exabgp migrate writes it for an ExaBGP neighbor configured as-set accept. On send, every UPDATE a producer hands the session (relay, API, configured static route, plugin) is checked in the one writer: when any AS_PATH or AS4_PATH occurrence holds a set, the UPDATE is written as the withdrawal of its prefixes instead, logged as a rate-limited warning naming the peer and the route count, and counted on ze_bgp_as_set_withdrawn_total. Only the send bgp <peer> raw test instrument writes operator bytes as given. Scope gaps: RFC 9774 Sections 5.2 and 6.1 bind route aggregation; which Ze does not implement (feature-out-of-scope in rfc/extraction/rfc9774.json).
RPKI ASPA Policy Enforcement Stub-backed ASPA path verification (draft-ietf-sidrops-aspa-verification-28) with configurable policy enforcement: rpki/aspa/action/invalid supports reject, log-only, accept. ASPA records use the RTR v2 format from draft-ietf-sidrops-8210bis-27.
RPKI Per-Peer Action Experimental (partial) Origin (invalid/not-found) and ASPA (invalid/unknown) validation actions are settable globally and per-peer/per-group (peer > group > global, resolved per leaf), while cache servers and ASPA enable stay global. rpki { blackhole-exempt true; } exempts a session's agreed blackhole routes from origin validation, at the peer and group levels; setting it on a session that names no blackhole community logs that it has no effect rather than passing silently. show bgp rpki status reports the effective global and per-peer resolved actions, and separates two states an operator could not otherwise see: sessions-synced counts the caches that have completed a sync, and synced is false while running is true when none has. The RTR client separates the RFC 8210 Section 6 Refresh Interval from the Retry Interval, so a cache that answered and a cache that failed are not polled on one timer. A VRP change re-validates the routes already installed rather than only the ones that arrive next, per RFC 6811 Section 4, and the ASPA cache does the same for path verification. Scope gaps: RFC 8210 gap row in rfc/short/rfc8210.md; invalid routes accepted under state policy (plan/release/fixes/spec-rpki-invalid-accepted-and-state-policy.md).
TACACS+ AAA Experimental (partial) RFC 8907 TACACS+ client for SSH login: PAP authentication, ordered server failover with per-server timeout, MD5 pseudo-pad body encryption, priv-lvl-to-profile mapping, command accounting (START/STOP records on every dispatched CLI command), and explicit-reject vs unreachable distinction so wrong-password TACACS+ replies do NOT silently fall through to local bcrypt. Runs as a pluggable aaa.Authenticator so local bcrypt remains the fallback when every TACACS+ server is unreachable (default). Configurable strict-fallback mode denies authorization when TACACS+ infrastructure is unavailable instead of falling back to local RBAC. Scope gaps: PAP is the only authentication type; no interop against a third-party TACACS+ server.
Typed-family NLRI discard (RFC 7606 Section 5.4) Experimental Answered per family by the plugin that owns it, because Section 5.4 leaves the ruling to the family's own document. EVPN, MCAST-VPN and MUP discard an unrecognized route type. BGP-LS does not: an unrecognized NLRI type is its common case, and RFC 9552 Section 5.1 requires those to be preserved and propagated rather than treated as an error, so only that NLRI is reported unparsed and decoding continues. MUP also answers a third verdict: a Type 1 Session Transformed route whose mandatory fields overrun its declared Length is treated as withdrawn (draft-ietf-bess-mup-safi Section 3.1.3.1), so an earlier generation of that route is withdrawn and the withdrawal relayed, while one Ze cannot key is discarded. A Direct Segment Discovery route announced in an UPDATE with no Prefix-SID attribute is treated as withdrawn the same way (draft-ietf-bess-mup-safi Section 3.3.6), through an UPDATE-level check the MUP plugin registers beside its recognizer.
VRRP Experimental (partial) First-hop redundancy on interface units: RFC 9568 VRRPv3 for IPv4 and IPv6 (the default) with RFC 3768 VRRPv2 available per group via version 2 (IPv4 only). Groups are named by the operator and carry a mandatory vrid, configured under the unit's family container so the group sits next to the addresses it backs: interface { ethernet eth0 { unit 0 { ipv4 { vrrp { group uplink { vrid 10; virtual-address [ 192.0.2.1 ]; } } } } } }. Each group gets its own macvlan device carrying the RFC virtual MAC (for IPv4, for IPv6), so failover moves the L2 address and not just the L3 one, and hosts need no ARP re-resolution. Adverts run over IP protocol 112 to 224.0.0.18 / ff02::12 with GTSM TTL/hop-limit 255 enforced on transmit and receive; a Master transition emits gratuitous ARP (IPv4) and unsolicited Neighbor Advertisements (IPv6). The address owner is detected from the unit's configured addresses and runs at priority 255 per RFC 9568 Section 5.2.4; accept-mode, preempt, preempt-delay-seconds, priority and track are per group. accept-mode is enforced on the dataplane: an Active router that does not own the address and carries accept-mode false installs a host-scoped drop for each virtual address at the input hook, so the address does not answer traffic and does not answer a ping, which RFC 9568 Section 6.4.3 requires. IPv6 Neighbor Solicitation and Neighbor Advertisement are accepted ahead of every drop, per Section 6.1, so failover still resolves. track names interfaces whose failure subtracts a priority-decrement from the advertised priority, so an Active router that loses the uplink it forwards through hands the virtual address to a peer; decrements sum, the floor is 1, and the address owner still advertises 255. Cross-leaf rules the YANG grammar cannot express are enforced by an in-process verifier shared with ze doctor (doctor-vrrp-config-invalid, doctor-vrrp-backend-unusable, doctor-vrrp-raw-socket), so a commit and a doctor run can never disagree. Operational surface: show vrrp, show vrrp interface name <iface>, show vrrp statistics, clear vrrp statistics all, plus ze_vrrp_state{device,group,vrid,family} and ze_vrrp_transitions_total for Prometheus. Netlink backend only: VRRP needs macvlan devices and raw sockets, so a VPP-backed tree is rejected rather than silently degraded. RFC 3768 authentication is not implemented by design (RFC 9568 Section 9 removed it as providing no real security). Virtual-MAC ownership of the virtual IP is enforced on the dataplane: the macvlan is created in private mode and the virtual IP carries the parent's subnet prefix, with arp_ignore/arp_filter/rp_filter sysctls (applied and later restored by the plugin) making the macvlan the sole ARP responder, so a host resolving the virtual IP gets the virtual MAC (mirrors keepalived's use_vmac). Experimental: the wire format is asserted against golden frames in QEMU and interoperability is proven against keepalived 2.3.1 (election, node-death failover, graceful stop, virtual-MAC ownership), but it has not been hardened in production. The VRRP plugin is compile-out-able with the ze_vrrp build tag: the default-on feature set includes it in normal and appliance builds, while ze-stripped and bare ze_core builds drop internal/plugins/vrrp (engine, FSM, packet codec, transport, schema) and reject the vrrp {} block under an interface unit as an unknown field; VRRP registers its CLI through the plugin registry, so it needs no dispatch-root companion. Scope gaps: owner ARP RFC defects (plan/release/fixes/spec-vrrp-owner-arp-rfc-defects.md); VPP backend (plan/post-release/features/spec-vrrp-7-vpp.md); RFC 9568 obligations the ledger marks Partial. 00:00:5e:00:01:{vrid}00:00:5e:00:02:{vrid}

Daemon services

Feature Status Description
AI-First Design Experimental Self-describing CLI-as-API with MCP transport for AI assistants. ze create agent skill installs the ze skill in Claude Code, Codex, OpenCode and Pi, and a session-start hook in Claude Code and Codex, so an agent reads the guide the installed binary serves.
API Commands Experimental Peer management, route updates, RIB operations, event subscription
Appliance Host Name Experimental On the appliance build, Ze sets the kernel host name (what uname -n, syslog and the shell prompt show) from system host at start and on every reload that changes it, so each appliance carries its own name rather than the image's build-time ze. With system host unset, the kernel keeps the image's name. The value is validated as an RFC 1123 host name before it is applied. A sethostname refusal leaves the kernel name as it was, logs one warn line naming the value, the error and the fix, and ze doctor reports doctor-system-host-not-applied; the commit is not refused. A distro build (any build without ze_appliance) never calls sethostname: the operating system owns the name there, and system host changes only Ze's own identity. The booted proof is ./le test qemu appliance-hostname.
Archive Pruning Supported commit-revisions (0 to 1000, default 0) caps the config archive files kept at each archive location, pruning the oldest after each archive write; 0 keeps every file, and an HTTP archive is never pruned. Only files whose whole name matches the archive block's filename format are counted or removed. . file://
ASN to Regional Internet Registry Experimental ze resolve rir <asn> and show resolve rir <asn> answer which registry holds an AS number, and that registry's whois host. Both read a delegation table the binary ships as embedded data, so the answer needs no network, no daemon and no file on disk. update resolve rir refreshes that table from the five registry delegation files into the managed store under meta/rir/delegation, and the stored copy answers whenever its generation date is later than the shipped seed's, so an upgrade carrying fresher data takes over on its own. The refresh is all or nothing: a registry that does not answer, a file the parser refuses, and a run that read no ASN record each store nothing and leave the previous table answering. An AS number in no delegated range and a table that cannot be read stay two distinct answers on every path. An appliance behind a mirror names where each file is read from, per registry, under system/rir: a registry with no block is read from the file it publishes, and a mirror is HTTPS or plain HTTP from the host itself. The stored table names the URLs that run read in its Source: lines. ./le data asn-delegation update rewrites the shipped table through the same fetch.
Autonomous Anomaly Response Experimental Shadow-first responder (anomaly/shape) that subscribes to anomaly-detect incidents and installs a surgical per-SOURCE firewall action (rate-limit via firewall.MatchSourceAddress+Limit, drop fallback). SHADOW is the default: it logs the would-be action and installs nothing. In armed mode each anomalous source gets its own live nft rule with a mandatory timed AUTO-REVERT (withdraws after a TTL regardless of any clear event), a global BLAST-RADIUS cap (refuses to arm beyond N), a KILL-SWITCH (reverts all + forces shadow), and an ALLOWLIST (protected sources are never armed). One mutex guards the armed map; a per-timer generation guard makes a superseded timer a no-op. Status via show anomaly shape. Separate firewall owner key isolates it from ddos/local. A ze doctor check (doctor-anomaly-shape-armed-no-firewall) warns when armed without a firewall. Prometheus: ze_anomaly_shape_armed, ze_anomaly_shape_reverted_total, ze_anomaly_shape_arm_refused_total, ze_anomaly_shape_killswitch_total.
Backend-Aware CLI Completion Experimental CLI auto-completion filters options based on the active backend. Config editor mode (set/delete/edit/show) and operational command mode (show/clear/monitor) hide nodes annotated with ze:backend when the active backend is not in the annotation's list. Backend names are derived from the candidate tree at each config completion call, and handed to the operational command completer after each edit. Same ze:backend annotations used by commit-time validation, applied earlier at completion time.
Backup and restore Supported ze data backup <file> [spare <n>] copies every key of the live store to one new 0600 blob artifact under the write lock, so a commit is in the backup whole or not at all. ze data restore <file> config [name <source-name>] commits one config from a verified artifact as a new version of this device's config and leaves credentials, identity and history unchanged. ze data restore <file> full replaces the whole tree, moves the previous tree to database.replaced-<stamp>, and records a durable intent, so an interrupted restore is refused by every opener until the same command finishes it. Both verbs are offline; while a daemon owns the store, request data backup path <file> and request data restore path <file> config run over SSH, and a restored config becomes active only when the reload accepts it. ze init --from <path-or-url> [--sha256 <hex>] creates a store from a blob, with the digest checked before a key is written. ze config edit --backup <artifact> edits a config inside a backup with no daemon. A damaged store is checked and salvaged while ze runs: ze data check and ze data repair --output <path> on the host, and show data check and request data repair path <file> through the daemon, which writes the salvage on its host with its writes held for the walk; installing the salvage needs ze stopped. The store is maintained while ze runs, beside backup and restore: ze data rm, ze data write and ze data import on the host send their work to the daemon (delete data key, update data key, update data config), which removes or writes runtime state and imports a config as a new version, through the reload for its own config. Offline, ze data import of a config the store holds commits a new active version and keeps the previous one as rollback.
Behavioral Anomaly Detection Experimental Darktrace-style SECURITY anomaly detector (report-only), a domain separate from volumetric DDoS. Consumes the neutral trafficfeature signals and learns each entity's own pattern-of-life via a per-(entity,feature) EWMA baseline (internal/core/stats), scores self-deviation plus peer-group rarity (prefix cohorts), and correlates multiple weak feature deviations on one entity into a single incident (capped/discounted combine, not naive sum). An entity is a SOURCE (an anomalous sender), a DEST (a distributed sink or a probed host) or a PORT; a port is identified by proto and port rather than by an address, and is scored by self-deviation alone because it has no cohort. A confirm/clear state machine debounces; confirmed incidents emit on the anomaly-detect event bus and land in a bounded recent-incident ring viewed via show anomaly detect. It takes NO action (the anomaly/shape responder acts); scoring is bounded per-entity with idle eviction. A ze doctor check (doctor-anomaly-detect-no-feature-source) warns when enabled without a flow source. Prometheus: ze_anomaly_incidents_total, ze_anomaly_active, ze_anomaly_tracked_entities (labeled dimension=source/dest/port since 2026-08-18; it was a bare gauge, so an existing query stops matching and must sum over the label). The detector's ring records confirmations only, so a separate anomaly-observe plugin subscribes to the same events and keeps the incident LIFECYCLE: a bounded ring (incident-ring-size) opened on AnomalyDetected and finalized with an end time on AnomalyCleared, or by a one-second stale sweep (stale-incident-timeout) when a source goes silent and the detector evicts it without a clear. show anomaly observe returns that list newest-first with finalized incidents included, which is where a finished incident's duration is readable. The detector, the lifecycle store and the shape responder are all compile-out-able with the ze_anomaly build tag: default-on in ZE_FEATURES, dropped from ze-stripped / bare ze_core builds, with an anomaly {} block rejected as unknown.
CLI Commands Experimental (partial) Protocol tools, config management, schema discovery, daemon control, AS topology graph, policy dry-run testing (show policy test). Verb-first is now the only spelling: every command starts with show, clear, monitor, request, set or delete, and the words after it are the YANG path. The bare forms are gone from the command tree, not aliased, so the dispatcher answers unknown command for daemon reload, daemon status, daemon quit, bgp summary, system memory, interface rate and the rest; the verb-first spellings are request reload, show status, request halt, show bgp, show system memory, show interface rate. Three exec verbs stay bare on purpose (stop, restart, reboot): the SSH exec middleware intercepts them before the dispatcher, which registers no key for them. show interface reshaped its keywords too: name <n> detail and name <n> counters replace detail <n> and counters <n>, and brief, scan, type, errors and rate each answer a distinct question. Scope gaps: declared commands without leaves (plan/release/fixes/spec-declared-commands-without-leaves.md).
CLI Default Output Format Experimental Configurable default output format via environment { cli { format { default text; } } }. Supported values: text (default), table, json, yaml, ndjson. Session override via set cli format <value> in operational mode. Explicit pipe operators (| json, | table, etc.) always win over the configured default, and over the --format flag of ze cli -c.
CLI Session Transcript Experimental Transcript recording of ze cli and ze config edit sessions to, written by the process that runs the session's model: the daemon for a session on a stored configuration, the client for ze cli -c. Preserves command input and output for post-disconnect recovery, with credential tokens on the command line replaced by <redacted>. Enabled via environment { cli { transcript enabled } } config or ze.cli.transcript env var. Best-effort writes never block CLI operation. . $XDG_DATA_HOME/ze/transcripts/
Commit-Time Backend Capability Check Supported YANG nodes that correspond to backend-specific features carry a ze:backend "<names>" annotation. On commit (daemon reload, first-apply, and ze config validate), the walker rejects the config with the YANG path and the list of supporting backends whenever the active backend does not implement the feature -- instead of letting an Apply-time "not supported" error fire inside the backend. The gate covers interface (netlink-only bridge, tunnel and veth under the vpp backend), traffic/control (the backend-leaf CALL wired into OnConfigure/OnConfigVerify; tc-only feature annotations ship with spec-fw-7-traffic-vpp), and firewall (seven ze:backend "nft" annotations on conntrack-driven matches and nft-only action/modifier leaves).
Config Dependency Graph Supported ze config graph visualizes config dependency relationships.
Config Schema Stamp Supported Config files carry a schema version stamp. When a config written by a newer release fails to load at startup, recovery keeps it in history, walks the rollback versions newest first, skips those a newer release wrote, loads the first that parses, and re-stamps it with this release. No field is pruned.
Configuration Experimental (partial) YANG-modeled config with prefix limits, update groups, session resilience, duplicate list-key rejection, side-effect-free in-process plugin verifiers for static/API/CLI validation, and transactional commits using active/candidate/rollback pointers. Live external plugin OnConfigVerify callbacks run only in daemon reload/commit transactions. Scope gaps: live external plugin OnConfigVerify runs only inside daemon reload and commit transactions; YANG types bits and identityref and instance-identifier and leafref (plan/pre-release/spec-config-yang-type-.md); YANG deviation and if-feature and submodules (plan/pre-release/spec-config-yang-.md).
Configuration Reload Experimental (partial) Live reload via SIGHUP with automatic reconciliation. Reload stages edited config as a candidate version and promotes it to active only after runtime reload succeeds. Plugin-server transactions, config-provider roots, subsystem reload, and changed external plugin replacement roll back on failure; remaining reload safety depends on component-specific journals and privileged dataplane evidence. Scope gaps: reload safety that depends on component-specific journals; privileged dataplane rollback evidence.
Connected Routes Experimental Redistribute directly connected interface prefixes into BGP via redistribute { import connected }. Subscribes to interface address events; emits RouteChangeBatch on address add/remove. Reference-counted: multiple addresses on the same prefix emit one announcement, withdrawn only when the last address is removed. IPv4 and IPv6. The prefix is also a path in the shared Loc-RIB, so rib { distance { connected N } } ranks it against BGP, OSPF, IS-IS and static for the same prefix, and it makes a next-hop covered only by an interface prefix resolvable. Ze still programs no kernel route for it: the protocol declares that the OS installs its entries, so a connected winner WITHDRAWS the route Ze had programmed rather than adding a second one beside the kernel's own.
Connection Tracking Management Experimental Declarative conntrack configuration under system { conntrack {} }. Conntrack helpers (ALGs) assigned only when listed: each module (amanda, ftp, h323, irc, netbios-ns, pptp, sane, sip, snmp, tftp) gets a ze-owned nft table with a ct helper object per kernel helper and transport, assigned by destination port in prerouting and output at priority -5, in an inet table for a helper the kernel registers for both families and an ip table for an IPv4-only one; an empty list assigns nothing. Ze's kernel builds every helper in; on a distribution kernel the module is loaded with modprobe. show system conntrack lists the assigned helpers. User-friendly config for table sizing (table-size, hash-size, expect-max), per-protocol timeouts (TCP, UDP, ICMP, ICMPv6, GRE, SCTP, DCCP), TCP behavior flags (be-liberal, loose, max-retrans, ignore-invalid-rst), and global flags (accounting, timestamp, checksum, log-invalid). All sysctl values routed through the sysctl plugin for three-layer precedence. Dual-setting prevention rejects keys in sysctl {} that conntrack manages. On gokrazy (modules built-in), module loading is skipped gracefully. CLI: show system conntrack. Telemetry: configured-max gauge alongside existing per-CPU counters.
Control-Plane Policing (CoPP) Experimental Rate-limit new TCP connections to the BGP listen port (TCP/179) to protect against connection-flood DDoS. Generates an nft input-hook chain via the firewall registry: established/related sessions pass at full rate, operator-supplied trusted-source prefixes bypass the limit, new connections are rate-limited. Configurable rate, burst, protected-port (default 179), trusted-source prefix list, and over-limit policy (accept/drop, default accept). The over-limit policy rides the rate-limit term as an nftables inverted limiter. The input chain keeps an accept policy under both settings, so no CoPP config locks the operator out. Doctor check verifies the CoPP input chain is active when configured. Compile-out-able with the ze_copp build tag: default-on in ZE_FEATURES, dropped from ze-stripped / bare ze_core builds, with its config block rejected as unknown.
Core Diagnostics Experimental (partial) Built-in diagnostic commands replacing ss, dmesg, lsof, dig, nc, traceroute, mtr, ping, tcpdump, and pprof on gokrazy appliances: show system sockets (TCP/UDP state), show system kernel-log (dmesg), show system goroutines (dump with singleflight dedup), show tcp-check (port probe), show traceroute (ICMP path trace with per-hop RTT, IPv4/IPv6), monitor traceroute (live mtr-style continuous trace with | log | resolve and | log | origin enrichment), monitor ping (continuous ICMP ping with live stats), show capture interface (AF_PACKET live capture with BPF filters, pcap or text output), show system file-descriptors (FD counts and limits), show dns lookup/cache (DNS resolution, cache listing, selective delete, flush, stats reset), show system profile (cpu/heap pprof), show system memory (/proc/self/status OS view). monitor system netlink streams kernel route/link/address change events as JSON (replaces ip monitor). A BFD raw capture ring is started and dumped with the other protocols when show capture raw names no protocol; its protocol leaf offers only l2tp and bgp, so BFD cannot be selected alone. At startup Ze warns when it runs without root or without a required capability, and keeps running. See Production Diagnostics Guide. Scope gaps: BFD raw capture cannot be selected alone.
Crash Capture Experimental Automatic stderr redirect captures panic stack traces from any goroutine. Forwarded to syslog (via ze.log.destination) in real time and persisted to crash files on disk. Crash reports include ring buffer context (last 64 log entries before the panic), version, build date, uptime. Crash dir autodetected (on gokrazy, fallback chain for other platforms). CLI: show crashes, show crashes latest. Env vars: ze.crash.dir, ze.crash.keep. Kernel panics are captured too: system crash-dump enabled true plus an appliance built with image.crash-dump reserves a named memory region the kernel writes its own panic message and backtrace into, which a warm reboot does not clear. Ze harvests the record on the next boot as a kernel-kind report in the same directory, under the same retention count, listed by the same show crashes. No Ze code runs at the moment of the fault. show crashes reports configured and armed separately, because a reservation is a boot argument: three ze doctor checks report the reservation, the record store and the crash directory. A full memory image is a separate opt-in and is amd64-only. Prometheus: ze_crashes_artifacts and ze_crashes_kernel_capture_armed, so a fleet can alert on capture being silently unarmed. . /perm/ze/crash/
Custom Value Validators at Startup and Reload Experimental A YANG leaf can name a custom validator with ze:validate, and the named function runs on the same walk the offline ze config validate uses, so the offline check and the daemon cannot disagree about the same bytes. The set covers address families, community ranges, event and message type tokens, MAC addresses, IS-IS NET / system-id / hostname, OSPF router-id and area-id, redistribute sources, IPv4 and IPv6 addresses and prefixes, set references, port specs, and internal plugin names. A ze:validate binding with no registered function is an integrity failure reported at schema build, so a leaf cannot silently declare a validator that does not exist.
Deactivate / Activate Experimental Junos-style inactive: prefix on any node (leaf, container, list entry, leaf-list value); kept in file, skipped at apply. CLI: ze config deactivate/activate <file> <path>. TUI: deactivate <path> / activate <path>. Engine-level, no schema annotation required.
Don't Fragment probes Experimental show ping, resolve ping, show traceroute and resolve traceroute take do-not-fragment honor-cache or do-not-fragment bypass-cache. The probe socket installs IP_MTU_DISCOVER and IP_RECVERR, the Linux kernel runs RFC 1191 and RFC 8201 path-MTU discovery, and the reply that a router refused carries status: too-big, next-hop-mtu-reported and next-hop-mtu read off the socket error queue, never parsed from ICMP by ze. A zero or an IPv6 value below 1280 is reported as no usable value. bypass-cache ignores the kernel's cached estimate so the wire answers. Without CAP_NET_RAW, ping runs on the unprivileged datagram ICMP socket when the daemon's group is inside net.ipv4.ping_group_range; ze doctor reports doctor-icmp-probe when neither socket opens and doctor-icmp-probe-unprivileged when only the datagram one does (traceroute needs the raw socket). Linux only.
Dynamic peer groups Experimental A group whose connection/remote/ip is dynamic accepts a session from any address inside its range list and opens its own listening socket, so a configuration naming no static peer still accepts members. Each accepted connection becomes one peer that inherits the group's whole resolved settings, its families, its attach process blocks and its per-peer plugin config. Overlapping ranges resolve by longest prefix match. max-peers bounds the group (1..100000, default 1000).
Environment Variables Experimental Ze-native env surface: ze.user, ze.pid.file, ze.pprof, ze.bgp.openwait, ze.bgp.announce.delay, ze.cli.format; ExaBGP-compat env keys retired 2026-04
ExaBGP Compatibility Experimental Automatic config migration and plugin bridge. The bridge plugin and the ze exabgp command, which carries ze exabgp migrate, are compile-out-able with the ze_exabgp build tag (default-on in ZE_FEATURES).
Firewall Experimental Packet filter and NAT via the nftables backend on Linux. The abstract model's match types are the Match implementations in: source/destination address, port ranges, protocol, input/output interface with wildcard prefix, connection state, marks, DSCP, ICMP type, ICMPv6 type, TCP flags, named sets, IPv4 TTL and IPv6 hop limit below a threshold, the TCP port and destination quoted inside an ICMP error, ARP operation and sender address, and ND target address, plus two predicates only the daemon builds: link-layer unicast (VRRP) and a route into an IPsec transform (the IKE tunnel-source guard). Its action and modifier types are the Action implementations: accept, drop, reject, jump/goto/return, SNAT/DNAT with address ranges, masquerade, redirect, notrack, flow offload, conntrack helper assignment (built by system conntrack module, not by a firewall { } term), set mark/connmark/DSCP/TCP-MSS, TCP-MSS clamped to the route MTU (tcp-mss-clamp-to-pmtu, forward, output and postrouting chains only), counter, log, rate limit. The lan-services topology scenario proves tcp-mss-set and masquerade on a CPE converted from VyOS, and road-warrior proves masquerade of WireGuard client traffic. NAT exclude rules emit a Return verdict to skip translation. Global-options container maps keyword toggles (all-ping, broadcast-ping, syn-cookies, source-validation, etc.) to kernel sysctls via the sysctl plugin's default layer; explicit sysctl settings always override. IRR-based prefix-list filtering: source-asn, source-as-set, destination-asn, destination-as-set leaves in from-block resolve ASN/AS-SET references to nftables interval sets via the shared IRR PrefixStore (firewall-irr plugin). Per-interface source validation: bind an AS-SET to a customer-facing interface via irr { interface <name> { source-as-set <AS-SET>; } } to drop ingress traffic with source addresses not in the IRR-resolved prefix set (BCP 38). An IRR answer carrying no prefixes never replaces cached ones: the store keeps the last known good list, show firewall irr reports the entry as stale with the age of the data, ze doctor reports it, and clear firewall irr asn|as-set is the only path that removes prefixes. A binding with no prefixes produces no table at all, so an empty answer cannot leave an interface dropping everything. DNS-sourced address groups: a domain-group holds domain-names, and source-domain-group / destination-domain-group leaves in the from-block match the addresses those names resolve to (firewall-domain plugin). Each name is re-resolved on its own answer TTL, per family, clamped by ttl-floor, and the set is reprogrammed only when the addresses actually changed. Only NXDOMAIN empties a set: a SERVFAIL, a REFUSED or an unreachable server keeps the last good addresses, so a DNS outage is never enforced as a filter. Resolved addresses persist in ZeFS, so a restart with DNS down resumes filtering from them, and every change is appended to a bounded JSON-lines log at <config-dir>/firewall-domain-group.dns.jsonl. show firewall ruleset shows the DNS name beside each address through the show-enricher registry, adding no field to the shared set model. Component reactor wires into ze's engine lifecycle: Apply on boot and reload, rollback on failure. ze_ prefix on all kernel tables. Every backend Apply is bounded by a deadline: 10s by default, clamped to 1s. 60s (ze.firewall.nft.netlink-timeout, ceiling firewall.MaxBackendDeadline). The bound is load-bearing rather than cosmetic, because ApplyAll holds one process-wide reconcile lock across Backend.Apply, so an unbounded kernel call would stall every firewall owner (copp, policy-routes, ddos-local, the firewall engine) and not just one. A wedged reconcile is counted, never hidden: ze_firewall_apply_timeout_total, and ze_firewall_apply_duration_seconds{result} with ok, timeout, error and panic. . internal/component/firewall/model.go
Fleet Management Experimental Centralized config distribution over TLS
FlowSpec-to-Firewall Bridge Experimental (partial) flowspec-firewall plugin converts BGP FlowSpec rules into nftables entries in a dedicated ze_flowspec table. Scope gaps: RFC 8955 and RFC 8956 predicates the ledger marks Partial.
Graceful Listener Migration Supported Hot reload of listener endpoints (web, LG, REST, gRPC, MCP, SSH). New listener starts before old one stops; in-flight connections are drained.
Granular Debug Experimental Verb-first debug (set/delete/show/clear, matching VyOS syslog-level config) with per-module flag/direction/scope filtering and named profiles. CLI: ze set debug module <name> (enable), ze delete debug module <name> (disable), ze set debug module <name> flag <flag>, ze set debug module <name> scope direction <dir>, ze set debug module <name> level <level>. Hierarchical prefixes work (ze set debug module bgp covers all bgp.* subsystems). Named profiles: ze set/delete debug profile name <name>, ze show debug profile [name <name>], ze set debug active name <name> (apply). Stored in debug.zefs (separate from config). Each plugin declares its valid flags via the debug YANG registry. Not auto-applied on reboot (safety). show debug (YANG-dispatched) queries live daemon state.
Health Registry Experimental (partial) Aggregated component health via show health and /health HTTP endpoint (503 when any component is down). Registered components: l2tp, report-bus, ipsec, pki, bgp (session-stuck/flap/EOR), fib (sync-failure/orphan/lag), firewall (stale-table/drift audit), iface (error counters), plugins (crash/disabled), vpp (API socket probe), flow-export. The l2tp check reports healthy whenever the subsystem is running and does not probe the kernel data plane. Each check is expected to return within 1 second by contract; the registry recovers panics but does not enforce a timeout. Scope gaps: l2tp health check does not probe the kernel data plane.
Host Inventory Experimental Structured hardware inventory for ISP fleet monitoring: CPU (vendor, topology, hybrid P/E layout, scaling driver, frequencies, throttle counts), physical NICs (driver, PCI IDs, link speed, queue counts, firmware, rings), DMI board identity, memory with ECC counters, hwmon thermal sensors + per-CPU throttle, block devices with NVMe firmware, kernel release/cmdline/microcode/arch flags. Read-only sysfs/procfs, no daemon required. Single show host cpu/nic/... command served by the daemon when reachable, falling back to the same in-process detection when no daemon is running; JSON by default for pipeline consumption.
Interactive Launcher Experimental Running ze with no arguments in a terminal shows a BubbleTea menu of all commands grouped by section, with type-ahead filtering, scrolling, and drill-down into YANG verb sub-commands. Non-TTY invocations fall back to static help text.
Interfaces Experimental The PPPoE client answers access-network LCP renegotiation on the existing session. Standalone tests cover repeated authentication, IPCP and complete result notifications. The interface consumer reapplies changed MTU, local/peer addresses and the default route; consumer tests cover reapplication and failure handling. Target-kernel proof and wholesale interoperability proof remain outstanding. The PPPoE client asks IPCP for the access network's DNS servers (RFC 1877 Primary and Secondary DNS), adopts the unicast values the access concentrator Naks back, and keeps the session up when it Rejects them. The learned servers become the session's resolver record, replaced when a renegotiation changes them and withdrawn when the session ends, and show interface pppoe-client reports them as dns-servers. The accel-ppp interop scenarios 01-pppoe-chap-ipv4 and pppoe-ipcp-dns-rejected-ze-client prove both halves. The PPPoE client's dead-peer detection and redial hold-off are configurable on each pppoe-client entry: keepalive { interval; failures } sets how often an LCP Echo-Request is sent (1 to 3600 seconds, default 10) and how many unanswered requests in a row end the session (1 to 255, default 3), and reconnect { delay-min; delay-max } bounds the doubling wait before the next discovery (1 to 3600 seconds, defaults 1 and 60). delay-max below delay-min is refused naming both leaves. A reload that changes only these leaves keeps the running session up: the new values apply from the next session and the next redial wait. The PPPoE client carries IPv6 when its ipv6 enabled is true: it negotiates IPv6CP beside IPCP (RFC 5072), each Configure-Request carrying one Interface-Identifier. A valid identifier the access concentrator Naks back is adopted for the next request, and a fresh one is chosen when the suggestion equals the one Ze last Naked (RFC 5072 Section 4.1). Once IPv6CP opens, the session device passes IPv6 and holds the link-local address formed from the negotiated identifier. An access concentrator that sends an LCP Protocol-Reject for IPv6CP, Configure-Rejects the identifier, or never answers stops IPv6CP only: IPCP and IPv4 stay up, and a rejected identifier is logged at WARN. The accept-ra, autoconf and forwarding leaves become the net.ipv6.conf.<name>.* sysctls of the session device each time a session creates it, so the client can take its default route and a SLAAC address from the access concentrator's Router Advertisements. A dhcpv6 block runs the DHCPv6 client on the session device, with its DUID-LL and IAIDs built from the source interface unless duid is set, and pd { length } asks for a delegated prefix. A LAN unit numbers from that prefix with ipv6 delegated-prefix <pppoe-client> { subnet-id; interface-identifier }: it holds the /64 at subnet-id with the remaining lifetimes of the delegation, and its Router Advertisements follow the CE rules of the IPv6 Router Advertisements feature. Config verify refuses a subnet-id the delegated length cannot hold, two units taking one id from one source, and a source that is not a pppoe-client whose dhcpv6 asks for a prefix; the editor completes the source from that same set. ze_pppoe_client_ipv6cp_opened{name} and ze_iface_delegated_prefixes_held{name} report the state. The accel-ppp scenarios pppoe-ipv6cp-ze-client and pppoe-ipv6cp-rejected-ze-client prove the negotiated link-local, the RA default route and SLAAC, and an IPv4 session that survives a rejected IPv6CP; the pppoe-dhcpv6-pd-ze-client topology scenario proves the delegation reaching a LAN host., "PPPoE client IPv6", is the operator guide. Linux interface management via netlink: ethernet, dummy, veth, bridge, loopback, VLAN (with 802.1p ingress/egress QoS maps translating PCP to internal priority and back, and named class-of-service profiles via the cos plugin with interface-level inheritance and per-unit override/opt-out; dynamic per-subscriber CoS via RADIUS Filter-Id "cos:<name>" or vendor-specific attributes (Cisco-AVPair, Juniper ERX, Nokia, Huawei) applied on session-up with mid-session CoA changes and session-down revert; MikroTik Mikrotik-Rate-Limit VSA for shaper rate extraction ), 9 tunnel kinds (GRE, GRETAP, IP6GRE, IP6GRETAP, IPIP, SIT, IP6TNL, IPIP6, VXLAN with a 24-bit VNI over UDP 4789 per RFC 7348), each carrying an outer-header TTL of 64 when the config names none, so an encapsulated packet survives a multi-hop underlay; ttl 0 still asks the kernel to inherit the inner packet's TTL, and the default reaches netlink-backed tunnels only, because the VPP tunnel calls carry no TTL field, so a commit that names a ttl on a vpp-backed tunnel is refused by path rather than accepted and dropped , and WireGuard (declarative peers with $9$-encoded keys); DHCP (config-driven, routes, DNS, NTP discovery), NTP client (clock sync, RTC, time persistence, max-step safety cap), monitoring, migration, mirroring, per-interface offload and steering (GRO, GSO, SG, TSO, LRO, hw-tc-offload via kernel ethtool ioctl; RPS, RFS via sysfs; boolean three-state: true/false/absent), per-family reverse path filtering (rpf-check strict|loose|disable in ipv4/ipv6 containers, backed by rp_filter sysctl on Linux; IPv6 enforcement requires VPP), per-interface rate tracking (1s sampler with show interface rate, monitor interface rate, 12 ze_interface_* Prometheus gauges, web rate columns). Local privileged integration covers first-apply non-adoption, reload deletion scoped to previously managed links, and rollback of created kernel links after partial apply failure; target-runner evidence is still required before production deployment claims. Every kernel route the interface layer installs (DHCP, RA, PPPoE, PPP) carries rtm_protocol 253, the ze-iface producer id, and a delete matches on that protocol, so one producer's expiry cannot remove an operator static route. A default route learned on a unit takes metric 254 by default (route-priority, range 0. 4294966271), on an interface unit and on a pppoe-client. The NTP client is compile-out-able with ze_ntp (the show system NTP block reads it through the nil-safe registry seam) and the class-of-service profiles with ze_cos; the dynamic per-subscriber CoS handler additionally requires ze_l2tp (a BNG feature: no sessions, no dynamic CoS). . docs/guide/pppoe.md
IPsec CLI and Diagnostics Experimental (partial) show vpn ipsec sa/status/peer, clear vpn ipsec sa all, clear vpn ipsec sa peer <name> (the bare form is refused), monitor vpn ipsec (live SA event stream). show vpn ipsec dataplane sa/policy/drift reads Linux XFRM state and compares expected Child SAs with the SAD. VPP and noop report unsupported enumeration. SA displays carry kernel byte and packet counters, with null for unavailable measurements, and show vpn ipsec sa lists a peer's leased inner address under virtual-ip. Web page at with SA table. Health reports degraded for drift or an unknown dataplane observation. Prometheus retains the belief gauges ze_ipsec_sa_count, ze_ipsec_tunnel_up, and ze_ipsec_tunnel_degraded. Kernel gauges ze_ipsec_dataplane_sa_count{if_id} and ze_ipsec_dataplane_drift{peer} remove their series when observation fails. Show commands reach the shared pipe layer; ze help command --json publishes each command's operators. Address operators require declared address fields. ze_ipsec_virtual_ip_leases{pool} counts the virtual IP addresses live IKE SAs hold in each remote-access pool, and ze doctor warns under ipsec-virtual-ip-pool when one family of a pool is at least 90% held, and under ipsec-unauthenticated-input for a peer whose handshake in progress dropped messages that failed their integrity check, and under ipsec-peer-malformed-message for a peer whose live IKE SA received authenticated messages that do not parse. Scope gaps: monitor vpn ipsec; the web page and the Prometheus gauges have no real-path test. /show/vpn/ipsec/
IPsec Data Model Experimental (partial) YANG vpn { ipsec {} } config for site-to-site VPN: ESP groups (proposals, lifetime, PFS), IKE groups (proposals, dead-peer detection, key-exchange, close-action; close-action and the dead-peer-detection action are parsed but every value produces the same behavior, and key-exchange ikev1 still negotiates IKEv2), site-to-site peers (X.509 and PSK auth, VTI bind, group references). A peer's remote-address is an IPv4 literal or a DNS name, resolved again on every connect cycle; its local-address is an address literal or absent, and commit refuses anything else (a keyword such as any, or a name). With no local-address the peer sends from the vpn ipsec interface address, waiting while the interface has none and restarting when it changes, or, with no interface, from the source the routing table picks toward the peer. Algorithm enums match strongSwan naming. Cross-reference validation (group names, PKI certificates, interface binding, local-id/CN match). Operator-authored Security Policy Database entries under vpn ipsec policy, carrying the BYPASS and DISCARD dispositions of RFC 4301 Section 4.4.1 with a selector, a direction and a total order. Named virtual-IP pools under vpn ipsec remote-access pool, each a range and range6 with DNS servers; a respond peer names one with virtual-ip-pool, and commit refuses a name no pool carries and two pools whose ranges overlap (RFC 3948 Section 5.1). Config diff detection for reload. Scope gaps: close-action and dead-peer-detection action values all produce the same behavior; key-exchange ikev1 still negotiates IKEv2.
IRR BGP Import Filtering Stub-backed bgp-filter-irr builds per-ASN import prefix-lists from explicit or PeeringDB-discovered IRR AS-SETs, refreshes the lists and keeps them in memory only (a restart resolves them again), and rejects received prefixes outside the selected list. Includes status, prefix inspection, dry-run checks, and manual refresh commands.
Kernel Routes Experimental Redistribute externally-installed kernel routes into BGP via redistribute { import kernel }. Consumes parsed route events from a shared netlink route watcher. Routes Ze installs itself are filtered out (the protocols rtproto.IsZe names: GTSM 249, fib-kernel 250, static 251, policy-route 252), as are RTPROT_KERNEL (2) and RTPROT_REDIRECT (1). A route of every other protocol is emitted as a RouteChangeBatch, for example DHCP (16), PPP/manual (BOOT=3) and admin static (STATIC=4) routes. Tracks announced prefixes; withdraws all on shutdown. IPv4 and IPv6. Shares a single netlink subscription with fib-kernel (route re-assertion). . internal/core/routewatch/
Kernel Tunable Management Experimental Sysctl plugin centralizes kernel parameter management with three-layer precedence (config > transient > default). Plugins declare required defaults (e.g., fib-kernel enables forwarding), users override via config or CLI. Original values restored on clean stop. Named profiles group co-dependent tunables (dsr, router, hardened, multihomed, proxy) applied per interface unit. User-defined profiles supported. CLI: show sysctl, ze sysctl list, ze sysctl describe, set sysctl, ze sysctl list-profiles, ze sysctl describe-profile.
Live Credential Revocation Experimental Every credential surface reads the running config's user list, so a user the config stops declaring stops authenticating at the next reload: the web password, the web session cookie, the SSH password, the SSH public key, and REST/gRPC Bearer. The revoker is identified rather than assumed. An authentication result names the backend that produced it, and only a result the local backend granted is revoked by the local list; an empty source is not local, because reading silence as local would attach the local list's revocation to a session some other backend granted. A session a RADIUS or TACACS+ backend granted is therefore not revoked by an edit to the local users. Revocation governs new authentication; an open session survives by design.
Local Audit Trail Experimental Structured local audit log for config commit/discard, daemon reload, and failed authentication across SSH, web, REST, gRPC, MCP, CLI, and system surfaces. show audit filters by action, actor, surface, time range, and count. Disk-backed JSON-lines storage is used when Ze starts from a config file; stdin configs use memory-only storage.
Looking Glass Experimental Public BGP looking glass with birdwatcher API, AS path graphs, and BMP-monitored route display. Runs on its own configurable port, separate from the web UI. tls defaults to true. The certificate leaf names a pki { certificate <name> } entry, and the listener then serves that leaf with every intermediate the store holds. An unset leaf keeps the self-signed certificate. An optional token gates every route and is compared in constant time. An unset token leaves the looking glass open, which is the default. Pages render through templ with typed view models, not html/template.
Management Listener Exposure Guard Experimental One boot-time, fail-closed check refuses to start a management service on a non-loopback address without authentication. It covers the insecure web listener, MCP, gNMI, and the API server (REST and gRPC). It runs once, after every address and credential is resolved and before anything binds, so a refusal leaves nothing bound and the process exits non-zero. Fail-closed on classification too: a wildcard (0.0.0.0, ::), an empty host, and any DNS name including localhost all count as non-loopback, so remote reachability cannot be smuggled past it through a name. An unauthenticated surface that declares no resolved address is refused rather than passed by iterating zero times, which is the empty-set trap that once let an insecure web server reach. The refusal names the service, the address, and the fix, and never prints a token. For MCP the guard mirrors the server's own precedence: a token written beside an explicit auth-mode none does not authenticate, because the server builds its accept-all authenticator in that case. . 0.0.0.0:3443
Memory Lock Experimental The memlock plugin locks the running ze executable's file-backed pages with mlock2(2) and MLOCK_ONFAULT, so the kernel cannot evict the daemon's own text under memory pressure and fault it back from disk. Linux only. The lock is taken in the package init(), before main(), so every ze process holds it from its first instruction. The whole mapped size is charged against RLIMIT_MEMLOCK, which the generated ze.service unit lifts with LimitMEMLOCK=infinity; a limit too small for the binary makes the lock fail, and show plugin list reports the memlock row as soft-failure carrying the cause and the remedy. The failure is soft: the daemon serves every session correctly with an unlocked executable. A ze doctor check answers the question the record cannot, before ze runs: it compares RLIMIT_MEMLOCK against the size of /proc/self/exe and warns under doctor-memlock-rlimit-low when the limit cannot hold the executable, staying silent for a process that holds CAP_IPC_LOCK.
Modular Deployment Experimental (partial) Config-driven plugin loading: BGP, interfaces, and FIB load only when their config section is present. Add or remove subsystems at runtime via config reload (SIGHUP). Required config-root autoload failures fail closed, reload diffs restart same-name plugins when their definition changes, and changed external plugin replacements are pre-started before the old handler is removed. Scope gaps: BGP-off plugin functional coverage (plan/post-release/engineering/spec-fixit-bgp-off-plugin-functional.md); idempotent deferred reapply at startup (plan/release/fixes/spec-startup-deferred-reapply-idempotency.md).
MRT Dump Experimental RFC 6396 daemon-side MRT recording with three independent streams (updates, all messages, periodic TABLE_DUMP_V2 RIB snapshots). YANG config, per-peer and direction filtering, extended timestamps, add-path aware, on-demand CLI dump, async non-blocking writes, strftime file rotation. Analysis tools: show, routes, aspath, inject, replay, convert (pcap/json), statistics, filter. The reader derives each record's AS width from the record type rather than from one file-wide guess, decodes the RFC 8050 add-path TABLE_DUMP_V2 and BGP4MP subtypes, and REPORTS what it could not decode instead of printing it as fact: a record that fails to parse renders [unparseable: <tag>] <err>, and every analysis subcommand ends with warning: N malformed MRT record(s) skipped or partially decoded; results are incomplete. The daemon MRT plugin is a BGP plugin gated under ze_bgp, with no build tag of its own: every MRT stream is BGP data and its TABLE_DUMP_V2 snapshot is filled only by bgp-rib, so ze-stripped and every build without ze_bgp drop internal/plugins/mrt and its config schema, and the internal/mrt format library plus the shared internal/core/bgp/msgtype leaf drop by dead-code elimination with the engine. In a BGP build the RIB dump always finds bgp-rib: it is auto-loaded by the same bgp config root that starts BGP. Its reactor bridges reach the engine through a plugin-registry seam so the always-on hub never imports the plugin.
Named Service Listeners Experimental (partial) Every service that accepts inbound connections (web, ssh, mcp, looking-glass, telemetry, REST, gRPC, plugin hub) models its listen endpoints as a named YANG list. Each entry binds its own listener on the same subsystem; bind is all-or-nothing with rollback on failure. At config parse time CollectListeners refuses two configured endpoints that share an ip:port, across services, and a dual-stack :: endpoint beside an IPv4 endpoint on the same port, whose bind could never succeed (dualStackPair; a service registered with RegisterListenerV6Only binds :: IPv6-only and is exempt). It does not fill in YANG defaults, so an endpoint left at its default is compared only by ze doctor (CollectListenersWithDefaults), and ServerEndpoint.Listen joins an IPv6 host to its port without brackets. Scope gaps: parse-time conflict check over endpoints left at their YANG default.
Netdata-compatible OS Telemetry Experimental Prometheus metrics from /proc and /sys (CPU, memory, network, disk, IPv4/IPv6 protocols, conntrack, PSI, cpuidle, cpufreq, ZFS, btrfs, mdstat, SCTP, IPVS, wireless, etc) named and labeled after Netdata's Prometheus exporter, so dashboards built on Netdata's metric names can read them. No test compares the names or the count against a running Netdata. Per-collector enable/disable, interval override, and prefix are scoped under telemetry.prometheus.netdata so Ze-native metrics keep their ze_* names. The Prometheus HTTP service defaults to loopback and can require HTTP Basic Auth. The Prometheus HTTP exporter (the /metrics + /health listener, telemetry config extraction, basic-auth, and the Netdata OS collectors) is compile-out-able with the ze_telemetry build tag: normal and appliance builds include it, while ze-stripped and bare ze_core builds drop internal/component/telemetry/exporter and internal/component/telemetry/collector and reject the telemetry {} config block as unknown. Metric COLLECTION (the always-on internal/core/metrics registry used by ~60 packages, plus its no-op dummy) stays linked in every build, so a no-telemetry binary still records every ze_* counter; it just cannot expose them over HTTP.
Operational Report Bus Experimental (partial) Cross-subsystem ze show warnings and ze show errors commands with source <name> filtering: single place to surface prefix-threshold crossings, stale route data, BGP NOTIFICATIONs sent/received, unexpected session drops, session-stuck/flap/EOR-timeout, route-count-anomaly (>50% drop), FIB sync failures/orphans/programming-lag, firewall stale-table/drift, plugin crashes, interface error counters. State-based warnings + event-based error ring, login banner reads the same source. Scope gaps: functional coverage of most named sources; empty-bus shutdown observation (plan/release/validation/spec-finish-report-bus.md).
Outbound source-address Experimental Optional source-address local-IP binding for outbound service connections: BMP collector, RPKI/RTR cache, flow-export (UDP), IRR whois, and the managed hub TLS client; LDP binds its transport-address as the session source (RFC 5036). Unset = OS-selected source (unchanged). Shared network.RealDialer applies the bind for TCP/TLS; flow-export binds the UDP socket. See Outbound Source Address.
Packet Capture and Decode Experimental show capture raw action start protocol bgp records whole BGP messages in memory, and show capture raw action dump protocol bgp format pcap writes them as a pcap under LINKTYPE_RAW (101) with a synthetic IP and TCP header around each message, so Wireshark dissects the file as BGP. The 19-byte BGP header is rebuilt at the tap, sequence numbers advance per direction, checksums are computed, and IPv6 peers are written in their own family. A truncated message declares its on-wire length, so a reader shows truncation rather than a malformed packet. Reading back: ze bgp decode pcap <file> decodes every BGP message in a capture ze wrote or tcpdump wrote, reassembling each TCP direction first; ze bgp decode pcap - and ze bgp decode - take a capture and hex lines from standard input. A hole in the capture is reported and never read across, and a file with no BGP in it exits non-zero naming what it examined. The TCP ports are fabricated as 179 at both ends, because reading the real pair costs two mutexes on the session read path, so a ze-written capture is a readable reconstruction rather than a packet-level record. When no BGP capture provider can start, the start command answers with an empty started list rather than refusing.
Password Weakness Warning Supported Every password-set path judges the plaintext before it hashes it and warns when the password is shorter than 8 characters or matches one of eight common passwords (password, 123456, 12345678, qwerty, admin, letmein, root, changeme, compared whole and case-insensitively). The warning is advisory: the password is hashed and set, the commit succeeds, and the exit code stays 0, so a config Ze accepted before the check existed still commits. One policy serves ze config set, ze config deactivate, the CLI editor commit, the daemon load path, the REST/gRPC/gNMI commit path and ze passwd; the CLI surfaces name the leaf on stderr or in the commit status, and the daemon paths log at WARN. The reason names the rule and never the password.
Path MTU diagnostic for IPsec tunnels Supported show mtu measures the path MTU to every IPsec peer's installed endpoint and to a reference address with Don't Fragment ICMP probes (a reported MTU confirmed on the wire, then a candidate ladder and a bisection when ICMP is filtered), derives each tunnel's ESP ceiling from the transform it negotiated, and reports each bound xfrm interface as oversized, tight, under-utilized, ok, down or without a usable MTU, with the set interface ... mtu commands to apply and whether the access circuit or only the peer paths are clamped. A peer whose IKE SA is up is measured a second time over the SA itself, with an INFORMATIONAL request padded to the size under test: the authenticated reply confirms the ICMP figure or refutes it where ICMP errors are filtered, and the row names its prober (ike, icmp). show mtu host <address> measures one path; exhaustive bypasses the kernel's cached estimate. The command changes nothing. Linux only.
Per-protocol FIB withholding Experimental rib { fib-withhold [ bgp isis ]; } names the protocols whose selected routes ze does not write to the forwarding table. The list is empty by default, so every protocol is programmed. It accepts a name only when a protocol registered it, and a commit that names anything else is refused with the names ze accepts. A withheld route is not a dropped route. It stays in the Loc-RIB, and show rib and show ecmp-groups report it with the equal-cost paths that competed for the prefix, because both commands read the RIB rather than the last group written to the FIB. It still wins the prefix on administrative distance when its distance is the lower one. redistribute still moves it into another protocol, and the protocol's own event stream still carries it. Only system-rib/best-change, the stream every FIB writer reads, drops it, and the prefix leaves the next-hop table with it, so show nexthop-table stops listing it under its next-hop. A commit that changes the list sweeps the routes already programmed: ze withdraws each prefix it has programmed for a protocol the list now names, programs each prefix whose protocol the list no longer names, and rewrites the multipath group of a prefix that lost or gained a member. The sweep is what makes the change reach a converged router, which sends no further update for a prefix. Permitting a protocol programs its prefixes the way a live change does, so a next-hop no route in the Loc-RIB covers is programmed all the same: such a gateway is on-link on an OSPF or IS-IS link whose connected route no plugin inserted, and reading it as unreachable would leave the prefix out of the forwarding table for good. An SRv6 Service SID that reaches nothing is the one refusal the sweep keeps. The setting covers every FIB writer. They all read one publish stream, so it cannot write BGP into VPP and withhold it from the kernel. A withheld protocol is no member of an equal-cost group either, so traffic does not reach its gateway through a multipath route a permitted protocol won. A prefix leaving the RIB is withdrawn from the FIB only where ze has an install outstanding for it, so a route ze never programmed produces no delete and no FIB sync error.
Persistent storage Experimental One live database/ tree holds checksummed keys, credentials, runtime state, and per-config version pointers. Config history is content-addressed: each version's bytes are stored once under their SHA-256, and every read verifies the hash. One process owns writes; read-only inspection remains available. Explicit config files remain authoritative on every explicit-file start. Daemon commits update the file and history through a recoverable publication intent. ZeFS blobs remain explicit offline artifacts and appliance seeds.
Pipe Output Limiting Experimental | first N and | last N pipe operators bound output to the first or last N ROWS. They act on rows, so a command whose answer has none refuses them by name rather than truncating a document (client-side truncation otherwise). Commands that register them as pipe filters (e.g. RIB) get server-side early termination: | first N stops the iterator at N, saving both iteration and serialization cost. | last N keeps a trailing window. JSON output includes a "pipe" metadata dict recording which data-shaping modifiers were applied.
PKI Certificate Store Experimental YANG pki {} config for CA certificates and device certificates with private keys. Every certificate and key leaf takes a PEM document or base64 DER, PKCS8/SEC1/PKCS1 private key detection, $9$ sensitive encoding for keys, chain validation, expiry checking, atomic reload. PEM export for IPsec and TLS consumers. ServerTLSMaterial gives a TLS listener the leaf plus every stored intermediate, so the web/API HTTPS listener (environment.web.certificate), the looking glass (environment.looking-glass.certificate) and the as112/geodns DoT/DoH listeners (tls { certificate }) can serve an operator certificate with its full chain. A configured name that does not resolve is an error, and no listener falls back to the self-signed certificate. Health check (degraded at 30 days, down when expired). Report bus warnings for approaching expiry. show pki certificates, show pki certificate name <name>, and one command per export form: pem, bundle pem and fingerprint. Shared infrastructure for IPsec, TLS, and future mutual-auth features. The package has a second half config does not reach: a local certificate authority. Ze generates one root at its first start, keeps it in ZeFS, and issues its own components' certificates from it, so a peer validates an ISSUER rather than a copy of one leaf. The root lives ten years, an issued leaf 24 hours, and every certificate backdates NotBefore by five minutes for clock skew. A listener does not outlive its leaf: it answers each handshake through plugin.ServingLeaf, which reissues once two thirds of the current leaf's life is spent. Three surfaces consume the root today: the plugin transport (the engine hands it to every plugin child as ZE_PLUGIN_CA_PEM), the managed hub's listener, and ze appliance init, which issues the appliance's web leaf from an appliance root. The operator-facing web, looking-glass and DoT/DoH listeners are unchanged and still self-sign when no certificate is named. show pki local-ca pem exports the root certificate for an operator to paste into another node's pki { ca <name> { certificate } } block; the root private key has no accessor and reaches no command, no log and no config dump. File permissions are its only protection, and they belong to the blob rather than to the key: ZeFS applies no per-key mode, and the whole store is 0600 because atomicWrite creates it with os.CreateTemp.
Plugin Setup Results Supported Every registered plugin records, from its own init(), what its setup achieved: succeeded, soft-failure, or hard-failure, with the reason an operator acts on. show plugin list carries that record in its outcome and reason columns, in any ze process with no daemon running, and lists a plugin that recorded nothing as unknown rather than omitting it, so a feature that is absent for an environment reason can say why. The daemon reads the same registry once, at the first statement of hub.run, and refuses to start when a plugin recorded a hard failure, naming every failing plugin rather than the first. A CLI verb never reaches that gate, so the command that reports the fault keeps working on a host where the daemon will not boot. This is not show health, which runs a probe now: this replays an outcome decided once, before main().
Plugin-Declared Pipe Aliases Experimental A pipe alias names an operator chain, so show bgp | summary says what show bgp | display router-id local-as uptime peers-configured peers-established says. A plugin names one for its own commands in the pipes list of its Stage 1 registration, and the engine parses the expansion once, at registration. The alias leaves the registry when the plugin stops, so a stopped plugin can start again. The pipe layer selects and re-sequences and computes nothing, so a command that offers an alias MUST emit its aggregate fields beside its detail rows. show bgp rpki does this, and show bgp rpki | summary answers the same record as show bgp rpki summary. command help "<name>" lists the aliases a command answers to, with the chain each one stands for. A declared alias resolves over ze cli -c and over ssh, and NOT inside ze cli with no command argument, which expands the chain in the client process.
Plugins Experimental (partial) The peer's config decides which program sees which peer: each peer attaches a program in an attach process block, receive states what that program is fed and send what it may originate toward that peer, and a peer that attaches nothing feeds nothing. A group's block reaches every member it produces, dynamic members included. show event delivery prints the edges. RIB, route server (with reactor-native RS fast path, dynamic peers, RS-client, community filtering), graceful restart, RPKI (ASPA policy enforcement), healthcheck, community filters, prefix-list, AS-path, AS-path length, community-match and reject-asn match conditions (each registered by its own package and evaluated in process inside a match instance) , external filter plugins in any language over the versioned, batched filter-update contract, which sends a filter only the fields it declared , per-address-family filters (remove an AFI/SAFI from an UPDATE on import or export -- e.g. a FlowSpec route reflector that never advertises ipv4/flow back to edge peers via export remove ipv4/flow -- or tear down the session on a received family; applies to forwarded and originated/injected routes), route attribute modifiers (set/increment/decrement for local-preference/med/aigp, community add/remove for standard/large/extended, MULTI_EXIT_DISC removal on an import chain as RFC 4271 Section 5.1.4 requires; a modifier can carry its own match container over standard, large and extended communities, and a route that meets none of the stated values passes through UNCHANGED rather than being rejected, because the chain already drops a rejected route and a conditional modifier exists so the routes it does not touch keep flowing), ingress community hygiene on the community filter (RFC 7454 Section 11 own-Global-Administrator scrub with a function keep-list, the RFC 8195 Section 3.2 relation-to-origin tag driven by the RFC 9234 role, and the RFC 7999 propagation guard), remove-private-AS policy action, AIGP (RFC 7311), BMP (RFC 7854), interface monitoring, cross-protocol redistribute (egress; routes injected by a redistribute source replay to a BGP peer that establishes after the injection, via a re-emit-on-peer-up request), FlowSpec-to-firewall bridge. BMP Loc-RIB and some redistribution claims remain explicitly scoped by readiness review. Scope gaps: BMP Loc-RIB; redistribution claims scoped by readiness review.
Policy Routing Supported Policy-based routing via nftables packet marking and kernel ip rules. Steers traffic to alternate routing tables or next-hops based on L3/L4 match criteria (address, port, protocol, TCP flags, set references). Actions: accept (bypass), drop, table N (fwmark + ip rule), next-hop (auto-managed table from 2000-2999), tcp-mss clamping. Interface binding by name or wildcard prefix (e.g., l2tp*). A policy that names several interfaces matches traffic on any of them. Ze installs one nftables rule per named interface. Config reload reconciles nftables tables, ip rules, and auto-managed routes. Compile-out-able with the ze_policyroute build tag: default-on in ZE_FEATURES, dropped from ze-stripped / bare ze_core builds, with its config block rejected as unknown.
Prefix-limit counting mode Experimental Per-family prefix { count offered | installed; }, default offered. offered counts announcement events off the wire; installed counts the set of prefixes the family currently holds, so a peer that re-announces the same prefix does not walk toward its limit.
Protocol Event Capture and Replay Experimental Per-peer, opt-in JSONL capture of a BGP session's inbound protocol events, and a replay harness that feeds a capture back through the same read path. Capture tees the COMPLETE wire message at both read paths (standard and coalesced) before RFC 7606 enforcement and before coalescing, so a malformed UPDATE is recorded exactly as the peer sent it and a coalesced batch is recorded as the separate messages it arrived as. Config operations applied while a capture runs are recorded with their transaction id, with secret-bearing values redacted. Off by default: the tee costs one nil comparison and no allocation per received message. Each file is capped at capture { maximum-size } megabytes exactly (1-1024, default 100); at the cap it rotates once to <file>.1 or stops, per capture { on-limit }, so a peer uses at most twice the cap on disk. Writer backpressure sheds events rather than blocking the read loop, counts them in ze_bgp_capture_dropped_events_total, and writes the gap into the stream. ze doctor reports a capture directory the daemon cannot write. Replay: le test replay <file> drives Session.ReadAndProcess over a stub connection and an injected clock and reports the FSM transitions, the prefixes announced and withdrawn, and any NOTIFICATION the session sent.
Resolution CLI and Pipes Experimental Offline ze resolve tool for DNS, Team Cymru ASN names, PeeringDB prefix counts, and IRR AS-SET expansion. The | resolve (reverse DNS) and | origin (ASN/network lookup via Team Cymru) pipe operators decorate the fields a command DECLARES to hold an IP address, and are refused by name over a command that declares none. ze pipe brings these pipe operators to offline commands: ze show debug profile | ze pipe match reactor, ze show debug profile | ze pipe count, ze show debug profile | ze pipe resolve; standalone input carries no declaration, so there they walk every field whose value parses as an address.
REST/gRPC API Experimental (partial) Programmatic API with OpenAPI 3.1 spec, config sessions. Both transports accept multiple named listen endpoints via environment.api-server.rest.server <name> / .grpc.server <name>. REST is plaintext and therefore loopback-only; expose it remotely only behind a TLS terminator. Non-loopback authenticated gRPC listeners require TLS. Bearer token auth, per-user auth, CORS support. Both transports share one engine for identical command output. SSE and gRPC streaming are wired to registered streaming commands such as monitor event, using the same authorization and accounting path as SSH monitor commands. Completion remains future work. Each transport is independently compile-out-able: ze_rest gates internal/component/api/rest and ze_grpc gates internal/component/api/grpc, so a build can ship gRPC-without-REST or vice-versa. normal and appliance builds include both; ze-stripped and bare ze_core drop both. With a transport compiled out its server code and its config container (rest{}/grpc{}) are absent, so that block is rejected as unknown; the shared api-server { token } base and the parent internal/component/api engine stay always-on (gNMI uses the parent). Scope gaps: API completion.
Route Installation Experimental FIB pipeline: protocol RIB best-path tracking, shared Loc-RIB selection by admin distance, recursive next-hop resolution (max depth 8, IGP metric accumulation, cascade on NH change), ECMP grouping (equal-cost paths collected into nexthop groups, max 128 members), rich route programming (route type blackhole/unreachable/prohibit, metric, VRF table ID, MPLS labels, SRv6 SID), kernel backend via netlink multipath with route type/metric/table/MPLS-lwtunnel/SRv6-seg6 support, VPP backend via GoVPP with multi-path/route-type/metric/table support, per-producer netlink protocol ownership, crash recovery via stale-mark-sweep, external change monitoring. Selection and programming are separate stages: the shared Loc-RIB picks one winner for each prefix, and the system RIB decides whether to program it. rib { fib-withhold } naming the winner's protocol is one of the reasons the write is declined, and the Per-protocol FIB withholding row states what withholding leaves intact. The forwarding action (unicast, blackhole, unreachable, prohibit) rides one route from the protocol RIB through sysrib into the FIB backend. It is deliberately NOT part of arbitration: selection stays on administrative distance, then metric, then first-seen order, so a discard route never beats a forwarding one on the strength of being a discard. It IS part of the change comparison, because a prefix that turns into a discard with every other field unchanged must still reach the kernel. A prefix and a PATH own different fields, and the split is at the type rather than at each call site: the label stack and the SRv6 SID belong to the forwarding path, so an equal-cost member promoted over an unreachable winner is programmed with its own, while the protocol, the route type, the metric and the fast-reroute alternate belong to the prefix and come from the winner whichever member takes it. Whether ze holds an install is the PRESENCE of the prefix in its installed map, never the validity of the address there, because a member named by a device alone resolves to an invalid address. The install also records the PROOF it was made under: a next-hop inside a connected covering route resolves to itself, so the address cannot say which rule programmed it, and a cascade that finds a once-proved path now unproved is the one case that withdraws. show rib reports it as route-type, omitted for an ordinary route, and a Linux discard route names no next-hop, device, multipath or encap. CLI: show nexthop-table, show ecmp-groups. Local privileged integration covers FIB restart sweep and flush-on-stop preserving static and policyroute-owned routes; target-runner evidence is still required before production deployment claims.
Route Policy Experimental One policy library supplies source import chains for connected, static, OSPF and IS-IS routes and a central rib import chain for every Loc-RIB source. Rejected paths remain hidden candidates, visible through show rib candidates. A policy reload re-judges stored producer values. Named static tables bypass these Loc-RIB attachments. BGP keeps peer import/export chains. Redistribution applies a destination/source import chain before the destination's IS-IS or OSPF export chain. Each attachment checks which fields its routes carry and which values its filters can set. The system RIB runs internally or externally with one daemon authority and the same forwarding worker. The external selected projection runs no policy or cross-protocol selection. Distance updates and forwarding output require daemon acknowledgment. The real-path tests run each case once with an internal and once with an external system RIB, against a real kernel in a network namespace of their own; the four rib-import-tag cases also cross the static producer's placement. A recorded green run, not the list, is what counts toward a level.
RPF Lookup Experimental Reverse Path Forwarding query: longest-prefix-match against Loc-RIB for any CIDR family (IPv4/IPv6 unicast/multicast). Exposes show bgp rib rpf <family> <source-addr> command returning matched prefix, next-hop, admin distance, and metric as JSON. Generic LPM on the sharded Loc-RIB (queries all shards, picks most specific).
Runtime Diagnostics Experimental Production debugging via CLI and MCP: show l2tp observer (per-session event ring), show l2tp cqm (per-login echo RTT/loss buckets), show l2tp echo (current echo state), show l2tp reliable (reliable transport Ns/Nr/cwnd), show traffic control (TC qdisc/class state), show metrics pool (BGP attribute pool occupancy and dedup rates), enhanced subsystem-list (real plugin state). All auto-exposed as MCP tools for AI-assisted troubleshooting.
Self-Documenting System Experimental Runtime introspection of plugins, env vars, RPCs, schemas, commands. Each command declares two help texts: a one-line summary every listing prints verbatim, and a long explanation only that command's own help page prints. A YANG command node declares them as ze:help and description. A plugin declares them as short-help and description in its Stage 1 registration. No surface derives one from the other. Inside ze cli, Tab reaches both halves. The completion menu lists command names, and the second message line above the prompt carries the summary of the selected command. Tab with nothing left to complete opens that command's long explanation in its own box. A command argument, an rpc or notification leaf, a config node and an enum value declare the same pair, and every surface that names the node renders both: the CLI JSON help, the site and wiki catalogs, the MCP tool schema, the web admin and config forms, the API and gRPC schemas, the published configuration reference and the completion menu. A config node several modules declare shows every declaration's summary, joined, because nothing in the schema says which module owns the node.
Self-Update Experimental Platform-aware update backend. Normal Linux uses Ze self-update or passive version checking with SHA-256 verified download, atomic binary replacement via rename, .prev hard-link rollback, deterministic spread scheduling (FNV-1a per device+version), maintenance windows, server-side pause, and persisted update history. Gokrazy appliances report backend: gokrazy-ab through the gokrazy backend and keep the manual update system firmware {check,download,apply,restart,rollback} command family wired; unsupported operations report that system image updates are managed by gokrazy. Minimal (no-tag) builds return an explicit self-update unavailable in minimal build response. ze update serve standalone server remains available on Ze-managed platforms to distribute artifacts. Config: system { update-check { auto-apply true; spread 1800; maintenance-window { start 02:00; end 06:00 }; restart { time 03:00 } } }.
Static Routes Experimental Config-driven static route plugin with named routing tables (policy-based routing), interface-only next-hops (PPPoE/GRE tunnels), mixed ECMP (gateway + interface-only in same group), next-hops through an interface Ze creates on demand (a pppoe-client), which wait as inactive members while the device is absent and join or leave the group as it comes up or goes, with no reload, ECMP (multiple active next-hops), per-next-hop weighted load balancing, BFD-tracked failover (next-hop removed from ECMP group on session DOWN, re-added on UP), blackhole/reject, IPv4/IPv6, config reload reconciliation, and redistribute integration (redistribute { import static }). Named tables resolved via routing-table registry; non-default table routes are PBR-only (not redistributed into BGP) and are programmed directly, via netlink multipath or VPP via GoVPP. A MAIN-table route is a Loc-RIB path instead: rib { distance { static N } } ranks it against BGP, OSPF and IS-IS for the same prefix, and the FIB plugin programs the winner as RTPROT_ZE, so one writer owns the entry. Such a route needs a FIB plugin and Ze loads one: static declares that it needs a data plane, each FIB plugin declares the data plane it programs, and the engine resolves the pair against the backend interface { backend } selects, so no fib { } block is required and an explicit one always wins.
Storage SMART Management Experimental YANG-modeled SMART disk health: auto-enable on detected ATA/NVMe devices, periodic health polling with three-tier temperature alerting (informational warning, rate-of-change warning, critical error) via report bus, scheduled self-tests (short daily, extended weekly with day-of-week constraint), in-progress detection (skips duplicate tests), live status via show storage smart (per-device health, temperature, power-on hours, error count, NVMe percent-used/available-spare, self-test schedule). Pure ioctl (no smartctl binary, gokrazy-safe). Config reload updates intervals live. ze doctor verifies SMART accessibility when enabled. First NOS with YANG-modeled SMART management.
Subscriber Session Model Experimental Unified subscriber session model for L2TP/PPPoE subscribers with shared session lifecycle, auth, pool, and shaper infrastructure. Show enricher registry lets plugins contribute data to show commands: in-process plugins register via show.MustRegister in init; external plugins declare enrichers at registration (Stage 1) and handle ze-plugin-callback:enrich-show callbacks at runtime with a 2s timeout. Web service-locator pages call show.Enrich explicitly. show subscriber detail and show subscriber gain CoS profile data when the cos plugin is loaded. . internal/core/show/
System Readiness (ze doctor) Experimental Offline pre-start checks: runtime platform detection (gokrazy, systemd, container, plain-linux, darwin) with capability probing (read-only root, /perm, systemd, gokrazy socket, reboot, persistent storage), config syntax, YANG validation, TLS certs (missing/expired/invalid), VPP socket, kernel modules, interface existence/state, SSH host key, listener conflicts, plugin binaries, storage integrity, dangling config references, disk space (<5% free), DNS resolver reachability, clock skew (>5 min vs NTP), VPP version (Linux), VPP hugepage reservation (Linux). Platform-aware checks: gokrazy /perm writability, container read-only root, missing Ze-managed clock synchronization, platform-mismatched persistence/DNS paths, and Linux machine-id presence. Config-delivery audit: doctor-config-root-unclaimed names a configured subtree that commits and reaches no plugin and no hub handler, with doctor-config-claims-unavailable when the claim set cannot be read. Other codes added since: doctor-tls-reference (a certificate name the PKI store does not hold), doctor-pki-ca-root-missing and doctor-pki-ca-root-expiry (the local certificate authority root absent, or within 90 days of expiry), doctor-bgp-capture-directory (a capture directory the daemon cannot write), doctor-iface-ra-forwarding (a unit advertising while its device has IPv6 forwarding off), and doctor-vpp-lcp-plugin (vpp.lcp on while the running VPP loads no linux_cp_plugin.so; a failed probe degrades to a warning rather than an error). Kernel capability gate: a subsystem registers the kernel feature it needs, a predicate that reads the config tree, and a native probe (netlink or procfs, never an external binary). When the configuration uses the subsystem and the kernel lacks the feature, ze doctor reports it at error severity, ze REFUSES to start with the same message and exit 1, ze config validate fails, and a reload is refused with the running configuration still serving. A capability that cannot be DETERMINED warns and ze starts, so an unreadable probe never turns a working deployment into a dead one. There is no operator override. MPLS (CONFIG_MPLS_ROUTING, from the fib kernel plugin) and IPsec (CONFIG_XFRM_USER, from the ike engine) are enrolled. An empty vpn { ipsec { } } block installs no Security Association, so it gates nothing, warns about no kernel module and binds no IKE listener: one predicate answers for all three. Ze WRITES net.mpls.platform_labels before it programs its first label, because a label space of 0 is a dead configuration ze can repair rather than report. --json output with stable diagnostic codes and ze show diagnostic <code> for remediation. Each finding may carry a fix, the command that repairs it, drawn on its own line after the message and carried as the fix key in JSON. Checks of live daemon state register in the runtime phase and run only in the daemon, through show doctor: the local ze doctor first asks the running daemon for its show doctor answer over SSH, and when no daemon answers it runs its own checks and adds a doctor-runtime-not-checked warning naming why and the command that gets the daemon's answer. The recent-events runtime check reports the report bus's recent error events and active warnings as warning rows, so a transient problem appears in show doctor without making the box read not ready.
Tech-Support Bundle (ze request support archive) Experimental Offline archive generator with 20 pure-Go modules (no shell-outs, gokrazy-safe): version, doctor, host, platform, config (sanitized), crashes, disk, interfaces (netlink), routes (netlink), neighbors (netlink), env, sysctl, runtime, dmesg, sockets, kernel modules, conntrack, file descriptors, DNS, firewall (nftables via netlink). Module selection (--module/--exclude), time scoping (--since), privacy-by-default (--sensitive to include secrets), reason metadata (--reason), JSON manifest (--json). Archive: ze-support-<hostname>-<timestamp>.tar.gz with one JSON file per module. No NOS vendor produces structured JSON-per-module output. None of the modules collects SMART disk health.
Traffic Control Lifecycle Experimental The traffic/control section of the config is now programmed at boot and on SIGHUP reload. The traffic component's reactor calls the selected backend's Apply(map[string]InterfaceQoS) in OnConfigure and OnConfigApply, with sdk.Journal rollback on apply failure. Linux default backend is tc (netlink); future backends plug in via traffic.RegisterBackend. Local privileged integration covers netlink qdisc snapshot/restore after backend restart; target-runner and reactor-level boot/reload kernel-state evidence remain open.
Traffic Feature Signals Experimental Neutral per-source detection SIGNALS (facts, never verdicts) derived from the observation feed by a second consumer alongside the traffic monitor: fan-out (distinct destinations), out/in byte ratio (exfiltration), destination-port entropy, new-peer, rare-port/proto, and coarse beaconing (interval regularity, bounded to periods of a few seconds by the 1s sampling tick). Computed via the shared internal/core/stats primitives (rolling window, Shannon entropy, interval regularity). Viewed via show traffic feature; bounded per-source state with idle eviction. The judgment layer (the anomaly detection family) consumes these facts.
Traffic Monitor Experimental Lazy consumer-refcounted aggregation service (internal/component/trafficstat) that subscribes to the observation feed and maintains a time-windowed ranked usage view (per-interface rates, top-N source/dest IPs, top ports with service names, protocol mix, 60s history). The aggregator is rebuilt on the shared internal/core/stats rolling-window primitive; severity is now a display-only CLI computation from the history facts (the neutral layer holds no verdict). Runs only while consumers are attached. Consumed by show traffic stat (one-shot JSON snapshot), monitor traffic stat (full-screen alt-screen TUI via the generic MonitorProvider registry), and ddos/detect (Depth-1: pre-computed per-interface rates instead of raw counter diffing). Includes internal/core/portname hardcoded port-to-service-name table with amplification-vector overlay for 7 known reflection ports.
Traffic Usage Experimental eBPF TCX per-(port, protocol) and opt-in per-IP byte accounting on operator-selected interfaces, exported as Prometheus metrics and viewed via show traffic usage [name <interface>]. IPv4 only, monitoring only (never drops or modifies traffic), Linux >= 6.6 (no-op elsewhere; needs CAP_BPF + CAP_NET_ADMIN). The eBPF programs are assembled in pure Go (cilium/ebpf asm.Instructions) and loaded from memory: no C source, no committed .o, no clang/LLVM; hand-written assembly validated by BPF_PROG_TEST_RUN tests. Per-port accounting (ingress by dst_port, egress by src_port) is always on; track-ip adds per source/destination IPv4 (off by default to bound cardinality). Configurable poll interval, stale-timeout (delete unseen series to bound /metrics cardinality), and per-map LRU max-entries (top-talker eviction). Prometheus metrics: ze_traffic_usage_ingress_port_bytes_total, ze_traffic_usage_egress_port_bytes_total, ze_traffic_usage_ingress_bytes_total and ze_traffic_usage_egress_bytes_total (track-ip only), ze_traffic_usage_map_entries. A ze doctor check (doctor-traffic-usage-ebpf) warns when enabled but eBPF/TCX is unavailable. Compile-out-able with the ze_trafficusage build tag: default-on in ZE_FEATURES, dropped from ze-stripped / bare ze_core builds, with its config block rejected as unknown.
Volumetric DDoS Detection and Mitigation Experimental The volumetric domain, kept separate from the behavioral anomaly detector above. ddos-detect runs two-stage detection over the traffic-monitor feed: per-source packet-rate and bandwidth p99 baselines, attack characterization, and incident confidence scoring. Three responders consume its incidents. ddos-local drops box-directed attacks with an on-host nft rule. ddos-flowspec originates a FlowSpec or RTBH rule upstream for transit attacks. ddos-flowtriq reports incidents to the Flowtriq cloud API. ddos-observe holds the incident lifecycle behind show ddos status and show ddos incidents. Clearing an upstream mitigation is the hard half, because an upstream drop blinds the box's own sensors: the leak probe narrows the announced rule to probe-rate and reads the detector's attack-ongoing bandwidth to see whether the flood still arrives. An announce is also withdrawn by max-mitigation-duration (checked once a second, 0 means no cap, default 3600s, range 0..604800), by a characterized exemption, and by a victim that reclassifies from remote to local. ddos-local enforces its own max-mitigation-duration on the on-host drop rule the same way: measured from when the rule went in, checked once a second, 0 means no cap, default 3600s, range 0..86400.
VPP Firewall Backend Stub-backed Registered as firewall { backend vpp }. Filter chains translate ze Match/Action types to VPP ACL rules via GoVPP binapi (source/destination prefix, port range, protocol, ICMP type/code, TCP flags, permit/deny/reflect). Connection-state established,related maps to ACL_ACTION_API_PERMIT_REFLECT (VPP reflexive ACL). NAT chains configure VPP NAT44-ED: masquerade via output-interface mode, SNAT via address pool + inside interface feature, DNAT via static mappings with tagged cleanup. SetMark and Limit actions use VPP's classify pipeline: classify tables match traffic by packet header fields, SetMark sets opaque metadata via CLASSIFY_API_ACTION_SET_METADATA, Limit creates a policer bound to the classify table via PolicerClassifySetInterface. Expression types without a faithful VPP representation are rejected at commit via firewall.RegisterVerifier("vpp", Verify): interface matches, connection marks, DSCP, sets, packet modification (connmark/dscp/tcp-mss), counters, log, chain traversal.
VPP Traffic Control Backend Stub-backed Registered as traffic { control { backend vpp } }. Scope is per-class policing: HTB and TBF qdiscs translate each class to a VPP policer (CIR = Rate, EIR = Ceil, kbps with round-up). An unfiltered single class binds to interface egress via PolicerOutput. A class carrying a steering filter -- filter protocol <n> or filter dscp <v> -- is instead bound to the ingress policer-classify feature: the backend builds per-family (IPv4 + IPv6) classify tables whose mask/match vectors match the packet at absolute frame offsets and steers matching packets to the class policer via HitNextIndex (byte-for-byte VPP's own policer-hit-next, verified on VPP v25.10). Offsets: IPv4 protocol byte 23 / IPv6 next-header byte 20 for filter protocol; IPv4 TOS byte 15 (mask 0xFC) / IPv6 traffic-class bytes 14-15 (masks 0x0F/0xC0) for filter dscp -- filter dscp polices the DSCP-matched traffic (police-by-dscp), it is NOT a QoS remark. Multi-class HTB/TBF is accepted when EVERY class carries a steering filter: per-interface, per-family the sessions are grouped by field mask into one table per distinct mask (a session per class -> its own policer), and distinct-mask tables are chained via ClassifyAddDelTable.NextTableIndex (real VPP v25.10 validated the multi-session steering and chain fall-through). A multi-class config with any unfiltered class, the prio qdisc (a scheduler VPP does not expose), mark filters (Linux SKB fwmark has no faithful VPP equivalent), and every other qdisc type are rejected at OnConfigVerify via traffic.RegisterVerifier("vpp", Verify). Per the exact-or-reject principle, shipping silent-no-op features (classify sessions in a detached table, or N unfiltered policers stacked on the output feature arc producing min(rates) instead of per-class shaping) is banned. Apply waits up to 5s for VPP to be reachable and returns vpp not connected after 5s on timeout. On partial-apply error the backend undoes what this call programmed in VPP before returning. Reconcile-time deletions are tolerant of stale indexes (post-VPP-restart): failures log a warning and continue instead of failing the commit. A fresh backend instance scans VPP policers with the ze/ prefix, removes undesired startup orphans, and rebinds desired policers from config. Same-process reapply also replays PolicerOutput(apply=true) for existing desired policers, repairing VPP-side output unbinds without requiring a Ze restart. Protocol-filter classify tables are reclaimed by in-process reconcile (unbind + delete by tracked index); because VPP classify tables are anonymous they cannot be reclaimed by name at startup like policers, so a table left by a previous process is inert (unbound) memory reclaimed only by a VPP restart. Real-daemon traffic-control evidence covers policer apply/bind, restart preservation, startup orphan cleanup, protocol-filter and dscp-filter classify-table attachment + reconcile removal, and multi-class per-class steering (two policers bound via one table per family). . ai/rationale/exact-or-reject.md
Web Interface Experimental HTTPS config editor with YANG-driven UI, CLI bar, and L2TP session management (CQM graph, event timeline, disconnect). Every page is a .templ source compiled to Go (58 in the web package, 9 in the Looking Glass), so a renamed view-model field is a compile error rather than a blank panel; regenerate with ./le repo update. The browser library is htmx 4.0.0, shared by the web UI, the Looking Glass, and the chaos dashboard. The service is default-on but compile-out-able with the ze_web build tag: normal and appliance builds include it, while minimal ze_core and ze-stripped-build builds drop internal/component/web. Self-signed HTTPS certificates are generated by the shared internal/core/selfcert helper and persisted through caller-owned storage. Every response carries the security headers, and the X-Ze-Version build banner among them. environment { hide-version true; } takes that banner off the web interface and the Looking Glass together; the default sends it, and no other header changes. Ze sends no Server header at all.
XFRM Interfaces Experimental Route-based IPsec via XFRM interfaces (interface { xfrm <name> { if-id <N> } }). Traffic routed through the interface is encrypted; traffic arriving is decrypted. Created and deleted via netlink.

Libraries

Feature Status Description
IKEv2 Cryptographic Primitives Experimental DH groups 14 (MODP 2048), 19 (ECP 256) and 20 (ECP 384), PRF (SHA-256/384/512), integrity (HMAC-SHA-256/384/512), encryption (AES-CBC, AES-GCM-16 128/256, and AES-CCM 8/12/16 for the IKE SA only; for ESP only, NULL encryption with an integrity algorithm, chacha20poly1305, and legacy 3des with sha1, none of which the IKE SA accepts), SKEYSEED derivation, key expansion (RFC 7296 Section 2.14).
IKEv2 Wire Format Experimental RFC 7296 wire codec: all payload types (SA, KE, Nonce, ID, AUTH, CERT, CERTREQ, Notify, Delete, Vendor, TSi/TSr, EAP, Configuration). Header encode/decode, payload chaining, encryption envelope.

Development tools

Feature Status Description
Chaos MCP Supported AI-queryable chaos test state via MCP: 6 tools (status, problems, peers, scenario, control, execute), Watchdog anomaly detector with structured PROBLEM lines, per-family convergence tracking
Chaos MRT Recording Experimental --mrt-file flag produces standard BGP4MP_MESSAGE_AS4 and BGP4MP_STATE_CHANGE_AS4 MRT records from chaos peer events, readable by bgpdump, bgpkit-parser and ./le mrt. Strftime filename patterns for rotation.
Development Activity Experimental The website's activity page has Calendar and Growth tabs. Calendar shows a year of daily commits and added lines. Growth plots the cumulative commits and added lines within that same window, with a date readout available by pointer or keyboard. Added lines count additions, rather than the repository's net size. The growth view also shows current Go line totals for code, tests and third-party dependencies, plus their overall total. These are a current snapshot; the existing measurements do not contain historical category totals.
Performance Benchmarking Experimental Cross-implementation latency benchmarking with le perf
Published RFC conformance ledger Experimental Every requirement this repository extracted from an RFC is published, one page per summary under /quality/rfc-compliance/<stem>/. Each page carries the requirement text, its level and section, the tests bound to it and the carrier that runs them, the audit verdict a reader recorded and how current it is, the recorded break each tagged unit was seen to fail under, and the extraction sign-off that decided which sentences became requirements. The disclosure is full: a gated MUST with no test, a weak, wrong or unimplemented verdict, a stale or shifted verdict, a tagged unit with no discrimination record, and a no-break record are each named under their own requirement id rather than folded into a count.

Packaging

Feature Status Description
Docker Support Experimental Two images, one binary. docker build -t ze:latest -f docker/Dockerfile. builds the deployment image: a static binary on a scratch base, 119 MB, ENTRYPOINT /ze. docker build -t netlab/ze:latest -f docker/Dockerfile.lab. builds the lab image: tini and iproute2, 137 MB, because lab tools run sh and ip inside a node. Both Dockerfiles derive their build tags from feature-gates.txt. ZE_TAGS adds tags to that set. Compose support is in. . alpine:3.24.3docker/compose.yaml
Installation Experimental ze install local copies the binary to a standard FHS prefix (/usr/local, /usr, /opt/ze) and scaffolds the config directory if no store exists. ze install systemd manages the systemd service: requires an existing database/ tree, creates the ze user/group, transfers store ownership explicitly, writes, grants the needed network capabilities, enables the unit, and can start it with --start. ze uninstall systemd stops, disables, and removes only the service unit. ze init --from <url> imports a store blob over http, https or tftp; the tftp scheme is Ze's own read-only TFTP client (RFC 1350 with RFC 2347 option negotiation, RFC 2348 blksize, RFC 2349 tsize and RFC 7440 windowsize as the receiver), checked against --sha256. ze install remote provides PXE-based bare-metal provisioning: generates ze config from CLI flags, forks ze - to start DHCP+PXE (dhcpserver plugin with options 43/60/66/67/77/93, BIOS/UEFI bootfile selection, iPXE chainloading via boot-script-url for automatic kernel cmdline), TFTP (RFC 1350 read-only tftpserver plugin with RFC 2347 option negotiation for UEFI PXE: RFC 2348 blksize, RFC 2349 timeout and tsize, and RFC 7440 windowsize as the sender, with max-windowsize and timeout leaves), and HTTP image server (imageserver plugin with Range support, dynamic boot.ipxe generation with ze.server/ze.image/ze.port). --kernel and --initrd flags auto-stage installer artifacts; stock iPXE binaries bundled in are copied to the TFTP directory if not present. ze appliance iso builds bootable amd64 or arm64 UEFI installer media around an existing appliance image, verifies the image checksum before ISO creation, and boots an initrd path that decompresses and writes the gzip-compressed embedded image while skipping PXE-style ZeFS download. ze uninstall local removes the binary (optionally config with --purge). Bootstrap mode: when ze starts with a store but no config and no template, it discovers all interfaces, enables DHCP client on every ethernet NIC, and starts SSH for operator access. Non-ethernet interfaces are skipped. SSH credentials come from the store (pre-provisioned by the installer). The installer initrd is a single statically-linked Go binary (cmd/ze-installer, packed into a pure-Go cpio with zero external binaries) running as PID 1 that either downloads the gokrazy disk image via HTTP or mounts appliance ISO media read-only, writes the selected image to a safe target disk, injects the zefs database only in HTTP mode, reboots in HTTP mode, and powers off in ISO mode so removable media can be removed before the next boot. Every appliance image boots Ze's own runtime kernel and no other: ze appliance build and ./le build gokrazy take the kernel from the runtime kernel cache for the image's architecture, built from at the same commit, so the image carries MPLS, L2TP and the rest of the runtime.require floor. Each image also carries /etc/linux-gpl-notice, naming the exact kernel.org version, the source tarball URL and its SHA-256 taken from the build's provenance. Appliance and gokrazy images compile the in-image ze binary with the ze_core build tag (the base personality). Positive build tags (ze_distro, ze_appliance, ze_setup) add feature sets on top. Finer per-feature compile-out tags (ze_<feature>, e.g. ze_lg for the looking glass, ze_ssh for the ssh server) include or exclude individual optional services: The default feature set in feature-gates.txt is included in normal and appliance builds, while ze-stripped omits them for a smaller, hardened binary; an omitted service is not linked and its config block is rejected as unknown. Alternate binaries (le test, le chaos run, le perf, le mrt) each have their own tag and exclude core. Build the initrd with ze appliance initrd. The netboot pair behind ze install remote (tftpserver + imageserver) is compile-out-able with the shared ze_pxe build tag, and the DHCP server with ze_dhcpserver: default-on in ZE_FEATURES, dropped from ze-stripped / bare ze_core builds. . /etc/systemd/system/ze.servicetools/ipxe-binaries/gokrazy/kernel/runtime.config
netlab device Experimental Ze runs as a netlab daemon device under containerlab. mirrors what netlab installs: the daemon definition, the Jinja2 templates, a reference topology, and the committed render. The templates render the whole running configuration into. Declared modules are bgp, ospf, isis, bfd, and routing. Ze reloads on SIGHUP, and netlab sends none, so ze.yml declares initial.reload: false. A configuration change in a running lab needs a manual signal or a node restart. netlab validate reads ze cli -c "show. | json compact" through docker exec. ./le test netlab check renders the templates with a real netlab and compares the result against the golden files. starts a daemon from one of them. A live lab was not started, so netlab up and netlab validate are unrun. The declared features are rendered and parsed, never proven against netlab's integration tests. No LLDP. . contrib/netlab//etc/ze/ze.conftest/plugin/netlab-lab-profile.ci

Test infrastructure

Feature Status Description
Interoperability Testing Experimental 390+ Docker-based interop scenarios against FRR, BIRD, and GoBGP; OpenBGPD, FreeRtr, and Rust implementations are exercised as performance-benchmark DUTs, not interop scenarios
IPsec Interop Testing Experimental Docker-based interop test infrastructure against strongSwan as the remote IKE peer, covering Ze as initiator (PSK, EAP-MSCHAPv2, EAP-TLS, EAP method negotiation by Nak, BGP redistribute, child rekey, RFC 4739 multiple authentication, IPv6 carried inside an IPv4 Child SA on an xfrm interface once strongSwan narrows a two-family proposal to ::/0, the RFC 4301 Section 4.4.1 SPD selection function and the xfrm interface SPD's own final DISCARD entry under unmatched discard, and the tunnel-source guard observed from strongSwan's side of the WAN) and as responder (PSK, EAP-MSCHAPv2, IKE-SA rekey, RFC 4739 multiple authentication) via. The dataplane checks require Linux XFRM: a scenario waits up to 30 seconds for the ESP state on each peer and fails when none appears. The manual ./le test qemu vpn-kernel additionally proves the kernel facilities for AES-GCM, AES-CBC/SHA256, ChaCha20-Poly1305, 3DES/SHA1 and NULL/SHA256 against strongSwan. It requires installed ESP states and received tunnel traffic with module loading disabled. Native amd64/KVM and arm64/HVF receipts cover that five-scenario subset; they are not a pass count for the whole IPsec suite and do not promote this feature's maturity. . test/interop-ipsec/scenarios/