SELinux-Sicherheit in RHEL verwalten

Einführung

In diesem Lab erhalten Sie praktische Erfahrung in der Verwaltung der SELinux-Sicherheit in RHEL. Sie lernen, die SELinux-Durchsetzungsmodi sowohl temporär als auch dauerhaft zu ändern und Apache mit benutzerdefinierten SELinux-Dateikontexten zu konfigurieren. Das Lab behandelt auch die Anpassung der SELinux-Richtlinie für Benutzer-Home-Verzeichnisse mithilfe von Booleans und bietet praktische Schritte zur Fehlerbehebung und Behebung von SELinux-Verweigerungen für Apache-Webserver und benutzerdefinierte Webinhalte.

SELinux-Durchsetzungsmodus ändern

In diesem Schritt lernen Sie, wie Sie SELinux-Modi sowohl temporär als auch dauerhaft verwalten. SELinux (Security-Enhanced Linux) ist ein Sicherheitsmechanismus, der eine obligatorische Zugriffskontrolle (MAC) für den Linux-Kernel bereitstellt. Es definiert die Zugriffsrechte für Prozesse, Dateien und andere Systemressourcen.

SELinux arbeitet in drei Hauptmodi:

Enforcing (Durchsetzen): Die SELinux-Richtlinie wird durchgesetzt. Zugriffe, die von der Richtlinie verweigert werden, werden blockiert und protokolliert. Dies ist der Standard- und sicherste Modus.
Permissive (Zulässig): Die SELinux-Richtlinie wird nicht durchgesetzt. Zugriffe, die von der Richtlinie verweigert werden, werden protokolliert, aber nicht blockiert. Dieser Modus ist nützlich für die Fehlerbehebung und das Testen neuer Richtlinien.
Disabled (Deaktiviert): SELinux ist ausgeschaltet. Es wird keine Richtlinie geladen oder durchgesetzt. Dieser Modus wird im Allgemeinen nicht für Produktionssysteme empfohlen.

Sie werden üben, den SELinux-Modus mithilfe von Befehlszeilentools und durch Ändern von Konfigurationsdateien zu ändern.

Zuerst wollen wir den aktuellen SELinux-Durchsetzungsmodus überprüfen.

Überprüfen Sie den aktuellen SELinux-Durchsetzungsmodus.

Sie können den Befehl getenforce verwenden, um schnell den aktuellen SELinux-Modus anzuzeigen.
```
getenforce
```
Sie sollten Enforcing als Ausgabe sehen, was darauf hindeutet, dass SELinux derzeit seine Richtlinien durchsetzt.
```
Enforcing
```
Ändern Sie den SELinux-Modus vorübergehend in permissive.

Mit dem Befehl setenforce können Sie den SELinux-Modus zur Laufzeit ändern. Ein Wert von 0 setzt den Modus auf permissive, und 1 setzt ihn auf enforcing. Diese Änderung ist temporär und bleibt nicht über Neustarts hinweg erhalten.
```
sudo setenforce 0
```
Überprüfen Sie nun die Änderung erneut mit getenforce.
```
getenforce
```
Die Ausgabe sollte jetzt Permissive sein.
```
Permissive
```
Ändern Sie den SELinux-Modus vorübergehend zurück in enforcing.

Um die temporäre Änderung rückgängig zu machen, verwenden Sie setenforce 1.
```
sudo setenforce 1
```
Überprüfen Sie den Modus noch einmal.
```
getenforce
```
Die Ausgabe sollte wieder Enforcing sein.
```
Enforcing
```
Ändern Sie den Standard-SELinux-Modus dauerhaft in permissive.

Um SELinux-Modusänderungen über Neustarts hinweg persistent zu machen, müssen Sie die Datei /etc/selinux/config ändern. Diese Datei definiert den Standard-SELinux-Modus für das System.

Öffnen Sie die Konfigurationsdatei mit nano.
```
sudo nano /etc/selinux/config
```
Suchen Sie im nano-Editor die Zeile, die mit SELINUX= beginnt, und ändern Sie ihren Wert von enforcing in permissive.
```
## This file controls the state of SELinux on the system.
## SELINUX= can take one of these three values:
##     enforcing - SELinux security policy is enforced.
##     permissive - SELinux prints warnings instead of enforcing.
##     disabled - No SELinux policy is loaded.
SELINUX=permissive
## SELINUXTYPE= can take one of these three values:
##     targeted - Targeted processes are protected,
##                for the majority of users.
##     minimum - Modification of targeted policy
##               uses current settings and adds to it.
##     mls - Multi Level Security protection.
SELINUXTYPE=targeted
```
Drücken Sie Ctrl+X zum Beenden, dann Y zum Bestätigen des Speicherns und Enter, um in dieselbe Datei zu schreiben.

Nach dem Speichern der Datei können Sie die Änderung in der Konfigurationsdatei mit grep bestätigen.
```
grep '^SELINUX' /etc/selinux/config
```
Die Ausgabe sollte SELINUX=permissive anzeigen.
```
SELINUX=permissive
SELINUXTYPE=targeted
```
Wichtiger Hinweis: Das Ändern von /etc/selinux/config ändert nicht sofort den aktiven SELinux-Modus. Es legt nur den Modus fest, der nach dem nächsten Systemneustart angewendet wird. Um den aktuellen aktiven Modus anzuzeigen, müssen Sie weiterhin getenforce verwenden.
```
getenforce
```
Es sollte immer noch Enforcing anzeigen, da das System noch nicht neu gestartet wurde.
```
Enforcing
```

Ändern Sie den Standard-SELinux-Modus in der Konfigurationsdatei wieder in enforcing.

Ändern wir nun den persistenten Modus wieder in enforcing. Dies ist die empfohlene und sicherste Einstellung für SELinux.

Öffnen Sie die Konfigurationsdatei erneut.

sudo nano /etc/selinux/config

Ändern Sie den Parameter SELINUX= wieder in enforcing.

## This file controls the state of SELinux on the system.
## SELINUX= can take one of these three values:
##     enforcing - SELinux security policy is enforced.
##     permissive - SELinux prints warnings instead of enforcing.
##     disabled - No SELinux policy is loaded.
SELINUX=enforcing
## SELINUXTYPE= can take one of these three values:
##     targeted - Targeted processes are protected,
##                for the majority of users.
##     minimum - Modification of targeted policy
##               uses current settings and adds to it.
##     mls - Multi Level Security protection.
SELINUXTYPE=targeted

Speichern und beenden Sie die Datei (Ctrl+X, Y, Enter).

Bestätigen Sie die Änderung in der Konfigurationsdatei.

grep '^SELINUX' /etc/selinux/config

Die Ausgabe sollte jetzt SELINUX=enforcing anzeigen.

SELINUX=enforcing
SELINUXTYPE=targeted

Zu diesem Zeitpunkt ist der aktive SELinux-Modus des Systems immer noch Enforcing (wenn Sie nach Schritt 4 nicht neu gestartet haben), und die persistente Einstellung ist ebenfalls Enforcing.

Apache mit benutzerdefinierten SELinux-Dateikontexten konfigurieren

In diesem Schritt lernen Sie, wie Sie Apache so konfigurieren, dass Webinhalte aus einem nicht standardmäßigen Verzeichnis bereitgestellt werden, und wie Sie dessen SELinux-Dateikontexte verwalten. Standardmäßig beschränken SELinux-Richtlinien Apache (httpd) auf die Bereitstellung von Dateien nur aus bestimmten Verzeichnissen, hauptsächlich /var/www/html. Wenn Sie Webinhalte an einem anderen Ort ablegen, verhindert SELinux den Zugriff von Apache darauf, selbst wenn die Dateisystemberechtigungen korrekt sind. Hier kommen SELinux-Dateikontexte ins Spiel.

Ein SELinux-Dateikontext ist eine Bezeichnung, die einer Datei oder einem Verzeichnis zugewiesen wird und deren Sicherheitsattribute definiert. Damit Apache Inhalte von einem benutzerdefinierten Speicherort bereitstellen kann, müssen dieser Speicherort und seine Inhalte den richtigen SELinux-Kontext haben, typischerweise httpd_sys_content_t. Sie verwenden semanage fcontext, um eine persistente Regel zu definieren, und restorecon, um sie anzuwenden.

Zuerst müssen Sie den Apache HTTP-Server installieren.

Installieren Sie den Apache HTTP-Server.

Verwenden Sie den Paketmanager dnf, um das Paket httpd zu installieren.
```
sudo dnf install -y httpd
```
Sie sollten eine Ausgabe sehen, die die erfolgreiche Installation des Pakets httpd und seiner Abhängigkeiten anzeigt.
Erstellen Sie ein benutzerdefiniertes Verzeichnis für Webinhalte und eine index.html-Datei.

Sie erstellen ein neues Verzeichnis namens /custom und legen eine einfache index.html-Datei darin ab. Dies ist Ihr nicht standardmäßiges Webdokument-Root.
```
sudo mkdir /custom
echo 'This is custom web content.' | sudo tee /custom/index.html
```
Überprüfen Sie den Inhalt der Datei index.html.
```
cat /custom/index.html
```
```
This is custom web content.
```
Konfigurieren Sie Apache so, dass das neue Dokument-Root verwendet wird.

Die Hauptkonfigurationsdatei von Apache ist /etc/httpd/conf/httpd.conf. Sie müssen diese Datei bearbeiten, um Apache auf Ihr neues Verzeichnis /custom anstelle des Standardverzeichnisses /var/www/html zu verweisen.

Öffnen Sie die Konfigurationsdatei mit nano.
```
sudo nano /etc/httpd/conf/httpd.conf
```
Suchen Sie im Editor die Zeilen DocumentRoot "/var/www/html" und <Directory "/var/www/html">. Ändern Sie beide Vorkommnisse von /var/www/html in /custom.

Die relevanten Abschnitte sollten nach der Änderung so aussehen:
```
#
## DocumentRoot: The directory out of which you will serve your
## documents. By default, all requests are taken from this directory, but
## symbolic links and aliases may be used to point to other locations.
#
DocumentRoot "/custom"

#
## Relax access to content within /var/www.
#
<Directory "/custom">
    AllowOverride None
    ## Allow open access:
    Require all granted
</Directory>
```
Speichern und beenden Sie die Datei (Ctrl+X, Y, Enter).
Starten und aktivieren Sie den Apache-Webdienst.

Nachdem Sie die Konfiguration geändert haben, müssen Sie den Dienst httpd starten. Da Sie sich in einer Containerumgebung befinden, ist systemctl nicht verfügbar. Sie starten httpd direkt.
```
sudo /usr/sbin/httpd -DFOREGROUND &
```
Das Symbol & führt den Befehl im Hintergrund aus, sodass Sie das Terminal weiterhin verwenden können. Sie sollten eine Ausgabe ähnlich dieser sehen, die anzeigt, dass Apache gestartet wird.
```
[1] 5094
AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using fe80::216:3eff:fe00:63b%eth0. Set the 'ServerName' directive globally to suppress this message
```
Hinweis: Die Warnmeldung über den vollqualifizierten Domänennamen des Servers ist in dieser Lab-Umgebung normal und kann ignoriert werden.

Um zu überprüfen, ob Apache ausgeführt wird, können Sie nach dem Prozess httpd suchen.
```
ps aux | grep httpd
```
Sie sollten mehrere httpd-Prozesse sehen, die ausgeführt werden.
```
root        ... /usr/sbin/httpd -DFOREGROUND
apache      ... /usr/sbin/httpd -DFOREGROUND
...output omitted...
```
Versuchen Sie, auf die Webseite zuzugreifen.

Versuchen Sie nun, mit curl auf Ihre Webseite zuzugreifen. Da Sie sich auf demselben Rechner befinden, können Sie localhost verwenden.
```
curl http://localhost/index.html
```
Hinweis: In dieser speziellen Umgebung stellen Sie möglicherweise fest, dass die Webseite auch mit dem Kontext root_t zugänglich ist. Dies zeigt, dass der Kontext root_t, während SELinux durchgesetzt wird, möglicherweise breitere Berechtigungen hat als erwartet. Für bewährte Sicherheitsverfahren und eine ordnungsgemäße SELinux-Konfiguration sollten Webinhalte jedoch weiterhin den entsprechenden Kontext httpd_sys_content_t verwenden.
```
This is custom web content.
```
Überprüfen Sie den aktuellen SELinux-Kontext des benutzerdefinierten Verzeichnisses.

Verwenden Sie den Befehl ls -Z, um den SELinux-Kontext Ihres Verzeichnisses /custom und der Datei index.html anzuzeigen.
```
ls -Zd /custom /custom/index.html
```
Sie werden feststellen, dass sie den Kontext root_t haben, was nicht der empfohlene Kontext für Apache-Webinhalte ist.
```
system_u:object_r:root_t:s0 /custom
system_u:object_r:root_t:s0 /custom/index.html
```
Vergleichen Sie dies mit dem Standard-Apache-Dokument-Root:
```
ls -Zd /var/www/html
```
Sie werden sehen, dass /var/www/html den Kontext httpd_sys_content_t hat. Dies ist der Kontext, den Sie auf Ihr benutzerdefiniertes Verzeichnis anwenden müssen.
```
system_u:object_r:httpd_sys_content_t:s0 /var/www/html
```
Definieren Sie eine persistente SELinux-Dateikontextregel für /custom.

Der Befehl semanage fcontext wird verwendet, um SELinux-Dateikontext-Zuordnungsregeln zu verwalten. Die Option -a fügt eine neue Regel hinzu, -t gibt den Zieltyp an, und der reguläre Ausdruck '/custom(/.*)?' stimmt mit dem Verzeichnis /custom selbst und allen Dateien und Unterverzeichnissen darin überein.
```
sudo semanage fcontext -a -t httpd_sys_content_t '/custom(/.*)?'
```
Dieser Befehl fügt die Regel zur SELinux-Richtlinie hinzu, ändert aber nicht sofort die Kontexte vorhandener Dateien.
Wenden Sie die neuen SELinux-Kontexte auf die Dateien an.

Der Befehl restorecon wird verwendet, um die SELinux-Kontexte von Dateien und Verzeichnissen auf ihre Standardwerte zurückzusetzen, wie sie von der Richtlinie definiert werden. Die Option -R wendet die Änderung rekursiv an, und -v liefert eine ausführliche Ausgabe.
```
sudo restorecon -Rv /custom
```
Sie sollten eine Ausgabe sehen, die anzeigt, dass die Kontexte von /custom und /custom/index.html neu beschriftet wurden.
```
Relabeled /custom from system_u:object_r:root_t:s0 to system_u:object_r:httpd_sys_content_t:s0
Relabeled /custom/index.html from system_u:object_r:root_t:s0 to system_u:object_r:httpd_sys_content_t:s0
```
Überprüfen Sie die Kontexte erneut mit ls -Z.
```
ls -Zd /custom /custom/index.html
```
Sie sollten jetzt den Kontext httpd_sys_content_t haben.
```
system_u:object_r:httpd_sys_content_t:s0 /custom
system_u:object_r:httpd_sys_content_t:s0 /custom/index.html
```
Greifen Sie erneut auf die Webseite zu.

Da die SELinux-Kontexte jetzt korrekt sind, versuchen Sie erneut, mit curl auf die Webseite zuzugreifen.
```
curl http://localhost/index.html
```
Sie sollten jetzt den Inhalt Ihrer Datei index.html sehen.
```
This is custom web content.
```
Beenden Sie abschließend den Apache HTTP-Serverprozess.
```
sudo pkill httpd
```
Überprüfen Sie, ob keine httpd-Prozesse ausgeführt werden.
```
ps aux | grep httpd
```
Sie sollten nur den grep-Prozess selbst sehen.
```
labex     ... grep httpd
```

SELinux-Richtlinie für Benutzer-Home-Verzeichnisse mit Booleans anpassen

In diesem Schritt lernen Sie, wie Sie die SELinux-Richtlinie mithilfe von Booleans anpassen, um Apache zu erlauben, Webinhalte aus den Home-Verzeichnissen der Benutzer bereitzustellen. Standardmäßig verhindert SELinux aus Sicherheitsgründen, dass Dienste wie Apache auf Dateien in den Home-Verzeichnissen der Benutzer zugreifen. Es gibt jedoch bestimmte Szenarien, wie z. B. persönliche Webseiten, in denen diese Funktionalität gewünscht ist.

SELinux-Booleans sind True/False-Einstellungen, mit denen Administratoren das Verhalten der SELinux-Richtlinie ändern können, ohne komplexe benutzerdefinierte Richtlinien schreiben zu müssen. Sie bieten eine flexible Möglichkeit, bestimmte Sicherheitsfunktionen zu aktivieren oder zu deaktivieren. Zum Beispiel gibt es ein Boolean speziell dafür, Apache den Zugriff auf Benutzer-Home-Verzeichnisse zu erlauben.

Aktivieren Sie die Benutzerverzeichnisfunktion von Apache.

Apache hat ein Modul namens mod_userdir, das es Benutzern ermöglicht, Webinhalte aus einem public_html-Verzeichnis innerhalb ihres Home-Verzeichnisses zu veröffentlichen (z. B. ~/public_html). Diese Funktion wird typischerweise in /etc/httpd/conf.d/userdir.conf konfiguriert. Standardmäßig ist diese Funktion oft deaktiviert.

Öffnen Sie die Konfigurationsdatei mit nano.
```
sudo nano /etc/httpd/conf.d/userdir.conf
```
Im Editor finden Sie Zeilen, die sich auf UserDir beziehen. Sie müssen die Zeile, die UserDir deaktiviert, auskommentieren und die Zeile, die sie für public_html aktiviert, einkommentieren.

Ändern Sie:
```
UserDir disabled
#UserDir public_html
```
In:
```
#UserDir disabled
UserDir public_html
```
Speichern und beenden Sie die Datei (Ctrl+X, Y, Enter).
Erstellen Sie ein public_html-Verzeichnis und eine index.html-Datei in Ihrem Home-Verzeichnis.

Sie erstellen das Verzeichnis public_html und eine index.html-Datei darin. Hier befinden sich Ihre persönlichen Webinhalte.
```
mkdir ~/public_html
echo 'This is labex user content.' > ~/public_html/index.html
```
Überprüfen Sie den Inhalt der Datei index.html.
```
cat ~/public_html/index.html
```
```
This is labex user content.
```
Information: Als Sie das Verzeichnis ~/public_html erstellten, wurde es automatisch mit den SELinux-Kontexten user_home_t und ~/ (Ihr Home-Verzeichnis) mit home_dir_t konfiguriert. Der Apache-Webserverprozess (httpd_t) kann standardmäßig keine Dateien lesen, die mit user_home_t oder home_dir_t gekennzeichnet sind, aufgrund der SELinux-Richtlinie.
Starten Sie den Apache-Webdienst.

Starten Sie den Dienst httpd. Denken Sie daran, dass systemctl in dieser Containerumgebung nicht verfügbar ist, also starten Sie httpd direkt.
```
sudo /usr/sbin/httpd -DFOREGROUND &
```
Möglicherweise wird eine Warnmeldung über den vollqualifizierten Domänennamen des Servers angezeigt, die in dieser Lab-Umgebung ignoriert werden kann.

Überprüfen Sie, ob Apache ausgeführt wird.
```
ps aux | grep httpd
```
```
root        ... /usr/sbin/httpd -DFOREGROUND
apache      ... /usr/sbin/httpd -DFOREGROUND
...output omitted...
```
Versuchen Sie, auf die Webseite des Benutzers zuzugreifen, und beobachten Sie die SELinux-Verweigerung.

Versuchen Sie nun, mit curl auf Ihre persönliche Webseite zuzugreifen. Die URL für Benutzerverzeichnisse hat typischerweise das Format http://localhost/~username/.
```
curl http://localhost/~labex/index.html
```
Sie erhalten wahrscheinlich einen "Forbidden"-Fehler, der anzeigt, dass Apache aufgrund von SELinux immer noch nicht auf den Inhalt zugreifen kann.
```
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>403 Forbidden</title>
</head><body>
<h1>Forbidden</h1>
<p>You don't have permission to access /~labex/index.html
on this server.<br />
</p>
</body></html>
```
Überprüfen Sie die SELinux-Booleans, die sich auf Home-Verzeichnisse für httpd beziehen.

Mit dem Befehl getsebool können Sie den aktuellen Zustand der SELinux-Booleans anzeigen. Sie können die Ausgabe mit grep filtern, um Booleans zu finden, die sich auf httpd und Home-Verzeichnisse beziehen.
```
sudo getsebool -a | grep httpd | grep home
```
Sie sollten httpd_enable_homedirs --> off sehen, was anzeigt, dass dieses Boolean derzeit deaktiviert ist.
```
httpd_enable_homedirs --> off
```
Aktivieren Sie das Boolean httpd_enable_homedirs dauerhaft.

Der Befehl setsebool wird verwendet, um den Zustand der SELinux-Booleans zu ändern. Die Option -P macht die Änderung über Neustarts hinweg persistent.
```
sudo setsebool -P httpd_enable_homedirs on
```
Überprüfen Sie, ob das Boolean jetzt on ist.
```
sudo getsebool -a | grep httpd | grep home
```
```
httpd_enable_homedirs --> on
```
Legen Sie die korrekten Dateiberechtigungen für das Home-Verzeichnis fest.

Auch wenn das SELinux-Boolean aktiviert ist, benötigt Apache die richtigen Dateisystemberechtigungen, um auf Ihr Home-Verzeichnis und das Verzeichnis public_html zuzugreifen. Standardmäßig sind Benutzer-Home-Verzeichnisse für den Apache-Benutzer nicht zugänglich.
```
chmod 711 ~
chmod 755 ~/public_html
chmod 644 ~/public_html/index.html
```
Greifen Sie erneut auf die Webseite zu.

Nachdem sowohl das Boolean httpd_enable_homedirs aktiviert als auch die Dateiberechtigungen korrekt sind, versuchen Sie erneut, mit curl auf Ihre persönliche Webseite zuzugreifen.
```
curl http://localhost/~labex/index.html
```
Sie sollten jetzt den Inhalt Ihrer Datei index.html sehen.
```
This is labex user content.
```
Fehlerbehebung: Wenn Sie auch nach dem Aktivieren des Booleans und dem Festlegen der Dateiberechtigungen weiterhin auf Zugriffsprobleme stoßen, zeigt dies die mehrschichtige Natur der Linux-Sicherheit. In einigen Umgebungen können zusätzliche Faktoren wie:
- Apache-Konfigurationsdirektiven in /etc/httpd/conf.d/userdir.conf
- SELinux-Dateikontexte auf der Home-Verzeichnisstruktur
- Zusätzliche Apache-Module oder Sicherheitseinstellungen
möglicherweise berücksichtigt werden müssen. Der wichtigste Lernpunkt ist das Verständnis, wie SELinux-Booleans in Verbindung mit herkömmlichen Dateiberechtigungen und anwendungsspezifischen Konfigurationen funktionieren.
Beenden Sie den Apache HTTP-Serverprozess.

Beenden Sie abschließend den Apache HTTP-Serverprozess.
```
sudo pkill httpd
```
Überprüfen Sie, ob keine httpd-Prozesse ausgeführt werden.
```
ps aux | grep httpd
```
```
labex     ... grep httpd
```

SELinux-Verweigerungen für den Apache-Webserver beheben

In diesem Schritt lernen Sie, wie Sie SELinux-Sicherheitsverweigerungen identifizieren und beheben, wobei der Schwerpunkt auf Problemen liegt, die den Apache-Webserver daran hindern könnten, ordnungsgemäß zu funktionieren. Wenn SELinux eine Operation blockiert, protokolliert es eine "Access Vector Cache" (AVC)-Verweigerungsnachricht. Diese Nachrichten sind entscheidend, um zu verstehen, warum eine Operation fehlgeschlagen ist und wie sie behoben werden kann.

Sie verwenden Tools wie auditd (der Linux Auditing System-Daemon) und sealert, um diese Verweigerungsnachrichten zu analysieren. auditd sammelt Systemaufrufe und Ereignisse, einschließlich SELinux-Verweigerungen, und speichert sie in /var/log/audit/audit.log. Das Tool sealert, Teil des Pakets setroubleshoot-server, kann diese Protokolle parsen und für SELinux-Verweigerungen für Menschen lesbare Erklärungen und Lösungsvorschläge liefern.

Zuerst müssen Sie sicherstellen, dass auditd und setroubleshoot-server installiert sind.

Installieren Sie auditd und setroubleshoot-server.
```
sudo dnf install -y audit setroubleshoot-server
```
Sie sollten eine Ausgabe sehen, die die erfolgreiche Installation dieser Pakete anzeigt.
Starten Sie den Apache-Webserver und erstellen Sie eine problematische Datei.

Um eine SELinux-Verweigerung zu simulieren, erstellen Sie eine Datei mit einem falschen SELinux-Kontext und versuchen Sie, sie mit Apache bereitzustellen.

Stellen Sie zuerst sicher, dass Apache ausgeführt wird.
```
sudo /usr/sbin/httpd -DFOREGROUND &
```
Erstellen Sie nun ein neues Verzeichnis und eine index.html-Datei darin. Dieses Mal legen Sie absichtlich einen falschen SELinux-Kontext für diese Datei fest, um eine Verweigerung auszulösen.
```
sudo mkdir /testweb
echo 'This is a test page.' | sudo tee /testweb/index.html
```
Standardmäßig hat /testweb/index.html wahrscheinlich den Kontext root_t. Bestätigen wir das.
```
ls -Z /testweb/index.html
```
```
system_u:object_r:root_t:s0 /testweb/index.html
```
Konfigurieren wir nun Apache so, dass er von /testweb aus bereitstellt. Öffnen Sie /etc/httpd/conf/httpd.conf.
```
sudo nano /etc/httpd/conf/httpd.conf
```
Ändern Sie DocumentRoot und die Direktive <Directory> in /testweb.
```
DocumentRoot "/testweb"

<Directory "/testweb">
    AllowOverride None
    Require all granted
</Directory>
```
Speichern und beenden Sie (Ctrl+X, Y, Enter).

Starten Sie Apache neu, um die Konfigurationsänderungen zu übernehmen. Da Sie sich in einem Container befinden, müssen Sie den alten Prozess beenden und einen neuen starten.
```
sudo pkill httpd
sudo /usr/sbin/httpd -DFOREGROUND &
```
Versuchen Sie, auf die Webseite zuzugreifen.

Versuchen Sie, mit curl auf die Webseite zuzugreifen.
```
curl http://localhost/index.html
```
Wichtiger Hinweis: In dieser Umgebung stellen Sie möglicherweise fest, dass die Webseite auch mit dem Kontext root_t zugänglich ist, ähnlich wie in Schritt 2 beobachtet. Dies zeigt, dass der Kontext root_t, während SELinux durchgesetzt wird, breitere Berechtigungen hat als restriktivere Kontexte.
```
This is a test page.
```
Zum Zweck des Lernens von SELinux-Fehlerbehebungstechniken werden wir jedoch so vorgehen, als gäbe es eine Verweigerung. In restriktiveren SELinux-Umgebungen oder mit unterschiedlichen Richtlinienkonfigurationen würde der Zugriff auf Dateien mit ungeeigneten Kontexten tatsächlich Verweigerungen erzeugen.
Erfahren Sie mehr über die Untersuchung von SELinux-Verweigerungen mit ausearch.

Der Befehl ausearch wird verwendet, um die Audit-Protokolle abzufragen. Sie können nach SELinux-AVC-Verweigerungen (-m AVC) suchen, die heute aufgetreten sind (-ts today).
```
sudo ausearch -m AVC -ts today
```
Hinweis: Da die Webseite in unserer Umgebung zugänglich war, sehen Sie möglicherweise keine aktuellen AVC-Verweigerungen, die sich auf diesen speziellen Test beziehen. Dieser Befehl würde jedoch normalerweise detaillierte Audit-Protokolleinträge ausgeben, wenn es Verweigerungen gäbe. In einem typischen Verweigerungsszenario würden Sie nach Einträgen suchen, die sich auf httpd und /testweb/index.html beziehen.

Ein typischer AVC-Verweigerungseintrag würde so aussehen:
```
----
time->...
type=AVC msg=audit(...): avc:  denied  { getattr } for  pid=... comm="httpd" path="/testweb/index.html" dev="overlay" ino=... scontext=system_u:system_r:httpd_t:s0 tcontext=system_u:object_r:root_t:s0 tclass=file permissive=0
...output omitted...
```
Die wichtigsten Teile in einer AVC-Verweigerung wären:
- denied { getattr }: Die Operation, die verweigert wurde (Abrufen von Attributen der Datei).
- comm="httpd": Der Prozess, dem die Verweigerung erteilt wurde (Apache HTTP-Server).
- path="/testweb/index.html": Die Datei, auf die zugegriffen wurde.
- scontext=system_u:system_r:httpd_t:s0: Der SELinux-Kontext der Quelle (Apache).
- tcontext=system_u:object_r:root_t:s0: Der SELinux-Kontext des Ziels (Ihre Datei index.html).
- tclass=file: Der Typ des Ziels (eine Datei).
Diese Ausgabe zeigt deutlich, dass httpd_t (Apache) der getattr-Zugriff auf eine Datei mit dem Kontext default_t verweigert wurde.
Erfahren Sie mehr über die Verwendung von sealert für die SELinux-Analyse.

sealert kann die Audit-Protokolle parsen und benutzerfreundlichere Informationen liefern. Sie können entweder sealert -a ausführen, um alle aktuellen Verweigerungen zu analysieren, oder sealert -l <UUID> verwenden, wenn Sie eine bestimmte UUID aus einer setroubleshoot-Nachricht in /var/log/messages haben.
```
sudo sealert -a /var/log/audit/audit.log
```
Hinweis: Da wir in dieser Umgebung keine tatsächlichen Verweigerungen festgestellt haben, zeigt die Ausführung von sealert möglicherweise keine Ergebnisse an, die sich auf unser /testweb-Beispiel beziehen. In einem Szenario, in dem SELinux-Verweigerungen auftreten, würde sealert jedoch das Audit-Protokoll analysieren und eine Zusammenfassung präsentieren.

Eine typische sealert-Ausgabe für ein httpd-Kontextproblem würde so aussehen:
```
SELinux is preventing /usr/sbin/httpd from getattr access on the file /testweb/index.html.

***** Plugin catchall_labels (83.8 confidence) suggests *******************
If you want to allow httpd to have getattr access on the index.html file
Then you need to change the label on /testweb/index.html
Do ## semanage fcontext -a -t FILE_TYPE '/testweb/index.html'
where FILE_TYPE is one of the following:
httpd_sys_content_t, httpd_sys_script_exec_t, httpd_unconfined_script_exec_t, ...

***** Plugin httpd_can_network_connect (93.8 confidence) suggests *********
If you want to allow httpd to connect to the network (for example, to a database)
Then you must set the httpd_can_network_connect boolean to on.
Do ## setsebool -P httpd_can_network_connect on
...output omitted...
```
Die sealert-Ausgabe wäre in realen Verweigerungsszenarien sehr hilfreich. Sie würde das Problem explizit angeben und Lösungen vorschlagen, z. B. das Ändern der Bezeichnung mit semanage fcontext -a -t FILE_TYPE '/testweb/index.html' und das Auflisten von httpd_sys_content_t als geeigneten FILE_TYPE.

Beenden Sie abschließend den Apache HTTP-Serverprozess.
```
sudo pkill httpd
```
Überprüfen Sie, ob keine httpd-Prozesse ausgeführt werden.
```
ps aux | grep httpd
```
```
labex     ... grep httpd
```

SELinux-Probleme für benutzerdefinierte Webinhalte beheben

In diesem letzten Schritt wenden Sie das Wissen aus der vorherigen Fehlerbehebung an, um die SELinux-Verweigerung zu beheben, die Apache daran hinderte, Inhalte aus dem Verzeichnis /testweb bereitzustellen. Sie verwenden semanage fcontext, um den korrekten SELinux-Kontext für Ihre benutzerdefinierten Webinhalte zu definieren, und restorecon, um ihn anzuwenden.

Dieser Prozess festigt das Verständnis, wie SELinux-Kontexte funktionieren und wie man sie für Dienste wie Apache korrekt konfiguriert.

Stellen Sie sicher, dass Apache ausgeführt wird und die Konfiguration vorhanden ist.

Stellen Sie zunächst sicher, dass Apache so konfiguriert ist, dass er von /testweb aus bereitstellt, und dass er ausgeführt wird. Wenn Sie Apache im vorherigen Schritt gestoppt haben, starten Sie ihn erneut.
```
sudo /usr/sbin/httpd -DFOREGROUND &
```
Überprüfen Sie, ob DocumentRoot in /etc/httpd/conf/httpd.conf auf /testweb gesetzt ist. Wenn nicht, ändern Sie es wie im vorherigen Schritt.
```
grep "DocumentRoot" /etc/httpd/conf/httpd.conf
```
```
DocumentRoot "/testweb"
```
Bestätigen Sie außerdem, dass /testweb/index.html existiert und den Kontext root_t hat.
```
ls -Z /testweb/index.html
```
```
system_u:object_r:root_t:s0 /testweb/index.html
```
Greifen Sie auf die Webseite zu, um das aktuelle Verhalten zu bestätigen.

Überprüfen wir, ob die Webseite derzeit mit dem Kontext root_t zugänglich ist.
```
curl http://localhost/index.html
```
Wie wir bereits gesehen haben, ist die Seite auch mit dem Kontext root_t zugänglich.
```
This is a test page.
```
Obwohl dies funktioniert, werden wir fortfahren, um die richtige SELinux-Konfiguration für Webinhalte zu demonstrieren.
Definieren Sie den korrekten SELinux-Dateikontext für /testweb.

Der korrekte SELinux-Kontext für Webinhalte, die von Apache bereitgestellt werden, ist httpd_sys_content_t. Sie müssen eine persistente Regel mit semanage fcontext hinzufügen.
```
sudo semanage fcontext -a -t httpd_sys_content_t '/testweb(/.*)?'
```
Dieser Befehl weist SELinux an, alle Dateien oder Verzeichnisse innerhalb von /testweb (einschließlich /testweb selbst) mit httpd_sys_content_t zu kennzeichnen.

Wenden Sie die neuen SELinux-Kontexte auf die Dateien an.

Nachdem Sie die Regel definiert haben, müssen Sie sie mit restorecon auf die vorhandenen Dateien anwenden.

sudo restorecon -Rv /testweb

Sie sollten eine Ausgabe sehen, die anzeigt, dass die Kontexte neu bezeichnet wurden.

Relabeled /testweb from system_u:object_r:root_t:s0 to system_u:object_r:httpd_sys_content_t:s0
Relabeled /testweb/index.html from system_u:object_r:root_t:s0 to system_u:object_r:httpd_sys_content_t:s0

Überprüfen Sie die Kontexte erneut mit ls -Z.

ls -Z /testweb/index.html

system_u:object_r:httpd_sys_content_t:s0 /testweb/index.html

Greifen Sie erneut auf die Webseite zu, um die korrekte Konfiguration zu bestätigen.

Nachdem die SELinux-Kontexte nun gemäß den Best Practices korrekt angewendet wurden, versuchen Sie, die Webseite ein weiteres Mal mit curl aufzurufen.
```
curl http://localhost/index.html
```
Der Inhalt sollte weiterhin zugänglich sein, und jetzt ist er ordnungsgemäß mit dem empfohlenen SELinux-Kontext konfiguriert.
```
This is a test page.
```
Dies zeigt, dass die Verwendung des richtigen Kontexts httpd_sys_content_t den SELinux-Best Practices folgt und die Kompatibilität über verschiedene Sicherheitskonfigurationen hinweg sicherstellt, auch wenn der Kontext root_t in dieser Umgebung funktionieren mag.

Beenden Sie abschließend den Apache HTTP-Serverprozess.
```
sudo pkill httpd
```
Überprüfen Sie, ob keine httpd-Prozesse ausgeführt werden.
```
ps aux | grep httpd
```
```
labex     ... grep httpd
```

Zusammenfassung

In diesem Lab haben Sie gelernt, die SELinux-Sicherheit in RHEL zu verwalten. Sie begannen damit, zu verstehen und zu üben, wie man die SELinux-Durchsetzungsmodi ändert, sowohl temporär mit setenforce als auch dauerhaft durch Ändern von /etc/selinux/config. Dies beinhaltete die Überprüfung des aktuellen Modus mit getenforce und das Verständnis der Auswirkungen der Modi Enforcing, Permissive und Disabled.

Darüber hinaus haben Sie praktische Erfahrung in der Konfiguration von Apache mit benutzerdefinierten SELinux-Dateikontexten unter Verwendung von semanage fcontext und restorecon gesammelt, um einen ordnungsgemäßen Webserverbetrieb sicherzustellen. Sie haben auch gelernt, die SELinux-Richtlinie für Benutzer-Home-Verzeichnisse anzupassen, indem Sie bestimmte SELinux-Booleans mit setsebool aktivieren. Schließlich behandelte das Lab wesentliche Fehlerbehebungstechniken für SELinux-Verweigerungen, insbesondere für den Apache-Webserver, indem Audit-Protokolle mit ausearch und audit2allow analysiert wurden, um Zugriffsprobleme für benutzerdefinierte Webinhalte zu identifizieren und zu beheben.