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 ( |
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 |
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.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.