Security & assurance

Named crypto. Verifiable builds. Honest hops.

Everything on this page is checkable: the primitives are named, the releases carry their own evidence, the trust boundaries are drawn where they actually are, and the certification items that don’t exist yet say so in plain text.

Memory-safe Rust coreContinuously tested end to end
Handshake

Noise IK · X25519 · ChaCha20-Poly1305 · BLAKE2s

A two-message authenticated key exchange with identity hiding. Simultaneous initiation resolves by deterministic tie-break — two nodes booting together after a power cut form exactly one session. Stalled handshakes retry at 1 s; unestablished and dynamically-added peers keep a periodic retry loop.

Swappable

The suite is a layer, not a hard-coding

Cryptography is one of the few things an operator is often not free to choose. Identity, handshake, cipher suite and authorization therefore sit behind narrow interfaces: the engine asks for a session and for sealed fragments, and never learns which algorithms answered. Within the Noise framework the primitive set is a parameter of the same handshake — a different key agreement, AEAD or hash is a build-time change — and replacing the handshake framework outright is a bounded integration at the same boundary rather than a fork.

Today: the default build ships the suite above, and the FIPS-validated and post-quantum variants below are specified engineering rather than shipped features. If a national standard, an accreditation regime or an internal policy obliges you to run something else, that is the seam it lands on. The trade is stated plainly: there is no cipher negotiation on the wire by design — one protocol version, one build across the fleet — so a suite is a fleet-wide decision, not a per-session one. The named tracks

Rekey

Make-before-break, every 2 minutes or 1 GiB

The initiator runs a fresh handshake with a new session ID beside the live session; both sides keep the previous keys warm so in-flight packets still decrypt. Measured across rekeys under load: zero packet loss. The rekey marker rides inside the encrypted Noise payload — no wire change; older builds degrade safely. Measured

Replay

2048-entry sliding window, post-authentication

Anti-replay is checked after AEAD verification against the verifying session’s window — checking earlier would let a stale high nonce poison a fresh window. The same window is what deduplicates broadcast-mode copies.

Hygiene

Keys that leave no residue

Decoded private keys live in zeroizing containers wiped on drop; a config file readable beyond its owner produces a load-time warning before anyone ships it that way. A plaintext test mode exists for benchmarking — both peers must explicitly agree, and it says what it is.

Key rotation

Nothing stops to change keys.

Rotation is the moment a tunnel is most likely to drop something — so the sessions overlap. The replacement finishes its handshake and starts carrying while the old one is still sending, and the old one stays warm afterwards so packets already in flight still decrypt. Two triggers run at once: 120 seconds of session age and 1 GiB through the session, whichever arrives first.

Make-before-break rotation — two triggers racing, two sessions overlapping, one unbroken streamSimulation
Offered load
Force
#7session carrying traffic
elapsed timetrigger arriving first
0 packetslost across rotations
What you’re watching: the rotation logic with its shipped defaults — 120 seconds or 1 GiB per session, both counters reset by the swap, and exactly one side of a pair initiating so a simultaneous attempt resolves by tie-break instead of forming two sessions. The clock is compressed ×12 and the handshake is drawn far wider than life, because at true scale a one-round-trip handshake inside a two-minute session is a single pixel and it is the only part worth looking at. The rekey marker rides inside the encrypted Noise payload, so the wire format is unchanged. Rekey behaviour is measured by the end-to-end test suites that gate every change.
Names, not keys Shipped

The name stays. The keys change.

In most tunnels a node is its public key. Change the key and, as far as every routing table is concerned, one node has left and a stranger has arrived. With a fleet list, a node is a record instead: a stable id and a name that hold keys for a while. Routes, the topology, configuration targeting and every snapshot follow the record, and the key is only what the node proves in its handshake.

NODE RECORD drone node id e191..81b6 · the same for life transport keys X25519 · current and next, each with a window signing keys Ed25519 · node tokens and authorship permissions tunnel addresses · capability flags ONE ROTATION, LEFT TO RIGHT overlap · both keys answer key 6142ed49 current, then retired key 5123339a next, then current next key listed activate retire node id, routes and topology never move — each peer rebinds the same entry to the new key
THE RECORDa stable id and a name, holding transport keys, signing keys and permissions
THE ROTATIONthe next key is listed beside the current one, both answer, then the old one is retired
WHAT STAYSthe node id, its routes and its place in the topology
The record

A node is a record

Each record carries a stable node id, a name and roles, the tunnel addresses the node may use, its capability flags, and its keys: X25519 for transport and Ed25519 for signing, each with a validity window. The records of a fleet travel together as one fleet list. A key without a record gets no session, its routing adverts are ignored and nothing it sends is forwarded, however it came to be in the peer table.

Rotation

Rotation with overlap

A record holds at most two keys of a kind at once: the current one and the next. The node loads both and answers a handshake on either. When it switches to the next key, each peer rebinds the same peer entry to the new key, so the node id, the routes and the topology stay where they were, and end-to-end sealed traffic keeps opening on either key through the overlap. Retiring the old key is one edit to the record and one signature, and no other node changes anything. session rekey ↗

Your keys

Your cryptographic module

The record binds a name to public keys and asks nothing else of them. Whatever produced the pair, whether atlasd keygen, an offline key ceremony or your own key-management system, Atlas refers to the node by its name and id, and the pair can be replaced on your schedule without the node leaving the fleet. peer authorization ↗

Boundaries

Signed, distributed, and a choice per fleet

The fleet list is signed on the operator’s host by a key every node already trusts, and numbered, so a node refuses any list older than the one it holds. The operator hands a new list to one node, and the rest receive it over the sessions they already have: each node verifies it before passing it on. Private keys stay on the node, in its own configuration; the list carries only public halves. A fleet without a fleet list keeps the earlier model, in which a node is identified by its transport key and holds every permission.

What a member may do Shipped

What its record allows, and nothing more.

Being admitted to a network usually means being trusted with everything in it: any member can carry traffic for the others, mark its packets as commands, sign configuration and read every dashboard. A record says which of those each node may do. Four flags, set per node, each enforced where its action happens.

NodeRelays for othersClasses it may sendSigns fleet configurationDashboards its token reads
Ground stationyesall sixyesevery member
Droneyesall sixnoits own
Weather sensornoTelemetryPositionBulknonone
Partner observernoVoicePositionnoits own
NODE RECORD gs ground station · role operator keys transport and signing, each with a window addresses 10.0.9.1/32 CAPABILITY FLAGS relayyes classesall six config_authoryes dashboardfleet NODE RECORD sensor weather sensor · role sensor keys transport and signing, each with a window addresses 10.0.9.3/32 CAPABILITY FLAGS relayno classesTelemetry · Position · Bulk config_authorno dashboardnone the flags are fields of the record, signed into the fleet list with it — not attributes of a key
GROUND STATIONrelays for others, sends every class, signs configuration, reads every member
WEATHER SENSORnever relays, sends Telemetry, Position and Bulk, signs nothing, reads no dashboard
BOTHflags are fields of the record, signed with it — not attributes of a key
Flags

Flags, not levels

There is no clearance ladder in which one level includes everything below it. Each flag answers one question, and any combination is valid: a drone may relay for the fleet without signing configuration, and an operator’s laptop may sign configuration without relaying anything. The flags belong to the record, not to a key, so a key rotation leaves them as they are, and changing one is an edit to the record signed into the next fleet list.

Sink

A member that may receive and never send

sink = true on a record makes a node that peers reach — handshake, probes, adverts and multicast subscriptions are accepted — and that can put nothing into the fleet: every data packet it originates is dropped at the first hop and at every later hop, counted caps.sink_dropped, and it is never a transit hop; fleet check warns when such a record also names classes, relaying, authorship or a fleet dashboard. It exists for the feed gateway, a host that publishes one group outward to viewers who never touch the mesh. the feed gateway ↗

REQUEST WHERE THE RECORD IS READ OUTCOME Packet through the sensor forwarded by it for another node Forwarding decision relay = false on its record Dropped the sensor is never a transit hop counted as relay refused Sensor packet marked Control its record lists Telemetry, Position, Bulk Class queue admission classes on its record Sent as Position the next class down that it holds counted as class clamped Epoch signed by the drone a configuration push Authors list config_author = false Refused the configuration never applies only anchors and authors sign Observer’s node token reading the ground station’s API Dashboard gate dashboard = own Refused its token reads its own node only fleet reads every member; none reads nothing
FORWARDINGa packet a non-relay node passes on for someone else is dropped and counted
CLASS QUEUEa class the record does not list is lowered to one it does, and counted
AUTHORS AND DASHBOARDSonly authors sign configuration; a node token reads only as far as its record allows
relay

The forwarding decision

Every node computes routes from the same fleet list, so every node leaves out the same members. Shortest-path routing reaches a node whose record says relay = false but never routes through it, and multipath never picks it as the first hop toward anyone else. The node refuses to forward, and its neighbours drop any packet it passes on for someone else, counting each one. Its own traffic is untouched and travels as many hops as it needs. routing ↗

classes

Admission to the class queue

Traffic is classified where it enters the mesh. A packet in a class the record does not list moves to the next class down that the record does list, so claiming Control never buys priority; only when nothing lower is allowed does it take the lowest class the record holds. The check runs on the sending node, again at its first neighbour, and at every hop that forwards the packet after that, so a sender running altered software still lands in its own classes, a relay cannot raise them on the way, and every change is counted. the classes ↗ clamped at every hop ↗

config_author

The authors list

Configuration epochs and fleet lists are accepted when they are signed by a trust anchor installed on the node, or by a member whose record carries config_author. Every other signature is refused, so the key of an ordinary member cannot push configuration or rewrite the fleet list. signed epochs ↗

dashboard

How far a node token reads

Where a node protects its reads, other nodes read its dashboard API with a short-lived token that the reading node signs with its own key. That node’s record decides how far the token reaches: fleet reads every member, own reads only the node itself, none reads nothing. Operator accounts and their hardware keys are a separate gate and are unaffected. operator sign-in ↗

Why here

Why this is possible here

A permission needs someone to attach to. In a radio network where every set shares one key, any set holding the key can do whatever any other set can, and the network cannot tell a sensor from a ground station. Here every node proves its own key in its own handshake, and that key resolves to one record, so every session, signature and token is tied to the node that holds it.

Default

Least privilege by default

A record that names no flags gets the least of each: no relaying, Telemetry, Position and Bulk only, no configuration authorship, and dashboard reads of its own node. A new record is written that way unless the operator says otherwise, so every member starts with the least and is raised only as far as its job needs.

Boundaries

Where the checks run

The class check runs at the sender, at its first neighbour and at every forwarding hop after them, each reading the origin named in the relay header; with end-to-end sealing the destination checks the origin and the class under the seal as well. Classes are admitted where QoS is on, since without it there is no class queue to admit to; the clamp in transit runs whether or not the hop runs QoS. A fleet without a fleet list has no records, and every node in it holds every permission, as before.

Classes hold at every hop Shipped

A relay cannot promote what it carries.

A packet that crosses three relays is handled by three nodes that did not send it. Each forwards it with the class byte it arrived with, and that byte picks the next hop’s routing map and queue — so a relay that re-marked a sensor’s telemetry as Control would be believed by every hop after it. Here every forwarding hop knows who sent the packet, clamps the class to that sender’s record, and the destination checks both the sender and the class under the seal.

relay header · 12 byteshop limit · reserved · path id · destination 10.0.9.1 · origin 10.0.9.3 the origin is stamped once by the sender and copied by every hop sensororigin 10.0.9.3 hop 1clamps to the record hop 2 · capturedre-marks it Control hop 3clamps to the record ground stationopens the seal Telemetry Telemetry Control Position AT EACH HOP origin 10.0.9.3 → record sensorTelemetry · Position · BulkTelemetry allowed — kept origin 10.0.9.3 → record sensorTelemetry · Position · BulkControl not allowed — Position counted: clamped in transit seal binds10.0.9.3 · Telemetrya downgrade: kept upgrade or new origin: dropped, counted every forwarding hop clamps to the origin’s record, QoS on or not · an origin no record covers is dropped there unclassified traffic is never clamped · the seal checks origin and class end to end tunnel MTU 1416: 44 B of Atlas headers + the 12-byte relay header + 28 B of UDP/IPv4 = 1500, one datagram per relayed packet
THE HEADERthe 12-byte relay header carries the origin’s tunnel address, stamped once by the sender and copied by every hop
EACH HOPlooks up the origin’s record and clamps the class to the classes it may send — a captured relay’s Control becomes Position at the next honest hop, and is counted
THE DESTINATIONopens the seal, which binds origin and class: a downgrade is kept; an upgrade or a changed origin is dropped and counted
The header

Who sent it, on every hop

A relayed packet carries a 12-byte cleartext relay header: a hop limit, a reserved byte, a path id, the final destination and the origin — the sending node’s tunnel address, stamped once by the sender and copied unchanged by every transit hop. It is what lets a hop that never saw the sender’s session know whose record applies to the packet in its hands.

The clamp

The record applies at every forwarding hop

Every node that forwards a relayed packet, whether or not it runs QoS, looks up the origin’s record and clamps the inner class byte to it by the same rule as at the sender: an allowed class is kept, otherwise the highest allowed class below it, otherwise the lowest the record holds — before the byte picks the routing map and the queue. Each clamp is counted, caps.class_clamped_transit. Unclassified traffic is never clamped. A classified packet whose origin no record covers is dropped and counted, caps.origin_unrecorded, so a relay cannot dodge the clamp by naming an unknown sender; and a first hop treats a packet whose header names someone else as the origin as forwarded, so it meets the relay check too. what a member may do ↗

The seal

Origin and class, bound end to end

With end-to-end sealing on, the seal binds the sender’s tunnel address and the class byte the sender stamped as associated data, and the destination checks what arrived against them: the relay header’s origin must be the sealed one — and, in a record fleet, an address of the sender’s own record — and the arriving class must be the sealed class or a downgrade of it: the same reliability mode with a lower class, or exactly what the sender’s record clamps the sealed class to. Anything else — an upgrade, a changed origin, a class stamped on unclassified traffic or stripped from classified traffic — is dropped and counted, e2e.class_tampered. The relays between carry a byte they can lower but never raise, and a sender they cannot replace.

The MTU

Why the tunnel MTU is 1416

The default inner MTU is the largest packet whose relayed frame still fits one datagram on a 1500-byte underlay: 44 bytes of Atlas headers, the 12-byte relay header and 28 bytes of UDP/IPv4 bring 1416 to exactly 1500. It was 1420 while the relay header was 8 bytes; carrying the origin grew the header by four, which made every full-size relayed packet four bytes too big for the underlay and left the kernel to fragment it. The default shrank by those four bytes so a full-size packet crosses any number of relays as one datagram. A direct frame is 1488.

Where it shows

Counted per hop, named on the dashboard

The dashboard’s Refusals row shows clamped in transit, relayed from no record and relay tampered beside the clamps and refusals of the first hop; the snapshot carries caps.class_clamped_transit, caps.origin_unrecorded and e2e.class_tampered on every node. A relay that re-marks traffic is visible on the honest hop after it, not only at the destination. the dashboard ↗

Boundaries

What the clamp alone cannot see

Without end-to-end sealing the origin field is only as honest as the relays that carried it: the clamp at the next honest hop still holds the class to the record of whichever sender the header names, but a relay that rewrites the origin to another recorded node is caught only under the seal. A fleet without a fleet list has no records, so its transit hops clamp nothing. The seal costs a sealed inner frame per packet, as it does for every end-to-end packet. the three boundaries ↗

Anti-replay

Reordering is not an attack.

A bonded link delivers out of order by construction — three paths, three latencies, one stream. The window has to tell that apart from a replayed capture, and it only gets to look once the packet has already authenticated.

The sliding window — 2048 slots, one bit per packet, checked after the tag verifiesSimulation
Arrival
Inject
4192high-water mark
0accepted out of order
0refused by the window
What you’re watching: the shipped filter’s rule, branch for branch — ahead of the mark accepts and slides the window; behind it accepts unless that slot’s bit is already set; 2048 or more behind it is refused whatever it carries. The window belongs to the session that decrypted the bytes and is consulted only after the tag verifies, so an invented sequence number is dropped a gate early and never moves the mark. The same window is what discards broadcast-mode duplicates — that is the repeat arriving on its own roughly one packet in ten here.
static

Reject unknown keys

The default and the historical behaviour: if it isn’t in the config, it doesn’t handshake.

keyfile

A hot-reloaded allowlist

A TOML file of public keys and their allowed IPs, re-read on modification — grant or revoke a node by editing one line, no restart, no redeploy. To remove a node, delete its line and evict it (atlasd peer evict); a key the file already admitted is not checked again until then.

command

Your identity system, as a hook

An external command receives the key and source address; exit 0 authorizes and stdout lines become allowed-IP CIDRs. This is the integration point for an external control plane — it’s how the hosted gateways admit app-generated keys with deterministically derived tunnel addresses.

fleet

Admission by record

Keys are admitted from the signed fleet list: a key that belongs to a record joins as that record, with the record’s addresses and capability flags, and a key without one is refused. The list reaches every node over the sessions they already have. node records ↗

custom

Replaceable wholesale — not just configurable

The providers above are implementations of one small trait, and an embedder can inject any other: your own PKI and certificate chain, an HSM or smartcard, a corporate identity service, an accreditation-mandated enrolment protocol. The module sits beside the data path, not inside it — replacing it changes nothing about the Noise handshake, the scheduler or the wire format.

The point is jurisdictional as much as technical: operators run the authorization scheme they want, or the one their organisation and accreditation oblige them to run, rather than the one a vendor happened to ship. If your programme mandates a specific identity infrastructure, that is an integration, not a fork.

Failure mode

Everything fails closed

Unreadable keyfile, missing hook, hook timeout, unknown provider — refused start or refused peer, never a silent allow. Providers run off the packet path with a deny cache so a handshake flood can’t fork a process per packet.

Admission modes Shipped

Four ways in, each one logged.

The providers above decide what a node does with a key it does not know. Four admission modes add a deliberate way in, chosen per fleet: a one-time invitation, a fleet certificate, a second secret at the handshake, and an operator approving each request. A key that passes none of them gets nothing, and every invitation, admission and decision lands in the node’s journal with who made it. A hub that cannot sign the fleet list forwards what it admits to a node that can.

One-time invitations Shipped

One code, one node, once.

ONE-TIME INVITATION Ground stationasks the hub, shows the QR shows Pairing codeminutes to live, one use anchors · authors · both addresses under the token’s MAC scan New nodeputs it in its first handshake takes the hub’s confirmation, and a pool address, over the session handshake Hubchecks it, spends the use drone07, a new recordno relay · Position, Telemetry, Bulk Fleet list, next seqsigned by an author, flooded the same code again, or from a second key: no session, and no use spent twice least privilege unless the invitation raised it · journalled with the operator who minted it
THE CODEThe ground station asks the hub for an invitation and shows its pairing code as a QR: minutes to live, one use; under the token’s MAC it carries the fleet’s anchors, the authors and both tunnel addresses.
THE HANDSHAKEThe new node presents the code in its first handshake; the hub checks it, spends the use, mints a least-privilege record and confirms the code over the session — with the address, for a pool code.
THE LISTA config author signs the record into the next fleet list and floods it. The same code again gets no session.
The code

A pairing code that cannot be edited into more rights

atlasd fleet invite --name drone07 --allowed-ip 10.1.0.17/32 --ttl 15m on a node, or POST /api/admission/invites from a platform backend with a write token, mints an invitation and returns its pairing code as text and as a QR. Beside the inviting node’s key the code carries the fleet’s anchor keys, the config authors of its list that are not anchors, the address the record gets — none for a pool — and the hub’s own tunnel address with the tunnel prefix: about 200–260 characters, a QR of version 10–12. The token inside is 40 bytes: an id, an expiry and a BLAKE2s MAC under the node’s invitation secret that covers the flags the invitation grants and a digest of everything else the code carries except the name and region hints, so a code whose anchor, author or address was altered does not verify.

The handshake

The record is minted for the key the handshake proved

The new node presents the code inside its first handshake, with its record UUID, its signing key and a signature proving it holds both. The inviting node verifies the token, spends one use and mints a record for that key — least privilege unless the invitation raised it: no relaying, Position, Telemetry and Bulk, its own dashboard only. A config author signs the record into the next fleet list at once and floods it. what a member may do ↗

Single use

Spent means spent

Minting is serialised, so one code presented from two keys at the same instant admits one node. A code that is spent, past its expiry or withdrawn admits nothing, and a key or UUID the list already holds or has revoked is refused without spending the use. A multi-use invitation gives each node the next free address of a pool and numbers the names.

Joining

The new node knows whom to trust

The invited node starts as a joining member with no fleet list and no anchors file of its own; its config may leave out its own address and the hub’s peer entry, both taken from the code. It adopts the first list signed by an anchor the code carried, by a carried author that the list itself names as one, or by a config author whose transport key is the hub’s — and the carried signers count only once the hub has confirmed the code over the session, with the binding its MAC verified, a confirmation the node keeps across restarts. So a node invited by a hub that cannot sign still takes the list the author signs, and from then on seals end to end and enforces records like every other member; the carried anchors are its anchors for later lists, certificates and the codes it mints in turn. forwarded to an author ↗

Pool address

Addressed by the hub, with no restart

A pool code carries no address, because the pool picks one at admission. Such a node starts with its interface up and unaddressed, advertising none; the hub’s confirmation names the address its record got and the tunnel prefix, taken only over the session with the code’s key and only for the node’s own binding, and the node configures it on the spot — on the interface, in its next advert, as the origin of the relay headers it sends, in its roster entry and as the hub address of the codes it mints in turn. No restart, and no placeholder address is ever advertised; after a restart it starts on the address its own record names.

Fleet certificates Shipped

Signed once, admitted wherever the authority is trusted.

FLEET CERTIFICATE Fleet authoritysigns once, at the factory signs Certificatethe record, signed · ≤ 940 bytes carried drone-cpresents it in its handshake handshake Any hubthat trusts the authority Every member learns itand checks drone-c’s adverts The list revokes itrefused from then on no entry for drone-c on any hub, and never a config author admitted with the flags the certificate names · journalled as admission.cert_accepted
AT THE FACTORYThe fleet authority signs drone-c’s record once. The certificate is at most 940 bytes.
ANY HUBA hub that trusts the authority admits drone-c with the certificate’s flags, with no entry for it, and every member learns the record.
REVOKEDOnce the fleet list revokes it, the certificate is refused.
The certificate

The record, signed by the fleet authority

atlasd fleet cert signs a node’s record — UUID, keys, addresses, flags and an optional expiry — with the fleet authority’s key, typically when the node is built. The node presents it from [auth] cert_file in its handshakes, and any node that trusts the authority admits it with the flags the certificate names. No list and no hub needs an entry for it.

Across the mesh

Reachable everywhere, not only from the hub it dialled

The admitting node offers the certificate on over its sessions, so every member learns the record and verifies the certified node’s signed adverts. A certificate never makes a config author. signed routing ↗

Revocation

Revocation is the list

atlasd fleet revoke --cert drone-c.cert, or the dashboard’s Remove nodes, puts the certificate’s id and keys on the list’s revocations. Every node evicts the node in the same intake, and the certificate is refused from then on, even from a factory-fresh start. removal ↗

Key plus secret Shipped

Two factors at the handshake. A wrong secret gets silence.

KEY PLUS SECRET TAG CHECKED FIRST Recorded key + secretboth factors Recorded key, no secreta stolen key on its own Secret, unknown keya leaked secret on its own Sessionthe secret also enters the session keys dropped before any Diffie-Hellman, no reply — the same silence a closed port gives no record, no session
KEY AND SECRETA session, with the secret mixed into its keys.
KEY ALONEDropped before any Diffie-Hellman, with no reply — the same silence a closed port gives.
SECRET ALONENo record for the key, so no session.
Two factors

A stolen key alone opens nothing

With [auth] psk, a fleet-wide 32-byte secret, or per-record secrets named by a record’s psk_id, every handshake initiation carries a tag computed over the whole message under the secret. With a fleet-wide secret the tag is checked before any Diffie-Hellman. A missing or wrong tag is dropped with no answer at all, not even a cookie, and counted, so from outside a wrong secret cannot be told apart from a port nobody listens on.

In the keys

The secret is part of every session key

The handshake runs Noise IKpsk2, so the secret also enters the session keys: a recorded handshake cannot be opened without it. That makes it a hedge for traffic recorded today, ahead of the hybrid post-quantum key exchange on the certification track. It works under every provider and with the other modes.

The approval queue Shipped

Who knocked, from where, and one decision.

THE APPROVAL QUEUE Unknown nodeno record, keeps retrying knock Pendingsource, the name it gives,first and last seen, how often shown Operatordashboard, CLI or API Approverecord minted, session Denyblocked, dropped unanswered JOURNAL admission.knock · admission.approved · admission.denied — each with the operator who decided
THE KNOCKA key that passes no other check is parked with its source, the name it gives, first and last seen and how often it tried.
THE DECISIONApprove mints a record and the node’s next retry gets a session; deny blocks the key.
THE RECORDEvery knock and every decision is journalled with the operator who made it.
The knock

An unknown device shows up for a decision

With [auth] pending = true, under any provider, a key that fails every other check — no record, a refused invitation, a denied hook — is parked instead of failing silently: its source address, the name it calls itself, the identity it proved, first and last seen, and how often it tried. The queue is rate-limited per source and bounded. A knock is listed in GET /api/admission/pending within half a second, and on the dashboard’s Peers tab under Pending.

The decision

Approve, with the flags you choose — or deny

Approve mints a record with the address and flags the operator picked, signed into the next fleet list by a config author, and the knocking node’s next retry gets a session — about two seconds later, with no restart. Deny blocks the key for an hour by default; its handshakes are dropped unanswered from then on. The same decisions are atlasd fleet pending approve | deny and POST /api/admission/approve | deny, so a platform backend can decide with a write token.

The record

Who let it in has an answer

Every knock, approval and denial is journalled with the operator who decided — a dashboard user, an API token or a command-line user — beside the invitations each operator minted and the nodes each one admitted.

Boundaries

Where each mode applies

Invitations and certificates admit into a record fleet; key plus secret and the approval queue work under every provider. A node that cannot sign fleet lists admits the node it minted there and forwards the record to a config author on its own, below. A certificate carries no geofence. The handshake initiation grows with what it carries — a pairing code, a certificate — and stays within 1,200 bytes.

Forwarded to an author Shipped

A hub that cannot sign hands the record to one that can.

FORWARDED ADMISSION dronepairing code or approval hubadmits the drone here,cannot sign the fleet list a neighbour: over the session relaycannot read it hops away: end to end, sealed config authorsender listed, record well formed,no right the hub lacks itself,nothing taken or revoked seq N+1signed and flooded about 1 s after admission
THE HUBAdmits the new node and forwards the record it minted to a config author, near or several hops away.
THE AUTHORChecks the record under its own policy: never a right the hub lacks itself.
THE LISTThe record is signed into the next list and flooded about a second after the admission.
The forward

Near or far, on its own

A hub that admits a node by pairing code or approval but cannot sign the fleet list keeps admitting it there and, once a second, hands its queued records to a node whose record carries config_author, up to four per message. To a neighbouring author they travel over the session on the fleet-list channel; to an author several hops away the same message goes end to end on the control channel, routed and sealed like data, so the relays between cannot read it. With no author reachable, the hub retries with backoff, from 5 s doubling to 5 minutes.

The author

Its own policy, not the hub’s word

The author takes a record only from a sender that holds a record in the signed list, only in the shape a node mints (one transport key, at most one signing key), never as a config author, and never with a right the sender lacks itself: a hub cannot hand out relaying, a wider dashboard role, a traffic class or the operator role it does not hold. A record whose id, name or key is already taken, or that the list revokes, is refused with its reason. Accepted records go into one next list, signed and flooded as usual, and the hub drops its local copy once a list carrying them arrives.

Held

Or held for a person

With [auth] accept_forwarded = false an author holds forwarded records for an operator instead: they show in atlasd fleet pending list and on the dashboard’s Pending card, and approve signs one exactly as minted. A refused record stays on its hub, still admitting its node there, and is not forwarded again. Every forward, answer and decision is journalled on both sides and counted.

Boundaries

Sealed when it crosses relays

An author takes a forward that crossed relays only sealed end to end, so a hub reaches an author several hops away when it runs [crypto] e2e; without it the hub forwards to a neighbouring author only. The node a hub admitted takes the author’s list as its first list when an anchor it trusts signed it; until then it runs as joining, known to every other node from the list and reaching its configured peers directly.

Removal that holds

Out everywhere at once.

Removing a node is one command on the operator’s host, or one action in the dashboard with the nodes picked from a list. The signed fleet list carries the removal, and every node that adopts it acts on it in the same moment: the removed node’s sessions end, its handshakes are refused, the hosted relays drop it, and the shared mesh secret changes.

FLEET · SIGNED LIST SEQ 8 gssigns seq 8 and pushes it node-aevicts node-x node-bevicts node-x node-cevicts node-x node-devicts node-x node-eevicts node-x Hosted relayrefuses node-x’s key node-xrevoked by seq 8 no session, no adverts, no gossip, no relay every node, in the same intake: passes the list on, evicts node-x, switches to the new mesh secret
THE PUSHgs signs list seq 8 and it reaches every node and the hosted relays over the sessions they already have
EVERY NODEpasses the list on, evicts node-x, switches to the new mesh secret
NODE-Xno session, no adverts, no gossip, no relay
Four things

Four things happen

The removed record’s id and every key it held go on the list’s revocations for good: no later list may carry them, and a node that comes back does so as a new identity with new keys. Every node that adopts the list, in the same intake, passes it on to every peer, the removed node included so it learns it is out; ends every session whose key resolves to no record; and switches to a new mesh secret. From then on the removed node’s handshakes are refused at every node, and the hosted relays refuse its key and tear down its relay sessions. Every node holds the new list, and none has a session with the removed node, within a second of the push. Measured

Mesh secret

A new secret, sealed to each remaining record

Each removal mints a fresh 32-byte mesh secret and seals one copy to each remaining record’s transport key, carried inside the signed list, so only a current member can open its copy. Nodes switch at once; the previous secret is still opened for ten minutes, so a node one hop behind is heard while the list reaches it.

What it keeps

What the removed node keeps

What it already received, and nothing new: no session, no membership, no gossip under the new secret, no traffic relayed for it. Traffic between other nodes that it recorded off the air stays unreadable, because session keys are ephemeral and nothing it holds derives them. Its own status reads revoked by fleet seq N, and it refuses to start again with that identity.

Operator

One command, or one dashboard action

atlasd fleet revoke <node> --reason "…" --push on the operator’s host, or Fleet → Remove nodes… in the dashboard: tick the nodes, preview the change (the list’s next sequence, the records that remain, how many nodes receive the new secret), then sign and push. Removed nodes show as revoked in the records table and in the health and configuration matrices. Every step is journaled as security.revoked, security.peer_evicted and security.secret_rotated, and counted in the snapshot. node records ↗

Boundaries

A record fleet removes; an allowlist refuses

Revocation works on the fleet list. A fleet without one removes a key by editing its allowlist, which refuses new sessions, and atlasd peer evict ends the live ones. The hosted relays pick up revocations on a poll, so a removed key leaves them within one poll interval.

Signed routing Shipped

Every route is signed by the node that announced it.

A link-state mesh routes on what its members tell each other. Here, what floods is signed by the node it describes, and what passes between two neighbours is sealed under their session, so nobody outside the fleet, and no node that has been removed from it, can inject a route or fake a link’s liveness.

FLEET advertfrom node-a sig node-aoriginator · signs node-brelay node-crelay gsground station verified verified verified forged advertremoved node or outsider dropped, counted each receiver checks the signature against the originator’s record before its topology sees the advert
A GENUINE ADVERTsigned by node-a and verified against its record at node-b, node-c and the ground station
A FORGED ADVERTfrom a removed node or an outsider: dropped and counted at the first receiver
Floods

Flooded messages are signed

Every link-state advert carries its originator’s node id, key id and an Ed25519 signature over its canonical bytes, and every receiver checks it against the originator’s record before the topology sees it. An advert that is unsigned, names an unknown key, fails its signature or comes from a node with no record is dropped and counted. Gossip documents carry their sender’s signature, each configuration-status entry is signed by the node it describes, and fleet lists and configuration epochs are signed by their authors, so a status relayed hop by hop stays attributable.

Hops

Hop messages are session-bound

Probes, probe acknowledgements and keepalives travel sealed under the session’s own keys and nonce counter, and pass the anti-replay window once they authenticate. A probe or acknowledgement that does not authenticate is not answered: it moves no RTT, revives no link and points no endpoint anywhere. the window ↗

What it closes

No injected routes, no faked liveness

A non-member or a removed member cannot announce a prefix, claim a link, revive a dead path or kill a live one, and holding the mesh secret does not let one member speak as another. Keys change only through the signed fleet list: no message from a node can add or rotate its own keys. Handshakes pass a per-source and a node-wide rate limit before any Diffie-Hellman work, and under load the node answers with a cookie bound to the sender’s address, as WireGuard does, so a flood of forged handshakes cannot starve the data path or crowd out a member’s handshake.

One version

Fleet-wide, one version

Signed adverts, signed gossip and sealed probes are part of the current protocol version, 5, which every node of a fleet speaks. There is no compatibility mode by design: a fleet upgrades together, a node on another version is refused and named, and every record in a record fleet carries its node’s signing key. The hosted relays carry the current version and the one before it, so they serve a fleet on either side of its upgrade.

Boundaries

Where the signatures stop

A fleet without a fleet list has no keys to verify against, so its adverts and gossip are unsigned and its underlay remains its trust boundary; record fleets are the answer. A few outer-header fields used for loss accounting sit outside the authenticated data, so an on-path attacker can disturb loss figures but cannot inject or change traffic.

By area, and by wipe Shipped

Remove by area. Wipe on command.

When a position is overrun or a vehicle park is lost in one event, finding each affected node by name is the slow part. Draw the area instead: the nodes last seen inside it come back as a list, the operator reviews it, and the removal runs on exactly those records. Each node can also carry a signed operating area of its own, and any node can be wiped by a signed command that rides in the fleet list.

Draw the area, review the list, revoke.

MAP · LAST KNOWN POSITIONS n3fix 1 s n4fix 1 s n5fix 2 s n6silent · 4 min gsoutside n1outside Review INSIDEn3 · n4 · n5 · n6 n6 silent, its fix 4 min old OUTSIDE2 records NO POSITIONn2, listed apart Revokesigned list, new secret,sessions end everywhere after the operator confirms the selection removes nothing: only the records the operator confirms are revoked, and never the node doing the selecting
THE AREAA polygon on the map, resolved against the last position each node advertised.
THE REVIEWThe nodes inside with the age of each fix, a count of those outside, and the nodes with no position listed apart.
THE REMOVALOnly the confirmed records are revoked: a signed list, a new mesh secret, sessions ended everywhere.
The area

A polygon, resolved against where nodes said they were

Every node of a record fleet keeps the last position each node advertised, and keeps it after the advert ages out, so a node that went silent inside an area is still found there. Click the corners on the dashboard’s Topology map, or hand a GeoJSON polygon to atlasd fleet select-area or POST /api/fleet/select-area. Polygons may cross the antimeridian and carry up to 256 corners.

The review

A list the operator confirms

The selection removes nothing. It returns the records inside, each with the age of its fix and whether its advert is still live, how many lie outside, and the records that never advertised a position, listed apart because no polygon can place them. Positions are what each node reported, which is why every fix carries its age and why a person confirms the list.

The removal

Exactly the confirmed records, through revocation

Revoke selected opens Remove nodes with the confirmed records ticked, and --revoke does the same on the command line: the records are revoked, the mesh secret is rotated, the list is signed and flooded, and every node ends their sessions in the same intake. The node doing the selecting is never on its own list. how removal works ↗

A signed operating area, enforced by the node itself.

GEOFENCE · SIGNED IN THE NODE’S RECORD inside · nothing happens leaves the area grace_secs · back inside cancels it fires once Isolate · the defaultrefuses every peer, tears sessions down;lifts when the node is back inside Zeroizekeys destroyed, every store emptied,the node stops NO FIX never fires: a jammed or absent GPS is not evidence of being outside · the timer is stored sealed, so a restart outside resumes it
OUTSIDEThe node’s own fix leaves its signed area and a grace timer starts; back inside cancels it.
THE ACTIONIsolate (the default, lifted when back inside) or zeroize (keys destroyed, stores emptied, the node stops).
NO FIXNever fires. A jammed GPS is not evidence of being outside.
The fence

Part of the record, signed with it

A record may carry [node.geofence]: a polygon, grace_secs (600 by default from the command line) and an action, isolate or zeroize. It is signed in the fleet list like every other record field, set with atlasd fleet set-geofence, and reaches the node with the list. The dashboard draws every record’s fence on the map, coloured by its state as seen from that node.

The timer

Checked against the node’s own fix

The node compares its own fix — live telemetry, a configured position or the position API — with its fence every 10 s. The first fix outside starts the grace timer; back inside before it runs out cancels it. The timer is stored sealed at rest, so a restart outside the fence restores the state instead of handing out a fresh grace period, and a changed fence re-arms the action without resetting the clock.

Isolate

Reversible, and announced first

The node stops admitting anyone, announces isolated in its own signed status entry and flushes that gossip to every peer, then tears every session down. Peers that hear it drop their side at once, and every handshake in either direction is refused and counted. Back inside, the announcement is withdrawn and the sessions return on their own.

Zeroize

The wipe, with the geofence as its cause

The same routine as the remote command below: the node announces zeroized, destroys its keys, empties every store and stops. Its one clear journal line names the cause, the time outside and the grace it had.

No fix

Never fires without a position

A node with no fix is flagged no fix and never fires its action, because a jammed or absent GPS is not evidence of being outside. A fix lost while outside keeps the timer’s start, so a fix that returns outside resumes it.

A signed command in the fleet list. It also revokes.

Operatorfleet zeroize n2 · Zeroize… Fleet list · seq 9 signed as a whole by an author command: zeroize n2, signed on its own over the fleet id revoked: n2 n2 · the addressed nodechecks the signer and not_before, announces zeroized,destroys its keys, empties every store, stops Every other nodeevicts n2 and purges its adverts at once;the revocation refuses it from then on an unknown signer is refused · a command not yet due is held · an older list replayed is refused before any command in it is read
THE COMMANDSigned on its own by a fleet author over the fleet id, inside a list signed as a whole.
THE NODEAnnounces zeroized, destroys its keys, empties every store and stops.
EVERY OTHER NODEEvicts it at once; the same list revokes it, so it is refused from then on.
The command

Signed twice over

The fleet list carries commands = [{ node_id, cmd = "zeroize", not_before, issued_at, author, sig }]. Each command is signed on its own by a fleet author over the fleet id and its fields, so it cannot be lifted into another fleet’s list or re-aimed at another node, inside a list that is signed as a whole. One command per node, kept in later lists until it is cancelled. atlasd fleet zeroize <node> writes and signs it on the operator host; the dashboard’s Zeroize… previews and signs it from a node with a config-author key; POST /api/fleet/zeroize does the same for a backend holding a write token.

It revokes

Wiped, and removed in the same list

A zeroize also revokes the node by default, so the list that carries the command takes the record out of the fleet: its id and keys are refused everywhere from then on, whether or not the device ever acts on the command. An operator who wants the record kept says so when signing the command.

The node

Checked every second, run once

The addressed node checks its commands every second. A command from an unknown signer is refused, one not yet due is held until not_before, and a verified, due one runs: the node sets zeroized in its own signed status entry, flushes that gossip to every peer, then destroys its store key, its private and signing keys, the mesh secret and its dashboard secrets, empties every store and stops. The one clear journal line left names the signer, the fleet sequence and the times; a restart refuses for want of a key.

The fleet

Out of every table at once

Every node that hears a peer’s verified zeroized announcement evicts it and purges its adverts and roster entry at once, instead of waiting for them to age out, and the Fleet tab marks the command acknowledged. A replayed older list never gets a command read: the list’s sequence check refuses it first. who may sign ↗

Boundaries

What each part rests on

Area selection and every fence state seen from another node use the positions nodes reported about themselves: a node that misreports, or moved since its last advert, is placed where it said it was. A geofence is enforced by the node against its own fix, so a device whose GPS is spoofed or whose software is altered does not enforce it; that device is the revocation’s job, and a remote zeroize revokes it in the same list even if it never acts on the command. Last-known positions are held in memory, so a restarted node knows the positions advertised since. Polygon edges are straight in latitude and longitude, which is exact at operating-area scale, and a polygon that winds around a pole is refused. A zeroized identity is never reused; the device returns as a new one. API tokens with write scope can revoke and zeroize, so mint them accordingly.

Hop honesty

Four path types, four trust models.

The single most important table on this page — because “encrypted” means something different on each row, and your review deserves the difference in writing.

Path typeTrust model: who holds keys to the payloadStated precisely
Directpeer ↔ peerEndpoints onlyno node in betweenEnd-to-end encrypted under the pair’s Noise session.
Mesh-forwardedyour own fleet, end-to-end sealing off (the default)Every hopevery forwarding node holds the payloadEach leg has its own Noise session: a forwarding node decrypts, makes the forwarding decision, and re-encrypts toward the next hop. Forwarders are trusted, authenticated members of your own fleet — per-hop protection, not payload blindness.
Mesh-forwardedyour own fleet, end-to-end sealing onEndpoints only, through untrusted forwardersforwarders carry sealed envelopesWith end-to-end sealing ([crypto] e2e) on both ends, the source seals each unicast packet to its destination before it leaves. Forwarding nodes carry the sealed envelope inside their own hop sessions and decide on the relay header alone, so a forwarder need not be trusted with the payload: it cannot read or alter what it carries, only delay, drop or repeat it. The seal binds the sender and the class; the tunnel runs at an MTU of 1349, so a sealed full-size packet stays one datagram. Broadcast, multicast and the FEC class keep the per-hop model.
Hosted relayone traversal relayEndpoints only, through a relaythe relay carries opaque envelopesThe relay forwards opaque encrypted envelopes addressed by static key; it authenticates clients but holds no key that opens what it forwards.
Federated relaysthe relay nearest each endEndpoints only, through two relaysboth relays carry opaque envelopesEach node stays on the relay nearest to it, and the two relays carry the frame between them in exactly one hop, over a session keyed from the signed relay map. A node takes this path only with end-to-end sealing on, unless an operator explicitly allows plain forwarding (federation_allow_plain). Neither relay holds a key that opens what it forwards. How federation works.
Why we print this: the difference decides deployments. Multi-hop through nodes you don’t fully trust is a job for end-to-end sealing; a hosted or federated relay carrying traffic you don’t want it reading is the right tool as it stands. A served LAN adds no new row: its traffic crosses the mesh like any member’s, and leaves the tunnel at the serving node as plain IP on the LAN, so that node, like any gateway, sees it in the clear. The mechanics live on mesh and traversal.
Accounts

Local users, argon2id, no cloud

Username/password accounts stored beside the daemon (atomic writes, 0600), managed from the CLI. Until users exist, every mutating endpoint answers 403 auth_not_configured — a deliberate lock-down of what used to be an open port.

FIDO2

Passkeys, with mandatory second factor

Enrolling a hardware key upgrades that account to mandatory 2FA — the password alone answers “second factor required” and only the WebAuthn assertion completes login. A break-glass CLI removes a lost key. Changing a fleet’s configuration can demand a hardware key, not just a login.

Session discipline

Signed cookies, CSRF, rate limits, TLS

HMAC-signed HttpOnly sessions, an explicit anti-CSRF header with origin checking, login rate-limiting per IP, same-origin only (the old permissive CORS layer is gone), and optional TLS with a persisted self-signed certificate — required in practice for FIDO2, which needs a secure context and a hostname identity.

Assistants

A model reads, and changes nothing

atlas-mcp lets an assistant read the fleet over the Model Context Protocol through an HTTP client that can only read. No tool edits configuration, revokes or admits a node, or pushes anything. The one write — a value for a policy variable the configuration declares — needs a start-up flag and the node’s signed record (mcp = ["read", "feed"]), and expires on its own. Off loopback it refuses to listen without a bearer token, and it logs every call without its credentials. The control rule

Supply chain

Releases that carry their own evidence.

Implemented in the release pipeline — every artifact ships with the material a supply-chain review asks for, and a written recipe for verifying it.

Memory-safe core

The data plane is Rust — the implementation direction recommended by the US ONCD (Feb 2024) and the NSA for security-critical software. The vulnerability classes that have plagued C/C++ tunnel implementations are excluded by construction. Behind it sits a continuously-run automated test estate — unit, integration and full-system — putting real daemons through failover, key rotation under load and configuration rollback on every change.

SBOM + embedded manifest

Every release ships a CycloneDX software bill of materials, and the binaries embed their own dependency manifest (cargo-auditable) — an auditor can interrogate the artifact itself, not just the paperwork beside it.

Signatures + provenance

Keyless Sigstore/cosign signatures — bound to the release pipeline’s own short-lived identity, so there is no long-term signing key to steal — and SLSA Level 3 build provenance: verifiable proof an artifact came from a specific commit on a specific build run. The verification recipe is part of the documentation on the developer portal, for approved engineering accounts.

Hardened by default

Unprivileged user with two capabilities (CAP_NET_ADMIN, and CAP_NET_BIND_SERVICE for the mesh DNS resolver’s port 53), hardened systemd unit with a seccomp filter, SELinux module (RHEL family) and AppArmor profile (Debian family), and an Ansible role that can chain an OS STIG baseline — one playbook lands a defensible posture.

Wording that stays disciplined: these artifacts support procurement checklists driven by the EU Cyber Resilience Act, NIS2, US EO 14028 and NDAA supply-chain requirements — support, not a compliance declaration.

Certification & interoperability tracks

The roadmap, labeled like a roadmap.

Three tracks procurement actually asks about — each with its honest “today” line, because a dashed border on a badge is a promise about the label, not the date.

Positioning

CSfC-style layered architectures

Atlas positions as the inner layer of an NSA CSfC-style two-layer design, beneath a FIPS-validated IPsec or MACsec outer layer. CSfC requires different cipher families, vendors and codebases between layers — the Noise IK / X25519 / ChaCha20 suite is that diversity by design. Positioning, not a listing: Nexus Atlas is not CSfC-listed and does not claim to be.

Roadmap

FIPS 140-3 build mode & post-quantum hybrid

Track A: a build mode (--crypto=fips) swapping the AEAD/KDF/RNG behind Noise to AWS-LC’s FIPS 140-3-validated module — same protocol, validated primitives. Track B: X25519 + ML-KEM-768 hybrid key exchange in the handshake (--crypto=pq-hybrid) — the construction Cloudflare, Apple and Signal ship — addressing harvest-now-decrypt-later ahead of the CNSA 2.0 timeline. Today: the default build is not FIPS-validated, and the key exchange is classical X25519.

Roadmap

FACE / DDS interoperability

A DDS bridge (via Zenoh) so DDS-based applications — RTI Connext, CycloneDDS, OpenDDS, FastDDS — interoperate over the bonded transport unmodified, keeping FACE-conformant software portable onto degraded links. Today: design stage; the spike is sequenced on integrator demand.

Roadmap means roadmap. If one of these gates your programme, say so in the evaluation conversation — sequencing is negotiable, dates invented on a website are not.
Coordinated disclosure

No bounty, no credit — and a person who answers.

This is the security policy for all of Nexus Atlas: the daemon, the adapters, the console and every one of our domains, whose security.txt files all point back to this section. It is blunt on purpose. We pay nothing, we name nobody, and a finding is most likely never published. What you get instead is an engineer who reads what you sent, tells you whether it is real, and tells you when it is fixed.

What a report gets you

  • A person reads it — not an auto-responder, not an outsourced triage queue, not a ticket that closes itself after thirty days.
  • An acknowledgement from that person, on the same working-day turnaround as anything else sent through the contact form.
  • A straight answer: whether it is a real issue, whether we already knew, and what we intend to do about it. If we think you are wrong, you get the reasoning rather than a form letter.
  • Word when it is fixed, and which release carries the fix.
  • Your report lands with the engineers who wrote the affected code. This is a small team — there is nobody in between, and nobody here is measured on closing tickets.

What it does not

  • No bug bounty, and no payment of any kind: no cash, no vouchers, no swag, no licence credit. We would rather run no paid programme than a bad one.
  • No public credit, and no naming of researchers. There is no hall of fame, no acknowledgements page, no thanks in a release note. Fixes ship without a byline — yours or anyone else’s.
  • Most likely no published finding at all: assume that neither the issue, nor the timeline, nor the fact that you reported it appears anywhere public.
  • None of the three is negotiable. They are decisions rather than an opening position, which is why they are printed here instead of explained in a reply.
How to report

Through the contact page, saying so in the first line

Open with the words “security report” — that is what gets it read ahead of the queue rather than in it. We do not print a security mailbox on this site; the form is the route in, and it reaches the same inbox and the same people as everything else. Please keep third-party data, live credentials and anything classified or export-controlled out of what you send — the form asks the same, for the same reason. The contact page

What helps

A reproduction, an affected version, and your read on the impact

Three things turn a report into a fix. A reproduction — steps, a capture, a config fragment, a few lines of script; anything we can run beats a paragraph describing it. An affected version — the build and the platform you saw it on, because the daemon, the adapters and the websites move on different clocks. What you believe the impact is — what an attacker gains, from what position, and what they must already hold. We may end up disagreeing with your severity; that is a conversation worth having, and a much shorter one when the first two are present.

In scope

The daemon, the adapters, the console, and these websites

The Atlas daemon and everything in its data path — handshake and session handling, the replay window, the scheduler, the mesh control plane, the traversal client — together with its operator dashboard and local API. The hardware adapters. The hosted console at console.nexusatlas.net, including node enrolment. And the Nexus Atlas websites themselves: this engineering site, the business site, the traversal service and the app site all publish a security.txt pointing here, because this is the one place the policy lives.

Out of scope

Four things that will come back declined

The simulations on this site. Every panel marked Simulation is a model — a drawing of a mechanism driven by invented numbers, with no daemon behind it and no code shared with the product. Driving one into a strange state is a bug in a diagram: there is nothing there to exploit and nothing downstream of it to fix. Tell us anyway if one is visibly broken, but as a defect rather than a vulnerability.

Third-party dependencies belong upstream — report them to the project that maintains the code and send us the advisory identifier, and we will pull the fix through. Social engineering of our people, our suppliers or our users is out of scope. So is anything requiring physical access to a node you do not own: if the hardware is yours, a physical finding is welcome; if it is somebody else’s, it is not yours to test.

Request an evaluation

Bring your security review.

Named primitives, verifiable releases, honest boundaries — and the engineers on the call. The artifacts are ready before the meeting is.