Johnathan Corgan 20cf6932cd Implement reactive MtuExceeded error signal (0x22)
Add a new session-layer error signal that transit routers send back to
the source when a forwarded packet exceeds the next-hop transport MTU.
This complements the existing proactive path MTU discovery (min'd at
each hop) by providing immediate feedback when oversized packets are
dropped, closing the transient window before the proactive mechanism
converges.

Wire format: 36-byte payload (msg_type + flags + dest_addr + reporter +
mtu) with FSP phase=0x0 and U flag set, matching the existing
CoordsRequired/PathBroken pattern.

Changes:
- Add SessionMessageType::MtuExceeded (0x22) and MtuExceeded struct with
  encode/decode methods to protocol/session.rs
- Add NodeError::MtuExceeded variant to propagate structured MTU info
  from TransportError through send_encrypted_link_message()
- Catch MtuExceeded in the forwarding path and send error signal back to
  the datagram source via send_mtu_exceeded_error(), rate-limited by the
  existing routing_error_rate_limiter
- Handle incoming MtuExceeded at the source by calling
  PathMtuState::apply_notification() for immediate MTU decrease
- Add unit tests for encode/decode roundtrip, boundary MTU values, and
  too-short payload rejection
2026-02-22 21:37:31 +00:00
2026-02-22 20:52:55 +00:00
2026-02-22 20:52:55 +00:00
2026-02-22 20:52:55 +00:00

FIPS: Free Internetworking Peering System

A distributed, decentralized network routing protocol for mesh nodes connecting over arbitrary transports.

Status: Experimental / Pre-release

FIPS is under active development. The protocol and APIs are not stable. Expect breaking changes.

Overview

FIPS is a self-organizing mesh network that operates natively over a variety of physical and logical media — local area networks, Bluetooth, serial links, radio, or the existing internet as an overlay. Nodes generate their own identities, discover each other, and route traffic without any central authority or global topology knowledge.

FIPS uses Nostr keypairs (secp256k1/schnorr) as native node identities, making every Nostr user a potential network participant. Nodes address each other by npub, and the same cryptographic identity used in the Nostr ecosystem serves as both the routing address and the basis for end-to-end encrypted sessions across the mesh.

Features

  • Self-organizing mesh routing — spanning tree coordinates and bloom filter candidate selection, no global routing tables
  • Multi-transport — UDP/IP overlay today; designed for Ethernet, Bluetooth, serial, radio, and Tor
  • Noise encryption — hop-by-hop link encryption plus independent end-to-end session encryption
  • Nostr-native identity — secp256k1 keypairs as node addresses, no registration or central authority
  • IPv6 adaptation — TUN interface maps npubs to fd00::/8 addresses for unmodified IP applications
  • Metrics Measurement Protocol — per-link RTT, loss, jitter, and goodput measurement
  • Zero configuration — sensible defaults; a node can run with no config file

Quick Start

Requirements

  • Rust 1.85+ (edition 2024)
  • Linux (TUN interface requires CAP_NET_ADMIN or root)

Build

git clone https://github.com/jmcorgan/fips.git
cd fips
cargo build --release

Run

# With default configuration (ephemeral identity, default ports):
sudo ./target/release/fips

# With a configuration file:
sudo ./target/release/fips -c fips.yaml

See docs/design/fips-configuration.md for the full configuration reference.

Multi-node Testing

See testing/ for Docker-based integration test harnesses including static topology tests and stochastic chaos simulation.

Documentation

Protocol design documentation is in docs/design/, organized as a layered protocol specification. Start with fips-intro.md for the full protocol overview.

Project Structure

src/          Rust source (library + daemon binary)
docs/design/  Protocol design specifications
testing/      Docker-based integration test harnesses
benches/      Criterion benchmarks

License

MIT — see LICENSE.

Description
The Free Internetworking Peering System
Readme MIT 30 MiB
Languages
Rust 86.1%
Shell 10.4%
Python 3%
PowerShell 0.2%
Makefile 0.1%