Liste der Capabilities

Die folgende Liste zeigt die in Linux implementierten Capabilities und die Aktionen oder Verhalten, die jede Capability erlaubt:

CAP_AUDIT_CONTROL (seit Linux 2.6.11)

Kernel-Auditierung aktivieren und deaktivieren; die Auditierung-Filterregel ändern; den Auditstatus und Filterregel abfragen.

CAP_AUDIT_READ (seit Linux 3.16)

Erlaubt das Schreiben des Audit-Protokolls über einen Multicast-Netlink-Socket

CAP_AUDIT_WRITE (seit Linux 2.6.11)

Datensätze in das Audit-Protokoll des Kernels schreiben

CAP_BLOCK_SUSPEND (seit Linux 3.5)

Funktionalitäten einsetzen, die die System-Supsendierung blockieren können (epoll(7) EPOLLWAKEUP, /proc/sys/wake_lock).

CAP_CHOWN

beliebige Änderungen an Datei-UIDs und GIDs vornehmen (siehe chown(2))

CAP_DAC_OVERRIDE

Lese-, Schreibe und Ausführrechteprüfungen umgehen. (DAC ist die Abkürzung für »discretionary access control«, benutzerbestimmbare Zugriffskontrolle)

CAP_DAC_READ_SEARCH

CAP_FOWNER

CAP_FSETID

CAP_IPC_LOCK

Speicher sperren (mlock(2), mlockall(2), mmap(2), shmctl(2)).

CAP_IPC_OWNER

Rechteprüfungen für Aktionen mit System-V-IPC-Objekten umgehen

CAP_KILL

Rechteprüfungen beim Senden von Signalen umgehen (siehe kill(2)). Dies schließt die ioctl(2)-KDSIGACCEPT-Aktion mit ein.

CAP_LEASE (seit Linux 2.4)

Etabliert Ausleihen für beliebige Dateien (siehe fcntl(2)).

CAP_LINUX_IMMUTABLE

Setzt die Inode-Schalter FS_APPEND_FL und FS_IMMUTABLE_FL (siehe ioctl_iflags(2)).

CAP_MAC_ADMIN (seit Linux 2.6.25)

MAC-Konfiguration oder Statusänderungen erlauben. Implementiert für das Smack-Linux-Security-Modul (LSM).

CAP_MAC_OVERRIDE (seit Linux 2.6.25)

Mandatory Access Control (MAC) außer Kraft setzen. Für das Smack-LSM implementiert.

CAP_MKNOD (seit Linux 2.4)

Spezielle Dateien mittels mknod(2) erstellen.

CAP_NET_ADMIN

Verschiedene Netz-bezogene Aktionen durchführen:

CAP_NET_BIND_SERVICE

Einen Socket an einen privilegierten Internet-Domain-Port binden (Portnummern kleiner als 1024)

CAP_NET_BROADCAST

(Unbenutzt) Socket-Broadcasts durchführen und auf Multicasts warten

CAP_NET_RAW

CAP_SETGID

CAP_SETFCAP (seit Linux 2.6.24)

Setzt beliebige Capabilities auf einer Datei.

CAP_SETPCAP

Falls Datei-Capabilites unterstützt werden (d.h. seit Linux 2.6.24): Füge alle Capabilities aus der Begrenzungsmenge des Threads zu der vererbbaren Menge hinzu; entferne Capabilities aus der Begrenzungsmenge (via prctl(2) PR_CAPBSET_DROP); nehme Änderungen an den securebits-Schaltern vor.

Falls Datei-Capabilites nicht unterstützt werden (d.h. Kernel vor Linux 2.6.24): eine Capability in der erlaubten Capability-Menge oder von anderen Prozessen entfernen oder dafür bewilligen. (Diese Eigenschaft von CAP_SETPCAP ist nicht verfügbar, falls der Kernel für die Unterstützung von Datei-Capabilities konfiguriert ist, da CAP_SETPCAP für diese Kernel eine komplett andere Semantik aufweist.)

CAP_SETUID

CAP_SYS_ADMIN

Hinweis: Diese Capability ist überladen, siehe Hinweise für Kernel-Entwickler weiter unten.

CAP_SYS_BOOT

reboot(2) und kexec_load(2) verwenden

CAP_SYS_CHROOT

chroot(2) verwenden

CAP_SYS_MODULE

CAP_SYS_NICE

CAP_SYS_PACCT

acct(2) verwenden

CAP_SYS_PTRACE

CAP_SYS_RAWIO

CAP_SYS_RESOURCE

CAP_SYS_TIME

Systemuhr setzen (settimeofday(2), stime(2), adjtimex(2)); Echtzeit- (Hardware-)Uhr setzen

CAP_SYS_TTY_CONFIG

vhangup(2) einsetzen; verschiedene privilegierte ioctl(2)-Aktionen auf virtuelle Terminals einsetzen

CAP_SYSLOG (seit Linux 2.6.37)

CAP_WAKE_ALARM (seit Linux 3.0)

Etwas auslösen, dass das System aufwecken wird (siehe die Timer CLOCK_REALTIME_ALARM und CLOCK_BOOTTIME_ALARM)

Frühere und heutige Implementierungen

Eine komplette Implementierung von Capabilities verlangt folgendes:

1.

Für alle privilegierten Aktionen muss der Kernel prüfen, ob der Thread die benötigten Capabilities in seiner effektiven Menge hat.

2.

Der Kernel muss Systemaufrufe bereitstellen, die es erlauben, dass die Capability-Menge des Threads geändert und ermittelt wird.

3.

Das Dateisystem muss das Anhängen von Capabilities an ausführbare Dateien erlauben, so dass ein Prozess solche Capabilities erhält, wenn die Datei ausgeführt wird.

Vor Kernel 2.6.24 waren nur die ersten zwei dieser Anforderungen erfüllt, seit Kernel 2.6.24 sind alle drei Anforderungen erfüllt.

Hinweise für Kernel-Entwickler

Wenn Sie eine neue Kernel-Funktionalität hinzufügen, die über eine Capability geregelt werden soll, beachten Sie die nachfolgenden Punkte.

• Das Ziel von Capabilitys besteht darin, die Macht des Systembenutzers in Teile zu zerlegen. Wird dann ein Programm, das eine oder mehrere Capabilitys hat, kompromittiert, dann kann weniger Schaden angerichtet werden, als wenn das Programm mit Root-Rechten liefe.
• Sie haben die Wahl, entweder ein neues Capability für Ihre neue Funktionalität hinzuzufügen, oder die Funktionalität einer bereits bestehenden Capability zuzuordnen. Um die Menge der Capabilitys auf eine verwaltbare Größe zu begrenzen, wird die zweite Variante bevorzugt, außer es gibt überzeugende Gründe, die erste Variante zu wählen. (Es gibt auch eine technische Grenze: Die Größe der Capability-Menge ist derzeit auf 64 bit beschränkt.)
• Um zu bestimmen, zu welcher bestehenden Capability Ihre neue Funktionalität am besten zugeordnet werden könnte, prüfen Sie die obige Liste der Capabilitys, um ein »Silo« zu finden, in das Ihre neue Funktionalität am besten passt. Ein Vorgehen besteht darin, zu bestimmen, ob es andere Funktionalitäten gibt, die Capabilitys benötigen, die immer zusammen mit Ihrer neuen Funktionalität benötigt werden. Falls Ihre neue Funktionalität ohne diese andere Funktionalität nutzlos ist, dann sollten Sie die gleiche Capability wie die andere Funktionalität verwenden.
• Verwenden Sie nicht CAP_SYS_ADMIN, falls Sie es irgendwie vermeiden können. Ein riesiger Anteil an bestehenden Capability-Überprüfungen ist dieser Capability zugeordnet (siehe die Teilliste weiter oben). Sie kann glaubhaft als »der neue Root« bezeichnet werden, da sie eine große Bandbreite an Rechten verleiht, und andererseits bedeutet ihr großer Geltungsbereich, dass es eine Capability ist, die von vielen privilegierten Programmen benötigt wird. Verschlimmern Sie das Problem nicht. Die einzigen neuen Funktionalitäten, die CAP_SYS_ADMIN zugeordnet werden sollten, sind diejenigen, die eng zu bestehenden Anwendungsfällen in diesem Silo passen.
• Falls Sie ermittelt haben, dass Sie wirklich eine neue Capability für Ihre Funktionalität benötigen, führen Sie sie nicht als »Einzelverwendung«-Capability ein (oder benennen Sie es so). Daher war beispielsweise die Ergänzung der hochspezifischen CAP_SYS_PACCT wahrscheinlich ein Fehler. Versuchen Sie stattdessen, Ihre neue Capability als ein breiteres Silo zu identifizieren und zu benennen, in das andere, damit im Zusammenhang stehende zukünftige Anwendungsfälle passen könnten.

Capability-Mengen von Threads

Jeder Thread hat drei Capability-Mengen, die null oder mehr der oben aufgeführten Capabilities enthalten:

Permitted (erlaubt):

Dies ist die begrenzende Übermenge für die effektiven Capabilities, die ein Thread annehmen kann. Es ist auch die begrenzende Übermenge für die Capabilites, die zu der vererbbaren Menge durch einen Thread hinzugefügt werden dürfen, der nicht die Capability CAP_SETPCAP in seiner effektiven Menge hat.

Falls ein Thread eine Capability aus seiner erlaubten Menge entfernt, kann es diese Capability niemals wiedererlangen (außer es führt ein Set-User-ID-Root-Programm mit execve(2) aus oder ein Programm, dessen zugeordnete Datei-Capabilities diese Capability wieder bewilligen).

Inheritable (vererbbar):

Dies ist eine Menge von Capabilities, die über execve(2) hinweg erhalten bleiben. Vererbbare Capabilities bleiben bei der Ausführung jedes Programms vererbbar und vererbbare Capbabilities werden zu der erlaubten Menge bei der Ausführung eines Programms, das die entsprechenden Bits in der Datei-Vererbbaren-Menge gesetzt hat, hinzugefügt.

Da vererbbare Capabilities im allgemeinen nicht über execve(2)-Aufrufe erhalten werden, wenn dies nicht als Benutzer root erfolgt, sollten Anwendungen, die Hilfsprogramme mit erhöhten Capabilities ausführen wollen, die Verwendung der unten beschriebenen Umgebungs-Capabilities in Betracht ziehen.

Effective (effektiv):

Dies ist die Menge an Capabilities, der vom Kernel zur Durchführung von Rechteprüfungen für den Thread verwandt wird.

Ambient (Umgebung) (seit Linux 4.3):

Dies ist eine Menge von Capabilities, die über execve(2) eines nicht privilegierten Programms hinweg erhalten bleiben. Die Umgebungs-Capability-Menge folgt der Invarianz, dass keine Capability jemals eine Umgebungs-Capability sein kann, falls sie nicht sowohl erlaubt als auch vererbbar ist.

Die Umgebungs-Capability-Menge kann direkt mit prctl(2) verändert werden. Umgebungs-Capabilities werden automatisch abgesenkt, falls entweder die entsprechende erlaubte oder vererbbare Capability abgesenkt wird.

Wird ein Programm ausgeführt, das die UID oder GID aufgrund von set-user-ID- oder set-group-ID-Bits ändert oder das über eine Menge an Datei-Capabilities verfügt, dann wird die Umgebungsmenge geleert. Umgebungs-Capabilities werden zu der erlaubten Menge hinzugefügt und der effektiven Menge zugewiesen, wenn execve(2) aufgerufen wird.

Ein mittels fork(2) erstelltes Kind erbt Kopien der Eltern-Capability-Menge. Lesen Sie weiter unten eine Diskussion der Behandlung von Capabilities während execve(2).

Mittels capset(2) kann ein Thread seine eigenen Capability-Mengen bearbeiten (siehe unten).

Seit Linux 3.2 legt die Datei /proc/sys/kernel/cap_last_cap den numerischen Wert der höchsten vom laufenden Kernel unterstützten Capability offen. Dies kann zur Bestimmung des höchsten Bits, das in einer Capability-Gruppe gesetzt werden kann, genutzt werden.

Datei-Capabilities

Seit Kernel 2.6.24 unterstützt der Kernel die Zuordnung von Capability-Mengen zu einer ausführbaren Datei mittels setcap(8). Die Datei-Capability-Mengen werden in erweiterten Attributen namens security.capability gespeichert (siehe setxattr(2) und xattr(7)). Das Schreiben in diese erweiterten Attribute benötigt die Capability CAP_SETFCAP. Die Datei-Capability-Mengen bestimmen zusammen mit den Capability-Mengen des Threads die Capabilities nach einem execve(2).

Die drei Datei-Capabilities-Mengen sind:

Permitted (erlaubt, früher als forced (erzwungen) bekannt):

Diese Capabilities werden dem Thread automatisch erlaubt, unabhängig von den geerbten Capabilities des Threads.

Inheritable (vererbbar, früher als allowed (erlaubt) bekannt):

Diese Menge wird mittels AND mit der vererbbaren Menge des Threads verknüpft, um zu bestimmen, welche vererbbaren Capabilities in der erlaubten Menge des Threads nach einem execve(2) aktiviert werden.

Effective (effektiv):

Dies ist keine Menge, sondern eher ein einziges Bit. Falls dieses Bit gesetzt ist, dann werden während eines execve(2) die gesamten erlaubten Capabilties für den Thread in die effektive Menge hochgezogen. Falls dieses Bit nicht gesetzt ist, dann wird nach einem execve(2) keine der erlaubten Capabilities in der neuen effektiven Menge sein.

Aktivieren des effektiven Datei-Capability-Bits impliziert, dass jede erlaubte oder vererbte Datei-Capability, die dazu führt, dass ein Thread die entsprechende erlaubte Capability während eines execve(2) erlangt (siehe die oben beschriebenen Transformationsregeln), auch dazu führt, dass er die Capability in seiner effektiven Menge erlangt. Werden daher Capabilities zu einer Datei zugeweisen ((setcap(8), cap_set_file(3), cap_set_fd(3)), falls der effektive Schalter für irgendeine Capability aktiviert ist, dann muss der effektive Schalter auch als aktiviert für alle anderen Capabilities, für die die entsprechenden erlaubten oder vererbbaren Schalter aktiviert sind, spezifiziert werden.

Datei-Capabilities-Masken-Versionierung

Um Erweiterbarkeit zu erlauben, unterstützt der Kernel ein Schema, um eine Versionsnummer innerhalb des erweiterten Attributs security.capability zu kodieren, die zur Implementierung von Datei-Capabilities verwandt wird. Diese Versionsnummern sind implementierungsintern und für Benutzerraum-Anwendungen nicht direkt sichtbar. Derzeit werden die folgenden Versionen untersützt:

VFS_CAP_REVISION_1

Dies war die ursprüngliche Datei-Capability-Implementierung, die 32-Bit-Masken für Datei-Capabilities unterstützte.

VFS_CAP_REVISION_2 (seit Linux 2.6.25)

Diese Version erlaubt Datei-Capability-Masken in der Größe von 64 Bit und wurde notwendig, da die Anzahl an unterstützen Capabilities 32 überstieg. Der Kernel unterstützt weiterhin transparent die Ausführung von Dateien mit 32-Bit-Version-1-Capability-Masken, aber wenn Capabilities zu Dateien hinzugefügt werden, die bisher keine Capabilities hatten, oder Capabilities von bestehenden Dateien geändert werden, wird automatisch das Version-2-Schema (oder möglicherweise das unten beschriebene Version-3-Schema) verwandt.

VFS_CAP_REVISION_3 (seit Linux 4.14)

Version-3-Datei-Capabilities werden zur Unterstützung von (nachfolgend beschriebenen) namensraumbezogenen Datei-Capabilities bereitgestellt.

Wie bei Version-2-Datei-Capabilities sind die Version-3-Capability Masken 64 Bit groß. Aber zusätzlich wird die Wurzelbenutzerkennung des Namensraums in dem erweiterten Attribut security.capability kodiert. (Eine Namensraum-Wurzelbenutzerkennung ist der Wert, auf den die Benutzerkennung 0 innerhalb dieses Namensraums in dem ursprünglichen Namensraum abgebildet wird.)

Version-3-Datei-Capabilities sind so entwickelt worden, dass sie mit Version-2-Capabilities koexistieren können, d.h. auf einem modernen Linux-System können einige Dateien Version-2-Capabilities tragen, während andere Version-3-Capabilities haben.

Vor Linux 4.14 war die einzige Art von Capability-Maske, die an eine Datei angehängt werden konnte, eine VFS_CAP_REVISION_2-Maske. Seit Linux 4.14 hängt die Version der Capability-Maske, die an eine Datei angehängt werden kann, von den Umständen ab, unter denen das erweiterte Attribut security.capability erstellt wurde.

Seit Linux 4.14 wird ein erweitertes Attribut security.capability automatisch als ein Version-3-(VFS_CAP_REVISION_3)-Attribut erstellt (oder in ein solches umgewandelt), falls beide folgenden Punkte zutreffen:

(1)

Der Thread, der das Attribut schreibt, befindet sich in einem nichtinitialen Namensraum. (Genauer: Der Thread befindet sich in einem Benutzernamensraum, der sich von dem unterscheidet, unter dem das darunterliegende Dateisystem eingehängt wurde.)

(2)

Der Thread hat die Capability CAP_SETFCAP über der Datei-Inode, was bedeutet, dass (a) der Thread die Capability CAP_SETFCAP in seinem eigenen Benutzernamensraum hat und (b) die UID und GID der Datei-Inode Abbildungen in den Namensraum des schreibenden Benutzers haben.

Wenn ein erweitertes Attribut VFS_CAP_REVISION_3 security.capability erstellt wird, wird die Wurzelbenutzerkennung des erstellenden Namensraums des Benutzers in dem erweiterten Attribut gespeichert.

Im Gegensatz dazu wird beim Erstellen eines erweiterten Attributs security.capability aus einem privilegierten (CAP_SETFCAP) Thread, der sich in dem Namensraum befindet, unter dem das darunterliegende Dateisystem eingehängt wurde, automatisch zu einem Version-2-(VFS_CAP_REVISION_2)-Attribut führen.

Beachten Sie, dass der Datei entweder ein erweitertes Attribut security.capability der Version 2 oder 3 zugeordnet werden kann, aber nicht beide: Erstellung oder Änderung des erweiterten Attributs security.capability wird automatisch die Version abhängig von den Umständen, in denen das erweiterte Attribut erstellt oder verändert wird, anpassen.

Umwandlungen von Capabilities während execve()

Während eines execve(2) berechnet der Kernel die neuen Capabilities eines Prozesses mit dem folgenden Algorithmus:

P'(ambient)     = (Datei ist privilegiert) ? 0 : P(ambient)
P'(permitted)   = (P(inheritable) & F(inheritable)) |


                  (F(permitted) & cap_bset) | P'(ambient)
P'(effective)   = F(effective) ? P'(permitted) : P'(ambient)
P'(inheritable) = P(inheritable)    [d.h. unverändert]

wobei:

Eine privilegierte Datei verfügt über Capabilities oder hat das set-user-ID- oder set-group-ID-Bit gesetzt.

Hinweis: Die oben beschriebenen Capability-Übergänge könnten aus den gleichen Gründen, aus denen auch die Bits set-user-ID and set-group-ID ignorieert werden, nicht durchgeführt werden (d.h. Datei-Capabilities könnten ignoriert werden); siehe execve(2).

Hinweis: Entsprechend den obigen Regeln werden alle Capabilities, die in der erlaubten und effektiven Menge vorhanden sind, zurückgesetzt, falls ein Prozess mit einer von Null verschiedenen Benutzerkennung ein execve(2) durchführt. Für die Behandlung der Capabilities, wenn ein Prozess mit der Benutzerkennung Null ein execve(2) durchführt, siehe unten unter Capabilities und Ausführung von Programmen durch root.

Sicherheitsprüfungen für Capability-unfähige Programme

Ein Capability-unfähiges Programm ist eine Anwendung, die für Datei-Capabilities markiert ist, aber noch nicht für die Verwendung des libcap(3)-APIs zur Bearbeitung seiner Capabilities konvertiert wurde. (Mit anderen Worten, dies ist ein traditionelles »set-user-ID-root«-Programm, das auf Datei-Capabilities umgestellt wurde, aber dessen Code nicht angepasst wurde, um mit Capabilities umzugehen.) Für solche Anwendungen wird das effektive Capability-Bit auf die Datei gesetzt, so dass die erlaubten Capabilities automatisch beim Ausführen der Datei in der effektiven Menge aktiviert werden. Der Kernel erkennt für den hier beschriebenen Zweck eine Datei, die das effektive Capability-Bit gesetzt hat, als Capability-unfähig.

Beim Ausführen eines Capability-unfähigen Programms prüft der Kernel nach den oben beschriebenen Umwandlungen, ob der Prozess alle erlaubten Capabilities, die in der Datei-erlaubten Menge angegeben wurden, erlangt hat. (Ein typischer Grund, warum dies nicht passieren könnte, liegt darin, dass die Capability-Begrenzungsmenge einige der Capabilities in der Datei-erlaubten Menge ausblenden könnte.) Falls der Prozess nicht die komplette Menge der Datei-erlaubten Capabilities erlangte, schlägt execve(2) mit dem Fehler EPERM fehl. Dies verhindert mögliche Sicherheitsrisiken, die daraus resultieren, dass ein Capability-unfähiges Programm mit weniger als den benötigten Privilegien ausgeführt wird. Beachten Sie, dass definitionsgemäß die Anwendung das Problem nicht selbst erkennen könnte, da sie nicht das libcap(3)-API einsetzt.

Capabilities und Ausführung von Programmen durch root

Um während eines execve(2) ein allmächtigen root mit Capability-Mengen bereitzustellen:

1.

Falls ein Set-User-ID-Root-Programm ausgeführt wird oder die reale oder effektive Benutzerkennung des Prozesses 0 (root) ist sind die vererbbaren und erlaubten Dateimengen komplett auf nur Einsen definiert (d.h. alle Capabilities aktiviert).

2.

Falls ein Set-User-ID-Root-Programm ausgeführt wird oder die effektive Benutzerkennung des Prozesses 0 ist (root), dann ist das effektive Datei-Bit als Eins (aktiviert) definiert.

Das Fazit der obigen Regeln, kombiniert mit den oben beschriebenen Capability-Umwandlungen, ist folgendes:

• Wenn ein Prozess ein Set-User-ID-Root-Programm mit execve(2) ausführt oder wenn ein Prozess mit einer effektiven UID von 0 ein Programm mit execve ausführt, er alle Capabilities in seinen erlaubten und effektiven Mengen erhält, außer denen, die durch die Capability-Begrenzungsmenge maskiert sind.
• Wenn ein Prozess mit einer realen UID von 0 ein Programm mit execve(2) ausführt, erhält es alle Capabilities in seiner erlaubten Capability-Menge, außer denen, die durch die Capability-Begrenzungsmenge maskiert sind.

Die obigen Schritte ergeben eine Semantik, die identisch zu der von traditionellen UNIX-Systemen ist.

Set-user-ID-root-Programme die Datei-Capabilities haben

Wird ein Programm ausgeführt, das sowohl set-user-ID-Root ist als auch über Datei-Capabilities verfügt, führt dies dazu, dass der Prozess nur die durch das Programm eingeräumten Capabilities erlangt (d.h. nicht alle Capabilities, was passierte, wenn ein set-user-ID-Root-Programm ausgeführt würde, das keine zugeordneten Datei-Capabilities hat). Beachten Sie, dass einem Programm eine leere Capability-Menge zugeordnet werden kann und es daher möglich ist, ein set-user-ID-root-Programm zu erstellen, das die effektive und die gespeicherte set-user-ID des Progresses, der das Programm ausführt, auf 0 setzt, aber dem Prozess keine Capabilities gewährt.

Capability-Begrenzungsmenge

Die Capability-Begrenzungsmenge ist ein Sicherheitsmechanismus, der zur Begrenzung der Capabilities, die während eines execve(2) erlangt werden können, dienen kann. Die Begrenzungsmenge wird auf die folgende Art und Weise benutzt:

• Während eines execve(2) wird die Capability-Begrenzungsmenge mittels AND mit der erlaubten Datei-Capability-Menge verknüpft und das Ergebnis dieser Aktion wird der erlaubten Capability-Menge des Threads zugewiesen. Die Capability-Begrenzungsmenge stellt daher eine Grenze für die erlaubten Capabilities dar, die einer ausführbaren Datei erlaubt werden dürfen.
• (Seit Linux 2.6.25) Die Capability-Begrenzungsmenge agiert als begrenzende Übermenge für die Capabilities, die ein Thread zu seiner vererbbaren Menge mittels capset(2) hinzufügen kann. Das bedeutet, dass ein Thread eine Capability nicht zu seiner vererbbaren Menge hinzufügen kann, falls es nicht in der Begrenzungsmenge enthalten ist, selbst falls es in seinen erlaubten Capabilities vorhanden ist, wenn er eine Datei mit execve(2) ausführt, die diese Capability in seiner vererbbaren Menge hat.

Beachten Sie, dass die Begrenzungsmenge die erlaubten Datei-Capabilities maskiert, aber nicht die vererbbaren Capabilities. Falls ein Thread eine Capability in seiner vererbbaren Menge betreut, die nicht in seiner Begrenzungsmenge ist, dann kann er weiterhin die Capability in seiner erlaubten Menge erlangen, indem er eine Datei ausführt, die diese Capability in seiner vererbbaren Menge enthält.

Abhängig von der Kernelversion ist die Capability-Begrenzungsmenge entweder ein systemweites Attribut oder ein prozessweises Attribut.

Capability-Begrenzungsmenge vor Linux 2.6.25

In Kerneln vor 2.6.25 ist die Capability-Begrenzungsmenge ein systemweites Attribut, das alle Threads auf dem System betrifft. Auf die Begrenzungsmenge kann über die Datei /proc/sys/kernel/cap-bound zugegriffen werden. (Zur Erhöhung der Konfusion wird dieser Bitmaskenparameter als vorzeichenbehaftete Dezimalzahl in /proc/sys/kernel/cap-bound ausgedrückt.)

Nur der init-Prozess darf Capabilities in der Capability-Begrenzungsmenge setzen; abgesehen davon kann der Superuser (oder genauer: ein Prozess mit der Capability CAP_SYS_MODULE) nur Capabilities aus dieser Menge entfernen.

Auf einem Standardsystem maskiert die Capability-Begrenzungsmenge immer die Capability CAP_SETPCAP. Um diese Einschränkung zu entfernen (gefährlich!), verändern Sie die Definition von CAP_INIT_EFF_SET in include/linux/capability.h und bauen Ihren Kernel neu.

Die systemweite Capability-Begrenzungsmengenfunktion wurde Linux in Version 2.2.11 hinzugefügt.

Capability-Begrenzungsmenge seit Linux 2.6.25

Seit Linux 2.6.25 ist die Capability-Begrenzungsmenge ein pro-Thread-Attribut. (Es gibt keine systemweite Capability-Begrenzungsmenge mehr.)

Die Begrenzungsmenge wird bei fork(2) von dem Elternprozess des Threads vererbt und bleibt über ein execve(2) erhalten.

Ein Thread kann mittels der Aktion prctl(2) PR_CAPBSET_DROP Capabilities aus seiner Begrenzungsmenge entfernen, vorausgesetzt, er verfügt über die Capability CAP_SETPCAP. Sobald eine Capability aus der Begrenzungsmenge entfernt wurde, kann sie nicht mehr zu der Menge wieder hinzugefügt werden. Ein Thread kann mittels der Aktion prctl(2) PR_CAPBSET_READ herausfinden, ob eine Capability in seiner Begrenzungsmenge liegt.

Entfernen von Capabilities aus der Begrenzungsmenge ist nur möglich, falls Datei-Capabilities in den Kernel kompiliert wurden. In Kerneln vor Linux 2.6.33 waren Datei-Capabilities eine optionale Funktionalität, die mittels der Option CONFIG_SECURITY_FILE_CAPABILITIES konfigurierbar war. Seit Linux 2.6.33 ist die Konfigurationsoption entfernt und Datei-Capabilities sind immer Teil des Kernels. Wenn Datei-Capabilities in den Kernel kompiliert sind, beginnt der init-Prozess (der Urahn aller Prozesse) mit einer kompletten Begrenzungsmenge. Falls Datei-Capabilities nicht in den Kernel kompiliert sind, dann beginnt init mit einer vollständigen Begrenzungsmenge ohne CAP_SETPCAP, da diese Capability eine andere Bedeutung hat, wenn es keine Datei-Capabilities gibt.

Die Entfernung einer Capability aus der Begrenzungsmenge entfernt sie nicht aus der vererbbaren Menge des Threads. Allerdings verhindert es das Zurückfügen in die vererbbare Menge des Threads in der Zukunft.

Effekt von Benutzerkennungsänderungen auf Capabilities

Um die traditionellen Semantiken für Übergänge zwischen 0 und von 0 verschiedenen Kennungen zu erhalten, führt der Kernel folgende Änderungen an den Capability-Mengen eines Threads bei Änderung der echten, effektiven, gespeicherten und Dateisystem-Benutzerkennung (unter Verwendung von setuid(2), setresuid(2) oder ähnlich) durch:

1.

Falls einer der realen, effektiven oder gespeicherten Set-User-IDs vorher 0 war und als Ergebnis der UID-Änderung alle dieser Kennungen eine von 0 verschiedenen Wert haben, dann werden alle Capabilities aus den erlaubten, effektiven und Umgebungs-Capability-Mengen gelöscht.

2.

Falls die effektive Benutzerkennung von 0 auf einen von 0 verschiedenen Wert geändert wird, werden alle Capabilities aus der effektiven Menge gelöscht.

3.

Falls die effektive Benutzerkennung von einem von 0 verschiedenen Wert auf 0 geändert wird, dann wird die erlaubte Menge in die effektive Menge kopiert.

4.

Falls die Dateisystem-Benutzerkennung von 0 auf einen anderen Wert geändert wird (siehe setfsuid(2)), dann werden die folgenden Capabilities aus der effektiven Menge entfernt: CAP_CHOWN, CAP_DAC_OVERRIDE, CAP_DAC_READ_SEARCH, CAP_FOWNER, CAP_FSETID, CAP_LINUX_IMMUTABLE (seit Linux 2.6.30), CAP_MAC_OVERRIDE und CAP_MKNOD (seit Linux 2.6.30). Falls die Dateisystem-UID von einem von 0 verschiedenen Wert auf 0 geändert wird, dann werden alle dieser Capabilities, die in der erlaubten Menge aktiviert waren, in der effektiven Menge aktiviert.

Falls ein Thread, der einen Wert 0 für mindestens eine seiner Benutzerkennungen hat, verhindern möchte, dass seine erlaubte Capability-Menge bereinigt wird, wenn er alle seine Benutzerkennungen auf einen von 0 verschiedenen Wert setzt, kann er dies mittels der unten beschriebenen SECBIT_KEEP_CAPS-Securebits-Schaltern erreichen.

Programmatische Anpassung von Capability-Mengen

Ein Thread kann seine Capability-Mengen mittels der Systemaufrufe capget(2) und capset(2) ermitteln und ändern. Allerdings werden für diesen Zweck die Verwendung von cap_get_proc(3) und cap_set_proc(3), beide im Paket libcap bereitgestellt, empfohlen. Die folgenden Regeln bestimmen die Änderungen an den Capability-Mengen des Threads:

1.

Falls der Aufrufende nicht über die Capability CAP_SETPCAP verfügt, dann muss die neue vererbbare Menge eine Teilmenge der Kombination der bestehenden vererbbaren und erlaubten Menge sein.

2.

(Seit Linux 2.6.25) Die neue vererbbare Menge muss eine Teilmenge der Kombination der bestehenden vererbbaren Menge und der Capability-Begrenzungsmenge sein.

3.

Die neue erlaubte Menge muss eine Teilmenge der bestehenden erlaubten Menge sein (d.h. es ist nicht möglich, erlaubte Capabilities zu erlangen, die der Thread derzeit nicht hat).

4.

Die neue effektive Menge muss eine Teilmenge der neuen erlaubten Menge sein.

Der Schalter securebits: eine reine Capability-Umgebung einrichten

Beginnend mit Kernel 2.6.26 und mit einem Kernel, in dem Datei-Capabilities aktiviert sind, implementiert Linux eine Menge von pro-Thread-securebits-Schaltern, die zur Deaktivierung von spezieller Handhabung von Capabilities für UID 0 (root) verwandt werden können. Dies sind die folgenden Schalter:

SECBIT_KEEP_CAPS

Durch Setzen dieses Schalters darf ein Thread, der mindestens eine 0 UID hat, Capabilities in seiner erlaubten und effektiven Menge behalten, wenn er alle UIDs auf von 0 verschiedene Werte umschaltet. Falls dieser Schalter nicht gesetzt ist, dann führt das Umschalten der UIDs dazu, dass er alle Capabilities in diesen Mengen verliert. Dieser Schalter wird bei execve(2) immer bereinigt.

Die Einstellung des Schalters SECBIT_KEEP_CAPS wird ignoriert, falls der Schalter SECBIT_NO_SETUID_FIXUP gesetzt ist. (Letzterer Schalter stellt eine Übermenge des Effekts des ersteren Schalters bereit.)

Dieser Schalter stellt die gleiche Funktionalität wie die ältere Aktion prctl(2) PR_SET_KEEPCAPS bereit.

SECBIT_NO_SETUID_FIXUP

Setzen dieses Schalters hindert den Kernel daran, die erlaubten, effektiven und Umgebungs-Capability-Mengen des Prozesses anzupassen, wenn die effektive und die Dateisystem-UID eines Threads zwischen null und von null verschiedenen Werten umgeschaltet werden. (Lesen Sie den Abschnitt Effekt von Benutzerkennungsänderungen auf Capabilities)

SECBIT_NOROOT

Falls dieses Bit gesetzt ist, dann verleiht der Kernel keine Capabilities, wenn ein Set-User-ID-Root-Programm ausgeführt wird oder wenn ein Prozess mit einer effektiven oder realen UID von 0 execve(2) aufruft. (Lesen Sie den Abschnitt Capabilities und Ausführung von Programmen durch root)

SECBIT_NO_CAP_AMBIENT_RAISE

Durch Setzen dieses Schalters dürfen keine Umgebungs-Capabilities mit der prctl(2)-Aktion PR_CAP_AMBIENT_RAISE gehoben werden.

Jeder der obigen »basis«-Schalter hat einen begleitenden »gesperrten« Schalter. Das Setzen eines »gesperrten« Schalters ist unumkehrbar und hat den Effekt, dass weitere Änderungen an dem entsprechenden Basisschalter nicht mehr möglich sind. Die gesperrten Schalter sind: SECBIT_KEEP_CAPS_LOCKED, SECBIT_NO_SETUID_FIXUP_LOCKED, SECBIT_NOROOT_LOCKED und SECBIT_NO_CAP_AMBIENT_RAISE_LOCKED.

Die Schalter securebits können mit den Aktionen prctl(2) PR_SET_SECUREBITS und PR_GET_SECUREBITS geändert und abgefragt werden. Die Capability CAP_SETPCAP wird für die Veränderung der Schalter benötigt.

Die Schalter securebits werden von Kindprozessen vererbt. Während eines execve(2) werden alle Schalter beibehalten, außer SECBIT_KEEP_CAPS, das immer bereinigt wird.

Eine Anwendung kann den folgenden Aufruf verwenden, um sich selbst und alle seine Abkömmlinge in eine Umgebung zu sperren, in der die einzige Möglichkeit, Capabilities zu erlangen, darin besteht, ein Programm auzuführen, das über die zugeordneten Datei-Capabilities verfügt:

prctl(PR_SET_SECUREBITS,
	/* SECBIT_KEEP_CAPS off */


        SECBIT_KEEP_CAPS_LOCKED |


        SECBIT_NO_SETUID_FIXUP |


        SECBIT_NO_SETUID_FIXUP_LOCKED |


        SECBIT_NOROOT |


        SECBIT_NOROOT_LOCKED);


        /* Setzen/Sperren von SECBIT_NO_CAP_AMBIENT_RAISE


           ist nicht erforderlich */

Interaktion mit Benutzernamensräumen

Für eine Diskussion der Interaktion von Capabilities und Benutzer-Namensräumen lesen Sie user_namespaces(7).

Namensraumbezogene Datei-Capabilities

Traditionelle (d.h. Version 2-)Datei-Capabilities ordnen nur eine Menge von Capability-Masken einem binären Programm zu. Wenn ein Prozess ein Programm mit solchen Capabilities ausführt, erlangt es die zugeordneten Capabilities (innerhalb seines Benutzernamensraums) wie in den oben beschriebenen Regeln »Umwandlungen von Capabilities während execve()« beschrieben.

Da Version-2-Datei-Capabilities dem ausführenden Prozess unabhängig davon, in welchem Namensraum er sich befindet, Capabilities verleiht, dürfen nur privilegierte Prozesse Capabilities einer Datei zuordnen. Hier bedeutet »privilegiert«, dass ein Prozess über die Capability CAP_SETFCAP in dem Benutzernamensraum, in dem das Dateisystem eingehängt wurde (normalerweise dem initialen Namensraum), verfügt. Diese Einschränkung führt dazu, dass in bestimmten Einsatzfällen Datei-Capabilities nutzlos sind. Es kann zum Beispiel in namensraumbezogenen Containern wünschenswert sein, in der Lage zu sein, ein Programm zu erstellen, das Capabilities nur an Prozesse, die innerhalb dieses Containers ausgeführt werden, zu verleihen, aber nicht an Prozesse, die außerhalb des Containers ausgeführt werden.

Linux 4.14 fügte sogenannte namensraumbezogene Datei-Capabilities hinzu, um solche Fälle zu unterstützen. Namensraumbezogene Datei-Capabilities werden als Version 3 (d.h. VFS_CAP_REVISION_3) erweiterte Attribute security.capability aufgezeichnet. Solch ein Attribut wird normalerweise erstellt, wenn ein Prozess, der in einem nichtinitialen Benutzernamensraum liegt, Datei-Capabilities einer Datei zuordnet (setxattr(2)), deren Benutzerkennung auf die Benutzerkennung des Erstellers des Namensraums passt. In diesem Fall zeichnet der Kernel nicht nur die Capability-Masken in dem erweiterten Attribut auf, sondern auch die Namensraumwurzelbenutzerkennung. Für weitere Details siehe Datei-Capabilities-Masken-Versionierung weiter oben.

Wie mit Programmen, die eine Datei-Capability VFS_CAP_REVISION_2 haben, verleiht ein Programm mit Datei-Capability VFS_CAP_REVISION_3 während eines execve() Capabilities an einen Prozess. Allerdings werden Capabilities nur verliehen, falls das Programm von einem Prozess ausgeführt wird, der in einem Benutzernamensraum, dessen UID 0 auf die Wurzelbenutzerkennung, die in dem erweiterten Attribut gespeichert ist, abgebildet ist oder wenn er von einem Prozess ausgeführt wird, der in einem Nachkommen solch eines Namensraums liegt.