OpenBSD Administration

Keine Treffer – Suchbegriff anpassen.

💻System- & Hardware-Informationen

uname -a	Alles: OS, Hostname, Release, Build-Kennung, Architektur
uname -r	Release, z. B. `7.9` – bei -current mit angehängtem Datum im Kernel
uname -m / uname -p	Maschinen-Architektur (`amd64`) / Prozessor-Architektur
machine / arch	Architektur kurz ausgeben (`machine` ist Alias von `arch`)
sysctl kern.version	Vollständige Kernel-Kennung inkl. Build-Datum und Compiler
sysctl kern.osrelease kern.osversion	Release und Kernel-Buildnummer
sysctl hw.vendor hw.product hw.serialno	Hersteller, Modell und Seriennummer (aus SMBIOS)
sysctl hw.model	CPU-Modellbezeichnung
sysctl hw.ncpu hw.ncpuonline hw.ncpufound	Genutzte / online / gefundene CPUs (SMT-Cores zählen mit)
sysctl hw.cpuspeed hw.setperf	Aktueller Takt in MHz / Performance-Sollwert in Prozent
sysctl hw.physmem hw.usermem	Physischer bzw. für Userland nutzbarer Speicher in Byte
sysctl hw.disknames	Alle Platten samt DUID – wichtig für `/etc/fstab`
sysctl hw.sensors	Temperaturen, Lüfter, Spannungen, RAID-Status der Treiber
sysctl kern.boottime	Zeitpunkt des letzten Bootvorgangs
sysctl -a \| less	Alle Kernel-Variablen (rund 1000 Einträge)
sysctl -n kern.hostname	Nur den Wert ausgeben (gut für Skripte)
hostname / hostname -s	FQDN / nur Kurzname; dauerhaft in `/etc/myname`
dmesg	Aktueller Kernel-Ringpuffer (Hardware-Erkennung, Fehler)
dmesg -s	Console-Message-Buffer – zeigt auch `rc`-Startmeldungen (nur root)
cat /var/run/dmesg.boot	Kopie des dmesg direkt nach dem Boot – die verlässliche Quelle
dmesg \| grep -i cpu0	CPU-Features und Mitigations der ersten CPU
uptime; w; date	Laufzeit und Load / angemeldete User / Systemzeit
apm -v / apm -l	Power-Status ausführlich / nur Akkustand (benötigt `apmd`)
apm -A / apm -H / apm -L	Frequenzregelung: automatisch / high / low
pcidump -v	PCI-Geräte mit Vendor-/Device-IDs ausführlich auflisten
usbdevs -v	Angeschlossene USB-Geräte

Praxis: Ist-Zustand vor jedem Change sichern: dmesg > /root/dmesg_$(date +%F).txt, sysctl -a > /root/sysctl_$(date +%F).txt, disklabel sd0 > /root/label.sd0. Der dmesg-Ringpuffer ist klein – nach längerer Laufzeit ist /var/run/dmesg.boot die einzige komplette Boot-Ausgabe.

Dauerhafte sysctl-Werte: Alles, was per sysctl kern.x=y gesetzt wird, ist nach dem Reboot weg. Dauerhaft gehört es als kern.x=y in /etc/sysctl.conf (Syntax: eine Zuweisung pro Zeile, ohne sysctl davor).

⏻Boot, Bootloader & Kernel

boot(8)-Prompt (`boot>`)

boot	Standardkernel `/bsd` starten (passiert nach Timeout automatisch)
boot -s	Single-User-Mode – nur `/` read-only, Rettungsmodus
boot -c	Kernel-Konfigurations-Editor UKC starten (Geräte an/abschalten)
boot -a	Beim Start nach dem Root-Device fragen
boot bsd.rd	RAM-Disk-Kernel – Installer, Upgrade und Reparatur-Shell
boot hd0a:/bsd.sp	Bestimmten Kernel von bestimmter Partition booten
boot -d	Direkt in den Kernel-Debugger ddb(4) fallen
machine diskinfo	Vom Bootloader gesehene Platten anzeigen
machine memory	Speicherkarte des BIOS/UEFI anzeigen
set tty com0	Konsole auf serielle Schnittstelle umlenken
stty com0 115200	Baudrate der seriellen Konsole setzen
set timeout 10	Wartezeit am Boot-Prompt in Sekunden
ls /	Wurzelverzeichnis auflisten – prüfen welche Kernel vorhanden sind

Bootloader & Kernel im laufenden System

/etc/boot.conf	Dauerhafte Bootloader-Kommandos (z. B. `set tty com0`)
installboot -v sd0	Bootstrap-Code und Bootloader auf die Platte schreiben
installboot -n -v sd0	Trockenlauf – zeigt nur, was geschrieben würde
config -e /bsd	UKC im laufenden System öffnen (Änderung in neue Datei schreiben)
config -e -f /bsd	UKC-Änderung direkt in den Kernel `/bsd` zurückschreiben
find / disable / enable / change	UKC-Kommandos; `quit` = schreiben, `exit` = verwerfen
/bsd · /bsd.mp · /bsd.sp · /bsd.rd	Aktiver Kernel · Multiprozessor · Einzelprozessor · RAM-Disk
/obsd	Vorheriger Kernel (Backup durch KARL-Relinking)
/usr/libexec/reorder_kernel	KARL: Kernel neu linken (läuft automatisch bei jedem Boot)
ls -l /usr/share/relink/kernel/	Objekte für das Relinking; muss vorhanden und beschreibbar sein
sysctl kern.securelevel	Aktueller Securelevel (Normalbetrieb: 1)
sysctl kern.osrevision	Kernel-Revision der laufenden Version

Herunterfahren & Neustart

reboot	Sofortiger Neustart
halt -p	Herunterfahren und ausschalten (Poweroff)
shutdown -hp now	Sauber herunterfahren und ausschalten, mit wall-Meldung
shutdown -r +10 "Wartung"	Reboot in 10 Minuten mit Meldung an alle User
shutdown -h now	Anhalten ohne Ausschalten (System bleibt am Prompt)
/etc/rc.shutdown	Eigene Kommandos, die vor dem Herunterfahren laufen

Kein Modulkonzept: OpenBSD kennt keine ladbaren Kernel-Module – es gibt kein kldload, modprobe oder /etc/modules. Geräte werden über UKC (boot -c / config -e) ein- und ausgeschaltet oder erfordern einen eigenen Kernel-Build.

KARL: Bei jedem Boot wird aus den Objekten in /usr/share/relink ein neuer, zufällig gelinkter Kernel gebaut. Dadurch unterscheidet sich /bsd nach jedem Reboot – Checksummen-Vergleiche des Kernels sind deshalb sinnlos.

⚙Init, rcctl & Dienste

rcctl – das zentrale Werkzeug

rcctl ls all	Alle bekannten Dienste und Services
rcctl ls on / off	Aktivierte / deaktivierte Dienste
rcctl ls started / stopped	Laufende / nicht laufende Dienste
rcctl ls failed	Aktiviert, läuft aber nicht – erster Blick bei Störungen
rcctl ls rogue	Deaktiviert, läuft aber trotzdem
rcctl enable httpd	Dienst aktivieren (Alias für `set httpd status on`)
rcctl disable httpd	Dienst deaktivieren, Variablen werden entfernt
rcctl start / stop / restart httpd	Dienst starten / stoppen / neu starten
rcctl reload httpd	Konfiguration neu einlesen (sendet SIGHUP)
rcctl check httpd	Läuft der Dienst? Exit-Code 0 = ja
rcctl configtest httpd	Konfiguration prüfen, falls das rc.d-Skript es unterstützt
rcctl -d start httpd	Debug-Modus – zeigt, warum der Start scheitert
rcctl -f start httpd	Start erzwingen, auch wenn der Dienst deaktiviert ist
rcctl get httpd	Alle Variablen eines Dienstes im rc.conf-Format
rcctl getdef httpd flags	Werkseinstellung der Flags anzeigen
rcctl get all \| less	Komplette Dienstkonfiguration des Systems dokumentieren
rcctl set httpd flags -s 5	Startparameter setzen (leeres Argument = Default)
rcctl set httpd status on	Langform von `rcctl enable`
rcctl set ntpd user _ntp	Ausführenden User ändern
rcctl set httpd timeout 60	Timeout für rc.d-Aktionen erhöhen (Default 30 s)
rcctl set httpd rtable 1	Dienst in einer anderen Routing-Tabelle starten
rcctl set httpd logger daemon.info	Ausgaben des Dienstes an syslogd weiterleiten
rcctl order unbound dhcpd	Startreihenfolge in `pkg_scripts` festlegen

Dateien & rc-Struktur

/etc/rc.conf	Defaults der Basis-Dienste – niemals editieren
/etc/rc.conf.local	Eigene Abweichungen; wird von `rcctl` gepflegt
/etc/rc.local	Eigene Kommandos am Ende des Bootvorgangs
/etc/rc.securelevel	Kommandos, die vor dem Anheben des Securelevel laufen müssen
/etc/rc.firsttime	Wird einmalig beim nächsten Boot ausgeführt, danach gelöscht
/etc/rc.shutdown	Kommandos beim Herunterfahren
/etc/rc.d/	Kontrollskripte aller Dienste (Basis und Pakete)
/etc/rc.d/httpd -f restart	rc.d-Skript direkt aufrufen, Start erzwingen
pkg_scripts="unbound nginx"	Reihenfolge der Paket-Dienste in `rc.conf.local`
ln -s /etc/rc.d/snmpd /etc/rc.d/snmpd6	Zweite Instanz eines Dienstes: Symlink anlegen und konfigurieren

Goldene Regel: rc.conf.local nicht mit dem Editor anfassen, sondern immer rcctl nutzen. Das vermeidet Tippfehler in Variablennamen (ein falsch geschriebenes httpd_flags wird still ignoriert) und hält pkg_scripts konsistent.

Service vs. Daemon: Manche Einträge sind reine Services ohne Prozess (z. B. pf, ipsec, library_aslr). Bei ihnen greifen nur enable/disable, nicht start/stop.

📦Pakete, Ports & Updates

Spiegel & Grundkonfiguration

cat /etc/installurl	Mirror-URL für `pkg_add`, `syspatch`, `sysupgrade`, `fw_update`
echo https://cdn.openbsd.org/pub/OpenBSD > /etc/installurl	Offiziellen CDN-Mirror setzen (eine Zeile, ohne Slash am Ende)
export PKG_PATH=/mnt/packages/	Alternative Paketquelle für eine Sitzung (z. B. lokaler Spiegel)
/etc/pkg.conf	Dauerhafte Optionen für die pkg-Werkzeuge (`installpath` u. a.)

Binärpakete

pkg_add nginx	Paket samt Abhängigkeiten installieren
pkg_add -v nginx	Ausführlich – zeigt Quelle, Signaturprüfung und Dateien
pkg_add -n nginx	Trockenlauf, nichts wird installiert
pkg_add -u	Alle installierten Pakete auf den passenden Release-Stand bringen
pkg_add -u -v nginx	Nur ein Paket aktualisieren
pkg_add -Dsnap -u	Paketupdate gegen Snapshots (nur auf -current sinnvoll)
pkg_delete nginx	Paket entfernen
pkg_delete -a	Automatisch installierte, nicht mehr benötigte Abhängigkeiten löschen
pkg_delete -n -a	Vorher anzeigen, was `-a` aufräumen würde
pkg_info	Alle installierten Pakete mit Kurzbeschreibung
pkg_info -m	Nur bewusst installierte Pakete (ohne mitgezogene Abhängigkeiten)
pkg_info -Q postgres	Verfügbare Pakete im Repository suchen
pkg_info nginx	Details eines installierten Pakets
pkg_info -L nginx	Alle Dateien, die das Paket mitbringt
pkg_info -E /usr/local/bin/rsync	Welches Paket besitzt diese Datei?
pkg_info -R nginx	Wer hängt von diesem Paket ab
pkg_info -f nginx	Packing-List mit @-Kommandos (readme, rcscript …)
pkg_check	Installierte Pakete gegen die Datenbank prüfen (fehlende Dateien)
pkg_info -mz > /root/pkglist	Paketliste versionsneutral sichern
pkg_add -l /root/pkglist	Paketliste auf einem neuen System wieder einspielen

Patches, Firmware & Release-Upgrade

syspatch -c	Verfügbare, noch nicht installierte Patches auflisten (cron-taugllich)
syspatch -l	Bereits installierte Patches auflisten
syspatch	Alle fehlenden Binärpatches holen, prüfen und installieren
syspatch -r	Den zuletzt installierten Patch zurückrollen
syspatch -R	Alle Patches zurückrollen
ls /var/syspatch/	Rollback-Archive und signierte Diffs der Patches
fw_update	Fehlende Firmware für erkannte Geräte nachladen
fw_update -a	Firmware aller unterstützten Treiber installieren
fw_update -d intel	Firmware-Paket wieder entfernen
sysupgrade	Auf das nächste Release hochziehen – lädt, prüft und rebootet
sysupgrade -n	Nur herunterladen und `/bsd.upgrade` anlegen, kein Reboot
sysupgrade -s	Auf den aktuellen Snapshot (-current) wechseln
sysupgrade -R 7.9	Auf eine bestimmte Release-Version aktualisieren
sysupgrade -k	Heruntergeladene Sets in `/home/_sysupgrade` behalten
sysmerge	Nach dem Upgrade Konfigurationsdateien in `/etc` abgleichen
signify -Vp /etc/signify/openbsd-79-base.pub -x SHA256.sig -m /dev/null	Signatur einer Set-Liste manuell prüfen

Ports-Tree (nur wenn nötig)

cd /usr && cvs -qd anoncvs@anoncvs.fr.openbsd.org:/cvs checkout -rOPENBSD_7_9 -P ports	Ports-Tree passend zum Release auschecken
cd /usr/ports && cvs -q up -Pd -rOPENBSD_7_9	Vorhandenen Ports-Tree aktualisieren
cd /usr/ports/www/nginx && make install clean	Port bauen und installieren, Arbeitsverzeichnis aufräumen
make search key=nginx	Im Ports-Tree nach Stichwort suchen
make show=FLAVORS && make show=RUN_DEPENDS	Varianten und Laufzeitabhängigkeiten eines Ports anzeigen
make package && make deinstall	Eigenes Paket erzeugen / Port wieder entfernen
make clean=depends	Auch die Build-Verzeichnisse der Abhängigkeiten aufräumen

syspatch nur für -release: syspatch funktioniert ausschließlich auf offiziellen Releases. Auf -current/Snapshots ist der Weg sysupgrade -s gefolgt von pkg_add -u.

Pakete passen zum Release: Pakete werden pro Release gebaut. Nach sysupgrade immer pkg_add -u laufen lassen, sonst laufen Binaries gegen alte Bibliotheken. Umgekehrt niemals Pakete eines neueren Releases auf ein älteres System installieren.

# Release-Upgrade Schritt für Schritt
syspatch                      # erst auf den letzten Patchstand des alten Release
pkg_add -u
sysctl kern.version           # Ausgangsstand dokumentieren
pkg_info -mz > /root/pkglist  # Paketliste sichern
sysupgrade -n                 # laedt Sets, prueft Signatur, legt /bsd.upgrade an
reboot                        # Bootloader waehlt /bsd.upgrade, Upgrade laeuft unbeaufsichtigt
# ---- nach dem Reboot ----
sysmerge                      # /etc abgleichen
pkg_add -u                    # Pakete auf das neue Release ziehen
fw_update                     # Firmware nachziehen
syspatch                      # Patches des neuen Release
rcctl ls failed               # kaputte Dienste finden
dmesg | tail -40

💽Disks, Partitionen & Labels

sysctl hw.disknames	Alle Platten mit DUID, z. B. `sd0:2f4a1b…,cd0:`
dmesg \| grep -E '^(sd\|wd\|nvme)'	Erkannte Platten mit Größe, Modell und Anschluss
disklabel sd1	Label anzeigen: DUID, Geometrie, Partitionen a–p
disklabel -p g sd1	Größenangaben in Gigabyte statt Sektoren
disklabel -E sd1	Interaktiver Label-Editor (`p`, `a`, `d`, `m`, `w`, `q`)
disklabel -A sd1	Automatisch ein sinnvolles Standard-Layout berechnen
disklabel -r sd1	Label direkt vom Datenträger lesen, nicht aus dem Kernel
disklabel sd0 > /root/label.sd0	Label sichern – Pflicht vor jeder Partitionierung
disklabel -R sd1 /root/label.sd1	Gesichertes Label zurückschreiben
fdisk sd1	MBR/GPT-Partitionstabelle anzeigen
fdisk -e sd1	Interaktiver fdisk-Editor (`p`, `e`, `edit`, `w`, `q`)
fdisk -iy sd1	MBR neu initialisieren, ganze Platte als OpenBSD-Partition
fdisk -gy -b 960 sd1	GPT anlegen mit 960 Sektoren EFI-Systempartition (UEFI-Boot)
newfs /dev/rsd1a	FFS auf der Raw-Partition anlegen (immer `r`-Device nutzen!)
newfs -O 2 /dev/rsd1a	FFS2 erzwingen (nötig für Partitionen > 1 TB)
newfs -i 4096 /dev/rsd1a	Mehr Inodes (Bytes pro Inode senken) für viele kleine Dateien
growfs -y /dev/rsd1a	Filesystem auf die volle Partitionsgröße ausdehnen (nur ungemountet)
installboot -v sd1	Bootblocks auf eine neue Systemplatte schreiben
dd if=/dev/zero of=/dev/rsd1c bs=1m count=1	Erstes Megabyte löschen (alte Label-/RAID-Reste entfernen)
dd if=/dev/rsd0c of=/mnt/sd0.img bs=1m status=progress	Rohabbild der ganzen Platte ziehen
scan_ffs sd1	Verlorene FFS-Partitionen auf einer Platte suchen

Partitionsbuchstaben: a = Root bzw. erste Datenpartition, b = Swap, c = die ganze Platte (nie formatieren!), ab d freie Verwendung. Das Raw-Device /dev/rsd1a ist für newfs, fsck und dd zuständig, /dev/sd1a für mount.

DUIDs statt sdX: Die Nummerierung sd0, sd1 hängt an der Erkennungsreihenfolge und kann sich beim Umstecken oder nach einem Firmware-Update ändern. In /etc/fstab deshalb immer die DUID aus sysctl hw.disknames bzw. disklabel sd1 verwenden: 2f4a1b9c8d7e6f50.a /data ffs rw 1 2.

# Neue Platte einbinden - kompletter Ablauf
dmesg | tail                        # neue Platte finden -> sd2, 4T
fdisk -iy sd2                       # MBR neu, ganze Platte OpenBSD  (UEFI: fdisk -gy -b 960 sd2)
disklabel -E sd2
  > a a                             # Partition a anlegen
  offset: [64]                      # Vorschlag uebernehmen
  size:   [7814037104] *            # "*" = Rest der Platte
  FS type: [4.2BSD]
  > p g                             # kontrollieren
  > w
  > q
newfs -O 2 /dev/rsd2a               # FFS2 wegen Groesse > 1 TB
disklabel sd2 | grep duid           # DUID notieren
install -d /data
# /etc/fstab ergaenzen:
# 2f4a1b9c8d7e6f50.a /data ffs rw,nodev,nosuid,softdep 1 2
mount /data && df -h /data
disklabel sd2 > /root/label.sd2     # Label sichern

📁Filesysteme & Mounts

mount	Alle gemounteten Filesysteme mit Optionen
mount -a	Alle Einträge aus `/etc/fstab` mounten
mount /data	Einzelnen fstab-Eintrag mounten
mount /dev/sd1a /mnt	Device direkt mounten
mount -u -o ro /	Bereits gemountetes FS umschalten (`-u` = update)
mount -o rw,noatime,softdep,nodev,nosuid /data	Typische Optionen für Datenpartitionen
umount /data	Aushängen; `umount -f` erzwingt
fuser -c /data	Wer benutzt das Filesystem (PIDs)
fuser -ck /data	Alle Zugriffe beenden, dann aushängen
df -h	Belegung menschenlesbar
df -i /var	Inode-Auslastung (voll trotz freiem Platz?)
du -shx /var/*	Größen, ohne Mount-Grenzen zu überschreiten
du -sk /var/* \| sort -rn \| head -20	Die 20 größten Verzeichnisse
fsck -p	Preen-Modus: alle fstab-FS prüfen, nur harmlose Reparaturen
fsck_ffs -y /dev/rsd1a	Vollprüfung mit automatischem „yes“ (nur ungemountet!)
tunefs -p /dev/rsd1a	Aktuelle FS-Parameter anzeigen
tunefs -o space /dev/rsd1a	Optimierung auf Platz statt Geschwindigkeit
tunefs -m 5 /dev/rsd1a	Reservierten Anteil für root von 5 % setzen

mount_*-Helfer

mount_ffs /dev/sd1a /mnt	FFS/FFS2 – das Standard-Dateisystem
mount_mfs -s 1G swap /tmp	Speicherbasiertes FS (Memory File System) für `/tmp`
mount_nfs -o ro,intr srv:/export /mnt	NFS-Share einbinden
mount_cd9660 /dev/cd0c /mnt	CD/DVD bzw. gemountetes ISO
mount_msdos /dev/sd2i /mnt	FAT/FAT32-Datenträger (USB-Stick)
mount_ext2fs /dev/sd2d /mnt	ext2/ext3 lesen (kein ext4)
mount_udf /dev/cd0c /mnt	UDF-Medien
mount_ffs -o noperm /dev/sd2d /mnt	Rechte auf dem Fremd-FS ignorieren (Datenrettung)

Quotas

quotacheck -a	Quota-Datenbanken prüfen/erzeugen
quotaon -a / quotaoff -a	Quotas ein-/ausschalten (fstab-Option `userquota`)
edquota benutzer	Limits eines Users bearbeiten
repquota -a	Quota-Report über alle Filesysteme
quota -v benutzer	Aktuelle Nutzung und Limits anzeigen

Kein ZFS, kein LVM: OpenBSD hat weder ZFS noch einen Logical Volume Manager. Flexibilität entsteht über softraid (Concat/RAID) und sorgfältige Planung der Partitionsgrößen. Snapshots gibt es nicht – dafür dump/tar.

wxallowed: Manche Pakete (Chromium, Java, Mono) brauchen Speicherseiten, die gleichzeitig schreib- und ausführbar sind. Dann die Partition mit /usr/local in /etc/fstab um die Option wxallowed erweitern – und nur diese.

Volles Filesystem, du zeigt wenig? Meist hält ein Prozess eine gelöschte Datei offen. Mit fstat | grep /var den Prozess finden und neu starten.

🗃softraid, Verschlüsselung & vnd

bioctl softraid0	Alle softraid-Volumes des Controllers anzeigen
bioctl sd3	Status eines Volumes: Online / Degraded / Rebuild
bioctl -h -v sd3	Ausführlich mit lesbaren Größenangaben
bioctl -c 1 -l /dev/sd1a,/dev/sd2a softraid0	RAID 1 (Mirror) aus zwei Chunks anlegen
bioctl -c 0 -l /dev/sd1a,/dev/sd2a softraid0	RAID 0 (Striping)
bioctl -c 5 -l /dev/sd1a,/dev/sd2a,/dev/sd3a softraid0	RAID 5, mindestens drei Chunks
bioctl -c c -l /dev/sd1a,/dev/sd2a softraid0	CONCAT – Chunks aneinanderhängen
bioctl -c C -l /dev/sd1a softraid0	CRYPTO – verschlüsseltes Volume, genau ein Chunk
bioctl -c 1C -l /dev/sd1a,/dev/sd2a softraid0	RAID 1 + CRYPTO: gespiegelt und verschlüsselt
bioctl -C force -c 1 -l … softraid0	Anlegen erzwingen, wenn Metadatenreste stören
bioctl -C noauto -c 1 -l … softraid0	Volume beim Boot nicht automatisch zusammensetzen
bioctl -P sd3	Passphrase eines CRYPTO-Volumes ändern
bioctl -p /etc/sr.pass -c C -l /dev/sd1a softraid0	Passphrase aus Datei (muss root:0600 sein)
bioctl -k /dev/sd4a -c C -l /dev/sd1a softraid0	Keydisk statt Passphrase verwenden
bioctl -r auto -c C -l /dev/sd1a softraid0	KDF-Runden automatisch nach Systemleistung wählen
bioctl -O /dev/sd1a sd3	Chunk künstlich offline setzen (Ausfall simulieren/vorbereiten)
bioctl -R /dev/sd2a sd3	Rebuild mit neuem Chunk starten
bioctl -d sd3	Volume abkoppeln (vorher aushängen!)
bioctl -c C -l /dev/sd1a softraid0	Nach dem Boot dasselbe Kommando = Volume entsperren
bioctl -q sd0	Hersteller, Produkt, Revision und Seriennummer einer Platte
bioctl -v nvme0	Auch für Hardware-Controller nutzbar (Status, Enclosure)

vnd – Datei als Blockdevice

vnconfig vnd0 /home/images/disk.img	Image-Datei an ein vnd-Device binden
vnconfig -l	Alle vnd-Devices mit Zuordnung anzeigen
vnconfig -u vnd0	Bindung wieder auflösen
vnconfig -k vnd0 /home/crypt.img	Image verschlüsselt einbinden (fragt nach Passphrase)
mount /dev/vnd0a /mnt	Partition im Image mounten (nach `disklabel`/`newfs`)

Chunk-Vorbereitung: Jeder Chunk braucht eine Partition mit dem FS-Type RAID. Im disklabel -E-Editor bei der Frage nach dem FS-Typ also RAID eintragen – nicht 4.2BSD. Sonst wird das Volume nicht erkannt.

Passphrase-Volumes und Boot: Ein CRYPTO-Volume wird beim Boot nicht automatisch entsperrt. Filesysteme darauf gehören mit noauto in die /etc/fstab, sonst hängt der Bootvorgang im Fehler.

# softraid RAID1 (Mirror) aus zwei neuen Platten
dmesg | grep -E '^(sd|wd)'          # -> sd1 und sd2, gleich gross
for d in sd1 sd2; do
  dd if=/dev/zero of=/dev/r${d}c bs=1m count=1   # alte Metadaten loeschen
  fdisk -iy $d
done
disklabel -E sd1                    # Partition a ueber die ganze Platte,
  > a a                             #   FS type: RAID
  > w
  > q
disklabel -E sd2                    # identisch anlegen
bioctl -c 1 -l /dev/sd1a,/dev/sd2a softraid0
dmesg | tail -3                     # -> "sd3 at scsibus3 ... SR RAID 1"
dd if=/dev/zero of=/dev/rsd3c bs=1m count=1
fdisk -iy sd3
disklabel -E sd3                    # Partition a, FS type 4.2BSD
newfs /dev/rsd3a
bioctl sd3                          # Status: Online
disklabel sd3 | grep duid           # DUID fuer /etc/fstab
# Ausfalltest / Rebuild:
bioctl -O /dev/sd2a sd3             # Chunk offline -> Volume "Degraded"
bioctl -R /dev/sd2a sd3             # Rebuild starten
bioctl sd3                          # Fortschritt in Prozent beobachten

📈Swap

swapctl -l	Alle Swap-Devices mit Größe, Nutzung und Priorität
swapctl -lk	Ausgabe in Kilobyte (`-lm` Megabyte, `-lh` lesbar)
swapctl -s	Kurze Zusammenfassung: total / used / available
pstat -s	Alternative Swap-Übersicht aus dem Kernel
swapctl -a /dev/sd1b	Swap-Partition sofort aktivieren
swapctl -a -p 1 /dev/sd1b	Mit Priorität 1 aktivieren (höhere Zahl = später genutzt)
swapctl -d /dev/sd1b	Swap-Device deaktivieren (Inhalt wird zurückgelagert)
swapctl -A	Alle Swap-Einträge aus `/etc/fstab` aktivieren
/dev/sd0b none swap sw 0 0	Klassischer fstab-Eintrag für die Swap-Partition
2f4a1b9c8d7e6f50.b none swap sw 0 0	Dasselbe mit DUID – die empfohlene Schreibweise
sysctl vm.swapencrypt.enable	Swap-Verschlüsselung abfragen (1 = aktiv, Standard)
sysctl vm.swapencrypt.enable=1	Einschalten; dauerhaft in `/etc/sysctl.conf`
vmstat 1 \| awk '{print $3,$4}'	Spalten `pi`/`po` beobachten – echtes Paging?

Faustregel: Partition b der Systemplatte ist der Standard-Swap. Anhaltende Werte in pi/po bedeuten RAM-Mangel – mehr Swap verschiebt das Problem nur. Für einen Kernel-Crashdump muss der Swap mindestens so groß wie der physische Speicher sein.

Verschlüsselter Swap: ist auf OpenBSD standardmäßig aktiv – ausgelagerte Seiten landen niemals im Klartext auf der Platte. Nicht abschalten; der Performance-Verlust ist minimal.

🖥Prozesse, Jobs, cron & Limits

ps auxw	Alle Prozesse mit CPU-/Speicheranteil, breite Ausgabe
ps auxww	Kommandozeilen nicht abschneiden
ps -axl	Langformat mit PPID, Nice-Wert und Wait-Channel
ps -ax -O rss,vsz	Zusätzliche Spalten anhängen (`-O` statt `-o` behält Defaults)
ps -axo pid,ppid,user,pcpu,rss,command	Eigene Spaltenauswahl
ps -U www	Nur Prozesse eines Users
ps -axo pid,rss,command \| sort -k2 -rn \| head	Speicherhungrigste Prozesse
pgrep -lf nginx	PIDs samt Kommandozeile suchen
pkill -HUP -x syslogd	Signal an exakt passenden Prozessnamen senden
kill -TERM 1234 / kill -KILL 1234	Sauber beenden / hart abschießen
kill -l	Alle Signalnamen auflisten
nice -n 10 cmd	Mit niedrigerer Priorität starten
renice -n 5 -p 1234	Priorität nachträglich ändern
timeout 30 cmd	Kommando nach 30 s abbrechen (`-k 5` danach SIGKILL)
nohup cmd > /tmp/log 2>&1 &	Abgekoppelt im Hintergrund starten
jobs / fg %1 / bg %1	Shell-Jobverwaltung in der ksh
doas cmd	Kommando als root ausführen (OpenBSDs Ersatz für sudo)
doas -u _postgresql psql	Als anderer User ausführen
ktrace -f /tmp/tr -p 1234; kdump -f /tmp/tr	Syscalls eines hängenden Prozesses mitschneiden und lesen

Zeitsteuerung

crontab -l / -e	Eigene crontab anzeigen / bearbeiten
crontab -l -u www	crontab eines anderen Users lesen
ls /var/cron/tabs/	Speicherort der crontabs – ins Backup aufnehmen
~ 3 * * * /usr/local/bin/job	OpenBSD-Spezialität: `~` = zufällige Minute (verteilt Last)
-Q * * * * cmd	Kein Mail-Report, kein zweiter Lauf bei Überlappung
at 22:00	Einmaligen Job planen, mit Ctrl-D abschließen
atq / atrm 12	Geplante at-Jobs anzeigen / löschen
/etc/daily · /etc/weekly · /etc/monthly	Systempflege-Skripte – niemals editieren
/etc/daily.local	Eigene Ergänzungen zum täglichen Lauf
sh /etc/daily	Täglichen Lauf manuell anstoßen (Report per Mail an root)

Limits & login.conf

ulimit -a	Alle Limits der aktuellen Shell
ulimit -n / -d / -s	Offene Dateien / Datensegment / Stack
ulimit -n 1024	Soft-Limit erhöhen (bis zum Hard-Limit der Klasse)
/etc/login.conf	Login-Klassen mit `openfiles`, `datasize`, `maxproc`, `umask`
/etc/login.conf.d/	Klassendefinitionen von Paketen (z. B. Datenbanken)
cap_mkdb /etc/login.conf	Nach Änderung Datenbank neu bauen, falls `login.conf.db` existiert
usermod -L daemon benutzer	User einer anderen Login-Klasse zuweisen
sysctl kern.maxfiles kern.maxproc	Systemweite Obergrenzen abfragen
sysctl kern.maxfiles=16384	Sofort erhöhen; dauerhaft in `/etc/sysctl.conf`
sysctl kern.nfiles kern.nprocs	Aktuelle Nutzung gegen die Grenzen halten

cron-Falle: cron startet mit minimalem Environment und ohne .profile. Immer absolute Pfade verwenden und benötigte Variablen im Skript selbst setzen. PATH und MAILTO lassen sich oben in der crontab definieren.

Limits greifen beim Login: Änderungen an /etc/login.conf wirken erst bei einer neuen Session bzw. nach Neustart des Dienstes – ein rcctl restart des betroffenen Daemons ist Pflicht.

📊Performance & Monitoring

Schnellüberblick

top	Interaktiv; Tasten: `o`=Sortierung `u`=User `m`=Modus `?`=Hilfe
top -H	Threads statt Prozesse anzeigen
top -C	CPU-Werte pro Kern einzeln ausweisen
top -b -d 1	Batch-Modus, ein Durchlauf – für Skripte und Logs
top -U www	Nur Prozesse eines Users
uptime; w	Load Average (1/5/15 min) und aktive Sitzungen

systat – die Schaltzentrale

systat	Startet mit der Ansicht `vmstat`; `Tab`/`n` wechselt Ansichten
systat vmstat	Gesamtüberblick CPU, Speicher, Interrupts, Disks
systat iostat	Durchsatz und Transfers pro Platte
systat ifstat	Durchsatz pro Netzwerk-Interface
systat netstat	Offene Verbindungen live
systat pf	pf-Statistik: States, Suchen, Matches, Drops
systat queues	Auslastung der pf-Queues (Traffic-Shaping)
systat states	Einzelne pf-States mit Rate und Alter
systat rules	Trefferzähler je pf-Regel – findet toten Regelcode
systat mbufs	mbuf-Cluster pro Interface (Netzwerkspeicher)
systat sensors	Temperatur- und Hardware-Sensoren live
systat pigs	Die größten CPU-Verbraucher
systat uvm / pool / malloc	Interna des virtuellen Speichers und der Kernel-Pools
systat -s 2 vmstat	Aktualisierungsintervall auf 2 Sekunden setzen

Messwerkzeuge

vmstat 1	Sekundenwerte: procs, memory, page, disks, faults, cpu
vmstat 2 10	Zehn Messungen im 2-Sekunden-Takt
vmstat -s	Kumulierte Zähler seit dem Boot
vmstat -i	Interrupts pro Gerät – findet störende Hardware
vmstat -m	Kernel-Speicherpools und ihre Auslastung
iostat 1	Disk-Statistik: tps, KB/t, MB/s je Platte
iostat -C 1	Zusätzlich CPU-Zeilen ausgeben
iostat -d 2 5	Nur Disk-Werte, fünf Messungen
fstat	Alle offenen Dateien systemweit
fstat -p 1234 / fstat -u www	Offene Dateien eines Prozesses / Users
fstat /var/log/messages	Wer hält diese Datei offen?
netstat -m	mbuf-Nutzung; „requests for memory denied“ muss 0 sein
netstat -s \| less	Protokollstatistiken (Retransmits, Checksum-Fehler)
netstat -bi	Bytes und Fehler pro Interface
sysctl kern.timecounter	Aktive Zeitquelle und Auswahl (`hardware`, `choice`)
sysctl hw.sensors	Temperaturen und Lüfter; `rcctl enable sensorsd` für Alarme
pstat -t	Terminal-Statistik (hängende Sessions)

Vorgehen bei „Server ist langsam“: 1. systat vmstat – wo geht die Zeit hin (user/sys/interrupt/idle)? 2. top -C – einzelner Kern am Anschlag? 3. systat iostat – wartet das System auf Platten? 4. vmstat 1 – Spalten pi/po prüfen. 5. systat pf – State-Tabelle voll?

Load Average täuscht: Auf OpenBSD zählen auch auf I/O wartende Prozesse in die Load. Ein Load von 4 bei 4 % CPU-Nutzung bedeutet meist ein Platten- oder Netzwerkproblem, keinen Rechenengpass.

🌐Netzwerk & Interfaces

Interfaces

ifconfig	Alle aktiven Interfaces mit Adressen und Status
ifconfig -A	Auch Interfaces ohne Adresse anzeigen
ifconfig em0	Einzelnes Interface: MAC, Media, Gruppen, Adressen
ifconfig -a inet	Nur IPv4-Adressen
ifconfig em0 inet 10.0.0.10/24 up	Adresse temporär setzen (nach Reboot weg)
ifconfig em0 inet alias 10.0.0.11/32	Zweite Adresse auf dasselbe Interface legen
ifconfig em0 inet 10.0.0.11 delete	Adresse entfernen
ifconfig em0 up / down	Interface ein-/ausschalten
ifconfig em0 media / ifconfig em0 mediaopt	Verfügbare Medientypen und Optionen anzeigen
ifconfig em0 media 1000baseT mediaopt full-duplex	Geschwindigkeit fest setzen (Autoneg abschalten)
ifconfig em0 mtu 9000	Jumbo Frames – Switch und Gegenstelle müssen mitspielen
ifconfig em0 descr "Uplink DMZ"	Beschreibung setzen – erscheint in `ifconfig`
ifconfig em0 group internal	Interface einer Gruppe zuordnen (in pf als `on internal` nutzbar)
ifconfig egress	Automatische Gruppe: das Interface mit der Default-Route
sh /etc/netstart em0	Ein Interface aus `/etc/hostname.em0` neu konfigurieren
sh /etc/netstart	Komplette Netzwerkkonfiguration neu einlesen

Dauerhafte Konfiguration

/etc/hostname.em0	Konfiguration je Interface, eine Anweisung pro Zeile
inet 10.0.0.10 255.255.255.0	Statische IPv4-Adresse (auch `inet 10.0.0.10/24` möglich)
dhcp	Adresse per DHCP holen (`dhcpleased` übernimmt)
inet6 autoconf	IPv6 per SLAAC (`slaacd` übernimmt)
/etc/myname	Hostname des Systems (FQDN, eine Zeile)
/etc/mygate	Default-Gateway, je eine Zeile für IPv4 und IPv6
/etc/resolv.conf	Nameserver; wird von `resolvd` gepflegt
rcctl enable unwind	Lokaler validierender DNS-Resolver mit DNSSEC
rcctl enable dhcpleased slaacd	DHCP- und SLAAC-Clients aktivieren
/etc/hosts	Statische Namensauflösung

Routing & Diagnose

route -n show	Routing-Tabelle numerisch
route -n show -inet	Nur IPv4-Routen
route -n get 8.8.8.8	Welche Route würde greifen?
route add default 10.0.0.1	Default-Route setzen (temporär)
route delete default	Default-Route entfernen
route add -net 192.168.5.0/24 10.0.0.254	Statische Netzroute
route -T 1 exec cmd	Kommando in einer anderen Routing-Tabelle ausführen
netstat -rn	Routing-Tabelle mit Flags und Interface
netstat -an	Alle Sockets, numerisch
netstat -na -f inet -p tcp	Nur TCP/IPv4 – welche Ports lauschen?
netstat -in	Interface-Übersicht mit Paketzählern
arp -a / arp -d 10.0.0.5	ARP-Cache anzeigen / Eintrag löschen
ndp -a	IPv6-Neighbor-Cache
ping -c 3 10.0.0.1	Drei Pakete senden (ohne `-c` läuft es endlos)
ping6 -c 3 fe80::1%em0	Link-lokale IPv6-Adresse mit Interface-Scope testen
traceroute -n host / traceroute6 -n host	Pfad verfolgen
ftp -o /tmp/f https://example.com/file	Download mit dem Basis-Werkzeug (kein curl nötig)
nc -z -v host 22	Port-Test ohne Datenverkehr
tcpdump -n -i em0	Mitlesen ohne Namensauflösung
tcpdump -nvvi em0 port 53	Sehr ausführlich, gefiltert auf DNS
tcpdump -n -w /tmp/dump.pcap -i em0 host 10.0.0.5	Mitschnitt in Datei (später mit `-r` lesen)

Virtuelle Interfaces

ifconfig vlan10 parent em0 vnetid 10 inet 10.10.0.1/24 up	VLAN-Interface anlegen (dauerhaft: `/etc/hostname.vlan10`)
ifconfig trunk0 trunkproto lacp trunkport em0 trunkport em1 up	Link Aggregation mit LACP
ifconfig trunk0 trunkproto failover trunkport em0 trunkport em1	Aktiv/Passiv-Bündel ohne Switch-Konfiguration
ifconfig carp0 vhid 1 carpdev em0 pass geheim 10.0.0.1/24 up	Redundante virtuelle IP (Failover-Cluster)
ifconfig carp0 advskew 100	Backup-Knoten kennzeichnen (höherer Wert = niedrigere Priorität)
ifconfig bridge0 add em1 add em2 up	Layer-2-Bridge zwischen zwei Interfaces
ifconfig bridge0 addr	Gelernte MAC-Adressen der Bridge
ifconfig vether0 / ifconfig tap0	Virtuelle Interfaces für Bridges bzw. VMs
sysctl net.inet.ip.forwarding=1	IPv4-Routing einschalten (dauerhaft in `/etc/sysctl.conf`)
sysctl net.inet6.ip6.forwarding=1	Dasselbe für IPv6

hostname.if-Syntax: Jede Zeile ist das, was hinter ifconfig em0 stehen würde. Typische Dateien: inet 10.0.0.10 255.255.255.0 für statisch, nur das Wort dhcp für DHCP, inet6 autoconf für IPv6. Kommentare mit #, mehrere Zeilen werden der Reihe nach abgearbeitet. Zum Testen sh /etc/netstart em0 – kein Reboot nötig.

Kein ip-Kommando: OpenBSD hat kein ip addr, kein nmcli und kein NetworkManager. Alles läuft über ifconfig, route und die /etc/hostname.if-Dateien.

resolv.conf wird überschrieben: resolvd pflegt /etc/resolv.conf aus den Daten von dhcpleased, slaacd und unwind. Feste Nameserver deshalb per nameserver-Zeile setzen und beachten, dass unwind sich als 127.0.0.1 davorschiebt.

🔥pf – Packet Filter

Regelwerk laden & prüfen

pfctl -nf /etc/pf.conf	Nur prüfen (parse), nichts laden – immer zuerst!
pfctl -vnf /etc/pf.conf	Prüfen und die expandierten Regeln anzeigen
pfctl -f /etc/pf.conf	Regelwerk laden (States bleiben erhalten)
pfctl -e / pfctl -d	pf einschalten / ausschalten
rcctl enable pf	pf beim Boot aktivieren (Service ohne Prozess)
pfctl -si	Statuszeile, Zähler, State-Tabelle, Counters
pfctl -sr	Geladene Filterregeln
pfctl -vvsr	Regeln mit Regelnummer, Paket- und Byte-Zählern
pfctl -sn	Geladene NAT-/Translation-Regeln
pfctl -ss	Aktuelle State-Tabelle
pfctl -ss \| wc -l	Anzahl States – gegen `set limit states` halten
pfctl -sq	Queues (Traffic-Shaping) anzeigen
pfctl -sm	Limits für States, Tabellen, Fragmente
pfctl -sT	Alle definierten Tabellen auflisten
pfctl -sI	Interfaces, die pf kennt
pfctl -sA	Vorhandene Anchors
pfctl -sa	Alles auf einmal – gute Change-Dokumentation
pfctl -a relayd/* -sr	Regeln in einem Anchor ansehen (hier: relayd)

Eingreifen im Betrieb

pfctl -k 10.0.0.5	Alle States mit dieser Adresse löschen (Verbindung kappen)
pfctl -k 10.0.0.5 -k 10.0.0.9	States eines bestimmten Adresspaares löschen
pfctl -F states	Komplette State-Tabelle leeren
pfctl -F rules	Filterregeln entfernen (Achtung: dann gilt `pass all`)
pfctl -F all	Alles zurücksetzen – nur bewusst und lokal!
pfctl -t bruteforce -T show	Inhalt einer Tabelle anzeigen
pfctl -t bruteforce -T add 10.0.0.5	Adresse zur Tabelle hinzufügen (sofort wirksam)
pfctl -t bruteforce -T delete 10.0.0.5	Adresse aus der Tabelle entfernen
pfctl -t bruteforce -T flush	Tabelle leeren
pfctl -t bruteforce -T test 10.0.0.5	Prüfen, ob eine Adresse enthalten ist
pfctl -t bruteforce -T expire 86400	Einträge älter als 24 h entfernen (typisch per cron)
pfctl -t bruteforce -T replace -f /etc/blocklist	Tabelle komplett aus Datei ersetzen
pfctl -t bruteforce -T zero	Zähler der Tabelleneinträge zurücksetzen
pfctl -x loud	Debug-Stufe erhöhen (`none`, `urgent`, `misc`, `loud`)
pfctl -z	Alle Regelzähler auf Null – vor einem Testlauf

Protokollierung

tcpdump -n -e -ttt -i pflog0	Live-Blick auf alle geloggten pf-Entscheidungen
tcpdump -n -e -ttt -i pflog0 port 22	Gefiltert auf einen Dienst
tcpdump -n -e -r /var/log/pflog	Gespeicherte pf-Logs auswerten
tcpdump -n -e -r /var/log/pflog action drop	Nur Blocks aus dem Log herausfiltern
block log (all) …	In der Regel `log` setzen; `(all)` loggt jedes Paket, nicht nur das erste
set loginterface egress	Interface, für das pf Byte-Statistiken führt

Reihenfolge ist Pflicht: Erst pfctl -nf /etc/pf.conf, dann pfctl -f /etc/pf.conf. Ein Syntaxfehler beim direkten Laden lässt pf im alten Zustand – ein logischer Fehler sperrt dich dagegen sofort aus der SSH-Sitzung aus. Bei Remote-Arbeit vorher eine Rückfalloption einplanen (siehe Workflow).

Letzte passende Regel gewinnt – außer bei quick. Regeln werden von oben nach unten ausgewertet, das letzte Match entscheidet. match-Regeln setzen Eigenschaften (nat-to, scrub, queue), ohne die Pass/Block-Entscheidung zu treffen.

# /etc/pf.conf - schlanke Server-Grundkonfiguration
ext_if = "em0"
table <bruteforce> persist
table <admins> const { 10.0.0.0/24 }

set skip on lo
set block-policy drop
set loginterface egress
match in all scrub (no-df random-id max-mss 1440)

block log all                                  # Default-Deny
block quick log from <bruteforce>
pass out quick inet keep state                 # ausgehend erlauben

pass in on egress proto tcp from <admins> to (egress) port 22 \
     keep state (max-src-conn 5, max-src-conn-rate 5/30, \
                 overload <bruteforce> flush global)
pass in on egress proto tcp to (egress) port { 80 443 }
pass in on egress inet proto icmp icmp-type echoreq

antispoof quick for { lo $ext_if }

# pf-Regelwerk sicher testen und laden (auch remote)
cp /etc/pf.conf /etc/pf.conf.bak            # Rueckfall sichern
pfctl -nf /etc/pf.conf                      # Syntax pruefen -> muss still bleiben
pfctl -vnf /etc/pf.conf | less              # expandierte Regeln lesen
# Notbremse fuer Remote-Arbeit: in 3 Minuten automatisch zurueck
( sleep 180 && pfctl -f /etc/pf.conf.bak ) &
pfctl -f /etc/pf.conf                       # neues Regelwerk laden
pfctl -si                                   # Status: Enabled?
pfctl -vvsr | head -40                      # greifen die Regeln?
tcpdump -n -e -ttt -i pflog0                # blockt etwas Unerwartetes?
pkill -f "sleep 180"                        # alles gut -> Notbremse loesen
pfctl -t bruteforce -T show                 # Blockliste kontrollieren

🔌Basisdienste im Überblick

OpenSSH

/etc/ssh/sshd_config	Serverkonfiguration; `ssh_config` ist die Client-Seite
sshd -t	Konfiguration prüfen – vor jedem `reload`
sshd -T \| grep -i permitroot	Effektive Konfiguration inkl. aller Defaults ausgeben
rcctl reload sshd	Neu einlesen, bestehende Sitzungen bleiben
ssh-keygen -t ed25519 -C "rene@logicalis"	Modernen Schlüssel erzeugen
ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub	Fingerprint eines Hostkeys anzeigen
ssh-copy-id -i ~/.ssh/id_ed25519.pub host	Öffentlichen Schlüssel verteilen
ssh-keyscan -t ed25519 host	Hostkey für `known_hosts` abholen

Zeit: ntpd

/etc/ntpd.conf	`servers`, `sensor *`, `constraints from …`
ntpd -n	Konfiguration prüfen
ntpctl -s all	Peers, Sensoren und Synchronisationsstatus
ntpctl -s status	Nur die Kurzfassung (Offset, Stratum)
rcctl set ntpd flags -s	Beim Start einmal die Zeit sofort setzen

Logging: syslogd & newsyslog

/etc/syslog.conf	Regeln `facility.level Ziel` (Tabulator als Trenner!)
*.notice;auth,authpriv.none /var/log/messages	Beispielzeile aus der Standardkonfiguration
. @loghost.example.com	Alles zusätzlich an einen zentralen Logserver senden
rcctl set syslogd flags -u	Logs anderer Hosts per UDP annehmen (unsicher, nur intern)
rcctl reload syslogd	Konfiguration neu einlesen
logger -t backup -p daemon.info "Lauf beendet"	Eigene Meldung ins Syslog schreiben
/etc/newsyslog.conf	Rotation: Datei, Rechte, Anzahl, Größe, Intervall, Signal
newsyslog -n	Trockenlauf – zeigt, was rotiert würde
newsyslog -F	Rotation erzwingen, unabhängig von Größe und Zeit

Web & Loadbalancing

/etc/httpd.conf	Konfiguration von `httpd(8)`, Root ist `/var/www`
httpd -n	Konfiguration prüfen
rcctl enable httpd && rcctl start httpd	Aktivieren und starten
acme-client -v example.com	Let's-Encrypt-Zertifikat holen (`/etc/acme-client.conf`)
/etc/relayd.conf	Reverse-Proxy und Loadbalancer
relayd -n	Konfiguration prüfen
relayctl show summary	Status aller Relays, Tables und Hosts
relayctl host disable 10.0.0.5	Backend aus dem Pool nehmen (Wartung)

DNS: unbound & nsd

/var/unbound/etc/unbound.conf	Konfiguration des Resolvers (läuft im chroot)
unbound-checkconf	Konfiguration prüfen
unbound-control status / stats_noreset	Status und Statistiken (vorher `unbound-control-setup`)
unbound-control reload / flush example.com	Neu laden / Cache-Eintrag verwerfen
/var/nsd/etc/nsd.conf	Autoritativer Nameserver, Zonen unter `/var/nsd/zones`
nsd-checkconf /var/nsd/etc/nsd.conf	Konfiguration prüfen
nsd-checkzone example.com /var/nsd/zones/master/example.com	Zonendatei prüfen
nsd-control reload / notify	Zonen neu laden / Slaves benachrichtigen

Mail & DHCP

/etc/mail/smtpd.conf	Konfiguration von `smtpd(8)`
smtpd -n	Konfiguration prüfen
smtpctl show queue	Warteschlange anzeigen
smtpctl schedule all	Alle wartenden Mails sofort erneut ausliefern
smtpctl show stats	Statistiken des Mailservers
/etc/mail/aliases && newaliases	Aliase pflegen und Datenbank neu bauen (root-Mails umleiten!)
/etc/dhcpd.conf	DHCP-Server-Konfiguration
dhcpd -n	Konfiguration prüfen
rcctl set dhcpd flags em1	Interface festlegen, auf dem dhcpd lauscht
cat /var/db/dhcpd.leases	Vergebene Leases nachsehen

Muster für alle Basisdienste: Konfiguration liegt flach in /etc, jeder Daemon hat einen Syntaxtest (-n bzw. -t), läuft unter eigenem _dienst-User im chroot und wird ausschließlich mit rcctl verwaltet. Reihenfolge immer: Syntaxtest → reload → Log prüfen.

root-Mail lesen: /etc/daily, syspatch und die Security-Reports schreiben an root. Ohne einen Alias in /etc/mail/aliases auf eine echte Adresse gehen diese Hinweise unter.

👥User, Gruppen & doas

adduser	Interaktiv anlegen – fragt Klasse, Gruppen, Shell, Passwort ab
adduser -batch rene wheel "Rene Pfeifer" geheim	Nicht-interaktiv (für Skripte)
useradd -m -s /bin/ksh -G wheel rene	Anlegen mit Homedir aus `/etc/skel`
useradd -D	Aktuelle Vorgaben für neue User anzeigen
usermod -G wheel,operator rene	Sekundäre Gruppen setzen (ersetzt die bisherige Liste!)
usermod -s /bin/sh rene	Shell ändern
usermod -L daemon rene	Login-Klasse aus `/etc/login.conf` zuweisen
usermod -l rpfeifer rene	Benutzer umbenennen
userdel rene	User entfernen, Home bleibt stehen
userdel -r rene	User samt Homedirectory entfernen
vipw	`/etc/master.passwd` sicher bearbeiten (baut die DB neu)
pwd_mkdb -p /etc/master.passwd	Passwort-Datenbanken manuell neu erzeugen
chpass rene	Einzelnen Datensatz im Editor ändern (Shell, Gecos, Ablauf)
passwd rene	Passwort setzen (bcrypt gemäß login.conf)
groupadd projekt	Gruppe anlegen (`-g` für feste GID)
groupmod -n neu alt	Gruppe umbenennen
groupdel projekt	Gruppe löschen
/etc/group	Gruppenmitgliedschaften; `wheel` darf `su` zu root
id rene / groups rene	UID, GID und alle Gruppen eines Users
w / who / users	Wer ist angemeldet, seit wann, von wo
last / last rene	Login-Historie aus `/var/log/wtmp`
lastcomm	Ausgeführte Kommandos (nur bei aktivem Accounting)
su -l	Zu root wechseln mit dessen Environment (nur `wheel`)
grep sshd /var/log/authlog \| tail -30	Fehlgeschlagene Anmeldungen prüfen

doas – Rechteerweiterung

/etc/doas.conf	Regelwerk; existiert nach der Installation nicht und muss angelegt werden
doas -C /etc/doas.conf	Konfiguration auf Syntaxfehler prüfen
doas -C /etc/doas.conf pfctl -si	Prüfen, ob ein bestimmtes Kommando erlaubt wäre
doas -L	Gemerkte Authentifizierung (persist) sofort verwerfen
doas -u _postgresql psql	Als anderer Benutzer statt root ausführen
doas -s	Root-Shell starten
permit persist keepenv :wheel	Typische Regel: Gruppe wheel, Passwort wird für 5 min gemerkt
permit nopass rene cmd /sbin/pfctl args -si	Genau ein Kommando ohne Passwort erlauben
deny rene cmd /bin/sh	Explizit verbieten (letzte passende Regel gewinnt)

doas.conf fehlt = kein doas: Ohne /etc/doas.conf funktioniert doas gar nicht. Datei anlegen, chown root:wheel, chmod 0600 und mit doas -C prüfen – bevor man sich per sshd_config den direkten Root-Login abschneidet.

Kein sudo im Basissystem: sudo ist nur ein Paket. Standard ist doas – deutlich kleiner, mit einer Konfigurationsdatei von wenigen Zeilen. In Skripten doas -n nutzen, damit kein Passwortprompt blockiert.

🔒Security-Härtung

Securelevel & unveränderliche Dateien

sysctl kern.securelevel	Aktuelle Stufe: -1 permissiv, 0 unsicher, 1 sicher (Standard), 2 hochsicher
sysctl kern.securelevel=2	Anheben – nur nach oben möglich, Absenken nur per Reboot
/etc/rc.securelevel	Kommandos, die noch bei Level 0 laufen müssen
chflags schg /usr/local/bin/wichtig	System-Immutable-Flag setzen (Datei nicht mehr änderbar)
chflags noschg datei	Flag entfernen – nur bei Securelevel 0 möglich
chflags -R schg /bin /sbin	Ganze Verzeichnisbäume schreibgeschützt machen
ls -lo /bin/ls	Gesetzte Flags anzeigen (`schg`, `uchg`, `uappnd`)
sysctl kern.allowkmem	Zugriff auf `/dev/mem` (sollte 0 sein)
sysctl ddb.console=0	Kernel-Debugger über die Konsole sperren
sysctl ddb.panic=0	Bei Panic nicht in den Debugger, sondern Dump und Reboot
/etc/sysctl.conf	Alle Härtungs-sysctls dauerhaft ablegen

Integrität & Reports

signify -Vp /etc/signify/openbsd-79-base.pub -x SHA256.sig -m -	Signatur der offiziellen Sets prüfen
signify -C -p /etc/signify/openbsd-79-base.pub -x SHA256.sig	Checksummenliste prüfen und Dateien vergleichen
ls /etc/signify/	Mitgelieferte Public Keys für Basis und Pakete
sh /etc/security	Sicherheits-Check manuell starten (läuft täglich automatisch)
ls /etc/mtree/	Referenz-Hierarchien für Rechte und Besitzer
mtree -f /etc/mtree/special -p / \| less	Abweichungen bei Rechten sicherheitsrelevanter Pfade finden
grep -A20 "insecurity" /var/log/messages	Auffälligkeiten aus dem Security-Report nachlesen
find / -xdev -type f -perm -4000 -ls	Alle setuid-Dateien auflisten und mit dem Report vergleichen
find / -xdev -nouser -o -nogroup	Dateien ohne gültigen Besitzer (Reste alter User)

Angriffsfläche verkleinern

rcctl ls on	Bestandsaufnahme: welche Dienste laufen wirklich?
rcctl disable dienst	Alles Unnötige abschalten – der wirksamste Einzelschritt
netstat -na -f inet -p tcp \| grep LISTEN	Offene Ports prüfen und gegen die Dienstliste halten
PermitRootLogin no	In `sshd_config`: kein direkter Root-Login
PasswordAuthentication no	Nur Schlüssel zulassen (vorher Key testen!)
AllowGroups wheel sshusers	SSH auf bestimmte Gruppen begrenzen
block log all	pf-Grundsatz: Default-Deny, danach gezielt öffnen
umask 077 in /etc/login.conf	Restriktive Standardrechte je Login-Klasse
nodev,nosuid für Datenpartitionen	fstab-Optionen: keine Devices, keine setuid-Binäries

pledge & unveil: Nahezu alle Basisdienste schränken sich selbst ein: pledge(2) begrenzt die erlaubten Syscalls, unveil(2) den sichtbaren Dateisystemausschnitt. Als Admin muss man nichts konfigurieren – aber wissen, dass ein Dienst nach einem Konfigurationsfehler mit „Abort trap“ endet, wenn er auf einen Pfad zugreift, den er sich selbst verboten hat. Dann Log lesen, nicht Rechte aufweiten.

chflags braucht Securelevel: Das schg-Flag wirkt erst ab Securelevel 1 – also im Normalbetrieb. Es lässt sich nur im Single-User-Mode (Securelevel 0) wieder entfernen. Vorsicht bei Dateien, die syspatch oder sysupgrade ersetzen wollen: das Update scheitert sonst.

Securelevel 2: Zusätzlich zu Level 1 sind Rohzugriffe auf gemountete Platten und Änderungen an der pf-Konfiguration und der Systemzeit gesperrt. Sehr wirksam für Firewalls – aber jede Regeländerung erfordert dann einen Reboot. Vorher testen, ob alle Dienste damit zurechtkommen.

📜Logs & Fehlersuche

dmesg \| tail -40	Neueste Kernel-Meldungen (Hardware, Treiber, Fehler)
cat /var/run/dmesg.boot	Vollständige Boot-Ausgabe
tail -f /var/log/messages	Allgemeines Systemlog live mitlesen
tail -f /var/log/authlog	Anmeldungen, `doas`, `su`, sshd
tail -f /var/log/daemon	Meldungen der Daemons (httpd, unbound, ntpd …)
/var/log/secure	Sicherheitsrelevante Meldungen (auth.info und höher)
/var/log/maillog	smtpd-Protokoll
/var/log/xferlog	FTP-Übertragungen
/var/log/pflog	Binäres pf-Log, nur mit `tcpdump -r` lesbar
/var/log/wtmp, /var/log/lastlog	Login-Historie für `last` bzw. `lastlogin`
zgrep -i error /var/log/messages.*.gz	Auch in rotierten Logs suchen
grep -i 'panic\\|error\\|fail' /var/log/messages \| tail -40	Schnellsuche nach harten Fehlern
newsyslog -n / newsyslog -F	Rotation testen / erzwingen
ls -lt /var/log \| head	Welche Logs sind aktiv, welche stehen still?

Tiefergehende Analyse

fstat \| grep /var	Wer hält Dateien in einem Filesystem offen?
fstat -p 1234	Alle File Descriptors eines Prozesses
ktrace -f /tmp/tr -p 1234; sleep 5; ktrace -C	Syscalls kurz mitschneiden, Tracing global beenden
kdump -f /tmp/tr \| less	Mitschnitt lesbar aufbereiten
ktrace -di -f /tmp/tr cmd	Kommando samt Kindprozessen von Anfang an tracen
ps -axl \| awk '$3 ~ /D/'	Prozesse im ununterbrechbaren I/O-Wait finden
tcpdump -n -e -ttt -i pflog0	Blockt die Firewall den Dienst?
pfctl -si	pf-Zähler: State-Limit erreicht? Fragmente verworfen?
savecore /var/crash	Crashdump aus dem Swap in Dateien ausschreiben
ls -l /var/crash/	Vorhandene Dumps (`bsd.0.gz`, `bsd.0.core`)
sysctl ddb.trigger=1	Bewusst in den Kernel-Debugger springen (nur bei Analyse!)
trace / ps / show panic (in ddb)	Stack, Prozessliste und Panic-Ursache im Debugger
boot dump (in ddb)	Dump schreiben und neu starten

Crashdumps vorbereiten: Ein Dump braucht eine Swap-Partition, die mindestens so groß wie der physische Speicher ist, sowie /var/crash mit genug Platz. Danach sysctl ddb.panic=0, damit das System nach der Panic automatisch dumpt und rebootet statt am Debugger-Prompt zu warten.

Manpages sind die Referenz: OpenBSDs Handbuchseiten sind Teil des Systems und immer zur installierten Version passend. Vor jeder Websuche erst man 8 dienst, man 5 datei und apropos begriff – die Trefferquote ist höher als bei jedem Blogartikel. Einstieg für neue Systeme: man afterboot.

💾Backup, Migration & Installation

dump / restore – das FFS-Werkzeug

dump -0uaf /mnt/home.dump /home	Vollbackup (Level 0), Datum in `/etc/dumpdates` vermerken
dump -1uaf /mnt/home.d1 /home	Inkrementell: alles seit dem letzten niedrigeren Level
dump -0af - /home \| gzip > /mnt/home.dump.gz	Auf stdout dumpen und komprimieren
dump -0af - /home \| ssh backup dd of=/srv/home.dump	Direkt auf einen anderen Host schreiben
dump -W	Welche Filesysteme sind laut `/etc/dumpdates` fällig?
restore -tf /mnt/home.dump	Inhaltsverzeichnis des Archivs anzeigen
restore -if /mnt/home.dump	Interaktiv einzelne Dateien auswählen (`add`, `extract`)
restore -rf /mnt/home.dump	Komplettes Filesystem in ein leeres FS zurückschreiben
restore -xf /mnt/home.dump ./pfad	Gezielt einen Pfad wiederherstellen

Weitere Wege

tar -czf /mnt/etc.tgz /etc	Klassisches Archiv mit gzip
tar -xzpf /mnt/etc.tgz -C /	Zurückspielen, Rechte erhalten
tar -cf - /etc \| ssh host 'cat > /srv/etc.tar'	Über SSH streamen
pax -rw -pe /home /mnt/home	Verzeichnis kopieren, alle Attribute erhalten
cpdup / rsync -aH --delete src/ dst/	Spiegel-Kopien (rsync ist ein Paket, nicht Basis)
cp -Rp /etc /mnt/etc-backup	Schnelle lokale Kopie mit Rechten
dd if=/dev/rsd0c of=/mnt/sd0.img bs=1m	Rohabbild der Systemplatte (System vorher stoppen!)
disklabel sd0 > /root/label.sd0; fdisk sd0 > /root/fdisk.sd0	Partitionierung dokumentieren – klein, aber unverzichtbar
pkg_info -mz > /root/pkglist	Installierte Pakete versionsneutral sichern
tar -czf /root/etc-$(date +%F).tgz /etc /var/cron /var/www	Minimales Konfigurations-Backup für Wiederaufbau

/altroot & unbeaufsichtigte Installation

ROOTBACKUP=1 in /etc/daily.local	Tägliche Sicherung der Root-Partition nach `/altroot` aktivieren
/dev/sd0j /altroot ffs xx 0 0	Passender fstab-Eintrag: Mountoption `xx`, Verzeichnis muss existieren
/etc/changelist	Dateien, deren Änderungen der tägliche Report melden soll
/etc/daily.local /etc/weekly.local /etc/monthly.local	Eigene Wartungsaufgaben einhängen
/install.site	Skript, das am Ende einer Neuinstallation im Ziel-Root läuft
/upgrade.site	Dasselbe für Upgrades (auch bei `sysupgrade`)
/auto_install.conf	Antwortdatei für unbeaufsichtigte Installation (autoinstall)
/auto_upgrade.conf	Antwortdatei für unbeaufsichtigtes Upgrade
boot bsd.rd -> "A" (autoinstall)	Installer holt die Antwortdatei per DHCP/HTTP vom Server

Wiederaufbau in 20 Minuten: OpenBSD-Systeme lassen sich fast immer schneller neu installieren als reparieren. Wer /etc, /var/cron, die Labels, pkglist und die Daten hat, ist nach Neuinstallation, pkg_add -l und dem Zurückspielen von /etc wieder produktiv.

dump und laufende Systeme: dump auf ein gemountetes, aktiv beschriebenes Filesystem kann inkonsistente Archive liefern. Sauber ist ein Lauf im Single-User-Mode oder auf ein read-only gemountetes FS. Da OpenBSD keine Snapshots kennt, ist das die einzige echte Absicherung.

🧩Virtualisierung mit vmm/vmd

dmesg \| grep vmm	Voraussetzung prüfen: `vmm0 at mainbus0` muss erscheinen
rcctl enable vmd && rcctl start vmd	Hypervisor-Daemon aktivieren und starten
/etc/vm.conf	Deklarative VM- und Switch-Definitionen
vmd -n	Konfiguration prüfen
vmctl status	Alle VMs mit ID, Speicher, Zustand und Besitzer
vmctl create -s 20G /home/vm/web.qcow2	Neues Disk-Image anlegen (qcow2 oder raw)
vmctl start web -m 2G -d /home/vm/web.qcow2 -i 1 -c	VM starten und direkt auf die Konsole verbinden
vmctl start web -b /bsd.rd -d /home/vm/web.qcow2 -c	Von `bsd.rd` booten, um das Gastsystem zu installieren
vmctl console web	An die serielle Konsole andocken (Verlassen mit `~.`)
vmctl stop web	VM sauber herunterfahren (`-f` erzwingt, `-w` wartet)
vmctl stop -a	Alle VMs stoppen
vmctl pause web / vmctl unpause web	VM anhalten und weiterlaufen lassen
vmctl reset all	Alle VMs und Switches zurücksetzen
vmctl load /etc/vm.conf	Konfiguration ohne Neustart von vmd einlesen
vmctl reload	Alles zurücksetzen und `/etc/vm.conf` neu laden
vmctl send web > /mnt/web.dump	Laufende VM in eine Datei serialisieren
vmctl receive web < /mnt/web.dump	VM aus der Datei wiederherstellen
ifconfig tap0	Host-Seite der VM-Netzwerkverbindung
/etc/hostname.veb0 bzw. bridge0	tap-Interfaces mit dem physischen Netz verbinden
chown build:build /home/vm/*.qcow2	Nicht-root-Besitzer, damit User ihre VMs selbst starten können

Grenzen von vmm: Nur amd64 (und arm64) mit Hardware-Virtualisierung (Intel VMX / AMD SVM). Verschachtelte Virtualisierung gibt es nicht – in einer VMware- oder KVM-Gast-Instanz läuft vmd in der Regel nicht. Als Gäste sind OpenBSD, andere BSDs und Linux vorgesehen; kein Windows, keine Grafikausgabe (nur serielle Konsole).

Dauerhaft über vm.conf: VMs, die beim Boot starten sollen, gehören nach /etc/vm.conf (mit owner, memory, disk, interface), nicht in ein rc.local-Skript. vmctl start ist für Tests und Installationen gedacht.

📂Wichtige Dateien & Verzeichnisse

Konfiguration in /etc

/etc/rc.conf.local	Aktivierte Dienste und ihre Flags (per `rcctl` pflegen)
/etc/rc.local /etc/rc.shutdown /etc/rc.securelevel	Eigene Kommandos beim Start, Stopp und vor Securelevel-Wechsel
/etc/hostname.em0, /etc/hostname.vlan10	Netzwerkkonfiguration je Interface
/etc/myname /etc/mygate /etc/hosts	Hostname, Default-Gateway, statische Namen
/etc/resolv.conf	Nameserver (wird von `resolvd` verwaltet)
/etc/pf.conf	Firewall-Regelwerk
/etc/fstab	Filesysteme und Swap – mit DUIDs statt `sdX`
/etc/doas.conf	Wer darf was als root ausführen
/etc/login.conf, /etc/login.conf.d/	Login-Klassen, Limits, Passwort-Hashing
/etc/sysctl.conf	Dauerhafte Kernel-Parameter
/etc/installurl	Mirror für Pakete, Patches und Upgrades
/etc/pkg.conf	Optionen der pkg-Werkzeuge
/etc/boot.conf	Dauerhafte Bootloader-Anweisungen
/etc/syslog.conf, /etc/newsyslog.conf	Logziele und Logrotation
/etc/daily.local, /etc/changelist	Eigene Wartung, überwachte Dateien
/etc/master.passwd, /etc/group	Benutzer (nur über `vipw`) und Gruppen
/etc/signify/	Public Keys zur Signaturprüfung von Sets und Paketen
/etc/ssh/sshd_config	SSH-Server
/etc/vm.conf	VM-Definitionen für vmd

Daten, Logs & Systempfade

/bsd, /bsd.mp, /bsd.sp, /bsd.rd, /obsd	Kernel: aktiv, MP, SP, RAM-Disk, Vorgänger
/var/run/dmesg.boot	Boot-Meldungen als Datei
/var/log/messages, authlog, daemon, secure	Die vier wichtigsten Logdateien
/var/log/pflog	pf-Log (binär, mit `tcpdump -r` lesen)
/var/cron/tabs/	crontabs der Benutzer
/var/syspatch/	Rollback-Archive installierter Patches
/var/crash/	Kernel-Crashdumps
/var/www/	chroot von `httpd`
/var/unbound/, /var/nsd/	chroots der DNS-Dienste samt Konfiguration
/home/_sysupgrade/	Von `sysupgrade` geladene Installations-Sets
/usr/local/	Alles aus Paketen und Ports (Basissystem bleibt sauber)
/usr/share/relink/	Objekte für das KARL-Kernel-Relinking
/usr/ports/, /usr/src/	Ports-Tree und Quellcode (optional)
/dev/sd0a vs. /dev/rsd0a	Block-Device (mount) vs. Raw-Device (newfs, fsck, dd)
/altroot	Ziel der täglichen Root-Sicherung

Trennung Basis / Pakete: Das Basissystem liegt komplett unter /bin, /sbin, /usr/bin, /usr/sbin und wird gemeinsam als ein Ganzes entwickelt und aktualisiert. Alles aus Paketen landet unter /usr/local. Diese Trennung macht Updates vorhersagbar – und Backups von /etc plus Paketliste ausreichend.

🔧Shell, Manpages & Praxis-Workflows

Dokumentation

man 8 rcctl	Gezielt die Section angeben (8 = Systemverwaltung, 5 = Dateiformate)
man -k firewall / apropos pf	Alle Manpages nach Stichwort durchsuchen
man -s 5 pf.conf	Das komplette pf-Regelsyntax-Handbuch
man afterboot	Checkliste für alles, was nach einer Installation zu tun ist
man hier	Erklärung der gesamten Verzeichnisstruktur
man intro / man 8 intro	Einstieg in eine Manpage-Section
whatis rcctl / man -f rcctl	Einzeilige Beschreibung eines Kommandos
man -w rcctl	Pfad zur Quelldatei der Manpage
/usr/share/doc/, man faq	Weitere Dokumentation im System

ksh & Werkzeuge

set -o vi	vi-Editiermodus (Esc, dann `k` für History) – in `~/.profile`
set -o emacs	emacs-Tastenbelegung als Alternative
PS1='\u@\h:\w\$ '	Prompt mit User, Host und Pfad
~/.profile, /etc/ksh.kshrc, ENV	Login-Profil, systemweite ksh-Einstellungen, Startdatei
which cmd / whereis cmd / type cmd	Pfad, Manpage-Ort und Typ eines Kommandos
grep -rn "muster" /etc	Rekursiv mit Zeilennummern durchsuchen
sed -i.bak 's/alt/neu/g' datei	In-place ersetzen und Backup anlegen
awk '{print $1, $5}' datei	Spalten extrahieren
for i in $(rcctl ls on); do rcctl check $i; done	Alle aktivierten Dienste durchprüfen
find /var/log -mtime -1 -type f	Was hat sich im letzten Tag geändert?
script /tmp/session.log	Komplette Sitzung protokollieren (Change-Nachweis)
tee -a /tmp/log	Ausgabe anzeigen und gleichzeitig mitschreiben
gzip -9 / bzip2 / xz / zstd	Komprimieren; Sets und Pakete nutzen `.tgz`
install -d -o www -g www -m 0755 /var/www/htdocs/app	Verzeichnis mit Besitzer und Rechten in einem Schritt

# Neuen Server aufsetzen und haerten (nach der Installation)
man afterboot                                  # Checkliste durcharbeiten
echo https://cdn.openbsd.org/pub/OpenBSD > /etc/installurl
syspatch && fw_update                          # Patch- und Firmwarestand
cat > /etc/doas.conf <<'EOF'
permit persist keepenv :wheel
EOF
chmod 0600 /etc/doas.conf && doas -C /etc/doas.conf
# --- SSH absichern (Key vorher testen!) ---
vi /etc/ssh/sshd_config    # PermitRootLogin no / PasswordAuthentication no / AllowGroups wheel
sshd -t && rcctl reload sshd
# --- Dienste reduzieren ---
rcctl ls on                                    # Bestandsaufnahme
rcctl disable smtpd                            # Beispiel: nicht gebraucht
netstat -na -f inet -p tcp | grep LISTEN       # offene Ports gegenpruefen
# --- Firewall ---
vi /etc/pf.conf                                # Default-Deny plus benoetigte Dienste
pfctl -nf /etc/pf.conf && pfctl -f /etc/pf.conf
rcctl enable pf
# --- Zeit, Logging, Mail ---
rcctl enable ntpd && rcctl start ntpd && ntpctl -s all
vi /etc/mail/aliases                           # root: admin@example.com
newaliases
echo 'ROOTBACKUP=1' >> /etc/daily.local        # /altroot-Sicherung
# --- Pakete und Doku ---
pkg_add -u
pkg_info -mz > /root/pkglist
disklabel sd0 > /root/label.sd0
sysctl -a > /root/sysctl-baseline.txt
reboot                                         # Kaltstart-Test - jetzt, nicht in 6 Monaten

Merksatz: OpenBSD ist konsequent einfach gehalten: eine Konfigurationsdatei pro Dienst, ein Werkzeug pro Aufgabe (rcctl, pfctl, bioctl, disklabel), und die Manpage ist immer aktueller als jede fremde Anleitung. Temporäre Änderungen per ifconfig, sysctl, mount oder route sind nach dem Reboot weg – dauerhaft wird es erst in /etc/hostname.if, /etc/sysctl.conf, /etc/fstab bzw. /etc/mygate.

Keine Linux- oder FreeBSD-Reflexe: Es gibt kein systemctl, service, journalctl, ip, iptables, lsblk, apt, sysrc, gpart und kein ZFS. Die Entsprechungen heißen rcctl, syslogd/tail, ifconfig, pfctl, disklabel, pkg_add und softraid.

💻System- & Hardware-Informationen

⏻Boot, Bootloader & Kernel

boot(8)-Prompt (boot>)

Bootloader & Kernel im laufenden System

Herunterfahren & Neustart

⚙Init, rcctl & Dienste

rcctl – das zentrale Werkzeug

Dateien & rc-Struktur

📦Pakete, Ports & Updates

Spiegel & Grundkonfiguration

Binärpakete

Patches, Firmware & Release-Upgrade

Ports-Tree (nur wenn nötig)

💽Disks, Partitionen & Labels

📁Filesysteme & Mounts

mount_*-Helfer

Quotas

🗃softraid, Verschlüsselung & vnd

vnd – Datei als Blockdevice

📈Swap

🖥Prozesse, Jobs, cron & Limits

Zeitsteuerung

Limits & login.conf

📊Performance & Monitoring

Schnellüberblick

systat – die Schaltzentrale

Messwerkzeuge

🌐Netzwerk & Interfaces

Interfaces

Dauerhafte Konfiguration

Routing & Diagnose

Virtuelle Interfaces

🔥pf – Packet Filter

Regelwerk laden & prüfen

Eingreifen im Betrieb

Protokollierung

🔌Basisdienste im Überblick

OpenSSH

Zeit: ntpd

Logging: syslogd & newsyslog

Web & Loadbalancing

DNS: unbound & nsd

Mail & DHCP

👥User, Gruppen & doas

doas – Rechteerweiterung

🔒Security-Härtung

Securelevel & unveränderliche Dateien

Integrität & Reports

Angriffsfläche verkleinern

📜Logs & Fehlersuche

Tiefergehende Analyse

💾Backup, Migration & Installation

dump / restore – das FFS-Werkzeug

Weitere Wege

/altroot & unbeaufsichtigte Installation

🧩Virtualisierung mit vmm/vmd

📂Wichtige Dateien & Verzeichnisse

Konfiguration in /etc

Daten, Logs & Systempfade

🔧Shell, Manpages & Praxis-Workflows

Dokumentation

ksh & Werkzeuge

boot(8)-Prompt (`boot>`)