Beyond IP, DNS, and Centralized CAs: Rebuilding Peer-to-Peer Secure Connectivity with DID-TLS and Symmetric Mesh

Deploy any serious service on the internet today, even a personal AI agent running on a Mac mini at home for your phone to call, or a shared workspace syncing between two nodes, and you immediately hit a thirty-year-old infrastructure wall: just to establish a trusted encrypted connection, you first have to secure a public IP (or configure NAT tunnels), rent a DNS domain from a registrar, and pass an ACME verification challenge from a centralized Certificate Authority (CA) like Let's Encrypt.
In the Web 2.0 era, where a handful of cloud data centers served billions of passive browsers, that ceremony was tolerable. In the ARC (Agentic Realm Computer) world we are building, every user has a phone switching between cellular and Wi-Fi, a laptop that sleeps whenever the lid closes, edge nodes sitting behind home routers or Starlink CGNAT, and hundreds of Blocklets and AI agents spinning up on demand. Forcing every node and every peer-to-peer connection through "Public IP -> DNS Record -> Public CA Certificate" makes zero-configuration computing impossible.
Even more absurdly, inside our own ecosystem, both communicating parties already possess cryptographically verifiable DIDs (Decentralized Identifiers). When two nodes already hold deterministic Ed25519 key pairs and know the exact DID they want to talk to, why should they detour through an external commercial CA just to get a rubber stamp on a rented domain name or a transient IP address?
Following that first principle to its logical conclusion, our newly finalized networking architecture closes the loop across the entire stack: we replace centralized CAs with in-memory self-issued DID-TLS certificates, replace legacy DNS trust chains with on-chain DID Names, and connect every node across a symmetric afs-mesh overlay where the DID itself is the only address you ever need (Everything-over-DID).
1. Why Legacy DNS + Public CAs Break Down in the Peer-to-Peer and Agent Era
Start by asking what traditional WebPKI actually verifies.
When your browser connects to an HTTPS website, a public CA like Let's Encrypt issues a certificate based on one check: proving that at that moment, you control the server pointed to by a specific DNS domain name (Domain Validation). That model has three structural blind spots:
- It verifies a rented street address, not who is inside the room: A DNS domain is a revocable lease from ICANN and a domain registrar. If a domain expires, gets hijacked at the registrar, or suffers a BGP routing hijack, an attacker can obtain a freshly signed CA certificate in minutes. Conversely, two nodes that already know each other's cryptographic DIDs cannot establish a standard TLS session without a public domain name.
- Mobile devices, sleeping laptops, and NAT-ed home nodes cannot obtain public CA certificates: Your phone moves between 5G and coffee-shop Wi-Fi; your home node sits behind carrier-grade NAT; your laptop sleeps when closed. Public CAs cannot run HTTP-01 validation probes against private nodes, nor can they issue hundreds of millions of ephemeral certificates for personal agent nodes without flooding public Certificate Transparency (CT) logs.
- One-way server authentication instead of peer symmetry: Traditional HTTPS authenticates the server's domain while leaving the client anonymous at the TLS layer. In a mesh of personal devices, Blocklets, and AI agents, every node is both a client and a server, requiring 1-RTT Mutual TLS (mTLS) from the first packet.
Once you see that the bottleneck is binding transport encryption to centralized DNS and public CAs, the architectural move becomes clear: keep the battle-tested TLS 1.3 transport stack, remove the domain-bound WebPKI verifier, and replace it with our native DID-TLS cryptographic identity verifier.
2. DID-TLS: In-Memory Self-Issued X.509v3 Certificates and 1-RTT Mutual Authentication
When engineers hear "no public CA," many assume the alternative is writing a custom transport encryption protocol from scratch (such as raw Noise streams).
Our engineering choice is the exact opposite: never reinvent the transport layer when you can reuse 100% of the operating system's native TLS 1.3 and QUIC stack with in-memory, self-issued X.509v3 certificates derived directly from DID keys.
Why keep standard TLS 1.3? Because OS kernels, OpenSSL, Rustls, and silicon-level AES-GCM / ChaCha20-Poly1305 hardware instructions have been optimized for TLS over two decades. Because RFC 8410 natively standardizes Ed25519 signatures inside X.509v3 certificates, our HTTP/2, QUIC, WebSocket, and AFS streams run at full hardware speed with zero custom framing. The only piece we replace is the certificate verification callback (verify_peer_certificate) during the TLS handshake.
Under the hood, DID-TLS solves two critical engineering problems:
1. Ephemeral In-Memory Certificates with Critical = TRUE Custom Extensions
When an ARC node boots, it never looks for .pem files on disk or calls an external CA. Instead, it generates a short-lived (24-to-72-hour) X.509v3 certificate directly in memory:
- The certificate's
SubjectandSAN (Subject Alternative Name)carry the node's canonical URI:did:abt:<node_did>; - Connections negotiate a dedicated ALPN protocol identifier (
arc-did-tls/1) and include an ArcBlock custom X.509 extension OID markedCritical = TRUE(carrying the node DID, role scope, chain ID, and embedded cold-wallet delegation proof).
Why enforce both a dedicated ALPN and Critical = TRUE? While a public browser would not trust a non-WebPKI self-issued certificate anyway, in real-world hybrid deployments (where reverse proxies or services handle both internal mTLS and external HTTPS, or reuse generic X.509 validators), RFC 5280 §4.2 mandates that any validator that does not explicitly recognize and verify a Critical = TRUE extension must abort the handshake unconditionally. Paired with ALPN: arc-did-tls/1, this guarantees strict cross-protocol isolation (preventing ALPACA-style cross-protocol confusion) while ARC nodes and AFS clients specifically parse and verify the extension.
2. Cold-to-Hot Key Delegation: 1-RTT Mutual Handshake Without Exposing Master Keys
Storing a user's or developer's master identity private key (User DID) in plaintext on an always-on server node is an unacceptable security risk.
For that reason, DID-TLS enforces a two-tier Cold-to-Hot Delegation model from Day 1:
- Every running ARC node generates its own local hardware-bound hot key pair (
Node DID) and uses it to self-issue its short-lived in-memory X.509v3 leaf certificate; - Instead of forcing the owner's cold wallet (
DID Wallet) to act as a legacy ASN.1 X.509 Root CA, the cold wallet signs a compact Delegation Proof (DeviceOwnershipCert) offline, stating: "For the next 30 days,Node DIDis authorized to operate specific scoped services on behalf ofUser DID, with zero authority to move funds or re-delegate." The node embeds this signed delegation proof directly inside the leaf certificate's critical extension (or TLS 1.3CertificateEntryextension); - When any two nodes connect, both sides exchange their ephemeral leaf certificates (with embedded delegation proofs) in a single TLS 1.3 round trip (1-RTT). With zero external network lookups, each peer mathematically verifies three facts at once: first, the peer holds the live private key for
Node DID(proven by TLS 1.3CertificateVerify); second,Node DIDcarries a valid delegation signature fromUser DID; third, the delegated role and expiration window are intact.
3. DID Names and the Dual-Track Gateway: Why We Don't Mint SSL Certificates as On-Chain NFTs
While designing this system, we also evaluated an idea that sounds tempting on the surface: "Since we have our own blockchain and NFT engine, why not mint every node's SSL certificate as an on-chain NFT, or run a dedicated sidechain as a certificate authority?"
After working through the mechanics, we explicitly rejected putting X.509 certificates on-chain as NFTs, and instead drew a clean separation of concerns: anchor human-readable DID Names and revocation state on-chain, while keeping high-frequency TLS certificates 100% off-chain and self-issued in memory. Here is why:
- Short-lived certificate rotation vs. on-chain state bloat: Modern transport security relies on rotating ephemeral certificates every few hours or days. Minting or updating an on-chain NFT every time a laptop wakes up or a node rotates its TLS cert would block node startup on block confirmation and flood the ledger with disposable transport state.
- The public key is already inside the DID: An ABT DID is either deterministically derived from its public key hash or anchored via an on-chain
Declarestate. Once you know a peer's DID, you already have the cryptographic root needed to verify its signature; fetching a bulky ASN.1 X.509 blob from a blockchain adds zero security. - Solving the
.well-knownbootstrap paradox with on-chainDID Names: Many decentralized identity specs (likedid:web) host identity documents athttps://example.com/.well-known/did.json. That creates a circular dependency: you set out to replace centralized DNS and CAs with DIDs, yet step one of resolving.well-knownrequires trusting legacy DNS and a legacy CA!
In our architecture, the blockchain does the one job only a verifiable ledger can do: serving as the decentralized trust root for DID Names and key revocation:
- Humans should not have to memorize raw strings like
did:abt:zNKt.... Instead, human-readable names (such asarc://rob-studio.abt/) map to target DIDs and active delegation roots inside on-chainDID Nameson ArcBlock Chain, functioning like a decentralized, tamper-proof DANE registry. - Native
<did>.didinside, seamless Public HTTPS Gateway fallback outside: Inside an AFS-enabled client or ARC node environment, the local resolver natively handlesarc://<name>.abt/and the<did>.didpseudo-TLD, resolving the target DID viaDID Namesand opening a direct 1-RTTDID-TLSconnection with zero public DNS or public CA involvement. When you share a link with an external user in an unmodified standard Web browser (since.didis not an ICANN public TLD), the shared link uses a public HTTPS gateway domain (such ashttps://<did>.did.arcblock.io/or a custom gateway domain), which terminates standard browser HTTPS at the edge and proxies overDID-TLSto the origin node. Better yet, if that visitor has a local AFS runtime installed, the client detects the gateway'sAlt-Svcand DID discovery headers and automatically upgrades the session to a direct peer-to-peerDID-TLSstream.
4. Everything-over-DID and Symmetric afs-mesh: How Devices and Friends Connect Without IP or DNS Configuration
Once every node, device, and personal space speaks native DID-TLS, the networking layer reaches its natural conclusion: IP addresses and DNS names are demoted to transient physical routing hints, while the DID becomes the sole universal address for discovery, routing, and mounting (Everything-over-DID).
Inside our symmetric afs-mesh architecture, a cloud server, a MacBook in your backpack, an iPhone in your pocket, and your home ArcSpace are all first-class peers on equal footing. This unlocks two immediate breakthroughs in everyday connectivity:
1. Your Personal Device Circle: Log In Once, Auto-Connect Every Device
Think about why users love Apple Continuity and AirDrop: as long as your iPhone and Mac are signed into the same Apple ID, they discover each other automatically without asking you to type IP addresses or configure router port forwarding.
With afs-mesh, we deliver that exact zero-config experience across any platform and network using pure cryptography:
- As soon as your phone, laptop, workstation, and personal
ArcSpacebind to the same primaryDID, each device receives a scoped delegation certificate carrying a shared-circle discovery tag; - On the same home or office Wi-Fi, devices discover each other in milliseconds over encrypted local mDNS broadcasts and establish direct gigabit LAN streams;
- When you walk out the door and your phone switches to 5G, or your laptop connects from a hotel Wi-Fi or Starlink CGNAT, the nodes exchange encrypted candidate endpoints (
ICE / STUN) through blinded rendezvous beacons and punch a direct end-to-endDID-TLStunnel. You never care what IP address your Mac currently holds; runningarc afs ls did:abt:zMyMac/workjust works.
2. Your Friend and Collaboration Circle: Plan 9-Style Remote mount and Serverless /inbox Messaging
The mesh extends naturally along your cryptographic social graph.
When you and a collaborator add each other as friends (exchanging mutually signed DID relationship credentials), your nodes automatically establish an authenticated collaboration channel on afs-mesh, unlocking three native capabilities:
- Live Service Introspection (
afs list/afs explain): Want to see which Blocklets, APIs, or shared folders a friend's node has granted you access to? Instead of reading stale documentation, you runarc afs lsandarc afs explaindirectly against their DID. Their node returns a live, permission-filtered manifest of callable actions and schemas. - Plan 9-Style Remote Mounting (
afs mount): Following the Unix and Plan 9 philosophy that everything is a file, you can mount a friend's authorized remote Blocklet or shared dataset directly into your local AFS directory tree viaarc afs mount. Discovery, NAT traversal, mutualDID-TLSauthentication, and seamless reconnection happen invisibly beneath the mount point. - Serverless Peer-to-Peer Messaging (
/inbox): Because every DID exposes a standard/inboxpath on the mesh, sending an encrypted message, dispatching an agent task, or delivering a signed verifiable credential is as simple as writing todid:abt:<friend_did>/inbox. No centralized chat server sits in the middle; every delivery is end-to-end encrypted and signed by the sender's DID.
5. Standing on the Shoulders of Pioneers: Comparison with dat://, IPFS, and Tailscale, Plus Five Security Defenses
We are far from the first team to challenge DNS and centralized servers. Studying the pioneers of peer-to-peer and overlay networking, specifically dat:// (Dat / Hypercore / Beaker Browser), IPFS / IPNS, and modern overlays like Tailscale, helped us avoid the exact traps that held earlier generations back:
| Dimension | dat:// (Hypercore) | IPFS / IPNS | Tailscale / Apple Continuity | ArcBlock DID-TLS + afs-mesh |
|---|---|---|---|---|
| Primary Address Primitive | Static 64-hex hypercore public key (dat://...) | Content hash (CID) or mutable IPNS pointer | Centralized SSO account (Google/Apple/OIDC) + virtual IP | Hierarchical did:abt:... + on-chain DID Names |
| What It Does Well | Syncing static folders or append-only logs | Public deduplicated distribution of static files | Zero-config personal device LAN overlay | Dynamic Blocklet RPC, AI agent collaboration, private spaces & cross-friend mounts |
| Why It Hits a Ceiling | Compromising the key kills the address forever; file sync only, no dynamic service RPC or scoped RBAC | Public DHT leaks metadata (anyone can monitor who publishes/requests any CID); slow IPNS resolution | Centralized root of trust: if the coordination server or Apple ID is suspended, your mesh breaks | Cold-to-hot key delegation + blinded rendezvous + 1-RTT TLS 1.3 + public gateway fallback & upgrade |
Connecting every personal device and friend node into a global mesh also raises five serious real-world security risks. We engineered five protocol-level defenses into afs-mesh to address each of them head-on:
- Containing Compromised Edge Devices: Role-Scoped
DeviceOwnershipCertWhat happens if a Raspberry Pi or an edge test box on your mesh gets compromised? Can the attacker pivot into your laptop's source code or drain your wallet? Never. No edge device ever holds your masterDIDprivate key; each device only holds a role-scopedDeviceOwnershipCertthat restricts which AFS paths it may mount or serve. If a device is lost or compromised, a single revocation from your wallet cuts it off across every peer in seconds. - Preventing Social-Graph and Online-Presence Scraping: 3-Circle Blinded Rendezvous
The fatal privacy flaw of IPFS and early
dat://networks was publishing raw public keys to a global DHT, allowing anyone with a script to map which devices belong to whom and when they come online. Inafs-mesh, discovery is partitioned into three strict circles: Personal Devices, Mutual Friends, and Public Services. Lookup keys for the first two circles are blinded using a time-windowed HMAC over pairwise shared secrets (HMAC(SharedSecret, TimeSlot)). Outsiders only see rotating random hashes and can never scrape your device inventory or social graph. - Surviving Mobile Roaming and Symmetric CGNAT: 200ms Zero-Knowledge Blind Relay Fallback
Anyone who has built production P2P systems knows that direct UDP hole punching fails 10% to 15% of the time when a phone roams between 5G and corporate Wi-Fi or when both peers sit behind symmetric carrier-grade NAT (such as Starlink). Our rule is Direct-First with a 200ms Zero-Knowledge Blind Relay Fallback: if direct hole punching does not complete within 200 milliseconds, the stream seamlessly routes through an edge relay. Because the payload is an end-to-end
DID-TLSsession authenticated against the peer's DID public key, the relay only forwards opaque ciphertext bytes and cannot see which AFS path or message you are exchanging. - Defeating Active Port Scanners: Pre-Shared DID Knock Guard
For private personal devices, allowing any random IP scanner on the internet to complete a TLS handshake and read your node's certificate would leak your device DID. Private nodes therefore enforce a lightweight Knock Guard: over QUIC / UDP, the client must include a valid knock proof derived from the target's DID inside the initial UDP datagram (
QUIC Initial), or the node silently drops the packet with zero response; over TCP / TLS, the knock proof must be presented in aClientHelloextension before the server ever replies withServerHelloor itsDID-TLScertificate, preventing active scanners from harvesting node DIDs. - Handling Sleeping Laptops: Always-On
ArcSpaceInbox Anchoring Phones and laptops sleep. When your laptop lid is closed, messages or collaboration requests sent to your/inboxautomatically route to the always-on ArcSpace node in your personal DID circle, where they are stored encrypted. The moment you open your laptop, it syncs from yourArcSpaceoverafs-mesh, giving you the responsiveness of a cloud messenger with 100% self-sovereign ownership. (One explicit compliance boundary: ourafs-meshand blind relays strictly transport authenticatedDID-TLSprotocol streams between known DIDs and never act as open exit VPNs (Exit-dVPN) for arbitrary third-party web traffic, eliminating the legal and abuse risks that plagued crypto exit-node networks.)
6. Conclusion: Give the Network Back to Identity, and Keep Simplicity for the User
Looking back at thirty years of internet engineering, the reason developers have spent millions of hours configuring DNS records, renewing SSL certificates, babysitting NAT tunnels, and wiring up API gateways is simple: early internet protocols only defined how to reach a physical network card (IP), never how to reach a verifiable person, application, or agent (Identity).
By locking together in-memory DID-TLS certificates, on-chain DID Names trust anchors, and a symmetric afs-mesh overlay, this architectural design defines a clean endgame for ARC:
- For everyday users, it feels like Apple Continuity across the open internet: sign in with one DID, and your phone, laptop, cloud
ArcSpace, and friends' services connect automatically without ever touching an IP address, port forward, or SSL certificate; - For developers and AI agents, the entire network collapses into a single, self-authenticating resource address:
did:abt:<who>/<path>.
When cryptographic identity itself is enough to authenticate, encrypt, and route every connection, the fragile plumbing that used to stand in the way simply disappears.