Skip to documentation
SLOP

tiny.reticulum.interface

Reference tiny.reticulum interface

Defined in tiny.reticulum.

The code every frame on one network interface carries to show it belongs there, and the two calls that add it on the way out and check it on the way in.

API (1)

Namespaces

Public namespaces.

No direct callersNo direct callstiny.reticuluminterface
Static calls · unresolved targets: unknown · external targets: unknown.

Source

Source: lib/reticulum/src/interface/root.zig

zig
//! The code every frame on one network interface carries to show it belongs//! there, and the two calls that add it on the way out and check it on the way//! in.//!//! An operator running a closed network over a shared medium wants its nodes to//! take each other's frames and nothing else. The check runs on every frame in//! both directions, so it has to be cheap and it has to work in the buffer the//! caller already holds.//!//! A shared secret sent in the clear on every frame is readable by anyone//! listening, so what goes on the wire has to prove knowledge of the secret//! without carrying it. A frame that still looks like a Reticulum packet to an//! outsider announces that the network is there. A check that stops at the//! first byte that disagrees tells an attacker how much of a guess was right.//!//! The subtree follows Reticulum 1.5.0, the reference implementation, pinned to//! one upstream commit by the package README and the generated conformance//! corpus. What it takes is the key derivation of Reticulum@1.5.0//! RNS/Reticulum.py:989-1002, the masking of Reticulum@1.5.0//! RNS/Transport.py:1244-1276, and the checking of Reticulum@1.5.0//! RNS/Transport.py:1648-1694. The package generates masked frames and verdicts//! from that release and replays them in tests, so each of those claims is//! checkable from this tree.//!//! The code a frame carries to show it belongs on one network interface (the//! *access code*) is the tail of an Ed25519 signature over the packet, from one//! to 64 bytes of it, taken under a key derived from the network's name and//! key, so the secret stays off the wire. Every other byte of the frame is//! combined with derived bytes (the *mask*) seeded by that code, which leaves//! the frame looking like unstructured bytes to anyone without the key.//! Checking recomputes the signature over the recovered packet and compares it//! against the carried code over a fixed 64 bytes, so the comparison takes the//! same time whatever the bytes are. Both directions refuse a call whose input//! and output buffers overlap.//!//! - *interface key*: the 64 bytes derived from a network name and a network//!   key, which both sign the access code and key the mask.pub const ifac = @import("ifac.zig");

Source: lib/reticulum/src/root.zig:64

zig
pub const interface = @import("interface/root.zig");

Audit

Definitions1
Public names1
Members0
Version26.7.0
Revisiondaab053ee433