Friday, December 8, 2023
Google search engine
HomeUncategorizedWhat every IT person needs to know about OpenBSD (2021)

What every IT person needs to know about OpenBSD (2021)

Peter N. M. Hansteen

How to have fun with the world’s most important free software project

“Functional, free and secure by default”, OpenBSD remains a crucial yet largely unacknowledged player in the open source field. This talk aims to highlight the project’s signature security features and development practices — razor sharp focus on correct and secure code coupled with continuing code audit — as well as the project’s role as source of innovation in security practices and ‘upstream’ source for numerous widely used components such as OpenSSH, PF, LibreSSL and others.

If you only have a few minutes to spare, the highlights are:

  • OpenBSD has been around for more than 25 years (started October 1995)
  • OpenBSD is proactively secure with only 2 remote holes in default install in all those years
  • OpenBSD pioneered use of strong cryptography, the first free system to ship with IPSec (entangling itself in US export regulations in the process)
  • OpenBSD pioneered and is still leading in code audit, fixing similar bugs tree-wide when found
  • OpenBSD has all security enhancements enabled by default and are hard going on impossible to disable
  • OpenBSD is open source, free software and the project actively encourages independent verification of code quality and security.
  • Today OpenBSD is in use in many network-centric roles, even though it is a general purpose operating system albeit with a particular emphasis on security.
  • OpenBSD has a high profile quality image based on actual code quality and proven performance in real world use
  • OpenBSD is upstream (origin) for several widely used pieces of software such as OpenSSH, OpenBGPD, PF, OpenSMTPd, LibreSSL, iked, mandoc and a number of others. For a complete list, please see the OpenBSD Innovations page on the OpenBSD website.
  • OpenBSD has been ‘growing up in public’ with code generally accessible via anonymous CVS (the first of its kind) since 1995 – transparent process, development discussions on public tech@ mailing list
  • Developers would do well to study high quality (mainly) C source and how the project runs a 6 month release cycle like clockwork (with only a few notable exceptions).

Note: If you are more of a slides person you will be happy to hear that indeed the presentation I used for this when given as a talk is available here with the main highlights and little to no geek jokes.

Now with that out of the way, let’s step back to  where it all started.

OpenBSD: How it all started

OpenBSD’s history is to a large extent the history of the Internet itself. You may have heard of the time back in the 1980s when the likes of IBM and Digital were slugging it out in the corporate IT sphere and the US department of defence paid for experiments in distributed, device independent networking.

That’s when a loosely organized group of hackers somewhat coordinated by researchers at University of California’s Berkeley campus rose to prominence with “BSD Unix”, which by a sequence of happy accidents became the home of the reference implementation of the TCP/IP internet protocols.

By the early 1990s, commercialization of the Internet had started, and the Berkeley Computer Science Research Group (CSRG) that had coordinated the efforts was set to be disbanded. In addition to the net itself, the main tangible product out of Berkeley was the Berkeley Software Distribution (BSD), often distributed on tapes in the mail but also available on the net itself, which had started as a collection of software for AT & T’s Unix but had over the years been extended become a full featured Unix operating system.

Several different groups wanted BSD to go on even if the CSRG did not, and several things happened in fairly rapid succession:


  • Lynne and Bill Jolitz ported BSD to Intel x86 (actually 80386sx), creating 386BSD. This was chronicled in a series of articles in Dr Dobbs’ Journal (also see a more condensed summary over at
  • Next up, hackers started sharing improvements to the 386BSD code as “patchkits”, and two separate groups took the work further to form their projects: The FreeBSD group would be working on bringing the best possible BSD to PC-style hardware, while the NetBSD group’s ambition was to make BSD run on any hardware they could get their hands on. [See Addendum at the end of the article.]
  • A group of former CSRG employees formed BSDi Inc. and marketed their product BSD/386 with among other things a contact phone number “1-800-ITS-UNIX”. The activities of an actual corporation in turn triggered a lawsuit from the owners of the UNIX trademark over code copyrights.

The lawsuit was eventually settled — only six files of several thousand in the tree were ‘potentially encumbered’ and had to be replaced, leaving both NetBSD and FreeBSD with a rush to replace the code which if I remember correctly was at least in part fairly central to the virtual memory subsystem.

OpenBSD came into existence a couple of years later, from a fork of the NetBSD code base in October 1995, with the initial release in July 1996.

From the very start, the OpenBSD project has been running a code audit of the entire tree, focusing on code correctness and security. We want secure, correct code that makes up a usable system with sane defaults and complete and readable documentation. And we want that code to be available under a free license and actually available to the world as soon as it is committed to the project’s version control.

One of the early achievements of the OpenBSD project was anonymous CVS, which makes it possible for anyone on the internet to get the code with changes in near real time. This was a major break with the normal practice of most projects of the time, which would typically work in relative isolation on private mailing lists and at quasi-random intervals issue a release as a tarball on an FTP server somewhere.

You are already an OpenBSD user!

It is probably useful at this point to reveal that even if you do not know it, you are more likely than not using code with an OpenBSD origin right now. Your Apple product, be it iPad, iPhone or Mac, your Android device, your Cisco router, Solaris, Linux or other Unix or even your Microsoft product has some or a lot of OpenBSD originated code in it. We will get back some detail on that later.


OpenBSD: Code audit and security evolution

But about the code audit. The activity runs roughly like this: 

Read the code, understand what it does.

Look for unsafe behaviors, assume a hostile environment.

When you find a bug and fix it, look for similar code elsewhere in the tree and fix everywhere.

You will be amazed how much different programmers think alike and make the same mistakes. Wash, rinse, repeat.

That may sound somewhat unexciting, but careful study of how the code actually performs in real life situations lead to a number of innovations over the years, with a strong slant for being proactively secure, making it harder for bugs to actually do damage:

  • W^X — memory can be writeable XOR executable
  • Address space randomization (ASLR) so the jump targets and gaps will vary for each execution
  • random-sized gaps inserted in the stack, again catching fixed-sized returns
  • unreadable, unwriteable guard pages at the end of malloc()ed chunks to catch overruns
  • privilege separation — daemons run the bulk of their code as a non-privileged user, more likely than not in a shell-less chroot, coupled with privilege revocation, which means that daemons drop privilege as soon as possible
  • the pledge(2) system call to declare a profile to restrict program behavior to only specified operations and resources
  • the unveil(2) system call to restrict file system access to specified paths and permissions only
  • A fairly user visible change came when OpenBSD 6.2 introduced kernel address randomized link, or KARL, which sees to it that the kernel is relinked to a new, randomized layout for each boot. Once again, introducing randomness where none had been before is seen as a way to mitigate possible exploits based on code loading at predictable addresses.

All of those features have been integrated in the OpenBSD source tree, and with the developers admonished to adhere to the rule

“where it is possible to spot damage, fail hard”.

-which means that poorly written software will crash a lot more often on OpenBSD than elsewhere. That in itself should make the platform attractive to developers. Exposing your code to a hostile environment and see it perform or fail can be quite entertaining and enlightening.

Usable, portable and secure

To complete the picture, it is useful to keep in mind that OpenBSD runs on a total of fourteen platforms. All platforms are self-hosting. Cross-compiling is only used in the early phase of porting to a new platform.

And of course, in addition to purely maintaining existing code to run on diverse platforms, users and developers have real world needs that are addressed by developing new software, extending the features of existing programs, adding new functionality or even replacing programs or entire subsystems.

Security is a many-faceted topic. Early on, OpenBSD stood out as the system that included real crypto in the base system, to the extent that exporting OpenBSD source code from the United States was technically illegal under that country’s munitions export restrictions as they were defined at the time. 

Fortunately for us, the project was always coordinated from Canada by undisputed project leader Theo de Raadt who lives in Canada. There is anecdotal evidence that US based developers would trek across the border for hackathons with clean slate equipment to install OpenBSD while in Canada and hack, that is, work on the system and would then legally bring the result back with them.

One early application of crypto in OpenBSD was when a full IPSEC stack was included in the system in 1997. OpenBSD was the first free system to include IPSec by default in its base install.

In a prime example of hacker humor of the time, a T-shirt featuring one of the early appearances of Puffy the blowfish that would become the project mascot touted the Blowfish password hashing algorithm which remains the default on OpenBSD both with the picture caption “So long and thanks for all the passwords” just below Puffy on the front, along with the full source code of the blowfish function on the back.

puffy with so long and thanks for all the fish

The expectation was that the T-shirt would be illegal to re-export from the US.

In addition to attention to security and code correctness, one other important feature of OpenBSD is attention to intellectual integrity and insisting on clearly worded and unambiguous license to use and modify code and documentation that forms part of the system.

So why use OpenBSD? What is it like?

So what is OpenBSD like for a user or developer, and why is it better?

I’d say the short version is that it’s a real Unix. Unlike the Linuxes of the world that spent years muddling through an evolutionary succession of init systems and have ended up more or less settling on the ever expanding systemd which seems to have tentacles into everything and is on a clear course to replacing most of what we have traditionally thought of as the base system, OpenBSD has stayed with and refined the traditional BSD init so can have both uncluttered services management and a base system that consists of programs that for the most part adhere to the classical Unix philosophy that every program should do exactly one thing, and do that thing well.

If you are a developer, you will also appreciate hearing that the base system of well designed programs that all have a readable and useful man page already contains basic Unix developer tools along with a C and C++ compiler — clang where supported and gcc where necessary — plus perl and a host of tools. Basically, everything that is needed to build the base system from a fresh checkout of the source code is contained in the base system on a default install.

Ported software goes under /usr/local

Once you have the thing installed on whatever hardware you have, keeping in mind that you can run a selection of 14 platforms ranging from fairly ancient kit to modern hardware, you will likely turn to installing ported third party software from packages, using pkg_add(8) which will suck in whatever you tell it to fetch from the same mirror you installed from or what appears to be the most local one.

More software is available on the more popular platforms than on the more, dare we say exotic ones.

For the OpenBSD 6.9 release, the most mainstream platform amd64 came with 11310 prebuilt and installable packages, while mips64 had only 8182 and the mips64el platform is marked as (still building).

Installing pre-built packages is almost always more convenient and is recommended in most cases, but if you for one reason or the other want to build your own from a cvs checkout of the ports tree, you are free to do so at the cost of your own time watching the process.

Whichever route you choose to go, you will see that installing packages does not land you with any files in the directories used by the base system outside of a few that drop their configuration files in subdirectories under /etc and add their combined startup/shutdown scripts to the collection in /etc/rc.d. Anything else ends up under /usr/local, and you can see why the installer by default sets up that file system on a separate and fairly roomy partition. My previous article You’ve installed it. Now what? Packages! is a few years old, but gives you the main motivations and some background along with some pointers on packages practice.

Note: If you are more of a slides person than a fulltext person, you may be relieved to hear that you can find the slides for the talk this article is based on (and vice versa) here.

The installer was always good, got better

When I found OpenBSD more than twenty years ago, my main Unix
exposure was from working with Linuxes and FreeBSD. What attracted me to
OpenBSD and finally had me buy an OpenBSD 2.5 CD set was the strong
focus on security and code correctness. When the CD set and the classic
wireframe daemon T-shirt finally arrived in the mail, I set about at
first to install it on whatever spare hardware I had lying around.

OpenBSD wireframe daemon head

If I remember correctly, the first machine I tried installing
OpenBSD on was an 80386/33MHz with 8MB RAM and I think a 100MB IDE hard
disk. Which I can report sounded pretty crappy even then, but the thing
did work.

The initial install was fairly straightforward, and when I started
poking around I found two things about myself and the new system:
Everything made sense, and everything I could think of had a readable man
page. So the first change I am aware of that made the world better with
OpenBSD was the decision to enforce the “No commit without
documentation” rule, which came into being early in the project’s life,
probably roughly at the same time the OpenBSD developers gave us a
real-time view of development via anonymous CVS. You can see things happening in almost real time.

It is worth mentioning that the installer has remained famously
non-graphical, text only. The reason the installer remains text-only is
that this is a major advantage that enables the developers and the users
to handle the fairly diverse collection of hardware platforms that OpenBSD runs on with the same portable, familiar and compact code everywhere.

The installer was always scriptable and extensible, and over the years
the installer has added automatic, repeatable and scriptable installs
(dubbed autoinstall(8) which appeared in OpenBSD 5.5 in 2014) and the sysupgrade(8) extension (first found in OpenBSD 6.6
in 2019) that automates snapshot to snapshot or release to subsequent
release upgrades for all not too hacked-up configurations. Each of these
moments, or more specifically when the new code started appearing in
snapshots, had me appreciate the OpenBSD system a bit more, and made me
feel quality of life had improved.

Now something for your laptop – hardware support

Fast forward some twenty-plus years and the last article I published, and even got into Norwegian mainstream IT news site,
centers on a few moments involving new OpenBSD developments. It took
some interaction with OpenBSD developers, but those interactions lead to
my new laptop with an 11th generation Intel Core chipset working even
better with OpenBSD. Yes, OpenBSD developers and a significant subset of
their user base actually run OpenBSD on their laptops. I do use a Mac
and a work-issued Thinkpad with Ubuntu Linux too, but life is not
complete without an OpenBSD laptop.

Now to be honest, what I saw within the space of a few days was
development that had me going from “Oh, sh*t, the SSD isn’t recognized”
— the controller was set to a RAID-ish mode by default — through this
kernel panic:

OpenBSD 6.9-current panic message

— to seeing it all fully supported.

The SSD problem turned out to be simple to fix: Simply find the
“Advanced” BIOS option that turned the pseudo-raid feature off and let
the operating system speak directly to the storage device.

For the rest there was a period of a couple of weeks I had to run with
not yet commited patches in a home baked kernel built from checkouts
from Jonathan Grey’s git repo. When the code was committed to -current, I
could resume my normal sysupgrade(8) routine, going from one development snapshot to the next.

The process, even with the need to build custom kernels for a while,
was actually quite pleasant, and when the support code went into the
main development branch, that too was a a moment when I felt my life had
been improved by changes in OpenBSD. The hardware support is now in
snapshots and will be in OpenBSD 7.0 which is set to be released on November 1st, 2021.

Why use OpenBSD? IPSEC

As I mentioned earlier, OpenBSD was the first free system to ship with IPSEC — the tools for enabling encrypted network traffic — in its base system. The first OpenBSD release with IPSEC was OpenBSD 2.1, which was released in 1997.

The tools worked of course, but in the early days the complaint was that IPSEC was hard and near impossible to debug from an almost-working to a fully working setup.

Further development took a while, but the tools got a major usuability upgrade in OpenBSD 3.8 with ipsecctl and its human-readable configuration file /etc/ipsec.conf to serve as a friendlier front end to the IPSEC tools.

A complete configuration for a minimal setup could look like this:

# Set up two flows:

# First between the machines and

# Second between the networks and

flow esp from to

flow esp from to peer

This was a major step compared to other platforms. One famous example is preserved in a presentation by Mathieu Sauve-Frankel at AsiaBSDCon 2007, where he demonstrated that setting up the equivalent of the config shown here with Microsoft tools took the user through a sequence of no less than 36 dialog boxes, and still there was a distinct possibility that the configuration was not actually a working one.

The problem in both the Microsoft implementation and others was that the developers had not really given any thought to the user experience. The majority of the options the user was required to set had sensible defaults and could easily have been hidden from view.

The standards documents the developers had worked from were fairly unclear, so it is not entirely unreasonable that “it was hard to write, so it should be hard to use” was a factor in how the products ended up from a user experience perspective.

What defaults would be actually sensible would perhaps not be clear to the developer from the specification, and the only way to see what would be the sensible default would be experience with actual use in the field. The OpenBSD developers who wrote ipsecctl came with extensive experience of using IPSEC and decided that IPSEC did not in fact need to be so hard. The defaults should make sense.

The next milestone in IPSEC development on OpenBSD came with Internet Key Exchange (IKE) protocol support in OpenIKED in OpenBSD 3.8 with iked and ikectl. For convenience, ikectl is able to generate configurations for Windows and macOS clients too. That might save you the agony of clicking through dozens of dialog boxes at the client end.

The thing that lured me in

But I hear you ask, what made me turn into an almost all-in OpenBSD user?

Back in 2001 I was still only experimenting with OpenBSD, but my experience with Linux and iptables
had made me long for a switch to a saner firewall. I had done some
small experiments with the IPF firewall that was in OpenBSD until the
2.9 release. Then, as some of us will remember, the it was discovered
that IPF’s license was in fact not free, so it needed to be replaced.

There was a distinct rush, not quite a stampede, to replace IPF over
the months that followed. Fortunately, the new code that replaced the
previous packet filter proved to perform better. The OpenBSD Packet
filter, dubbed PF for short, had been born and made its debut in OpenBSD 3.0
in December 2001. The release had originally been planned for November,
but was pushed out a month to hack the “working prototype” packet
filter into something usable.

Almost needless to say, this turn of events finally pushed me to take
the final steps to replace the Linux gateways I had in place with
OpenBSD ones. I was pleasantly surprised to find that not only did they
perform well, but they also came with complete and reasonably well
documented tools so I could understand what was going on. That’s how I
got started on the process that lead to among other things writing The Book of PF and taking that text through three editions so far. But more about that later.

It is worth noting that the IPFilter copyright episode spurred the OpenBSD developers to perform a license audit
of the entire source tree and ports in order to avoid similar
situations in the future. This activity ran for some months and
uncovered a number of potential problems. Theo de Raadt summed up the
effort in a message to the openbsd-misc mailing list on February 20th, 2003.

What they found when they started looking was that there was a
significant number of files that were in fact not under a free license,
much like the entire IPF subsystem had been. Those needed to be
replaced. Other parts had either no license or no copyright stated. In
some cases the developers gave explicit permission to continuing use,
but quite a few things needed to be rewritten with a free license so
OpenBSD and other free software would be able to move forward without
copyright problems.

I later heard in a rather informal setting that among the no copyright
and/or no license cases, it was usually possible to track down the
developers via version control system logs or mailing list archives. In a
large number of those cases, the initial reaction was along the lines “Say what? Are people still using that?“.

SSH, open and better

PF was written from scratch to replace a subsystem that it turned out
was illegal to use in an open source context. But it was not the first
time the OpenBSD project had performed a nonlibreectomy, that is, taken on the task of replacing code for license reasons.

A few years earlier it had become clear that the original developer of the secure shell system ssh
had commercial ambitions and the license for the software had changed
in a proprietary direction. After a bit of deliberation on how to
resolve the situation, the OpenBSD developers started digging around for
earlier versions of the code that had been published with an acceptable
license. Then they forked their version from the last version they
found that still had free license. Next came an intensive period of
re-introducing the features that were missing in the old code.

The result was introduced as OpenSSH in OpenBSD 2.6 in 1999. Over the next few years OpenSSH
grew a portable version that started grabbing market share rapidly. The
last I heard OpenSSH’s market share is somewhere in the high nineties

With a state of the art secure shell subsystem in place and growing all
sorts of useful features, the time finally came to end unencrypted shell
login sessions on OpenBSD. OpenBSD’s telnetd was moved to the CVS attic in time for OpenBSD 3.8, which was released November 2005.

One other notable thing about OpenSSH is that it was the first daemon to
be properly privilege separated, a model practice that debuted with the
overhauled OpenSSH in OpenBSD 3.2
in March 2002. Since then privilege separation has been put in place in
all daemons where it made sense to do so, and it is now a signature
part of the secure by default stance of all newer OpenBSD daemons.

And yes, that packet filter

I mentioned PF, the OpenBSD packet filter, earlier. I must confess that
PF has been an important part of my life in various contexts since the
early noughties. Over the years, things I have written have contributed
to creating the popular but actually wrong perception that OpenBSD was
primarily a firewall operating system. There are a lot of useful and fun
features that turned up in or in connection with PF over the years and
were pioneered by OpenBSD. Some features were ported to or imitated in
other systems, while others remain stubbornly OpenBSD only.

So I will touch on some of my favorite PF and PF-attached features, in quasi-random but almost chronological order.

Beating up spammers with OpenBSD spamd(8) since OpenBSD 3.3

When I started playing with OpenBSD in general and PF in particular
way back when, I was already responsible for the SMTP mail service for
my colleagues. My gateways by then ran OpenBSD, while the mail server rosalita, named after a Springsteen song, was not too badly specced server running FreeBSD with exim as the mail transfer agent that fed the incoming messages to spamassassin and clamav for content filtering before handing off to user mailboxes.

So when it dawned on me that I could set up spamd(8) the spam deferral daemon on the internet-facing gateway and save load on the poor suffering rosalita that was running hot with content filtering, I was quick to implement a setup that sucked in well known block lists.

Going grey, then trapping

The effect was obvious and immediate, the mail server’s fans grew noticeably quieter. When greylisting was introduced in spamd soon after, I implemented that too, and witnessed yet another drop in pitch and intensity of the sound from rosalita‘s
fans. Then a couple of releases later greytrapping — the practice of
adding IP addresses of incoming SMTP connections to blocklists if the
attempted delivery is aimed at a known-bad address in the target domain
— was introduced, and that sounded like enough fun that I just went
ahead and did it.

The idea of detecting spam senders by the bogus addresses they were
already trying to deliver to just sounded too good to not try. And we
knew that getting started would be pretty easy too. We had seen rejects
for addresses that had never existed in our domains in our mail server
logs for quite a while, so it was simply a matter of harvesting from a
fairly bountiful source and adding stuff that we were sure would never
ever be actually deliverable here to the spamtrap list. I think the
first setup had only a couple of hundred entries in it, but I did not
note the exact number at the time.

By July 2007 I had decided to publish
both the list of spamtrap addresses and an hourly dump of the
greytrapped addresses. Both remain free to download. The list of
spamtraps, harvested from various log sources, by now numbers just over
270,000 imaginary friends, while the number of trapped hosts is
typically in the 3000 to 5000 range. We occasionally see the list swell
to 20,000 or more when high volume campaigns run with bad address lists fed to them. I am pretty sure it went over 100,000 at one point.

It’s fun to watch, and it looks like a significant subset of the
spamtraps have made it into the address lists of active spam operations.
I frankly never thought I would still be collecting spam traps from
logs all these years later. Yes, it all sounds a bit absurd, but it is
effective for keeping our mailboxes largely spam free, even though it
feels at times like running a weird found object-ish art project.
Anyway, a summary of the lists we publish can be found in this article.

The brutes, the password gropers and the state tracking options

If you run an SSH service or really any kind of listening service with
the option to log in, you will see some number of failed authentication
attempts that generate noise in the logs. The password guessing, or as
some of us say, password groping, turned out to be annoying enough that
OpenBSD 3.6-current and later OpenBSD 3.7
introduced a set of features to use data that would anyway be available
in the state table, to track the state of active connections, and to
act on limits you define such as number of connections from a single
host over a set number of seconds.

The action could be to add the source IP that tripped the limit to a
table. Additional rules could then subject the members of that table to
special treatment. Since that time, my internet-facing rule sets have
tended to include variations on

table  persist
block quick from 
pass inet proto tcp from any to $localnet port $tcp_services 
        flags S/SA keep state 
	(max-src-conn 100, max-src-conn-rate 15/5, 
         overload  flush global)

which means that any host that tries more than 100 simultaneous
connections or more than 15 new connections over 5 seconds are added to
the table and blocked, with any existing connections terminated.

It is a good practice to let table entries in such setups expire eventually. At first I followed the spamd(8)
defaults’ example and set expiry at 24 hours, but with password gropers
like those caught by this rule being what they are, I switched a few
years ago to at four weeks at first, then upped again a few months later
to six weeks. Groperbots tend to stay broken for that long. And since
they target any service you may be running, state tracking options with
overload tables can be useful in a lot of non-SSH contexts as well.

It is also worth noting that state tracking actions are useful for essentially all services. The article Forcing the password gropers through a smaller hole with OpenBSD’s PF queues has a few suggestions on how to handle noise sources with various other services.

One final point I would like to make about the state tracking and actions is that much like the greytrapping feature of spamd, this feature gives you the tools to build a configuration that adapts to network conditions and learns from the traffic it sees. 

While this does not rise to the level of being an actual Artificial Intelligence or AI, this has enough buzzwordability
potential that I remain to this day extremely puzzled that none of the
other big names at least imitated those features in their own products
and marketed for all it would be worth. 

I certainly know what I
would have done in their position. But then I am more engineer than
marketer and in the contexts where I call the shots, the best option is
just to keep running OpenBSD.

We went to modern queueing

OpenBSD has had traffic shaping available in the ALTQ subsystem
since the very early days. ALTQ was rolled into PF at some point, but
the code was still marked experimental 15 years after it was written,
and most people who tried to use it in anger at the time found the
syntax inelegant at best, infuriating or worse at most times.

So Henning Brauer took a keen interest in the problem, and reached the
conclusion that all the various traffic shaping algorithms were not in
fact needed. They could all except one be reduced to mere configuration
options, either as setting priorities on pass or match rules or as variations of the theme of the mother algorithm Hierarchical Fair Service Curve (HFSC for short).

Soon after, another not-small diff was making the rounds. The patch was applied early in the OpenBSD 5.5 cycle, and for the lifetime of that release older ALTQ setups were possible side by side with the new queueing system.

The feedback I get is that the saner syntax in the new queueing system
lead to more users taking up traffic shaping. Here is the queue setup
that I came up with for one of my sites:

queue rootq on $ext_if bandwidth 20M
        queue main parent rootq bandwidth 20479K min 1M 
                                    max 20479K qlimit 100
             queue qdef parent main bandwidth 9600K min 6000K  
                                    max 18M default
             queue qweb parent main bandwidth 9600K min 6000K 
                                    max 18M
             queue qpri parent main bandwidth 700K min 100K 
                                    max 1200K
             queue qdns parent main bandwidth 200K min 12K 
                                    burst 600K for 3000ms
        queue spamd parent rootq bandwidth 1K min 0K max 1K 
                                    qlimit 300

while tying the queues into the subsequent rules with a set of match rules just following that block.

This is what triggered the need to write the third edition of The Book of PF.
The book includes descriptions of both the new and the old system as
well as tips on how to make a smooth transition. The ALTQ code was
removed from OpenBSD during the OpenBSD 5.6 cycle, but continues to live on in some form in FreeBSD and NetBSD.

And yes, if you think my queues setup punishes spammers a bit more in addtion to being subjected to spamd(8), you’re right.

pflow(4) offers network insights lite

Everybody who has been tasked with looking after a network has at some
point been at least a little curious about what actually moves around
there. At times we will see situations where it is essential for
troubleshooting purposes to see the traffic flows with data about
endpoints, packets and bytes transferred, protocol and so forth.

If you do not need to see the data itself, but rather the metadata, the NetFlow standard and its close cousin IPFIX offers just that. Netflow tools existed as packages on OpenBSD already, but from OpenBSD 4.5 PF has the pflow state tracking option, paired with the pflow(4) virtual network interface which together offer a full netflow sensor package.

Set up one or more pflow interfaces to send data to one or more collectors, and add the pflow
option to specific rules or as a state default and you have started
your collecting. You can even have metadata for traffic matching
specific rules going to separate pflow devices and collectors.

My field notes in Yes, You Too Can Be An Evil Network Overlord – On The Cheap With OpenBSD, pflow And nfsen
offers some practical examples and insights, including how we used a
pflow setup to track down a noisy machine on a somewhat critical network
as well as some pointers to valueable further reading.

LibreSSL, the great deobfuscation

People tell me they think that the reason LibreSSL was created was the Heartbleed bug, but no, actually not, just damn close.

The LibreSSL project was in fact started a few weeks before heartbleed
became common knowledge. LibreSSL is the result of a group of OpenBSD
developers taking the existing OpenSSL code and starting to fix it.

This time it was not a matter of a bad license. No, this was the result
of the number of OpenBSD developers who took a look at the OpenSSL
code that had been part of the OpenBSD base system since quite early
on, and turned away in disgust and with symptoms of physical pain,
reached a critical mass of sorts. I had heard OpenBSD developers
complain about the absolute horror of the OpenSSL code for at least ten
years. The code quality was just that bad.

What happened next was that a group of hardened OpenBSD developers
grabbed the OpenSSL code and started two activities in parallel. One was
looking in the OpenSSL request tracker for bugs that had not been
addressed. The other was reformatting the OpenSSL code into something
resembling the OpenBSD style of readable and maintainable C.

With the code in more readable form, discovering what it did became
easier. In addition to a few obvious eye-stinging bugs the LibreSSL
developers found a number of oddities, including, but not limited to

  • Code was never deleted even when it became irrelevant or obsolete
  • OpenSSL did not use the system memory allocation system,
    but rather opted for their own which never actually deallocated memory,
    but rather used LIFO recycling, and could easily be made to put private
    info into logs
  • all written in “OpenSSL C”, which according to beck@ is a dialect of the “worst common denominator”

It is worth digging out the various articles and presentations made by
LibreSSL developers over the years, with specific emphasis on Bob Beck’s
BSDCan talk on the first 30 days of LibreSSL (available on youtube), which is the original source of the term code flensing.

Since the OpenBSD 5.6
release in 2014, LibreSSL has been the default TLS library in OpenBSD.
LibreSSL has been ported elsewhere based on the -portable variant.

For my own part I can only attest to not ever running into a TLS problem
that was LibreSSL’s fault. It probably still has bugs, but it is a lot
more of a healthy choice than its predecessor.

This was my list of life improving OpenBSD events – I’d love to hear yours

As I warned earlier, this has been about my personal list of OpenBSD events that I remember fondly.

I am sure your list is at least a little different. I am sure there are things from the innovations page that I have simply forgotten about.

Each release comes with a detailed list of changes, such as this one for OpenBSD 6.9, and the page has pointers back to the equivalent pages for previous releases.

I would love to hear about your favorite OpenBSD moments.

More items for your OpenBSD reading is the official OpenBSD web site. If you want to donate, go to the donations page and find the most appropriate option. Corporate entities may prefer to donate via The OpenBSD Foundation, which is a Canadian non-profit corporation. is the OpenBSD Journal news site. My rant^H^H^H^Hblog posts Ted Unangst (tedu@) on developments

Michael W Lucas: Absolute OpenBSD, 2nd edition

Peter N. M. Hansteen: The Book of PF, 3rd edition

Henning Brauer: OpenBSD sucks (… least)

Addendum 2021-11-06

The original statement in the article that the two groups (NetBSD and FreeBSD) were only vaguely aware of each other in the early days has been disputed by at least one patchkit era participant, Tom Ivar Helbekkmo, who wrote in to say,

“That is not entirely true.  When Bill Jolitz didn’t include patches from the Internet community in 386bsd 0.1, and then again not in 0.2, Chris Demetriou took the initiative to fork the project, and call ours NetBSD.

 It soon became apparent, however, that there were divergent goals for further development.  This led to the creation of FreeBSD.  So we had one community that amicably divided itself into two separate groups.”

In my own experience, however, those who joined in the post-patchkit era of both projects frequently seem to be unaware of this aspect of the early days. 

Read More



Please enter your comment!
Please enter your name here

- Advertisment -
Google search engine

Most Popular

Recent Comments