Silent to strangers: defending against the zero-day nobody has found yet
Nobody can patch a flaw that hasn't been found yet. What you can control is who gets to talk to your software before they've proved who they are. Here's why every reply to a stranger is a risk, how VeilNet's knock keeps your services silent until a member proves itself, and where that silence stops.
Every piece of software you run has bugs that nobody has found yet. That isn't pessimism, just arithmetic: millions of lines of code, written by people, on deadlines. Some of those bugs are security holes, and some of those will be found first by someone who would rather use them than report them. That's a zero-day: a flaw that's used before the people who could fix it know it exists, so they've had zero days to respond.
You can't patch a flaw nobody knows about. What you can control is who gets to talk to your software before they've proved who they are. That's the idea behind one of the quieter parts of VeilNet's design: the agent on each machine doesn't answer strangers, and neither do the services you put behind it. Not with an error, not with a banner, not with anything at all.
This post covers why that matters, how it works, and, just as importantly, where it stops.
Every reply is a clue
Start with what happens to any machine with a public address. Within minutes of it coming online, something will come knocking. A free tool called masscan can sweep every IPv4 address on the internet in under five minutes from a single machine, given a fast enough connection. Services such as Shodan and Censys scan all the time, and keep a searchable record of what answered and what it said.
Most machines say a lot. Connect to an SSH server and it introduces itself with its version, something like SSH-2.0-OpenSSH_9.6. A web server hands over its TLS certificate, name and all. A VPN gateway shows its sign-in page, which often gives away the product and its version. Even a closed port usually answers with a reset, which tells the scanner there's a live machine at that address.
None of that is a vulnerability in itself. It's how the internet was built to work: be helpful, answer politely. But picture a building where every door has a sign saying what's behind it and which lock it uses. Nobody has to break in today. They just have to write it all down.
Scanners note what every address answers long before anyone knows about a flaw. When one is published, the list of machines to attack already exists. A machine that never answers isn't on it.
Zero-days land on whatever answers
That list matters on the day a flaw is published, or the day before. The most dangerous bugs are the ones that work before anyone has signed in, because anyone who can reach the software can trigger them. This year alone:
- SSHole (CVE-2026-123158), this month. On Linux systems built on musl libc without PAM, such as Alpine, OpenSSH's sshd accepted any password between 256 and 1,024 characters long for some accounts. The fix shipped on 5 November, and four days later CISA listed the flaw as being exploited.
- Ivanti Connect Secure (CVE-2026-104935), in October. Volexity found an unknown attacker chaining zero-days to get root on a fully patched VPN appliance without ever signing in, then going after Active Directory credentials and BitLocker recovery keys.
- Three more gateways and firewalls since May. In Palo Alto Networks firewalls (CVE-2026-0300), crafted packets could run code as root. Check Point's VPN (CVE-2026-50751) let attackers connect without a valid password, and ransomware groups did. Citrix NetScaler gateways (CVE-2026-88771) let attackers who hadn't signed in run commands. All three were being exploited by the time they were disclosed.
Four of those five are security products, and that stings. Their whole job is to sit at the edge of the network and face the internet, so they answer everyone who asks.
Here's the uncomfortable part. When a flaw like that goes public, attackers don't have to go looking for victims. They search the scan data they already have for the product and version, and their list of targets is ready before most people have read the advisory. SSHole went from fix to confirmed exploitation in four days, which is quicker than many teams get through a change window. Patching becomes a race, and every machine that answered the scans starts it from behind.
The machines that are safe on day zero are the ones the attacker can't reach at all.
Don't answer strangers
Staying quiet until someone proves who they are isn't a new idea. Port knocking, which dates back to the early 2000s, kept a port closed until a client sent the right sequence of connection attempts, like a secret knock on a speakeasy door. Single-packet authorisation tightened that up with one cryptographically signed packet. Zero-trust designs such as the software-defined perimeter grew from the same instinct.
Those ideas work, but they've mostly lived at the edges: a shared secret to hand out, a gateway in front of the real network, or one more daemon to look after. VeilNet builds the same instinct into every machine on the network, and ties it to the identity each machine already has.
On a VeilNet network, each machine runs an anchor, the part of VeilNet that connects it to its peers. Every anchor has its own post-quantum identity, vouched for by a PKI tree. On a sovereign network, that's your organisation's own tree, run from your own guardian (we wrote about it after eMudhra). The anchor listens on a single UDP port, and that port doesn't answer anyone who can't prove they belong to the tree.
How the knock works
The first thing one anchor sends another is a knock. Think of it as a sealed envelope slipped under the door. Inside are:
- Who's knocking: the sender's identity key.
- Why it should be let in: its credential chain, which leads back to the root of the tree.
- A signature made with ML-DSA, NIST's post-quantum signature standard. It names the anchor the sender expects to answer and the address it dialled.
The envelope is sealed with a key that only members of the tree can work out, so nobody outside can read it. It's also stamped with the hour it was made.
The anchor that receives it runs six checks, cheapest first, and stops at the first one that fails:
- Is it from our tree? A knock the anchor can't read goes no further.
- Is its clock close to ours? Up to an hour apart always passes. Two hours never does.
- Was it made for this anchor, this address and this purpose?
- Is it a copy of a knock already seen from somewhere else?
- Are we being flooded? An anchor takes at most 64 knocks a second for each processor core.
- Do the signature and the credential chain check out against the tree's root? This is the expensive one, so it comes last.
A knock that fails any check gets nothing back. Not an error, not a reset, not a certificate. To the sender, the anchor's port looks the same as a port behind a firewall that drops everything. The same silence meets machines from another tree, members whose credentials have expired or been blocked, and knocks meant for a different anchor.
A knock that passes lets that address go on to the handshake, and only for the next ten seconds.
A stranger's packet gets nothing back. A member's knock passes six checks and opens a ten-second window for the handshake. Nothing carries data until the post-quantum handshake and the proof of membership are both done.
After the knock
Getting past the knock earns a conversation, not trust. Two more steps come before any data moves.
First, the two anchors run a TLS 1.3 handshake over QUIC. Its key exchange is a hybrid that pairs a classical algorithm with ML-KEM, NIST's post-quantum key exchange standard. There's exactly one option on the table and no fallback, so nobody can talk the connection down to something weaker. Sessions are never resumed, either: every connection proves itself from scratch.
Second, each side proves it belongs by signing a value unique to this one session. That proof can't be lifted and replayed on another connection, because it wouldn't match. Each side checks the other's credential chain again, along with the compartments it claims, and only then does the connection carry data. The data itself gets a second, end-to-end layer of post-quantum encryption, with keys that are replaced every ten minutes.
The docs on admission and cryptography go into the details. The short version: nothing is usable before the proof.
Cheap to refuse
Silence only helps if it's also cheap. A server that has to do expensive cryptography for every stranger's packet has traded one problem for another, because anyone can make it burn CPU just by sending junk.
That's why the checks run in the order they do. The first one, “is this from our tree?”, costs almost nothing, and everything from outside the tree stops there, which means every scanner and botnet on the internet. The flood limit sits just before the expensive step, so even a determined attacker can't push more than 64 knocks a second per core through to it. And the expensive step itself, checking a genuine member's knock, takes under a millisecond.
The anchor doesn't write refused knocks to a log, either. It counts them by cause, so a burst of junk shows up as a number climbing on a dashboard rather than a wall of log lines.
Most junk fails the first check, which costs almost nothing. Only a knock that has passed every cheap check reaches the one expensive check, the signature, and even that takes under a millisecond.
If something does get through
Silence keeps strangers away from your software. It doesn't make that software free of bugs, and it does nothing about a machine that's a real member but has been compromised. So the rest of VeilNet is built on the assumption that something, someday, will get through:
- In proxy mode, the anchor runs without root. It carries the whole network inside its own process, in a micro virtual kernel, and runs as its own ordinary account. If something in it ever went wrong, it would go wrong with that account's rights. (On Linux it can keep one or two narrow capabilities, for its socket buffers or a low port, which the security reference lists. TUN mode, for laptops, needs more, because it creates a real network interface.)
- In proxy mode, peers reach only the ports you publish. Each one points at a service the machine can already reach, like a database on
127.0.0.1, and nothing else on the machine is exposed to the overlay. - Compartments are signed in. VeilNet's compartments, called taints, are written into each machine's credential, so a compromised laptop in one compartment can't talk its way into another.
- Your services keep their own sign-in. The network decides who can connect, and your SSH server or database still decides who can log in.
We wrote more about this layered approach after the Tailworm findings in Tailscale SSH.
Side by side
Here's how a typical internet-facing service compares with the same service behind a VeilNet anchor:
| Exposed service | Behind a VeilNet anchor | |
|---|---|---|
| What answers a scan | Every open port: banners, certificates, sign-in pages, resets | Nothing. The anchor's one UDP port stays silent |
| What a scan learns | Which products and versions you run | At most, that one UDP port might be open |
| What a stranger can reach | Everything that runs before sign-in | The anchor's cheapest checks, on a sealed packet |
| Cost of refusing a stranger | Often a full handshake | Almost nothing |
| What a stolen password gets | A sign-in attempt from anywhere on the internet | Nothing on its own. Only machines admitted to your network, in the right compartment, can reach the service |
Where silence stops
Silence is a strong default, but we'd rather you knew where its edges are than found them yourself:
- The port is still there. The anchor's UDP port is open, so a scan reports it as “open or filtered” rather than closed. Set your firewall to drop unsolicited UDP instead of rejecting it, and the anchor's port looks like any other filtered port. If the firewall rejects, the anchor's port is the one quiet port among the rejections.
- Neighbours can tell an anchor is there. By default, anchors look for each other on the local network over UDP 4747, and those messages tell everything on the same network segment that an anchor is present. They never cross a router, but on a host that faces the internet, drop UDP 4747 from outside or turn local discovery off.
- Silence makes troubleshooting harder. When a connection fails, the anchor can't say why without answering. The refusal counters exist for exactly this, and the docs walk through diagnosing a silent dial step by step.
- Members get ordinary answers. Once a machine is admitted, it talks to your services like any other client. A compromised member is a job for revocation, blocking and compartments, not for the knock.
- On the free network, the tree is shared. Anyone can enrol a machine on the network VeilNet hosts, and an enrolled machine passes the knock. Your network's taint is what keeps those machines away from your data. For a tree only your organisation can join, run your own guardian.
- A captured knock can draw a reply. Someone sitting on the network path between two of your machines can hold back a member's knock and forward it later. That gets the anchor's TLS certificate back, but never a connection, because the handshake that follows needs the member's own keys.
- It doesn't hide that traffic exists. Someone watching the wire between two of your machines can still see that they're exchanging encrypted packets, and roughly how much.
See it for yourself
The quickest way to feel the difference is to take one server's SSH off the internet, and after SSHole, this is a good month to do it. Follow the get-started page to put your laptop on a network, then join the server to it in proxy mode, publishing its own sshd through the anchor:
$ sudo conflux proxy --taint <your taint> 22=127.0.0.1:22
The sudo is only there to register the boot service and write the configuration. The anchor itself runs as its own account, not as root. Once ssh works over VeilNet, tell sshd to listen only on the loopback address:
ListenAddress 127.0.0.1
Restart sshd, and keep your current session open until a new one connects over VeilNet. From then on, sshd no longer answers anyone on the internet. Scan the server from outside and, where SSH used to introduce itself, you'll find nothing to fingerprint. This runs on the free network, where the knock silences every scanner and your taint keeps other people's machines out. Our Tailworm post walks through the same move one step at a time.
To go deeper, read how admission works or what the anchor runs as. You can also book a demo, or write to sovereign@veilnet.net.