turna

Repository on GitHub, which provides public git repositories with URLs.

Repository on GitHub, which uses git. git can track the changes, who made them, and when they were made.

Development happens in branches merged through pull requests, so every interim commit is in the repository and reviewable between releases — not only tagged releases. Branch protection on main requires a pull request and passing CI checks.

Repository on GitHub, which uses git. git is distributed.

Each release has a unique version identifier; the current release is 0.3.1.
Releases are published at https://github.com/kruatech/turna/releases

Releases are identified by git tags: v0.2.0-alpha.1, v0.3.0-beta.1, v0.3.0-rc.1, v0.3.0,v0.3.1

Non-trivial release notes file in repository: https://github.com/kruatech/turna/blob/main/CHANGELOG.md.

No publicly known vulnerability with a CVE assignment has been reported against turna, so no release notes have had one to identify.

Non-trivial SECURITY[.md] file found file in repository: https://github.com/kruatech/turna/blob/main/SECURITY.md. [osps_do_02_01]

GitHub Issues: https://github.com/kruatech/turna/issues

No externally submitted bug reports or enhancement requests have been received in this period; those opened were by the maintainer and were resolved.

No externally submitted bug reports or enhancement requests have been received in this period; those opened were by the maintainer and were resolved.

GitHub Issues are publicly readable and searchable, and remain available after
closing: https://github.com/kruatech/turna/issues?q=is%3Aissue

SECURITY.md publishes the process: report privately, do not open a public issue.
https://github.com/kruatech/turna/blob/main/SECURITY.md

Private reporting via GitHub's private vulnerability reporting, enabled on the
repository: https://github.com/kruatech/turna/security/advisories/new
SECURITY.md documents this as the channel and asks for a minimal reproduction and
the commit or tag tested.

No vulnerability report has been received in the last 6 months. SECURITY.md commits to acknowledging reports within a few business days.

Cargo builds the whole workspace from source: cargo build --release. Optional transports and datapaths are Cargo features (tls, dtls, quic, web-transport, io-uring, af-xdp). Container images build from deploy/Dockerfile, and CI rebuilds every feature combination on each pull request.

Cargo, the standard Rust build tool. The admin frontend uses npm. Container images
use Docker. The AF_XDP feature additionally needs clang and libbpf headers, which
the build script checks for and reports clearly if absent.

Every build tool is FLOSS: the Rust toolchain (MIT/Apache-2.0), Cargo, npm, clang and libbpf. No proprietary tool is required to build the project.

The workspace test suite runs with cargo test --workspace, documented in
CONTRIBUTING.md and enforced by CI on every pull request. Beyond unit and
integration tests there are fuzz targets (cargo-fuzz), mutation testing
(cargo-mutants), Miri for undefined behaviour in unsafe code, and Loom for
lock-free concurrency. All are FLOSS.
https://github.com/kruatech/turna/blob/main/CONTRIBUTING.md

cargo test --workspace — the standard invocation for Rust.

Unit and integration tests cover the protocol codec, authentication, peer filtering, allocation lifecycle and the relay datapath, with hermetic integration tests running a real node. Fuzz targets cover STUN/TURN parsing and encoding, and mutation testing checks the tests actually detect changed behaviour rather than merely executing it.

GitHub Actions runs on every push and pull request: formatting, clippy with -D warnings, the workspace test suite, hermetic integration tests, every Cargo feature combination, MSRV, cargo-deny for licences and advisories, CodeQL, Miri and Loom.

New functionality is expected to come with tests. Beyond that, mutation testing runs on a schedule and fails when a test executes changed code without detecting the change — so a test that does not actually assert on new behaviour is reported rather than counted as coverage.

Recent changes carry tests. Two examples: the corrected ATTR_ALTERNATE_SERVER
value is guarded by tests asserting the encoded bytes rather than the constant,
because a test written against the constant passed throughout the bug; and the
attribute getters gained tests after mutation testing showed they could each be
replaced by None with every test still passing.

CONTRIBUTING.md, "Tests come with the change": new functionality arrives with
tests, fixes arrive with a test that fails without them, and tests assert on
observable behaviour rather than on the constant under test.
https://github.com/kruatech/turna/blob/main/CONTRIBUTING.md

Clippy on the whole workspace and all targets, plus rustc's own warnings, run in
CI on every pull request:

cargo clippy --workspace --all-targets --locked -- -D warnings

Rust's safe-by-default mode applies throughout; unsafe is confined to the
transport and relay datapaths and is inventoried in docs/unsafe-audit.md.

Warnings are errors, not advisories: -D warnings means any warning fails the build. A pull request cannot merge with one outstanding. This has caught real issues rather than only style — a deprecated aes-gcm call and dead code left behind a feature gate both surfaced this way.

Maximally strict where practical: -D warnings across the workspace and all targets, every Cargo feature combination checked separately, plus Miri for undefined behaviour in unsafe code, Loom for lock-free concurrency, cargo-deny for licences and advisories, and CodeQL. Suppressions are gated by feature rather than blanket allow attributes, so an unused item is reported instead of hidden.

Knowledge from practice rather than formal training, applied in the design: least privilege (optional transports are off by default and refused outright under production = true), fail safe (a configured listener that cannot bind is fatal rather than a warning), validation at the trust boundary (the STUN/TURN parser is fuzzed continuously, and the peer filter denies private ranges as SSRF protection), and defence in depth (per-IP rate limits, allocation quotas, bounded relay port ranges and egress queues). The threat model and the non-goals are written down in SECURITY.md and docs/COMPLIANCE.md.

The classes that matter for a TURN relay, and how each is countered:

• SSRF through a relayed peer — the filter denies loopback, private and
  link-local ranges, and the NAT64/6to4/Teredo/IPv4-compatible v6 prefixes that
  would otherwise smuggle an internal v4 address past a v6 check.
• Amplification and resource exhaustion — per-IP and per-prefix rate limits,
  per-user allocation quotas, a bounded relay port range, bounded egress queues.
• Memory safety — Rust, with unsafe confined to two datapaths, inventoried in
  docs/unsafe-audit.md and checked by Miri in CI.
• Parser flaws — the codec is fuzzed; malformed input is counted, not trusted.

Only published, reviewed algorithms, all specified by the relevant RFCs: TLS 1.2/1.3 (rustls), DTLS 1.2 (webrtc-dtls), QUIC (quinn), HMAC-SHA1 for STUN MESSAGE-INTEGRITY and HMAC-SHA256 for MESSAGE-INTEGRITY-SHA256 as RFC 5389/8489 specify, AES-GCM for RFC 7635 third-party tokens, and Argon2 for password hashing in the management plane.

turna's purpose is relaying, not cryptography, and it implements none of its own: rustls for TLS, webrtc-dtls for DTLS, quinn for QUIC, and the RustCrypto crates (hmac, sha1, sha2, aes-gcm, argon2) for primitives.

Every cryptographic dependency is FLOSS under MIT/Apache-2.0: rustls, ring, quinn, webrtc-dtls, and the RustCrypto crates. cargo-deny enforces the licence allowlist in CI.

TLS 1.2 and 1.3 via rustls, which offers only modern cipher suites and 2048-bit or stronger key exchange; the deployment certificate is P-256 ECDSA. AES-128-GCM and AES-256-GCM for RFC 7635 tokens. HMAC-SHA1 appears only where RFC 5389 mandates it for STUN MESSAGE-INTEGRITY — it is a protocol requirement for interoperability, not a configurable choice, and RFC 8489 MESSAGE-INTEGRITY-SHA256 is supported alongside it.

MD5 and HMAC-SHA1 appear only where RFC 5389 mandates them: the long-term credential key is MD5(username:realm:password) and MESSAGE-INTEGRITY is HMAC-SHA1. Every TURN client and server on the network requires them, and no alternative is interoperable. RFC 8489 MESSAGE-INTEGRITY-SHA256 is supported alongside, and is used when the client offers it. The situation is documented in docs/COMPLIANCE.md. Everything not fixed by the protocol uses modern algorithms: TLS 1.2/1.3 via rustls, AES-GCM, Argon2 for stored passwords.

TLS 1.3 provides forward secrecy by construction, and rustls offers only (EC)DHE suites in TLS 1.2. QUIC and DTLS use the same rustls-backed key exchange.

Management-plane passwords are stored with Argon2 and a per-user salt (crates/auth/src/store.rs). TURN's own long-term credentials are not stored hashed — RFC 5389 requires the server to hold the shared secret to compute MESSAGE-INTEGRITY — which is a property of the protocol, not a storage choice.

All keys and nonces come from the operating system CSPRNG: rand's OsRng for credential and token generation (crates/crypto/src/lib.rs), and ring's own CSPRNG inside rustls for TLS, DTLS and QUIC key material. STUN transaction identifiers also use rand's thread-local CSPRNG, not a predictable counter.

Distribution channels use HTTPS exclusively. [osps_br_03_02]

No hash is fetched over plain http and trusted. Dependencies are pinned by version and checksum in Cargo.lock and verified by cargo against crates.io over HTTPS. Container base images are pinned by digest rather than by mutable tag, and CI actions are pinned by commit SHA.

No vulnerability has been reported against turna itself. Dependency advisories are watched by cargo-deny in CI and by Dependabot, and are acted on promptly — the two open at the time of writing were closed the same day: RUSTSEC-2025-0134 by dropping the unmaintained crate, and RUSTSEC-2026-0258 by updating a transitive dependency.

No critical vulnerability has been reported. The advisory gate fails the build on any known advisory, so one cannot be introduced unnoticed and then linger.

No credential is committed. Secrets are supplied through configuration, with
environment-variable and file references supported so they need not appear in a
config file at all (shared_secret = "${TURNA_SHARED_SECRET}" or
"file:///run/secrets/..."). Certificates and keys used in tests are generated at
run time and discarded. GitHub secret scanning and push protection are both
enabled, so a secret is blocked before it enters history rather than found
afterwards.

Clippy across the workspace and all targets with -D warnings, CodeQL for Rust and JavaScript/TypeScript, and cargo-deny for advisories and licences. All run on every pull request and on main, so a release cannot be cut without them having passed.

CodeQL carries rules for common vulnerability classes. Alongside it, Miri detects undefined behaviour in unsafe code on the abstract machine, Loom explores thread interleavings for the lock-free primitives, and cargo-deny reports known advisories in the dependency tree.

Warnings are build failures (-D warnings), so a finding blocks the merge rather than accumulating. Recent examples: a deprecated aes-gcm call and dead code left behind a feature gate, both fixed the same day they appeared.

On every push and every pull request, not on a schedule.

Fuzzing with cargo-fuzz (libFuzzer) over five targets covering STUN and TURN parsing, semantics, lifecycle and encoding, run in CI. Miri executes the parsing crates on its abstract machine and reports undefined behaviour and data races in unsafe code. Loom explores thread interleavings for the lock-free primitives. Mutation testing checks the tests detect changed behaviour rather than merely executing it.

Rust is memory-safe, but turna contains unsafe in two datapaths (io_uring and
AF_XDP) and a small C BPF program for AF_XDP, so N/A would be overstating it. That
unsafe is inventoried in docs/unsafe-audit.md; the pure-memory portion runs under
Miri in CI, and the syscall-bound portion is covered by hardware soak runs instead,
since Miri cannot execute mmap or io_uring.

Tests and fuzz targets build in debug, where Rust's debug assertions and integer overflow checks are on — release builds have them off, which is the split this criterion describes. Fuzz targets additionally assert invariants on parsed input.

Findings are fixed rather than filed. Two from this cycle: the io_uring datapath
stopped relaying after exactly 64 packets per worker because the zero-copy path
never re-armed its receive slot, and the AF_XDP datapath stopped receiving after
exactly 2015 frames because the descriptor buffer was taken from the frame pool
and leaked. Both were found by soak runs and fixed the same day.