rinse

A Reticulum network stack implementation in Rust

Note

rinse implements a functional subset of core Reticulum networking features

rinse does not provide a CLI or daemon - it's primarily a library for building Reticulum applications

Reticulum

Reticulum is a cryptography-based networking stack for wide-area networks built on any available medium.

The reference implementation is Reticulum by Mark Qvist, with documentation at reticulum.network.

Features

• tokio - async node api
• tcp - TCP transport using HDLC framing
• config - TOML configuration file support
• relay - feature gate for the relay binary dependencies

Usage

use rinse::config::{Config, InterfaceConfig, load_or_generate_identity};
use rinse::{Interface, Node, TcpTransport};

let config = Config::load()?;
let identity = load_or_generate_identity()?;

let mut node: Node<TcpTransport> = Node::new(config.network.relay);
let service = node.add_service("myapp", &["/ping"], &identity);

for (name, iface) in config.enabled_interfaces() {
    if let InterfaceConfig::TCPClientInterface { target_host, target_port, .. } = iface {
        let addr = format!("{}:{}", target_host, target_port);
        let transport = TcpTransport::connect(&addr).await?;
        node.add_interface(Interface::new(transport));
    }
}

node.announce(service);

tokio::spawn(node.clone().run());

while let Some(req) = node.recv_request(service).await {
    if req.path == "/ping" {
        node.respond(service, req.request_id, b"pong", None, false).await?;
    }
}

Examples

• serve - file server that serves a directory over Reticulum
• request - CLI client for making requests to Reticulum nodes
• page - interactive micron page server with guestbook

cargo run --example serve --features config,tcp -- ./public files
cargo run --example request --features config,tcp -- <node_id> /path
cargo run --example page --features config,tcp

Binaries

• rinse-relay - transport node that forwards packets between interfaces, with TUI stats

cargo run --bin rinse-relay --features relay,tcp

Note

• As many recent projects are, rinse was written with the assistance of LLMs, with very close guidance & review in terms of architecture, testing, & adherence to the original implementation.

• The API is very much in flux & there won't be significant effort towards stability at this stage.

• This repo doesn't implement every single feature the original python implementation contains (there are a lot of features in the original), but the implemented core features are interoperable with other reticulum nodes.

• From the original repo's readme: "Reticulum is relatively young software, and should be considered as such. While it has been built with cryptography best-practices very foremost in mind, it has not been externally security audited, and there could very well be privacy or security breaking bugs."

Contributing

By submitting a contribution, you agree that it will be licensed under the project’s license.

License Info

This information is for convenience only and does not grant any rights or warranty, please see the license file for the official terms.

This project is licensed to allow individuals and small businesses to use, modify, and sell software built on it. Larger organizations may not qualify under the license terms.