The dendritic network

Security & anonymity

What the dendritic network hides, what it doesn't, and how far the network running today is from what the design promises. Read this before you rely on it for anything that matters.

1. The short version

  • The design is the same shape as Tor: three-hop onion circuits, pinned guards, self-certifying addresses, and hidden services reached by rendezvous. Run correctly and at scale, it hides who is talking to whom and the IP of every service.
  • That protection needs many independent relays. Anonymity is only as large as the set of honest relays, run by different people on different networks. A handful of relays, or relays on one network, protects almost nothing.
  • The network today is small and still maturing. Treat it as an overlay that works end to end, not yet as one that hides you.
  • The naming layer is public by design. Registering a name is a public transaction, and the name-to-key binding is world-readable.

2. How it works

  • Self-certifying addresses. <56 characters>.key.axon is a service's Ed25519 public key plus a checksum. There is no certificate authority and no lookup: if you have the address, you can check the key.
  • Onion circuits. A client builds a circuit through three relays (guard, middle, terminal), each with its own layer of encryption. Each relay knows only the hop before and after it; none sees both the client and the destination.
  • Pinned guards. Your first hop stays the same, the standard defence against being exposed to a new possibly hostile first hop on every circuit. Your guard sees your IP, but not where you're going.
  • Hidden services. A service never accepts an inbound connection and never reveals its IP. It keeps circuits open to three introduction points; a client picks a rendezvous relay, and both sides build circuits to it. Neither learns the other's IP, and the service works from behind any NAT.
  • No central authority. Relays find each other by gossip, service records live in a DHT on the relays closest to a blinded key, and any node with a reachable address relays by default. Seeds are only entry points.
  • No exit by default. The network is internal. A node's proxy refuses ordinary internet addresses unless its owner opts into an exit.

3. What it protects against

WhoWhat they learn
Your ISP or local networkAn encrypted flow to one guard, and nothing about the destination, given a real guard on another network.
Any single relayIts two neighbours in the circuit. A middle relay learns neither end.
A directory holderBlinded descriptors it can't turn into a list of services.
A service you connect toThat someone asked and what they asked, but not who (no IP).
Someone who knows a service's nameIts key (names are public), but not its IP.

4. What it does not protect against

  • A global passive adversary. Someone watching both ends of a circuit can match timing and volume. This is the known, unsolved limit of low-latency onion routing, Tor included. Padding raises the cost; it doesn't remove the attack.
  • Enough hostile relays. If an attacker runs a large share of the relays, the odds that they hold both ends of your circuit rise sharply. Small networks are easy to deanonymise this way.
  • A compromised guard. Your guard sees your IP. A hostile guard plus visibility near the service can link you.
  • What you send. The overlay hides the path, not the content. A login, an identifier, or anything else that names you in a request names you, whatever the circuit. The expert layer is a case of this: model requests hide who asked, but the service and its model read the prompt in the clear.
  • rabbiit, for node operators. A node's heartbeat goes to rabbiit directly, so rabbiit sees the IP of every node. The privacy guarantee is between volunteers.

5. The network today

Small and still maturing

The deployments built so far are development networks, and they are not anonymous. Any one of these is enough to defeat anonymity:

  • Few relays. Six is the floor for hidden services to work at all (three introduction points, a rendezvous point and some headroom). It is nowhere near an anonymity set: someone who watches a couple of them can rebuild circuits by elimination.
  • Relays on one network. Test clusters set allow_same_network so relays sharing one subnet can form circuits. With that on, one observer on the subnet sees every hop.
  • Two-hop circuits, where used. hops: 2 is for speed, not privacy: one relay sits next to the client and the other next to the service.

What changes this is people: many relays run by independent operators, on different networks and in different jurisdictions. If you can forward a port, running a relay is the single most useful thing you can do for the network.

Two gaps remain in the design itself. Every node currently learns the whole relay list, which is fine at this size but won't scale to I2P size. And a node behind NAT can't relay yet, so routing capacity comes from machines with reachable addresses.

6. Names leak

  • Registration is a public transaction. The wallet, the name and the key are on-chain permanently, and a wallet's funding history can often be traced to a person.
  • The name-to-key binding is world-readable. Naming a service publishes its identity key to everyone. Its IP stays hidden; its existence doesn't.
  • Resolution leaks the query. The RPC you resolve through sees which name you asked for and when, and you trust its answer: no proof is verified.
  • Names are guessable. Short or dictionary names can be enumerated.

If a service must stay hidden, keep it to its .key.axon address and don't register a name. Name the things you want found.

7. Running it so it is anonymous

  • allow_same_network false everywhere.
  • hops at the default 3, never 2.
  • Many relays, run by independent operators, across different networks and jurisdictions. Not a handful on one host.
  • Guards pinned (the default), with a plan for rotating and watching them.
  • Requests that carry nothing identifying. The overlay can't un-leak a login.
  • For names: a local chain or an RPC you trust, and a wallet whose history doesn't identify you, accepting that the binding is public forever.
  • An eye on the relay set for sudden growth from one operator.

The full analysis, with references into the code, is ANONYMITY.md in the node's source.