1.18. Running Over FIPS

Experimental

In the code and tested, but not supported in this alpha: it may change or go away. See Experimental features.

1.18.1. Reaching a fleetmesh node over FIPS

Working note. No code in this repository knows FIPS exists, and after reading this you will see why that is the point.

FIPS is a self-organizing encrypted mesh whose node addresses are secp256k1 x-only schnorr keys — the same nostr identity fleetmesh uses for its node key. It carries IPv6 over UDP, TCP, Ethernet, Tor, Nym and Bluetooth, punches UDP NAT with STUN over gift-wrapped nostr events, and finds same-link peers over mDNS.

A fleetmesh node gets all of that by advertising an endpoint on the fips0 interface. No new transport scheme, no new key, no digest move.

1.18.1.1. What to do

Run FIPS on the box, with its IPv6 adapter enabled. Then point the node’s relay face at the fips0 address and declare it:

"endpoints": [["wss", "wss://<npub>.fips:7777", "30"]]

<npub>.fips is resolved by the FIPS .fips resolver to the fd00::/8 address the adapter maps that npub to. A peer running FIPS reaches it from behind a NAT, over Bluetooth, through Tor, or across an 802.11s backhaul with no IP infrastructure under it. A peer not running FIPS reaches the node’s clearnet endpoints as before, which is why the preference value is set above them rather than below.

That is the whole integration.

1.18.1.2. Why the native datagram API is not the answer

FIPS also offers a native datagram API that addresses a peer as npub:port with no IPv6 emulation. It looks like an exact fit for a transport rung, and it is not one.

It is deliberately not a reliability layer: no acknowledgement, no retransmission, no ordering, no flow control. A connect is a local registration that contacts no peer and proves nothing about it. A peer cannot end a flow, because it has no close to send. And FIPS performs no fragmentation anywhere, at the source or in transit, by explicit policy.

Put fleetmesh’s traffic against that:

nostr rung today

a native-API rung

payload ceiling

65536 per wrap

about 1170 on UDP, and it can fall mid-flow

fragment size

24000 (FRAGMENT_BYTES)

one datagram

envelope ceiling

about 1.5 MB

about 75 KB at the same 64-fragment cap

a lost fragment

the relay stored it

the envelope is dead, with nothing to resend it

delivery signal

the relay’s OK, plus please_ack

none

fleetmesh_node/transport/ says of MAX_FRAGMENTS that “both ends read this number”. That stops being true the moment the fragment size is a property of the path rather than of the protocol, and the two ends have to agree per rung.

The deeper problem is the last row. please_ack exists because this project spent a release learning that a relay saying OK is not a peer receiving the message. On the native API there is not even an OK — and the transport ladder is only safe to attempt in order because a rung that fails says so.

FIPS’s own MTU document reaches the same conclusion from the other side: applications needing oversized payloads run TCP over the IPv6 adapter, which has its own segmentation under MSS clamping. That is exactly what the wss endpoint above does.

The native API becomes interesting when Reliable Object Delivery lands. Not before.

1.18.1.3. What is not shared, and why

The node key. FIPS’s security reference says compromise of fips.key is compromise of the node’s nostr identity, and its native API is explicitly not an authorization boundary: membership of group fips lets any process send as the node, and a descriptor passed over SCM_RIGHTS sends as the node without opening the socket at all.

The fleetmesh node key never rotates — rotating it creates a new node — and it signs every grant, report, receipt and descriptor. Running FIPS beside the node under a key of its own costs nothing here, because nothing above requires the two identities to be the same. The npub in the .fips name is FIPS’s, and the node is reached at it the way it would be reached at any other hostname.

If a fips scheme is ever added to the ladder and peers should address the node by its fleetmesh npub, bind a separate FIPS key the way the transport key is bound: a ["key", "fips", "<multikey>"] tag in the descriptor, valid only through a live descriptor. A compromise then costs one republish. Do not share the node key to save a tag.

1.18.1.4. One thing to watch

FIPS wraps its NAT-traversal offers in kind 21059 NIP-59 gift wraps, addressed by #p, sealed under an untagged kind 13. So does fleetmesh’s live DIDComm transport. The envelopes are byte-identical and are told apart only by what is inside.

If one machine ever runs both under one key, each daemon’s subscription receives the other’s traffic. fleetmesh fails closed — giftwrap.unwrap succeeds, then fleetmesh_node/transport/ finds no protected member — so it was never a security problem, only a diagnosability one: meshnode health showed a drop stream from a healthy box and gave it the same reason as genuinely malformed traffic. Since 2026-09-26 the reason names the protocol instead, from the type the payload carries, and is counted apart from the payloads this node cannot parse at all. The drop is still a drop.

Two keys, as above, avoids it entirely. The general fix is upstream: NIP-59 does not namespace the payload, and neither project is wrong to have picked the kind it did.