The Noir Edition
A faster, leaner OpenVPN-compatible VPN, written from scratch and released under Apache-2.0.
A few days ago, I announced the availability of noirvpn on GitHub, released under the Apache-2.0 license so that it can be freely used in pretty much any setting. I’ll refer to it as Noir in this article, so that it isn’t confused with other services that might use the “noirvpn” name.
What is Noir?
Noir is a new, independent implementation of the OpenVPN protocol which can read your existing OpenVPN configuration files and works with version 2.6 and newer servers and clients. The code for Noir can run as a client on Linux, Windows and macOS, and as a server on Linux; mobile clients are coming.
It is compatible with most of OpenVPN. We deliberately left out the features that deployments rarely use, so that Noir keeps only what is useful.
What’s gone:
- bridged (layer-2) networks
- older address layouts, compression and static keys
- smart-card (PKCS) keys
- scripts, plugins and the old management interface, replaced by a modern control bus
- support for clients and servers older than OpenVPN 2.6
What’s new:
- A control bus that lets other software watch events and manage the VPN live.
- Device key pinning without certificates so a server can accept a device by its key, with or without a certificate authority.
- Web sign-in, so users can log in with their company account.
- Post-quantum key exchange
- Traffic that looks like HTTPS, so the VPN gets through networks that block everything else.
- Client network protection - access-control lists on client side so that it can control what reaches its own hosts and ports through the tunnel, without changing its firewall.
- Port forwarding on the client, so a service on the client’s LAN can be reached through the tunnel.
- An open interface for fast data paths, so anyone can plug in their own packet engine.
How fast is it?
Even as a pure userspace program, Noir is faster than any OpenVPN build we tested, including its in-kernel data channel offload (DCO).
The open source build of Noir is about 6 times faster than stock OpenVPN and about 3 times faster than OpenVPN with kernel DCO. Speed is only half of the story: Noir also does it with less CPU, which means better battery life on laptops and more headroom on small routers.
The Cosinium build of Noir goes further, to more than 11 Gbit/s over UDP and about 20 Gbit/s over TCP on the same machines. Cosinium-Noir adds an accelerated encryption library and a faster packet path. Stock OpenVPN peers don’t see any difference, but they can benefit from a Cosinium server that can handle connections efficiently. The Cosinium build is part of our commercial platform, and you can get the same performance by running Cosinium on an appliance, a virtual machine or in a container.
For those inquisitive, on the same testbed we measured WireGuard (both kernel and Go) to reach around 9.5 Gbit/s to show that the OpenVPN protocol is not the problem.
Why did we create Noir?
While our flagship VPN product is Cosineq+QuicN, a huge number of deployments still use OpenVPN. Many people don’t know they’re using it, because it’s built into branded products such as the Azure VPN Client and many hosted VPN services. It’s a robust protocol that supports a wide variety of setups, from a basic home gateway to enterprise single sign-on.
The problem is that what’s available is slow. The protocol isn’t the cause, bur rather how it has been implemented and shipped to users is. As a result, many people quote that weak performance as a protocol problem.
We wanted to show that it doesn’t have to be that way. Without changing the protocol, the same tunnel can run several times faster, as the charts above show.
Performance wasn’t the only reason. We had already prototyped a userspace DCO for OpenVPN that reached 17 Gbit/s. The bigger need was Cosinium OS: a complete firewall environment that has to manage the VPN live and connect it to our event monitoring, policy-based routing, DNS service and firewall rules. That is hard to do when the base product’s goals differ from our own.
Tracking upstream and patching it causes long-term headaches, and the wider community doesn’t benefit from those patches. With Noir, everyone uses the same core, and our Cosinium OS controller talks to it over the control bus. Anyone can use that same bus to build their own management platform; it’s generic enough for that. New messages can be added to the bus without touching the core.
Noir inside Cosinium
In Cosinium, Noir is one part of a bigger system. The Cosinium controller manages everything inside CosOS. Part of it is setting Noir up, listen to its events, and wire its services to the rest of the appliance: the firewall, our odns DNS server, user accounts and sign-in, policy routing, high availability and the WebUI.
The integration means users sign in with the same accounts as everywhere
else, firewall rules are written for their group, odns filters their
DNS and replies with internal names, and their traffic is sent to the
path chosen for that group. With high-availability turned on, Cosinium’s
firewall pair fails over and brings the VPN connection over.
Why not change OpenVPN itself?
We appreciate what OpenVPN Inc. has done by giving the public a stable product and protocol. Many VPN protocols came before it, and most of them have fallen off the radar.
We wanted a clean base and removed the protocol features that we felt no longer helped users. Noir integrates tightly with the Cosinium platform, but it is open enough that anyone can extend it freely.
We put Noir through a lot of testing against OpenVPN servers and clients. One full test cycle takes about 5 hours because of the number of configurations it covers. Even so, there will be cases we haven’t thought of, and we expect to find them as more people use Noir.
Why Odin?
My strengths are in C, C# and Go, and Odin is similar in form, which bears a low “mental weight”. After a few weeks away from a piece of code, I can pick it up again and see what’s happening, without having to untangle abstractions or voodoo. Odin has modern features, calls C directly, and lets me control memory use exactly. That makes it an excellent language for both systems and application programs.
We already use Odin in other parts of Cosinium. odns, our DNS server, is lightweight and fast, using less than 100 MB for 2 million block list entries. odini, our container init for OCI images, starts and stops the services quickly. So Odin was the natural choice for Noir: the daemon uses only 5 MB of memory at idle and about 30 MB at a full load of 20 Gbit/s. The same Noir Odin core also compiles for iOS and Android.
Getting Noir
- The source code is on GitHub.
- Cosinium images and software are on our download site, downloads.cosinium.com, and the Noir desktop clients will be available there too.
- Noir works with your existing OpenVPN server, so you can start with a single client without changing anything.
If something doesn’t work with your setup, please tell us. Reports from real networks are the most useful help we can get right now.
Final remarks
We started by adding OpenVPN to Cosinium and quickly ran into its limits. By creating Noir, we hope the community gets an alternative that is not only faster but also more practical to run, and ready for post-quantum threats whenever (or if ever) a large quantum computer arrives.
Cosineq+QuicN remains our flagship. It is a ZTNA implementation that gives stricter access control for each endpoint, and we continue to develop it to protect networks as AI agents and automated workloads take on more of the traffic.
Noir is for the many networks that already run OpenVPN and can’t simply replace it. They deserve better performance and modern security without a forklift upgrade. That’s why Noir’s core and desktop apps are open source, and why we’ll keep working on them in the open.
Whatever VPN protocol you prefer, we hope Noir shows the care that goes into every Cosinium product. Give it a try, and tell us how fast it runs for you.