Configuration Reference
What the engine is, what each setting does on the phone and on the server, the lines of a phone's file, where the phone's traffic and names go, and what the app keeps private.
Where this page comes from
The source code of both apps and of our Aether fork, the server as Aether server sets it up, and the cases of Test results, which the descriptions below name where they show a setting at work.
The engine
Aether is a Cloudflare WARP client by CluvexStudio (github.com/CluvexStudio/Aether, AGPL 3.0). The apps and the server guide build our fork of it, tag v2.4.0-srp.2 of github.com/bigmoveus/Aether: Aether 2.4.0 with these changes, each its own commit:
- Uploads no longer stall the tunnel. Aether's network stack dropped the packets it sent whenever the queue to the MASQUE connection was full, and under an upload every connection of the tunnel backed off until nothing moved. The fork keeps them until there is room. We sent this change to Aether as CluvexStudio/Aether#168.
- The lines that name each connection's destination are at debug level, so a server does not keep a list of every place its phones connect to.
- The certificate pins of the MASQUE edges include Let's Encrypt's YE2 intermediate, which signs the certificates the edges now serve.
- The apps run the engine through its C interface: there the fork installs the logger, so the log levels apply, and lets a tunnel ask for Tor.
Public mode
| Setting | What it does |
|---|---|
| The WARP identity | On its first connection the engine registers a free WARP device and keeps its keys in the app's own storage, one for MASQUE and one for WireGuard. Later connections use them again. No account or e-mail address is involved. |
| Transport | MASQUE carries the tunnel as an HTTP CONNECT-IP request to a WARP edge on port 443, over HTTP/3 (QUIC) or HTTP/2 (TLS over TCP). With Both, the app falls back to HTTP/2 when no HTTP/3 edge works. WireGuard is WARP's original transport over UDP. Over MASQUE, the engine opens the tunnel only after a packet has gone through it; an edge that takes the request but carries no traffic is given up. |
| Endpoint Scan | Balanced checks more of WARP's edges and takes a good one. Turbo takes the first that answers, which saves time when it works. |
| WARP+ License | At connect time the app binds the key to the WARP device in use and checks the account type. An invalid key is refused by WARP, and the connection goes on with free WARP (case ae-warp-plus-invalid-license). |
| Tor | WARP via Tor reaches the WARP edge through Tor, over MASQUE on HTTP/2; the traffic still leaves the internet at Cloudflare. Tor Only leaves the internet at a Tor exit, without WARP. Tor needs a few seconds to half a minute more to connect: 5 to 25 seconds in our runs. |
| TLS Fragmentation | Splits the ClientHello of the HTTP/2 connection's TLS handshake, for networks that block connections by the name in it. |
The server's settings
The container of the server guide gets these settings:
| Setting | What it does |
|---|---|
AETHER_PROTOCOL=masque | The engine reaches WARP over MASQUE. Without it, the engine asks which protocol to use. |
AETHER_SCAN=balanced | The endpoint scan, as in the app. |
AETHER_NOIZE=firewall | The engine's profile for disguising its QUIC traffic: firewall is its default for MASQUE. |
AETHER_TLS_VERIFY=1 | The engine checks the certificate of the WARP edge against the pins it carries (the apps set the same); without it the container logs tls verification: disabled and takes any certificate. |
AETHER_QUICK_RECONNECT=1 | After a restart the engine goes back to the last edge that worked instead of asking whether to. |
-v aether-data:/data | The engine's WARP identity and its last working edge, kept across restarts and new images. The image sets AETHER_CONFIG=/data/aether.toml. |
-p 10.66.66.1:1819:1819 | The engine's SOCKS5 port, which the image sets with AETHER_SOCKS=0.0.0.0:1819, published on wg0's address only. |
The phone's file
In Private mode the app reads these lines of the file add-phone.sh makes:
| Line | What the app does with it |
|---|---|
PrivateKey | The phone's key for the WireGuard handshake. |
Address | The phone's address inside the tunnel. It must be IPv4, and the server's address must be the first of its network: the app reaches the engine at that address, port 1819. |
PublicKey, PresharedKey | The server's public key and the phone's preshared key. If either does not match, the server does not answer the handshake (cases ae-private-wrong-server-key and ae-private-closed-port show the message). |
Endpoint | The server and its UDP port; Server and Port in the profile fill in from it and, if changed, replace it. |
AllowedIPs | The addresses the phone may reach through WireGuard: 10.66.66.1/32, the engine, is enough. |
PersistentKeepalive | A keepalive every 25 seconds when nothing else is sent. |
Routing and DNS
- All of the phone's IPv4 traffic goes into the tunnel, with an MTU of 1400. The app's own connections to the WARP edge, or to your server, stay outside it.
- In Public mode the phone asks 1.1.1.1 and 1.0.0.1 for names, through the tunnel.
- In Private mode the app answers name lookups itself, with stand-in addresses from 198.19.0.0/16. Each connection then carries the name to your server's engine, which looks it up.
- The traffic leaves the internet with a Cloudflare address (AS13335): every Public and Private case of Test results checked this. With Tor Only, it leaves with a Tor exit's address.
What stays private
- The WARP+ license, the phone's file and its keys are kept in the Keychain on iPhone and in the app's encrypted store on Android. No log level writes them (cases
ae-warp-plus-invalid-licenseand theae-*log*cases check the logs for them). - In Private mode, WARP sees your server's identity and address, not the phone's. The server's engine writes no destinations to its log at its default level.