© Tatiana Popova / 123RF.com

Der Linux-Kernel hat über ein Netlink-Interface reichlich Kryptofunktionen im Angebot. Applikationen müssen nur zugreifen, entweder nativ oder ganz unkompliziert über die Bibliothek Libkcapi.

IT-Sicherheit ist für IT-Systeme so wichtig wie die Bremse fürs Auto. Kein Wunder also, dass Linux üppig Kryptofunktionen auftischt und dabei abstrahiert, ob sie über Hard- oder Software realisiert sind. Das Portfolio reicht von diversen Ver- und Entschlüsselungsverfahren über Hashing (Message Digest), HMAC und Kompression bis hin zur Generierung von Pseudozufallszahlen (siehe Kasten “Kryptografie-Basics”).

Die virtuelle Datei »/proc/crypto« (Abbildung 1) listet die vom aktuell laufenden Kernel unterstützten Verfahren auf. Das Ergebnis kann sich sehen lassen: Abhängig von der Kernel-Konfiguration kommen locker mehr als 75 Algorithmen zusammen. Die Liste nennt nicht nur deren Name, sondern auch den Typ, den zugehörige Treiber, die Blockgröße und die Priorität. Letztere spielt durchaus eine Rolle, da einzelne Verfahren mehrfach implementiert sind, beispielsweise einmal in Hardware und einmal in Software.

Abbildung 1: Über eine Proc-Datei offenbart der Kernel unterstützte Kryptofunktionen.

Auf diese Algorithmen und Verfahren greifen sowohl der Kernel (über ein In-Kernel-API [1]) als auch ganz normale Applikationen zu. Dass Anwendungen den Weg durch den Kernel nehmen und nicht direkt auf Kryptofunktionen der CPU zugreifen, hat den schlichten Grund, dass die Software sonst nicht mehr portabel wäre. Darüber hinaus erfordert das Nutzen der einen oder anderen Prozessorfunktion auch besondere Rechte, die stinknormale Applikationen einfach nicht besitzen.

Abbildung 2: Die Betriebsart CBC sorgt bei identischen Klartextblöcken für unterschiedliche Cipher-Blöcke.

Netlink-Interface

Der Zugriff aus dem Userland auf die Kernel-Funktionen (Abbildung 3) findet nicht über spezielle Systemcalls oder über eine Dateischnittstelle statt, sondern über ein Netlink-Interface [2]. Wie der Name andeutet, hat diese Schnittstelle ihren Ursprung im Netzwerk-Subsystem und dient unter anderem zur Konfiguration der Firewall.

Abbildung 3: Per Netlink-Interface erhalten Applikationen Zugang zu Kernel-Kryptofunktionen.

Längst ist sie zu einer generellen Methode der Interprozesskommunikation (Inter-Process Communication, IPC) geworden, mit der Applikationen Daten mit ihresgleichen, dem Kernel und der Kernel wiederum mit den Applikationen und ebenfalls mit sich selbst austauschen können. Da das Interface auf BSD-Sockets beruht, ist es asynchron und unterstützt Multicasts. Ein einzelner Kernel-Thread kann also gleich einen ganzen Reigen verschiedener Rechenprozesse mit identischen Informationen versorgen.

Es kommt hinzu, dass sich über ein Netlink-Interface auch größere Datenmengen einfach transferieren lassen. Damit eignet es sich hervorragend für Kryptofunktionen. Als Socket-Typ haben die Kernel-Developer »AF_ALG« und als Setsock-Option »SOL_ALG« festgelegt. Die angebotenen Verfahren wählen Sie über deren Namen aus, die Sie in der Datei »/proc/crypto« aufgelistet finden.

Will eine Applikation eines der Verfahren nutzen, erzeugt sie zunächst einen Socket vom Typ »AF_ALG« mit »struct sockaddr_alg« als Parameter. Anschließend ruft sie zur Auswahl des Verfahrens »bind()« auf, bevor ein nachfolgendes »accept()« einen neuen Socket-Deskriptor zurückliefert. Über ihn findet die eigentliche Interaktion mit dem gewählten Verfahren mittels »send()«, »sendto«, »write«, »recv()«, »recvmsg« oder »read« statt.

Hash mich!

Listing 1 zeigt das grundsätzliche Verfahren an einem einfachen Hashing-Beispiel als Teil des Message Digest API, das der Kompaktheit wegen auf die Auswertung der Rückgabewerte verzichtet. Lautet der Name der Quellcode-Datei »sha1sample.c«, generiert der Aufruf »make sha1sample« das Executable, aufrufen lässt sich das Testprogramm mit »./sha1sample«.

Die Software hasht per (unsicherem) SHA-1 den String “Linux Magazin”, den sie dazu per »write()« dem Kernel übergibt. Das Ergebnis liest das Programm per »read()« aus. Ob das Hashing in Hard- oder in Software vonstattenging, bleibt dem Anwender verborgen. Die Korrektheit des Ergebnisses lässt sich übrigens über die Konsole einfach testen: Das Kommando »echo -n “Linux Magazin” | sha1sum« zeigt den identischen Hash-Wert.

#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/if_alg.h>
#include <linux/socket.h>
#include <string.h>
#ifndef SOL_ALG
#define SOL_ALG 279
#endif
// Quelle: https://lwn.net/Articles/410833/
int main( int argc, char **argv, char **envp ) {
  int opfd, tfmfd;
  char buf[20];
  int i, ret;
  struct sockaddr_alg sa = {
    .salg_family = AF_ALG,
    .salg_type = "hash",
    .salg_name = "sha1"
  };
  tfmfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
  bind(tfmfd, (struct sockaddr *)&sa, sizeof(sa));
  opfd = accept(tfmfd, NULL, 0);
  write(opfd, "Linux Magazin", 13);
  ret = read(opfd, buf, sizeof(buf));
  for (i = 0; i < ret; i++) {
    printf("%02x", (unsigned char)buf[i]);
  }
  printf("\n");
  close(opfd);
  close(tfmfd);
  return 0;
}

Komplexe Datenstrukturen

Eine Ver- beziehungsweise Entschlüsselung (Symmetric Cipher API) gestaltet sich durch die zum Einsatz kommenden komplexen Datenstrukturen schon aufwendiger. Das verwendete Verschlüsselungsverfahren (zum Beispiel AES) inklusive der Betriebsart (zum Beispiel CBC) geben Sie dem Socket als Adressparameter (»cbc(aes)«) über die Struktur »struct sockaddr_alg« mit. Für das Ver- beziehungsweise Entschlüsseln benötigen Sie noch den Schlüssel selbst und je nach Betriebsart einen Initialisierungsvektor (IV).

Den Schlüssel verknüpfen Sie per »setsockopt()« mit dem Socket-Deskriptor. Für den eigentlichen Datenaustausch, also die Übergabe der zu verschlüsselnden Nachricht und des zugehörigen IVs, verwenden Sie »sendmsg()«: Mit diesem Aufruf lassen sich neben den Daten auch Kontrollinformationen übergeben. Dazu packen Sie die eigentliche Nachricht in eine »struct iovec« und die Kontrollnachricht in eine »struct cmsghdr« (Abbildung 4).

Abbildung 4: Komplexe Datenstrukturen zeichnen das native Netlink-Interface aus.

Genau genommen gilt es, gleich zwei Kontrollnachrichten zu übermitteln und mithilfe der Makros »CMSG_FIRSTHDR()«, »CMSG_NEXTHDR()« und »CMSG_DATA()« zusammenzuschrauben. Die erste Nachricht definiert, dass eine Verschlüsselung (»ALG_OP_ENCRYPT«) stattfinden soll, die zweite definiert den IV. Ist alles korrekt verknüpft, übergeben Sie den Auftrag per »sendmsg()« dem Kernel, der für die optimierte Abarbeitung sorgt und das Ergebnis mit dem nächsten »read()« zur Verfügung stellt. Listing 2 zeigt den zugehörigen Code. Die dort zu verschlüsselnde Nachricht (“Single block msg”), der verwendete Schlüssel und der eingesetzte IV werden übrigens gern zum einfachen Testen der Verfahren eingesetzt. Befindet sich der Quellcode in der Datei »cbcaes.c«, erzeugen Sie das Programm durch »make cbcaes« und starten es über »./cbcaes«.

Ähnlich wie Message Digest und Cipher funktionieren dann auch die Random Number Generator API und die AEAD Cipher API. Als asymmetrische Verschlüsselung ist AEAD aber noch komplexer als die Symmetric Cipher API und schreit geradezu nach Erleichterung.

#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/if_alg.h>
#include <linux/socket.h>
#include <string.h>
#ifndef SOL_ALG
#define SOL_ALG 279
#endif
int main(void) {
  int opfd, tfmfd, i;
  struct sockaddr_alg sa = {
    .salg_family = AF_ALG,
    .salg_type = "skcipher",
    .salg_name = "cbc(aes)"
  };
  struct msghdr msg = {};
  struct cmsghdr *cmsg;
  char cbuf[CMSG_SPACE(4) + CMSG_SPACE(20)] = {0};
  char buf[16];
  struct af_alg_iv *iv;
  struct iovec iov;
  tfmfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
  bind(tfmfd, (struct sockaddr *)&sa, sizeof(sa));
  setsockopt(tfmfd,
    SOL_ALG, ALG_SET_KEY,
    "\x06\xa9\x21\x40\x36\xb8\xa1"
    "\x5b\x51\x2e\x03\xd5\x34\x12"
    "\x00\x06", 16);
  opfd = accept(tfmfd, NULL, 0);
  msg.msg_control = cbuf;
  msg.msg_controllen = sizeof(cbuf);
  cmsg = CMSG_FIRSTHDR(&msg);
  cmsg->cmsg_level = SOL_ALG;
  cmsg->cmsg_type = ALG_SET_OP;
  cmsg->cmsg_len = CMSG_LEN(4);
  *(__u32 *)CMSG_DATA(cmsg) = ALG_OP_ENCRYPT;
  cmsg = CMSG_NXTHDR(&msg, cmsg);
  cmsg->cmsg_level = SOL_ALG;
  cmsg->cmsg_type = ALG_SET_IV;
  cmsg->cmsg_len = CMSG_LEN(20);
  iv = (void *)CMSG_DATA(cmsg);
  iv->ivlen = 16;
  memcpy(iv->iv,
    "\x3d\xaf\xba\x42\x9d\x9e\xb4"
    "\x30\xb4\x22\xda\x80\x2c\x9f"
    "\xac\x41", 16);
  iov.iov_base = "Single block msg";
  iov.iov_len = 16;
  msg.msg_iov = &iov;
  msg.msg_iovlen = 1;
  sendmsg(opfd, &msg, 0);
  read(opfd, buf, 16);
  for (i = 0; i < 16; i++) {
    printf("%02x", (unsigned char)buf[i]);
  }
  printf("\n");
  close(opfd);
  close(tfmfd);
  return 0;
}

Alles easy

Abhilfe schafft die Libkcapi, deren voller Name Linux Kernel Crypto API User Space Interface Library lautet. Die Bibliothek bietet ein einfach zu nutzendes Interface, das die Besonderheiten des Netlink-Interfaces abstrahiert. Ubuntu 20.04 liefert ärgerlicherweise noch die veraltete Libkcapi 1.1 aus, unter Ubuntu 22.04 installieren Sie die aktuelle Version 1.4 aus den Paketquellen (Listing 3, Zeile 2).

Alternativ zur Systeminstallation – und um insbesondere die aktuellste Version zu fahren – holen Sie am besten den Quellcode, die Beispielprogramme und die Dokumentation via Git auf die eigene Maschine (Zeile 4). Einige wenige Aufrufe (ab Zeile 5) konfigurieren, übersetzen und installieren die Bibliothek inklusive der Hashing-Beispielprogramme. Weitere Optionen liefert die Libkcapi-Dokumentation [3].

### Unter Ubuntu 22.04
$ sudo apt install libkcapi1 libkcapi-dev libkcapi-doc
### Einrichten aus den Quellen
$ git clone https://github.com/smuellerDD/libkcapi.git
$ cd libkcapi
$ autoreconf -i
$ ./configure --enable-kcapi-hasher
$ make && make install

Nach Schema F

Grundsätzlich sieht die Libkcapi für sämtliche unterstützten Kryptoverfahren eine Initialisierung, ein (wiederholtes) Ausführen der Operationen und ein Aufräumen vor. Diesem Schema folgt auch die Namensgebung der Bibliotheksfunktionen, die allesamt mit »kcapi_« beginnen.

Im Mittelteil folgt die Benennung der Kryptofunktionalität, wobei »md« für Message Digest steht und »cipher« für Verschlüsselung. Optional kommt noch ein »stream_« hinzu. Der Rest des Funktionsnamens beschreibt die eigentliche Aktion (»_init«, »_destroy«, »_digest«, »encrypt« oder »decrypt«). Die Tabelle “Funktionen der Libkcapi (Auswahl)” führt einige Varianten auf.

Die Libkcapi legt Wert auf Performance. Sie vermeidet unnötiges Kopieren von Daten und nutzt Zero Copy sowie Funktionen wie »vmsplice()«. Die Anwendung kommt diesem Anliegen dadurch entgegen, dass sie Speicherbereiche für Input- und Output-Daten möglichst auf Page-Grenzen legt.

Die Bibliothek unterstützt einen sogenannten Single-Shot Mode ebenso wie Streams. Beim Single-Shot liegen sämtliche Input-Daten bereits vor und können der Bibliothek übergeben werden. Beim Stream ist die Datenlänge noch nicht bekannt, die Daten rauschen peu à peu beispielsweise über SSD oder Netzwerk herein. Zugriffe können synchron und asynchron erfolgen.

Einer für alles

Listing 4 zeigt analog zu Listing 1 den Code, um den Text “Linux Magazin” per SHA-1 unter Verwendung der Libkcapi zu hashen. Die Initialisierungsfunktion hat das gewünschte Hash-Verfahren ausgewählt und an einen Handle gebunden. Der Funktion »kcapi_md_digest()« übergeben Sie die zu hashenden Daten und einen Speicher, in dem nach erfolgreichem Durchlauf der Funktion das Ergebnis liegt. Am Ende geben Sie den Handle und die damit gebundenen Ressourcen per »kcapi_md_destroy()« wieder frei. Der Dreiklang »kcapi_md_init()«, »kcapi_md_digest()« und »kcapi_md_destroy()« kommt ohne die komplexen Datenstrukturen des Netlink-Interfaces aus.

In vielen Fällen geht es sogar noch einfacher: Unter dem Label Convenience Functions, also Bequemlichkeitsfunktionen, ermöglicht die Bibliothek ein Hashing oder ein Verschlüsseln mit einem einzigen Funktionsaufruf. Dazu übergeben Sie »kcapi_md_sha1()« die Eingangsdaten inklusive einer Längenangabe zusammen mit der Speicheradresse zur Ablage des generierten Hash-Werts.

#include <stdio.h>
#include <kcapi.h>
int main( int argc, char **argv, char **envp ) {
  struct kcapi_handle *handle;
  int32_t ret;
  const uint8_t *in = "Linux Magazin";
  uint8_t buffer[20];
  int i;
  ret = kcapi_md_init( &handle, "sha1", 0 );
  if (ret!=0)
    return -1;
  ret = kcapi_md_digest( handle, in, 13, buffer, sizeof(buffer) );
  if (ret<0)
    return -1;
  for (i=0; i<sizeof(buffer); i++ ) {
    printf("%02x", buffer[i]);
  }
  printf("\n");
  kcapi_md_destroy( handle );
  return 0;
}

Vor allem beim Ver- und Entschlüsseln lernen Sie die Bibliothek schnell zu schätzen. Wie beschrieben, genügen wenige Funktionsaufrufe, die aber jetzt anstelle von »md« (Message Digest) ein »cipher« im Mittelteil des Namens tragen. Den Namen des Verschlüsselungsverfahrens geben Sie in der typischen Kombination mit der Betriebsart, zum Beispiel »cbc(aes)«, beim Aufruf von »kcapi_cipher_init()« an.

Anders als beim Hashing benötigen Sie für das Verschlüsseln einen Key und abhängig von der Betriebsart auch einen Initialisierungsvektor (IV). Für das Setzen des Schlüssels sieht die Libkcapi die Funktion »kcapi_cihper_setkey()« vor. Der eventuell benötigte IV ist dagegen ein Parameter der Funktion »kcapi_cipher_encrypt()«, die ansonsten die Adressen und Längen der beteiligten Speicherbereiche enthält.

Der Performance zuliebe sollten Sie strikt darauf achten, dass der Ergebnisspeicher für die verschlüsselten Daten jeweils auf eine Speicherseite ausgerichtet (aligned) ist. Dazu reservieren Sie ihn am besten dynamisch durch Aufruf der Funktion »posix_memalign()«.

Bequem machen

Auch das -Ver- und Entschlüsseln können Sie in vielen Fällen noch bequemer haben. Der Funktion »kcapi_cipher_enc_aes_cbc()« beispielsweise übergeben Sie Schlüssel, Eingangsdaten, IV und Speicherplatz für Ausgangsdaten inklusive der jeweiligen Längenangaben. Ein Handle sowie Init-und Destroy-Aufrufe entfallen (Listing 5). Allerdings müssen Sie darauf achten, dass die Länge der Eingangsdaten ein Vielfaches von 16 beträgt. Die Länge des Schlüssels entscheidet darüber, ob AES-128, AES-192 oder AES-256 zum Einsatz kommt.

#include <stdio.h>
#include <kcapi.h>
int main( int argc, char **argv, char **envp ) {
  int32_t ret;
  int i;
  const uint8_t *in = "Single block msg";
  uint32_t inlen = 16;
  uint8_t out[16];
  uint32_t outlen = 16;
  const uint8_t *key = "\x06\xa9"
    "\x21\x40\x36\xb8\xa1\x5b\x51"
    "\x2e\x03\xd5\x34\x12\x00\x06";
  uint32_t keylen = 16;
  const uint8_t *iv = "\x3d\xaf"
    "\xba\x42\x9d\x9e\xb4\x30\xb4"
    "\x22\xda\x80\x2c\x9f\xac\x41";
  ret = kcapi_cipher_enc_aes_cbc( key, keylen, in, inlen, iv, out, outlen );
  if (ret<0) {
    perror( "kcapi_cipher_enc_aes_cbc" );
    printf("ret=%d\n", ret);
    return -1;
  }
  for (i=0; i<ret; i++ ) {
    printf("%02x", out[i]);
  }
  printf("\n");
  return 0;
}

Wirklich nützlich

Die hier gezeigten einfachen Beispiele basieren darauf, dass Sie die Länge der Eingangsdaten kennen und diese endlich groß ist, sprich: dass Sie beides über Buffer übergeben können. Die Libkcapi unterstützt aber zusätzlich zu diesem One-Shot-Modus einen Stream-Modus. Er vermag einen theoretisch unendlichen Eingabestrom von Daten zu hashen, zu ver- oder zu entschlüsseln oder was auch immer. Per »kcapi_foo_update()« übergeben Sie dem Kernel neue Daten, »kcapi_foo_final()« beendet den Durchlauf. In Kombination mit einer asymmetrischen Verschlüsselung steigt damit der Komplexitätsgrad noch einmal – aber das liegt in der Natur der Algorithmen.

Grundsätzlich erlaubt die Libkcapi das Nutzen der Kernel-Kryptofunktionen mit überschaubarem Aufwand. Die Dokumentation erfüllt zwar ihren Zweck, aber anstelle der umfangreichen Eierlegende-Wollmilchsau-Quellcodes wären kompakte, übersichtliche Einzelbeispiele nützlicher. Schließlich dürfte sich die überwiegende Mehrheit von Applikationen mit den Basisfunktionen bestens realisieren lassen. Aber egal, welches Interface mit welcher Middleware zum Einsatz kommt: Mit Kernel-Krypto lassen sich Hacker leicht ausbremsen. (jlu)