fh-trier/linux_ws2122
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Initial Commit
All checks were successful
continuous-integration/drone Build is passing
Details

Browse Source
This commit is contained in:
Markus Pesch
2021-10-13 19:25:16 +02:00
commit fed26c8bbd
66 changed files with 9016 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

201
chapters/01-ssh.tex Normal file
View File

@ -0,0 +1,201 @@
% <#>-----------------------------------------------------------------------<#>
\section{SSH}%
\label{sec:ssh}
Genau so wie eine Anmeldung am Linux-Rechner über ein Terminal (\textit{tty}),
ist auch die Anmeldung eines Benutzers über das Netzwerk möglich. Das gleichnamige Programm und Protokoll \acrfull{acr:telnet} wurde durch das gleichnamige Programm und Protokoll \acrfull{acr:ssh} in laufe der Zeit ersetzt.
Beim ersten Implementierung \acrshort{acr:ssh} von wird eine unverschlüsselte
Verbindung zwischen den beteiligten Rechnern aufgebaut und die Identifizierung
des Benutzers erfolgt nur durch dessen Namen und Passwort. Beim der zweiten
Implementierung von \acrshort{acr:ssh}, wird eine verschlüsselte Verbindung
aufgebaut, die sowohl das Abhören der Login-Daten, also auch der später
gesendeten Daten nahezu unmöglich macht. Es wird sowohl ein rechnerspezifischer
Schlüssel als auch ein benutzerspezifischer Schlüssel verwendet. Zu Testzwecken
ist natürlich auch eine Verbindung zu dem eigenen Rechner (localhost) möglich.
% #>------------------------------------------------------------------------<#
\subsection{Relevante Befehle für die weiteren Übungen}%
\label{sec:ssh.relevante_befehle_fuer_die_weiteren_uebungen}
\begin{itemize}[label={},itemsep=0pt]
\item \textit{ssh:} Stellt eine verschlüsselte Verbindung zwischen zwei
Rechnern her, über die neben der Shell auch andere Programme der
\acrshort{acr:gui} angesprochen werden können.
\item \textit{scp:} Ermöglicht das bidirektionale kopieren von Dateien und Verzeichnissen zwischen zwei Rechnern über eine \acrshort{acr:ssh}-Verbindung.
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsection{Relevante Konfigurationsdateien}%
\label{sec:ssh.relevante_konfigurationsdateien}
\begin{itemize}[label={}]
\item \textit{/etc/ssh/sshd\_config:} Konfigurationsdatei des
\acrshort{acr:ssh}-Servers.
\item \textit{/etc/ssh/ssh\_config:} Systemweite \acrshort{acr:ssh}-Client Konfiguration.
\item \textit{\textasciitilde/.ssh:} Enthält Benutzerspezifische \acrshort{acr:ssh}-Client Konfigurationen und Metainformationen.
\end{itemize}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 2a:} Erkundigen Sie sich nach ihren
\acrshort{acr:ssh}-Zugangsdaten der Hochschule Trier.
\item \textbf{Aufgabe 2b:} Melden Sie sich mit ihren
\acrshort{acr:ssh}-Zugangsdaten per \acrshort{acr:ssh} an dem Rechner
\textit{ssh.hochschule-trier.de} an.
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsection{Authentifizierungsverfahren}%
\label{sec:ssh.authentifizierungsverfahren}
Bei \acrshort{acr:ssh} werden asymetrische Verschlüsselungsverfahren (Public-Key
Verfahren) eingesetzt. Wie Sie bei der ersten Verbindung bereits festgestellt
haben, werden die SSH-Server durch ein Schlüsselpaar identifiziert (\textit{Sie
mussten den öffentlichen Schlüssel des Servers bei der ersten Verbindung
akzeptieren}). In einer Umgebung mit erhöhtem Sicherheitsbedarf würde man den
angezeigten Fingerabdruck des Schlüssels mit einem vorher über einen anderen
Kanal übermittelten Fingerabdruck vergleichen, um eine sichere Verbindung zu
einem gefälschten Server zu vermeiden.
Die akzeptierten öffentlichen Schlüssel des Servers werden zur Abwehr von
Man-in-the-Middle Attacken in der Datei \textit{known\_hosts} gespeichert. Diese
befindet sich im Unterverzeichnis \textit{.ssh} des Heimatverzeichnis des
Benutzers.
Solange der private Schlüssel nicht abhanden kommt und auf dritten Server
repliziert und konfiguriert wird, ist bei der aktuellen Protokollversion 2 keine
umbemerkte Man-in-the-Middle Attacke möglich. Passt der auf dem Client
gespeicherte öffentliche Schlüssel nicht zu dem öffentlichen Schlüssel, den der
Server beim Verbindungsaufbau übermittelt, wird der weitere Verbindungsaufbau
mit einer entsprechenden Warnung abgebrochen.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 3a:} Nachdem Sie sich das erste mal per \textit{ssh} mit
dem \acrshort{acr:ssh}-Server der Hochschule Trier erfolgreich verbunden
haben. Überprüfen Sie die Dateiberechtigungen für den Ordner
\textit{\textasciitilde/.ssh} auf ihrer lokalen VM. Was fällt Ihnen in Vergleich zu anderen Verzeichnissen auf?
\end{itemize}
Bisher melden Sie sich an ihrem virtuellen Server oder den der Hochschule Trier
mit Benutzername und Passwort an. Die Daten werden zwar verschlüsselt übertragen
und können daher auch nicht abgehört werden, aber ein Angreifer kann beliebig
viele Passwörter per Brute-Force-Attacke an ihrem oder dem Server der Hochschule
Trier ausprobieren. Bei schwachen Passwörtern wird es daher nicht allzu lange
dauern, bis ein ernsthafter Angreifer erfolg hat. Bei einer frisch in Betrieb
genommenen virtuellen Maschine in einem Rechenzentrum dauert es meist nur wenige
Stunden, bis der erste derartige Angriff erfolgt! Daher sollte man so schnell
wie möglich auf ein besseres Verfahren umstellen.
Ähnlich wie die Authentifizierung der Rechner kann auch die Authentifizierung
der Benutzer per Public-Key Verfahren konfiguriert werden. Der Benutzer, der
sich unter einem entfernten Benutzer anmelden möchte, muss auf seinem lokalen
Rechner ein Schlüsselpaar generieren und den öffentlichen Schlüssel im
Heimatverzeichnis des entfernt liegenden Benutzer hinzufügen. Bei einem späteren
Login wir dann mit Hilfe des privaten Schlüssels des Client festgestellt,
dass der Anfragende tatsächlich der berechtigte Benutzer ist.
Die Schlüssel werden ebenfalls im Verzeichnis \textit{\textasciitilde/.ssh}
gespeichert. Ändert man bei der Erzeugung des Schlüsselpaares den dazugehörigen
Dateinamen, muss dieser bei jeder Verwendung angegeben werden! Alternativ kann
auch die Konfigurationsdatei \textit{\textasciitilde/.ssh/config} erstellt
werden, um dort den zugehörigen Schlüssel explizit anzugeben. Das Schlüsselpaar
kann optional mit einer Passphrase (Passwort) gesichert werden, falls man jedoch
automatische Logins z.B. für Backups wünscht, sollte man auf diese zusätzliche
Sicherung verzichten.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 3b:} Generieren Sie für ihren lokalen Benutzer eine
Schlüsselpaar mit dem \textit{ed25519} Algorithmus. Der Befehl \textit{ssh-keygen}
erzeugt Schlüsselpaare. Informieren Sie sich über \textit{ssh-keygen} per \textit{man ssh-keygen}.
\item \textbf{Aufgabe 3c:} Ermitteln Sie mit Hilfe der man-page via
\textit{man ssh-keygen} den Namen der Datei, in der der öffentliche Schlüssel
auf dem entfernten Rechner hinterlegt werden muss.
\item \textbf{Aufgabe 3d:} Mit dem Befehl \textit{scp} können Dateien über ein
\acrshort{acr:ssh}-Tunnel von einem Rechner zu einem anderen kopiert werden.
Die Syntax lautet: \textit{scp quelle ziel}. Beide Adressen enthalten einen
Pfad an dem die Ressourcen zu finden bzw. zu kopieren sind. Nur die entfernte
Adresse benötigt zusätzlich noch weitere Informationen wie Benutzername und
Rechnername bzw. IP des entfernten Systems. Die Adresse würde folgendem Schema
entsprechen \textit{user@rechner:pfad}. Kopieren Sie mit Hilfe von
\textit{scp} ihren öffentlichen Schlüssel in das Heimatverzeichnis ihres
entfernten Benutzers.
\item \textbf{Aufgabe 3e:} Der kopierte Schlüssel auf dem entfernten System
muss der Datei aus Aufgabe 3c hinzugefügt werden.
\item \textbf{Aufgabe 3f:} Nachdem der öffentliche Schlüssel erfolgreich
kopiert und konfiguriert wurde, öffnen Sie eine zweite
\acrshort{acr:ssh}-Verbindung ohne Eingabe des Passworts.
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsection{Absicherung des SSH-Servers}%
\label{sec:ssh.absicherung_des_ssh-servers}
Nachdem die Authentifizierung mit dem Public-Key-Verfahren erfolgreich getestet
wurde, kann im nächsten Schritt die unsichere Passwort-Authentifizierung auf dem
Server abgeschaltet werden. Dabei ist zu beachten, dass bei einem Neustart des
\acrshort{acr:ssh}-Servers bestehende Verbindungen gehalten werden. Vor dem
Logout sollte daher nach einer Konfigurationsänderung immer getestet werden, ob
der Login noch möglich ist. Falls man sich bei dieser Gelegenheit selbst vom
Server aussperrt, sind "Helping Hands" vom Provider meist nicht billig zu haben.
\begin{info-popup}
Dies ist für den Server \textit{ssh.hochschule-trier.de} nicht möglich, mangels
Berechtigungen. Führen Sie daher die Abschaltung an ihrem lokalen \acrshort{acr:ssh}-Server
durch.
\end{info-popup}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 4a:} Wie heißt der Eintrag in der Konfigurationsdatei
des Server, mit dem der Zugang für den Benutzer \textit{root} eingestellt
werden kann? Genaueres Betrachten der Konfigurationsdatei sollte schon zum
Ergebnis führen.
\item \textbf{Aufgabe 4b:} Stellen Sie diesen Eintrag so ein, dass für
\textit{root} nur noch der Zugang per Public-Key-Authentifizierung möglich
ist. Lesen Sie die Dokumentation für weitere Informationen.
\item \textbf{Aufgabe 4c:} Mit welchem Konfigurationswert kann das Verhalten
aus Aufgabe 4b auch für normale Benutzer erreicht werden? Informieren Sie sich
auch hier über die Dokumentation.
\item \textbf{Aufgabe 4d:} Stellen Sie das Verhalten so ein, dass für normale
Benutzer nur noch Zugang per Public-Key-Authentifizierung möglich ist.
\item \textbf{Aufgabe 4e:} Nach dem Speichern dieser Änderungen muss der
\acrshort{acr:ssh}-Dienst mit \textit{systemctl restart ssh} neu gestartet werden
\item \textbf{Aufgabe 4f:} Testen Sie die korrekte Funktionsfähigkeit dieser
Änderung mir einer zweiten \acrshort{acr:ssh}-Verbindung.
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsection{Client-Konfiguration}%
\label{sec:ssh.client-konfiguration}
Da Sie nun den Server erfolgreich auf Public-Key-Authentifizierung umgestellt
haben, kann im nächsten Schritt die \acrshort{acr:ssh}-Client Konfiguration
angepasst werden. Dazu ist die Datei \textit{\textasciitilde/.ssh/config}
notwendig. Der \acrshort{acr:ssh}-Client liest die Datei ein und setzt die
Konfiguration, welcher für den Verbindungsaufbau notwendig ist, rekursiv
abhängig von dem DNS-Namen, zusammen.
Möchte man Beispielsweise eine Verbindung zu \textit{verwaltung.example.local}
aufbauen. Werden zuerst alle Konfigurationsoptionen, welche für
\textit{verwaltung.example.local} definiert wurden, angewendet. Als nächstes
sucht der \acrshort{acr:ssh}-Client nach Konfigurationsoptionen, welche für
\textit{*.example.local} definiert wurden, anschließend für \textit{*.local} und
zum Schluss für \textit{*}. Konfigurationsoptionen, welche einmal definiert
wurden, können nicht mehr durch andere Optionen, welche in einem höhren
Scope definiert wurden, übersteuert werden.
\begin{itemize}[label={}]
\item \textbf{Aufgabe 5a:} Erstellen Sie die Datei
\textit{\textasciitilde/.ssh/config} und setzen Sie die entsprechenden
Berechtigungen.
\item \textbf{Aufgabe 5b:} Erstellen Sie einen Eintrag in der Konfiguration
für alle Verbindungen. Definieren Sie dort, welcher Schlüssel zur
Authentifizierung verwendet werden soll.
\item \textbf{Aufgabe 5c:} Erstellen Sie einen Eintrag in der Konfiguration
für alle Verbindungen, welche gegen die Domain \textit{*.hochschule-trier.de}
aufgebaut werden. Für die Domain \textit{*.hochschule-trier.de} soll der Port
22 verwendet werden. Die Authentifizierung per Passwort und der Verbindungsaufbau
über IPv6 soll nicht verwendet werden.
\item \textbf{Aufgabe 5d:} Erstellen Sie einen Eintrag in der Konfiguration
für die Verbindung \textit{ssh.hochschule-trier.de}. Geben Sie dort den
Benutzernamen an unter welchen Sie sich anmelden möchten.
\end{itemize}

208
chapters/02-dns.tex Normal file
View File

@ -0,0 +1,208 @@
% <#>-----------------------------------------------------------------------<#>
\section{DNS}%
\label{sec:dns}
% #>------------------------------------------------------------------------<#
\subsection{Aufbau des DNS}%
\label{sec:dns.aufbau}
Die Adressierung der Rechner in IP-basierten Netzen erfolgt über die IP-Adresse
des angesprochenen Rechners. Da der Mensch sich Nummernfolgen schlecht merken
kann, wurde schon früh eine Ersetzung der Nummern durch Namen auf der
Benutzerschnittstelle eingeführt. Die ursprüngliche Zuordnungsmethode wird auch
heute noch in kleinen Netzen angewendet: jeder Rechner im Netz verfügt über eine
Datei mit zuordnungen von Namen zu Nummern. Unter Unix-artigen Betriebssystemen
ist dies die Datei \textit{/etc/hosts}.
\begin{verbatim}
127.0.0.1 localdomain.localhost localhost
::1 localdomain.localhost localhost
\end{verbatim}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 1a:} Überprüfen Sie ihre \textit{hosts} Datei, ob dort
abweichende Zuordungen zu der obrigen Ausgabe definiert sind
\item \textbf{Aufgabe 1b:} Welche Website wird ihnen im Browser dargestellt,
wenn Sie den folgenden Eintrag in die Datei \textit{hosts} aufnehmen und per
Browser die Seite \textit{hello-world.local} aufrufen? \texttt{198.145.29.83
hello-world.local}
\item \textbf{Aufgabe 1b:} In welchem Pfad findet man die entsprechende Datei
in Windows Systemen?
\end{itemize}
Dieses Verfahren der Namensauflösung führt in großen Netzwerken schnell zu
Problemen. Alle beteiligten Rechner benötigen in ihrer Version der Datei die
Zuordnungen aller Rechner, was die zentrale Verwaltung der Zuordnungen schnell
sehr aufwändig macht. Als Folge dieser Erkenntnis wurde das \acrfull{acr:dns}
entwickelt, das eine verteile Datenbank darstellt, bei der einzelne Server für
genau beschriebene Teilbereiche verantwortlich sind.
Den Namensraum im Internet ist hierarchisch gegliedert, ausgehend von der
höchsten Ebene, den sog. \acrfullpl{acr:tld}, können viele untergeordnete Ebenen
(Domains) eingefügt werden. Da die Internet-Entwicklung in den USA begann,
teilten die ersten \acrshortpl{acr:tld} den amerikanischen Netzbereich auf (z.B.
com, edu und org). Später kamen dann weitere \acrshortpl{acr:tld} für jedes Land
hinzu, die den genormten Länderkürzeln entprechen (ISO 3166), beispielsweise be,
de, nl usw. In der jüngsten Entwicklung wurden weitere allgemeine
\acrshortpl{acr:tld} hinzugefügt. Beispielsweise info, firm, museum, movie und
berlin.
Bei Domänennamen wird die Groß- und Kleinschreibung nicht beachtet, \textbf{edu}
und \textbf{EDU} bedeuten das gleiche. Einzelne Teil-Domainnamen dürfen maximal
63 Zeichen lang sein, der vollständige Domainname, \acrfull{acr:fqdn}, darf
nicht länger als 255 Zeichen sein. Für die Genehmigung eines neuen Domainnamens
ist die Verwaltung der nächst höheren Domain zuständig, für die Root-Zone und
damit die \acrshortpl{acr:tld} ist dies die \acrfull{acr:icann}.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 2a:} Für welche Verwaltungsmaßnahmen ist die
\acrshort{acr:icann} verantwortlich? Nutzen Sie die Internetpräsenz der
\acrshort{acr:icann}, um die Frage zu beantworten.
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsection{Betrieb einer Domain}%
\label{sec:dns.betrieb_einer_domain}
Für jede offiziell registrierte Domain müssen mindestens zwei DNS-Server
eingerichtet werden, die in unterschiedlichen Subnetzen stehen müssen. Einer
dieser Server wird dann als Primary, der andere als Replica betrieben.
Änderungen müssen dann nur noch am Primary vorgenommen werden, der oder die
Replicas werden durch den Primary über die Änderungen informiert, worauf ein
Zonentransfer der Daten vom Replica veranlast wird.
Sucht ein Rechner die IP-Nummer zu einem Namen, wird er zuest den DNS-Server,
der voreingestellt ist, befragen. Dies ist meist der Server der eigenen Domain
bzw. des eigenen Providers. Für Heimnetzwerke stellt beispielsweise der Router
einen DNS-Server bereit. Hat dieser Server den gewünschten Datensatz in seiner
Datenbank, so kann er die Anfrage sofort beantworten (Authorative Answer). Ist
der Datensatz nicht vorhanden, kann je nach Konfiguration ein Server aus einer
höheren Ebene befragt werden, der dann den zuständigen Server kennt oder
seinerseits die Anfrage wieder nach oben weiterreicht. Der Server kann jedoch
auch als Antwort dem Client mitteilen, welchen Server er fragen soll, um seine
Anfrage zu beantworten. Jeder DNS-Server muss mindestens die DNS-Server seiner
direkt untergeordneten Domains kennen, um Anfragen hierfür weiterreichen zu
können und er muss die Adressen aller Root-Server kennen.
Für die Verwaltung des Namesraums wird dieser in Zonen aufgeteilt. Ein
DNS-Server kann für eine oder mehrere DNS-Zonen verantwortlich sein. Es gibt
üblicherweise Zonen für die Vorwärtsauflösung (Forward Lookup) und
Rückwärtsauflösung (Reverse Lookup). Vorwärtsauflösung bedeutet, dass für einen
gegebenen Rechnernamen eine IP-Adresse gesucht wird. Rückwärtsauflösung bedeutet
dementsprechend, dass für eine gegebene IP-Adresse ein Rechnername gesucht wird.
Für jede Zone werden die Informationen als sogenannte \acrfullpl{acr:rr}
gespeichert. Dies sind die gängigen \acrshortpl{acr:rr}:
\begin{itemize}[itemsep=0pt]
\item[\textbf{\acrshort{acr:soa}}] \acrfull{acr:soa} markiert den Start einer
DNS-Zone mit verschiedenen allgemeinen Informationen
\item[\textbf{A}] Enthält die IPv4-Adresse zu einem gegebenen Rechnernamen
\item[\textbf{AAAA}] Enthält die IPv6-Adresse zu einem gegebenen Rechnernamen
\item[\textbf{NS}] Enthält den Rechnernamen eines für die Domain
verantwortlichen DNS-Servers. Darf nicht auf einen \textit{CNAME} Eintrag
verweisen!
\item[\textbf{MX}] Enthält die Prioritätsangabe und den Rechnernamen eines
zuständigen Mailservers. Darf nicht auf einen \textit{CNAME} Eintrag
verweisen!
\item[\textbf{PTR}] Enthält den Rechnernamen zu einer gegebenen IP-Adresse
(IPv4 oder IPv6)
\item[\textbf{SSHFP}] Enthält den Fingerabdruck des privaten SSH-Schlüssels,
welcher auf dem jeweiligen Rechner beim Verbindungsaufbau abgefragt und
überprüft wird. Ein Vergleich der Fingerabdrücke aus dem DNS mit dem, welcher
der entfernte Server anbietet, deckt so einen möglichen Man-in-Middle Angriff
auf.
\end{itemize}
Clientseitig können die Programme \textbf{dig}, \textbf{resolvectl},
\textbf{nslookup} und \textbf{host} zur Abfrage verwendet werden. Diese Abfragen
werden normalerweise über das Transportprotokoll UDP abgewickelt und sind an den
Port 53 gerichtet.
Lesen Sie die Dokumentation eines der oben genannten Programme oder informieren
Sie sich im Internet, um folgende Fragen zu beantworten:
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 2a:} Wann wird bei DNS das Transportprotokoll TCP eingesetzt?
\item \textbf{Aufgabe 2b:} Fragen Sie mit Hilfe eines der oben genannten
Programme den \acrshort{acr:rr} \textit{SSHFP} der Domain
\textit{pontos.cryptic.systems} ab. Welche Informationen werden zurück
gegeben?
\item \textbf{Aufgabe 2c:} Welche DNS-Server sind für die DNS-Zone
\textit{cryptic.systems} verantwortlich?
\item \textbf{Aufgabe 2c:} Welcher der DNS-Server ist für die Zone
\textit{cryptic.systems} der Primary und welcher der Replica DNS-Server?
\item \textbf{Aufgabe 2d:} Welche Mail-Server sind für die Zone
\textit{cryptic.systems} verantwortlich?
\item \textbf{Aufgabe 2e:} Welcher Mail-Server wird zur Zustellung von E-Mails
für die DNS-Zone \textit{cryptic.systems} privorisiert?
\item \textbf{Aufgabe 2f:} Welcher DNS-Name steht hinter der IP-Adresse
\textit{45.9.61.170}?
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsection{Konfiguration des Clients}%
\label{sec:dns.konfiguration_des_clients}
Für die Namensauflösung auf der Seite des Clients ist der \textbf{Resolver}
verantwortlich, welcher von den Anwendungsprogrammen bei Bedarf automatisch
aufgerufen wird. Die Konfiguration erfolgt in Unix-Systemen über die Datei
\textit{/etc/resolv.conf}. Die wichtigsten Einträge in dieser Datei sind
\textit{domain} und \textit{nameserver}.
Immer seltener muss die Datei \textit{/etc/resolv.conf} manuell gepflegt werden.
Programme bzw. Dienste wie Beispielsweise der \textit{network-manager} oder
\textit{systemd-resolved} erstellen die Datei automatisch anhand der
Informationen, welche Sie per DHCP erhalten haben. Ändert man direkt den Inhalt
der Datei, kann dies dazu führen, dass das Programm oder der Dienst die
Einstellungen wieder überschreibt. Dem Programm bzw. dem Dienst muss daher
direkt mitgeteilt werden, welchen DNS-Server bzw. Domain der Rechner angehört,
um ein überschreiben zu vermeiden.
Mit dem Eintrag \textit{domain} wird festgelegt, welcher Domainname
standardmäßig an unvollständige Namen angehängt wird, bevor die Anfrage
abgesendet wird. Als unvollständig werden in der Regel Namen betrachtet, die
keinen Punkt enthalten. Es kann hier eine Liste mehrere Domainnamen angegeben
werden.
Mit dem Eintrag \textit{nameserver} wird angegeben, welcher DNS-Server für eine
Anfrage angesprochen wird. Zu Erhöhung der Redundanz ist es möglich, mehrere
Einträge dieser Art vorzunehmen. Ist der erste DNS-Server nicht erreichbar, wird
der nächste aus der Liste gefragt.
Die Datei \textit{/etc/nsswitch.conf} ist eine weitere Konfigurationsdatei aus
dem Bereich der Namensauflösung, in der eingestellt wird, in welcher Reihenfolge
interne und externe Quellen für die Namensauflösung verwendet werden. Wenn
folgende Zeile enthalten ist, wird zuerst in der lokalen Datei
\textit{/etc/hosts} gesucht. Wird dort kein passender Eintrag gefunden, wird das
DNS abfragt.
\begin{verbatim}
hosts: files dns
\end{verbatim}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 3a:} In Kapitel \ref{sec:network} haben Sie erfolgreich
\textit{systemd-networkd} konfiguriert. Passen Sie ihre Konfiguration so an,
dass primär der DNS-Server \textit{8.8.8.8} und sekundär der DNS-Server
\textit{8.8.4.4} für ihren Netzwerkadapter verwendet wird.
\item \textbf{Aufgabe 3b:} Überprüfen Sie die Konfiguration mit dem Aufruf von
\textit{resolvectl}. Beide DNS-Server sollten unter Ihrem Netzwerkadapter
gelistet und zusätzlich in der Datei \textit{/etc/resolv.conf} aufgeführt
sein.
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsection{Einstellen des Rechnernamens}%
\label{sec:dns.einstellen_des_rechnernamens}
Der Rechnername ist in der Datei \textit{/etc/hostname} gespeichert. Nach
Änderung der Datei ist es sinnvoll, den Rechner neu zu starten, um die Änderung
allen Diensten bekannt zu machen.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 4a:} Ändern Sie den Rechnernamen ab und starten Sie das System neu
\item \textbf{Aufgabe 4b:} Nutzen Sie eines der Programme zur Namensauflösung,
um die IP-Adresse ihres Rechners anhand des neuen Rechnernamens durch den im
lokalen Netzwerk befindlichen DNS-Server auflösen zu lassen. Überprüfen Sie,
ob die IP-Adresse mit der IP-Adresse ihrer Netzwerkkarte übereinstimmt.
\end{itemize}

274
chapters/03-network.tex Normal file
View File

@ -0,0 +1,274 @@
% <#>-----------------------------------------------------------------------<#>
\section{Netzwerk}%
\label{sec:network}
% #>------------------------------------------------------------------------<#
\subsection{Netzwerkkonfiguration}%
\label{sec:netzwerk.konfiguration}
Bei der Installation des Basis-Systems (Fedora Server Edition) wird das Paket
\textbf{network-manager} installiert. Dieses Paket ist für die einfache und
weitgehend automatische Netzwerk-Konfiguration auf Endbenutzer-Systemen
entwickelt worden. Daher ist es auf Serversystemen, bei denen eine statische
Adressvergabe oder es zu komplexen Netzwerkstrukturen kommen kann,
kontraproduktiv.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 1a:} Stellen Sie mit dem Befehl \textit{yum list
installed} fest, ob das Paket mit dem Namensbestandteil
\textbf{network-manager} installiert ist.
\item \textbf{Aufgabe 1b:} Falls Sie hierbei fündig geworden sind, stoppen und
deaktivieren Sie den Dienst \textit{NetworkManager} per \textit{systemctl} und
\dots
\item \textbf{Aufgabe 1c:} überprüfen Sie mithilfe von \textit{systemctl}, ob
der Dienst \textit{NetworkManager} gestoppt und deaktiviert ist.
\end{itemize}
Nachdem Sie den Dienst \textit{NetworkManager} entfernt haben, stellen Sie
mithilfe von \textit{systemd} die Netzwerkkonfiguration ein und erstellen ggfl.
notwendige virtuelle Netzwerkkarten. \textit{systemd} unterteilt die
Netzwerkkonfiguration in drei unterschiedliche Dienste:
\begin{itemize}[label={},itemsep=0pt]
\item \textit{systemd-networkd:} Erstellt virtuelle Netzwerkkarten und richtet
diese als auch physische ein. Dadurch ist die Zuweisung einer dynamischen per
\acrshort{acr:dhcp} oder statischen IP-Adresse möglich.
\item \textit{systemd-resolved:} Kümmert sich um die Namensauflösung per
\acrshort{acr:dns}.
\item \textit{systemd-timesyncd:} Richtet die Uhrzeit mithilfe des
\acrfull{acr:ntp} auf dem System ein.
\end{itemize}
Die Dienste \textit{systemd-resolved} und \textit{systemd-timesyncd} rufen
notwendige Informationen von anderen Diensten auf dem System ab. Ein anpassen
des Standardverhaltens ist hier nicht notwendig.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 1d:} Starten und aktivieren Sie die beiden Dienste
mithilfe des Befehls \textit{systemctl}.
\item \textbf{Aufgabe 1e:} Überprüfen Sie, ob die Dienste als \textit{active
(running)} markiert sind.
\item \textbf{Aufgabe 1f:} Zusätzlich überprüfen Sie, ob die Dienste auch als
\textit{enabled} markiert sind, sodass diese bei einem erneusten Systemstart
ausgeführt werden.
\end{itemize}
Die Netzwerkkonfiguration per \textit{systemd} wird über die unterschiedlichen
Dateiendungen \textit{.netdev} und \textit{.network} im Verzeichnis
\textit{/etc/systemd/network} geregelt.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 1g:} Rufen Sie die Dokumentation von
\href{https://www.freedesktop.org/software/systemd/man/systemd.network.html}{systemd.network}
und
\href{https://www.freedesktop.org/software/systemd/man/systemd.netdev.html}{systemd.netdev}
auf und erklären Sie den Unterschied der beiden Konfigurationsdateien
\textit{.netdev} und \textit{.network}.
\end{itemize}
Mit dem Befehl \textit{ip link show} werden alle Netzwerkkarten, welches Ihr
System kennt ausgegeben.
\begin{bashcode}
$ ip link show
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: enp1s0: <BROADCAST,MULTICAST> mtu 1500 qdisc fq_codel state DOWN mode DEFAULT group default qlen 1000
link/ether 52:54:00:b3:95:e4 brd ff:ff:ff:ff:ff:ff
\end{bashcode}
Das System, auf dem der Befehl ausgeführt wurde, kennt zwei Netzwerkadapter. Mit
dem Index 1 ist das \textit{loopback device} \textbf{lo} aufgeführt. Über das
\textit{loopback device} können Dienste, welche auf dem lokalen System
ausgeführt werden, per Netzwerk sich selbst oder andere Dienste adressieren bzw.
zugreifen. Dies ist durch die IP-Adresse \textit{127.0.0.1} oder den DNS-Namen
\textit{localhost} möglich.
Vorteil des \textit{loopback device} ist es, dass die Netzwerkpakete nicht den
Rechner verlassen. Dadurch wird unnötiger Netzwerkverkehr, welcher über das
physische Netzwerk geleitet wird, vermieden.
Mit dem Index 2 wird der Netzwerkadapter \textbf{enp1s0} geführt. Dieser besitzt
die MAC-Adresse \textit{52:54:00:b3:95:e4}. Der Netzwerkadapter ist als inaktiv
bzw. ausgeschaltet markiert. Dies kann durch die Information \textit{state DOWN}
entnommen werden. Dieser ist nicht konfiguriert und besitzt auch keine
IP-Adresse.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 1h:} Ermitteln Sie ihren Netzwerkadapter, welcher nicht
konfiguriert wurde. Überprüfen Sie mit dem Befehl \textit{ip address show}, ob
ihr Netzwerkadapter eine IP-Adresse zugewiesen wurde.
\item \textbf{Aufgabe 1i:} Schauen Sie sich in der Dokumentation zu
\href{https://www.freedesktop.org/software/systemd/man/systemd.network.html}{systemd.network}
die Beispielkonfigurationen an und erstellen Sie für ihren Netzwerkadapter
eine passende Konfiguration.
Falls Sie die Konfiguration ihres lokalen Netzwerks nicht kennen, um ihrem
System eine statische IP-Adresse zu zuweisen, verwenden Sie
\acrshort{acr:dhcp}.
\item \textbf{Aufgabe 1j:} Starten und aktivieren Sie den Dienst
\textit{systemd-networkd} mithilfe von \textit{systemctl}.
\item \textbf{Aufgabe 1k:} Überprüfen Sie, ob der Dienst als \textit{active
(running)} markiert ist und \dots
\item \textbf{Aufgabe 1l:} ob dieser als \textit{enabled} markiert ist.
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsection{Routing}%
\label{sec:netzwerk.routing}
Das \acrfull{acr:ip} ist auf Schicht 3 des OSI-Modells angesiedelt. Es dient der
Strukturierung von großen Netzwerken, d.h der Aufteilung dieser Netze in
übersichtliche Teilnetze und der Verbindung dieser Teilnetze. \acrshort{acr:ip}
ist für die Vermittlung eines Weges, einer Route, zwischen zwei
Kommunikationspartnern zuständig. Diese Route muss auch über mehrere Teilnetze
hinweg gefunden werden. Die Verbindungspunkte zwischen Netzen werden als Router
oder Gateway bezeichnet.
Jeder Rechner, auch solche, die keine Routingfunktion haben, muss Informationen
zur Wegefindung im Netz speichern. Dies geschieht bei jedem
\acrshort{acr:ip}-fähigen Betriebssystem in einer Routingtabelle, die statisch
oder dynamisch verwaltet werden kann. In einem Maschennetz wie dem Internet ist
eine dynamische Verwaltung sinnvoll, da so die Wegewahl der aktuellen
Belastungssituation auf den verschiedenen Wegen angepasst werden kann. Auch bei
Ausfall einer Verbindung kann so automatisch eine Ersatzroute konfiguriert
werden. Bei einfachen Netzverbünden ohne Maschenstruktur wird statisches Routing
verwendet, was auch ohne Zusatzsoftware von den üblichen Betriebssystemen
geleistet werden kann.
% >---------------------------------------------------------------------------<
\subsubsection{Einfache Netze}%
\label{sec:netzwerk.routing.einfache-netze}
Selbst in \acrshort{acr:ip}-Netzen ohne Anbindung an andere Netze besitzt jeder
Rechner eine statische Routingtabelle in minimaler Größe. Die Tabelle enthält
mehrere Informationen, die wichtigsten sind in den ersten Spalten festgehalten.
Darunter wird das Zielnetzwerk, die verwendete Schnittstelle und das verwendete
Gateway aufgeführt. In diesem einfachsten Fall bleibt die Spalte für das Gateway
leer und es gibt nur einen Eintrag in jeder Tabelle. Diese minimale
Routingtabelle wird bei allen Betriebssystem mit der normalen
Netzwerkkonfiguration automatisch erstellt.
\begin{table}[H]
\footnotesize
\centering
\begin{tabularx}{17cm}{p{2.6cm}|p{2.6cm}|p{1.9cm}||p{2.6cm}|p{2.6cm}|p{1.9cm}}
\multicolumn{3}{c||}{\textbf{PC}} & \multicolumn{3}{c}{\textbf{Laptop}} \\
\hline
Zielnetz & Netzwerkadapter & Gateway & Zielnetz & Netzwerkadapter & Gateway \\
\hline\hline
192.168.178.0/24 & enp1s0 & - & 192.168.178.0/24 & wlp5s1 & - \\
\end{tabularx}
\end{table}
\begin{table}[H]
\footnotesize
\centering
\begin{tabularx}{8.5cm}{p{2.6cm}|p{2.6cm}|p{1.9cm}}
\multicolumn{3}{c}{\textbf{Server A}} \\
\hline
Zielnetz & Netzwerkadapter & Gateway \\
\hline\hline
192.168.178.0/24 & eth0 & - \\
\end{tabularx}
\end{table}
\begin{figure}[H]
\centering
\includegraphics[width=0.65\textwidth]{img/einfache-netze.png}
\end{figure}
% >---------------------------------------------------------------------------<
\subsubsection{Einfache Netze mit Internetanbindung}%
\label{sec:netzwerk.routing.einfache-netze-mit-internetanbindung}
Hat ein Netzwerk genau eine Anbindung an die anderen Netzwerke, erhält die
Routingtabelle auf jedem Rechner eine zusätzliche Zeile, in der angegeben wird,
auf welchem Weg die anderen Netzwerke erreicht werden können. Da alle Netzwerke
über den gleichen ersten Router erreicht werden, wird diese Zeile der
Routingtabelle als Standard- bzw. Default-Route bezeichnet. Dieses
Standard-Gateway muss bei allen Betriebssystemen gesondert konfiguriert werden.
\begin{table}[H]
\footnotesize
\centering
\begin{tabularx}{17cm}{p{2.6cm}|p{2.6cm}|p{1.9cm}||p{2.6cm}|p{2.6cm}|p{1.9cm}}
\multicolumn{3}{c||}{\textbf{PC}} & \multicolumn{3}{c}{\textbf{Laptop}} \\
\hline
Zielnetz & Netzwerkadapter & Gateway & Zielnetz & Netzwerkadapter & Gateway \\
\hline\hline
192.168.178.0/24 & enp1s0 & - & 192.168.178.0/24 & wlp5s1 & - \\
0.0.0.0/0 & enp1s0 & 192.168.178.1 & 0.0.0.0/0 & wlp5s1 & 192.168.178.1 \\
\end{tabularx}
\end{table}
\begin{table}[H]
\footnotesize
\centering
\begin{tabularx}{8.5cm}{p{2.6cm}|p{2.6cm}|p{1.9cm}}
\multicolumn{3}{c}{\textbf{Server A}} \\
\hline
Zielnetz & Netzwerkadapter & Gateway \\
\hline\hline
192.168.178.0/24 & eth0 & - \\
189.10.55.47/32 & ppoe1 & - \\
0.0.0.0/0 & ppoe1 & 189.10.55.47 \\
\end{tabularx}
\end{table}
\begin{figure}[H]
\centering
\includegraphics[width=1\textwidth]{img/einfache-netze-mit-internetanbindung.png}
\end{figure}
% >---------------------------------------------------------------------------<
\subsubsection{Zwei Netze mit Internetanbindung}%
\label{sec:netzwerk.routing.zwei-netze-mit-internetanbindung}
\begin{table}[H]
\footnotesize
\centering
\begin{tabularx}{17cm}{p{2.6cm}|p{2.6cm}|p{1.9cm}||p{2.6cm}|p{2.6cm}|p{1.9cm}}
\multicolumn{3}{c||}{\textbf{PC}} & \multicolumn{3}{c}{\textbf{Laptop}} \\
\hline
Zielnetz & Netzwerkadapter & Gateway & Zielnetz & Netzwerkadapter & Gateway \\
\hline\hline
192.168.178.0/24 & enp1s0 & - & 192.168.178.0/24 & wlp5s1 & - \\
0.0.0.0/0 & enp1s0 & 192.168.178.1 & 0.0.0.0/0 & wlp5s1 & 192.168.178.1 \\
\multicolumn{6}{c}{} \\
\multicolumn{3}{c||}{\textbf{Server A}} & \multicolumn{3}{c}{\textbf{Server B}} \\
\hline
Zielnetz & Netzwerkadapter & Gateway & Zielnetz & Netzwerkadapter & Gateway \\
\hline\hline
192.168.178.0/24 & eth0 & - & 192.168.178.0/24 & eth0 & 192.168.179.1 \\
192.168.179.0/24 & eth0 & 192.168.178.4 & 192.168.179.0/24 & eth1 & - \\
189.10.55.47/32 & ppoe1 & - & 0.0.0.0/0 & eth0 & 192.168.178.1 \\
0.0.0.0/0 & ppoe1 & 189.10.55.47 \\
\multicolumn{6}{c}{} \\
\multicolumn{3}{c||}{\textbf{Tablet}} & \multicolumn{3}{c}{\textbf{Smartphone}} \\
\hline
Zielnetz & Netzwerkadapter & Gateway & Zielnetz & Netzwerkadapter & Gateway \\
\hline\hline
192.168.179.0/24 & wlp7s3 & - & 192.168.179.0/24 & wlp3s8 & - \\
0.0.0.0/0 & wlp7s3 & 192.168.179.1 & 0.0.0.0/0 & wlp3s8 & 192.168.179.1 \\
\end{tabularx}
\end{table}
\begin{figure}[H]
\centering
\includegraphics[width=1\textwidth]{img/zwei-netze-mit-internetanbindung.png}
\end{figure}
\newpage
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 2b:} Ermitteln Sie mithilfe des Befehls \textit{ip} Ihr
Gateway.
\item \textbf{Aufgabe 2c:} Erstellen Sie anhand des folgenden
Netzwerkdiagramms die Routingtabellen für alle abgebildeten Netzwerkgeräte.
\end{itemize}
\begin{figure}[H]
\centering
\includegraphics[width=1\textwidth]{img/aufgabe-netze-mit-internetanbindung.png}
\end{figure}

673
chapters/04-file-permissions.tex Normal file
View File

@ -0,0 +1,673 @@
% <#>-----------------------------------------------------------------------<#>
\section{Benutzer, Gruppen und Dateiberechtigungen}%
\label{sec:benutzer-gruppen-und-berechtigungen}
Die Verwaltung von Benutzer, Gruppen und Dateiberechtigungen unter Unix-artigen
Systemen sind identisch. Das hat den Vorteil, dass es für Anwender einfacher ist
Benutzer, Gruppen und Dateiberechtigungen auf Linux Distributionen wie Debian,
Ubuntu, Linux Mint oder RHEL, CentOS, Fedora als auch BSD Distributionen wie
MacOS, FreeBSD oder OpenBSD zu übertragen.
Optional können durch sogenannte \acrfull{acr:acl} Berechtigungen
erweitert werden, um die Rechtevergabe für Benutzer und Gruppen noch feiner
einteilen zu können.
In der Praxis gibt es jedoch sehr selten Szenarien, bei denen dies notwendig ist.
Aus diesem Grund liefern manche Distributionen die notwendigen Programme zum
verfeinern der Rechtevergabe nicht standardmäßig aus.
% #>------------------------------------------------------------------------<#
\subsection{Benutzer und Gruppen}%
\label{sec:benutzer-gruppen-und-berechtigungen.benutzer-und-gruppen}
Linux ist als Mehrbenutzer-Betriebssystem entwickelt worden. Dies bedeutet, dass
mehrere Benutzer gleichzeit auf dem System Prozesse ausführen können. Dabei
werden die Berechtigungen auf Dateien und Verzeichnisse klar durch den Besitzer,
als auch durch die Gruppe, welche als mehrere Benutzern bestehen kann, geregelt.
% #>------------------------------------------------------------------------<#
\subsubsection{Benutzer}%
\label{sec:benutzer-gruppen-und-berechtigungen.benutzer-und-gruppen.benutzer}
Man unterscheidet bei Benutzern zwischen funktionalen und realen Benutzern.
Funktionale Benutzer werden vorwiegend für Dienste verwendet, um zu vermeiden,
dass der Dienst ungewollt auf Dateien und Verzeichnisse Zugriff erhält. Aus
diesem Grund wird auch vermieden, dass funktionale Benutzer eine Shell öffnen
können. Dazu später mehr.
Reale Benutzer sind natürliche Personen, die sich entweder direkt per
Desktopmanager, einer Shell oder über ein Protokoll (\acrshort{acr:rdp},
\acrshort{acr:ssh}, \acrshort{acr:vnc}) Zugang verschaffen.
Alle Benutzer werden in der Datei \textit{/etc/passwd} gelistet. Sie wird als
Tabellenform geführt, getrennt durch einen Doppelpunkt \textbf{:}. Zur
einfacheren Darstellung kann folgender Befehl verwendet werden.
\begin{bashcode}
cat /etc/passwd | column --table --separator :
\end{bashcode}
Die Spalten, exemplarisch für den Benutzer root, haben folgende Bedeutung:
\begin{itemize}[itemsep=0pt]
\item[\textbf{1. Spalte}] Name des Benutzers
\item[\textbf{2. Spalte}] Ehemals Spalte für das Kennwort. Das \textit{x}
kennzeichnet, dass für den Benutzer in der Datei \textit{/etc/shadow} ein
Kennwort existiert. Dazu später mehr.
\item[\textbf{3. Spalte}] Die ID des Benutzers. Wird oft auch als \textit{UID}
angegeben.
\item[\textbf{4. Spalte}] Die ID der Hauptgruppe. Wird oft auch als \textit{GID}
angegeben.
\item[\textbf{5. Spalte}] Erweiterter Name des Benutzers. Damit
nachvollziehbar ist, welchem Dienst oder welcher realen Person der Benutzer
zuzuordnen ist.
\item[\textbf{6. Spalte}] Das Heimatverzeichnis des Benutzers. Im Regelfall
wird dieses Verzeichnis betreten, sofern der Benutzer sich über eine
Login-Shell anmeldet. Die Tilde verweist auf das hier definierte
Heimatverzeichnis.
\item[\textbf{7. Spalte}] Enthält den absoluten Pfad zur Login-Shell. Dies ist
im Regelfall die \acrfull{acr:bash}. Um zu vermeiden, dass sich als Benutzer
eines Dienstes angemeldet werden kann, kann hier auch auf
\textit{/usr/bin/nologin} verwiesen werden.
\end{itemize}
Die 2. Spalte wurde ausgelagert nach \textit{/etc/shadow}, um die Sicherheit auf
dem System zu erhöhen. In der Datei \textit{/etc/shadow} werden weitere
Informationen gespeichert. Beispielsweise die Information, mit welchem
Hash-Algorithmus die Kennwörter gehasht wurden bzw. wie der Salt-Wert lautet.
Erzeugen Sie sich erneut mit dem genannten Befehl aus Kapitel
\ref{sec:benutzer-gruppen-und-berechtigungen.benutzer-und-gruppen.benutzer} eine
Ausgabe in tabellarischer Form für die Datei \textit{/etc/shadow}. Die Spalten
haben folgende Bedeutung:
\begin{itemize}[itemsep=0pt]
\item[\textbf{1. Spalte}] Name des Benutzers.
\item[\textbf{2. Spalte}] Das Kennwort, gespeichert als Hash mit Informationen
zum Hash.-Algorithmus. Der Wert \textit{!!} bedeutet, dass kein Kennwort
definiert wurde.
\item[\textbf{3. Spalte}] Enthält die Tage seit Beginn der Unix-Zeitrechnung,
wann das Kennwort zuletzt geändert wurde.
\item[\textbf{4. Spalte}] Tage bevor das Kennwort geändert werden muss.
\item[\textbf{5. Spalte}] Tage ab wann eine Warnung ausgegeben werden soll,
dass das Kennwort abläuft.
\item[\textbf{6. Spalte}] Tage bevor das Kennwort abläuft, nachdem keine
Anmeldung erfolgt ist.
\item[\textbf{7. Spalte}] Enthält die Tage seit Beginn der Unix-Zeitrechnung,
seit dem das Kennwort abgelaufen ist.
\item[\textbf{8. Spalte}] Reservierte Spalte. Wird aktuell nicht verwendet.
\end{itemize}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 1a:} Ermitteln Sie den Hash-Algorithmus, welcher
verwendet wurde um Ihr Kennwort zu hashen.
\item \textbf{Aufgabe 1b:} Wann beginnt die Unix-Zeitrechnung?
\item \textbf{Aufgabe 1c:} Wann wurde zuletzt das Kennwort des Benutzers root geändert?
\item \textbf{Aufgabe 1d:} Ermitteln Sie die \textbf{User-ID} ihres aktuellen
Benutzers mithilfe eines Befehls, welcher in den GNU Core Utilities enthalten
und dem Bereich \glqq{}Shell Utilities\grqq{} zugeordnet ist.
\item \textbf{Aufgabe 1e:} Nutzen Sie den Befehl \textit{wc}, um alle
eingerichteten Benutzer auf ihrem System zu zählen. Lesen Sie die Manpage für
weitere Informationen zu diesem Befehl.
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsubsection{Gruppen}%
\label{sec:benutzer-gruppen-und-berechtigungen.benutzer-und-gruppen.gruppen}
Ähnlich wie bei Benutzern gibt es auch Dateien in denen die Gruppen bzw.
Gruppenkennwörter festgehalten sind. Dies sind die Dateien \textit{/etc/group}
und \textit{/etc/gshadow}. Die beiden Dateien sind ähnlich wie
\textit{/etc/passwd} und \textit{/etc/shadow} aufgebaut. Sie enthalten jedoch
weniger Spalten.
Die Datei \textit{/etc/group} enthält eine Spalte für den Namen der Gruppe, ob
ein Eintrag in \textit{/etc/gshadow} vorhanden ist, die Gruppen-ID, als auch alle
Benutzer, welche der Gruppe angehören. Die Benutzer werden durch ein Komma.
Die Datei \textit{/etc/gshadow} enthält noch weniger Informationen. Die ersten
drei Spalten sind identisch zu den Spalten aus der Datei \textit{/etc/shadow}.
Die letzte Spalte enthält Benutzer, welcher das Kennwort ändern dürfen.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 2a:} Ermitteln Sie die \textbf{Gruppen-ID} ihres
aktuellen Benutzers mithilfe eines Befehls, welcher in den GNU Core Utilities
enthalten und dem Bereich \glqq{}Shell Utilities\grqq{} zugeordnet ist.
\item \textbf{Aufgabe 2b:} Nutzen Sie den Befehl \textit{wc}, um die Gruppen
zu zählen. Lesen Sie die Manpage für weitere Informationen zu diesem Befehl.
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsubsection{Benutzer root}%
\label{sec:benutzer-gruppen-und-berechtigungen.root}
Der Benutzer root besitzt auf allen Unix-artigen Systemen die User-ID und
Gruppen-ID 0. Er besitzt vollen Zugriff auf das gesamte System und damit auf
alle Dateien und Einstellungen aller Benutzer. Er kann beispielsweise ohne
Einschränkungen auf alle angeschlossenen Geräte unter \textit{/dev} zugreifen.
Der Benutzer root ist ein funktionaler Benutzer, mit dem sich reale Benutzer
anmelden können, um Befehle, welche einen höheren Berechtigungsgrad benötigen,
auszuführen. Durch die Verwendung des Benutzers root ist nachträglich nicht mehr
nachvollziehbar, welcher reale Benutzer welchen Befehl ausgeführt hat. Aus
diesem Grund und anderen Gründen wurde das Programm \textit{sudo} entwickelt.
% #>------------------------------------------------------------------------<#
\subsubsection{sudo}%
\label{sec:benutzer-gruppen-und-berechtigungen.sudo}
Das Programm \textit{sudo} führt den nachgestellten Befehl mit root
Berechtigungen aus. Mithilfe von sudo lässt sich die Verwendung von root
Berechtigungen auf einzelne Benutzer einschränken. Für die Verwendung von
\textit{sudo} muss ein Benutzer der Gruppe \textit{wheel} unter RHEL basierenden
Distributionen angehören oder der Gruppe \textit{sudo} für Debian basierende
Distributionen.
Mithilfe des Befehls \textit{visudo} lässt sich die Konfiguration von
\textit{sudo} bearbeiten. Dort kann unter anderem auch eingestellt werden, dass
der Aufruf eines Befehls mit \textit{sudo} keiner erneuten Kennworteingabe des
Benutzers benötigt.
Mit dem folgenden Beispiel kann ein realer Benutzer mit \textit{sudo} den Ordner
\textit{/mnt/sda1} erstellen, für welchen root Berechtigungen notwendig sind, da
root der Eigentümer des Verzeichnisses \textit{/mnt} ist.
\begin{bashcode}
sudo mkdir --parent /mnt/sda1
\end{bashcode}
Möchte man mehrere Befehle mit root Berechtigungen ausführen lohnt sich die
Anmeldung als root Benutzer von einem normalen Benutzer aus. Dies kann entweder
mit \textit{sudo -i} oder alternativ mit \textit{su} erreicht werden.
% #>------------------------------------------------------------------------<#
\subsubsection{Passwort ändern}%
\label{sec:benutzer-gruppen-und-berechtigungen.benutzer-und-gruppen.s}
Um das Passwort zu ändern reicht die Ausführung des Befehls \textit{passwd}.
Damit ist es möglich das Kennwort des gerade verwendeten Benutzers zu ändern.
Möchte man das Kennwort anderer Benutzer ändern, muss man root Berechtigungen
besitzen, sei es als Benutzer root oder per \textit{sudo}, und gibt hinter den
Befehl den Namen des Benutzers an, wessen Kennwort man ändern möchte.
Das Programm \textit{passwd} ändert dem entsprechend die Zeile in
\textit{/etc/shadow} für den Benutzer, für welchen das Passwort geändert werden
soll.
Nachteil von \textit{passwd} ist, dass es interaktiv bedient werden muss -
sprich, mit \textit{passwd} ist es nicht möglich Kennwörter von Benutzern per
Skript zu ändern. Aus diesem Grund wurde das Programm \textit{chpasswd}
entwickelt.
Allerdings möchte man nicht nur das Kennwort eines Benutzers ändern können,
sondern auch wann das Kennwort ablaufen soll oder ab wann das System eine
Warnung ausgeben soll. Mit Hilfe des Programms \textit{chage} ist dies möglich.
% #>------------------------------------------------------------------------<#
\subsubsection{Gruppe hinzufügen, bearbeiten und löschen}%
\label{sec:benutzer-gruppen-und-berechtigungen.gruppen.add-mod-rm}
Das Bearbeiten der Gruppen direkt in der Datei \textit{/etc/group} sollte
vermieden werden und stattdessen auf die Programme zurück gegriffen werden,
welche die Distribution bereit stellt.
Zum Erstellen, Bearbeiten und Löschen werden folgende Programme zur Verfügung
gestellt.
\begin{itemize}[label={},itemsep=0pt]
\item \textit{groupadd:} Erstellt eine neue Gruppe
\item \textit{groupmod:} Modifiziert eine bestehende Gruppe
\item \textit{groupdel:} Löscht eine Gruppe
\end{itemize}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 3a:} Estellen Sie die Gruppe \textit{hr} für
\textit{human resources} mit der \textit{GID} 2000.
\item \textbf{Aufgabe 3b:} Vergewissern Sie sich, dass in der Datei
\textit{/etc/group} die neue Gruppe mit entsprechender \textit{GID} angelegt wurde.
\item \textbf{Aufgabe 3c:} Benennen Sie die Gruppe \textit{hr} nach
\textit{dev} für \textit{development} um und überprüfen Sie, ob sich der Name
der Gruppe in der Datei \textit{/etc/group} geändert hat
\item \textbf{Aufgabe 3d:} Ändern Sie die \textit{GID} auf 3000 und überprüfen
Sie, ob diese sich in der Datei \textit{/etc/group} geändert hat.
\item \textbf{Aufgabe 3e:} Löschen Sie die Gruppe \textit{dev}
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsubsection{Benutzer hinzufügen, bearbeiten und löschen}%
\label{sec:benutzer-gruppen-und-berechtigungen.benutzer.add-mod-rm}
Ähnlich wie Gruppen können auch Benutzer hinzugefügt, modifiziert und gelöscht
werden. Auf folgende Befehle kann zurück gegriffen werden.
\begin{itemize}[label={},itemsep=0pt]
\item \textit{useradd:} Erstellt einen neuen Benutzer
\item \textit{usermod:} Modifiziert einen bestehenden Benutzer
\item \textit{userdel:} Löscht den Benutzer
\end{itemize}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 4a:} Erstellen Sie den Benutzer \textit{manfred} mit dem
Namen \textit{Manfred Mertens}. Der Benutzer nutzt die \acrlong{acr:bash}.
Sein Heimatverzeichnis soll unter \textit{/home} erstellt werden. Das Kennwort
lautet \textit{manni}. Seine Primärgruppe lautet \textit{manfred}. Als
\textit{UID} verwenden Sie \textit{2000}.
\item \textbf{Aufgabe 4b:} Setzen Sie das Ablaufdatum des Kennworts für den
Benutzer \textit{manni} auf den \textit{31. Juni 2021} und überprüfen Sie die
passende Spalte aus der Datei \textit{/etc/shadow}.
\item \textbf{Aufgabe 4c:} Fügen Sie den Benutzer der Gruppe \textit{wheel} hinzu.
\item \textbf{Aufgabe 4d:} Entfernen Sie den Benutzer \textit{manfred} aus der
Gruppe \textit{wheel} ohne ihn dabei aus anderen Gruppen zu entfernen.
\item \textbf{Aufgabe 4e:} Setzen Sie das Kennwort des Benutzers auf
\textit{manni-der-busfahrer}.
\item \textbf{Aufgabe 4f:} Entfernen Sie den Benutzer \textit{manfred} und
löschen Sie ggfls. seine Primärgruppe, sofern niemand mehr Mitglied ist.
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsection{Dateiberechtigungen}%
\label{sec:benutzer-gruppen-und-berechtigungen.dateiberechtigungen}
% #>------------------------------------------------------------------------<#
\subsubsection{DOS Ideologie}%
\label{sec:benutzer-gruppen-und-berechtigungen.dateiberechtigungen.dos-ideologie}
Unter Windows sind Grundsätzlich alle Dateien, welche auf den Suffix
\textit{.exe} enden Ausführbar. Unix-artige Systeme interpretieren Dateiendungen
anders. Sie sind ausschließlich dafür da, damit Desktopmanager wie gnome,
cinnamon, kde, xfce oder andere erkennen, um welche Datei es sich hier handel
und mit welchen Programmen aus einer Liste diese geöffnet werden können.
Dies bedeutet, dass auch die PDF-Datei \texttt{Aufgabensammlung.pdf} ausführbar
sein kann, obwohl diese nur lesbar sein sollte, damit Programme wie evince oder
masterpdfeditor von ihr lesen können.
% #>------------------------------------------------------------------------<#
\subsubsection{Einfache Dateiberechtigungen}%
\label{sec:benutzer-gruppen-und-berechtigungen.dateiberechtigungen.einfach}
Unter Unix-artigen Systemen, welche die GNU Core Utilities verwenden, ist das
Programm \textit{ls} vorinstalliert. Das Programm dient zu Auflistung von
Dateien und Verzeichnissen.
Die Ausgabe ist eine Zusammenstellung von mehreren Einträgen unterschiedlicher
Auflistungen, um Dateiberechtigungen exemplarisch zu erklären.
\begin{verbatim}
drwxr-xr-x. 2 markus users 40 29. Sep 21:48 hello-world
-rw-r--r--. 1 christian users 0 29. Sep 21:48 hello-world2
srw-rw----. 1 root docker 0 5. Okt 19:34 docker.sock
lrwxrwxrwx. 1 markus markus 38 14. Apr 11:32 .g -> .gnupg
brw-rw----. 1 root disk 8 5. Okt 19:34 sda
crw--w----. 1 root tty 4 5. Okt 19:34 tty0
-rwx------. 1 demo users 0 5. Okt 20:01 mybin
\end{verbatim}
Die Attributzeichenkette besteht auch 10 Zeichen und gibt Auskunft über den Typ
als auch die Berechtigungen auf die Ressource.
Das erste Attribut gibt den Typ der Ressource wieder. Folgende Attribute
beschreiben die Ressource.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{-:} Ist eine normale Datei
\item \textbf{d:} \textbf{d}irectory
\item \textbf{s:} unix \textbf{s}ocket - Beispielsweise TCP socket eines Web Servers
\item \textbf{l:} symbolic \textbf{l}ink - Link auf eine andere Datei oder
anderes Verzeichnis
\item \textbf{b:} \textbf{b}lock device - Festplatten
\item \textbf{c:} \textbf{c}haracter device - Terminal
\end{itemize}
Die verbleibenden neun Attribute werden in drei Gruppen gesplittet. Jede Gruppe
beschreibt die Berechtigungen für den Besitzer (engl. user, kurz u), die Gruppe
(engl. group, kurz g) und alle anderen Benutzer, welche weder als Besitzer noch
Mitglied in der genannten Gruppe sind. Diese Benutzer werden auch als Andere
(engl. other, kurz o) beschrieben.
Dabei haben die Attribute folgende Bedeutung:
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{r:} \textbf{r}ead - Von Ressource lesen oder Verzeichnisinhalt
auflisten
\item \textbf{w:} \textbf{w}rite - Ressource beschreiben oder
Verzeichnisinhalt ändern (hinzufügen, umbenennen, löschen)
\item \textbf{x:} e\textbf{x}ecute - Programm ausführen oder in das
Verzeichnis hineinwechseln
\end{itemize}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 5a}: Sind block devices in der obrigen Ausgabe gelistet,
wenn ja welche?
\item \textbf{Aufgabe 5b:} Nenne alle Dateien aus der obrigen Ausgabe.
\item \textbf{Aufgabe 5c:} Kann der Benutzer \textit{root} in das Verzeichnis
\textit{hello-word} hineinwechseln, wenn ja warum?
\item \textbf{Aufgabe 5d:} Welche Gruppe und was für Berechtigungen wurden der
Aufzählung \textit{hello-world2} zugewiesen?
\item \textbf{Aufgabe 5e:} Kann der Benutzer \textit{christian} das Programm
\textit{mybin} ausführen?
\item \textbf{Aufgabe 5f:} Kann der Benutzer \textit{demo} die Datei
\textit{helloworld2} lesen?
\item \textbf{Aufgabe 5g:} Wer kann mit welchen Berechtigungen mit dem
Unix-Socket \textit{docker.sock} kommunizieren?
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsubsection{Änderung der Dateiberechtigungen}%
\label{sec:benutzer-gruppen-und-berechtigungen.dateiberechtigungen.mod}
Die Berechtigungen auf Ressourcen als auch der Besitzer bzw. die Gruppe kann
geändert werden. Dazu sind in GNU Core Utilities folgende Programme enthalten.
\begin{itemize}[label={},itemsep=0pt]
\item \textit{chown:} Ändert den Besitzer einer Ressource
\item \textit{chgrp:} Ändert die Gruppe einer Ressource
\item \textit{chmod:} Ändert die Berechtigung auf eine Ressource für alle
anderen Benutzer, welche weder als Besitzer noch Mitglieder der Gruppe sind
\end{itemize}
Das Ändern des Besitzers per \textit{chown} kann durch \textit{chown user
ressource} geändert werden. Gleiches gilt für das Ändern der Gruppe:
\textit{chgrp group ressource}. Möchte man den Besitzer als auch die Gruppe in
einem ändern kann dies durch \textit{chown} umgesetzt werden. Dabei muss der
Besitzer als auch die Gruppe getrennt durch einen Doppelpunkt angegeben werden:
\textit{chown user:group ressource}. Alternativ zu den Namen kann auch die
\textit{UID} bzw. für die Gruppe die \textit{GID} verwendet werden.
Die Dateiberechtigungen lassen sich per \textit{chmod} anpassen. Das Programm
\textit{chmod} unterstützt die Symbolische- als auch die Oktal-Notation, um
Berechtigungen für Ressourcen zu beschreiben.
Für die Oktal-Natation müssen die Oktal-Werte für jede Gruppe (Besitzer, Gruppe,
Andere) addiert werden, um die symbolische Notation nachbilden zu können. Bei
der Symbolischen-Notation können die Gruppen über die Buchstaben u für engl. user, g
für engl. group und o für engl. other referenziert werden.
\begin{table}[H]
\centering
\begin{tabularx}{\textwidth}{X|X|X}
\textbf{Berechtigung} & \textbf{Oktal-Wert} & \textbf{Symbolisches-Attribut} \\
\hline\hline
read & 4 & r \\
write & 2 & w \\
execute & 1 & x \\
\end{tabularx}
\end{table}
Hier zwei Beispiele, um die Berechtigungen aus der Aufzählung aus Kapitel
\ref{sec:benutzer-gruppen-und-berechtigungen.dateiberechtigungen.einfach}
anzupassen. Dabei führen die ersten beiden und letzen beiden Befehle, unabhängig
von der Notation, zu dem gleichen Ergebnis.
\begin{bashcode}
$ chmod 750 helloworld2
$ chmod u=+rwx,g=+rx-w,o=-rwx helloworld2
$ chmod 775 helloworld mybin
$ chmod u=+rwx,g=+rwx,o=+rx-w mybin
$ ls -la
drwxr-x--- 2 markus users 40 29. Sep 21:48 hello-world
-rwxrwxr-x 1 demo users 0 5. Okt 20:01 mybin
\end{bashcode}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 6a:} Wie lautet der Befehl die Berechtigung zum lesen
des Verzeichnis \textit{helloworld2} für die Gruppe zu entfernen? Bitte gebe
die Symbolische- und Oktal-Notation an.
\item \textbf{Aufgabe 6b:} Wie lautet der Befehl der Datei mybin die
Berechtigung zum Ausführen für alle Gruppen (Besitzer, Gruppe und Andere) zu
entfernen? Symbolische- und Oktal-Notation erforderlich.
\item \textbf{Aufgabe 6c:} Wie lautet der Befehl anderen Benutzern, welche
nicht Besitzer oder Mitglied der Gruppe docker sind von dem Unix-Socket
\textit{docker.sock} zu lesen. Symbolische- und Oktal-Notation erforderlich.
\item \textbf{Aufgabe 6d:} Wie lautet der Befehl den Besitzer auf
\textit{root} und die Gruppe auf \textit{markus} für die Datei
\textit{helloworld} zu setzen? Einzeiler bitte.
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsubsection{Erweiterte Dateiberechtigungen}%
\label{sec:benutzer-gruppen-und-berechtigungen.dateiberechtigungen.erweitert}
Neben den einfachen Dateiberechtigungen unterstützen alle Unix-artige Systeme
die erweiterten Dateiberechtigungen. Diese werden \textit{setuid},
\textit{setgid} und \textit{sticky bit} genannt.
Sie lassen sich ebenfalls über die Symbolische- als auch die Oktal-Notation
setzen.
\begin{table}[H]
\centering
\begin{tabularx}{\textwidth}{X|X|X}
\textbf{Berechtigung} & \textbf{Oktal-Wert} & \textbf{Symbolisches-Attribut} \\
\hline\hline
setuid & 4 & s \\
setgid & 2 & s \\
sticky bit & 1 & t \\
\end{tabularx}
\end{table}
Die \textit{setuid} auf Dateien wird ignoriert, außer sie ist ausführbar. Ist
die Datei ausführbar wird diese mit den Berechtigungen des Besitzers ausgeführt.
Ein gutes Beispiel ist das Programm \textit{/bin/passwd}. Ohne die Option
\textit{setuid} wäre ein normaler Benutzer nicht in der Lage sein Kennwort zu
ändern, da das Programm die Dateien \textit{/etc/passwd} und
\textit{/etc/shadow} bearbeitet, welche dem Besitzer \textit{root} als auch der
Gruppe \textit{root} gehören.
Ist das \textit{setuid} auf eine Datei oder ein Verzeichnis gesetzt, wird das
Attribut \textit{x} durch ein \textit{s} unter den Berechtigungen des Besitzers
in der Attributzeichenkette ersetzt.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 7a:} Überprüfe, ob für das Programm \textit{/bin/passwd}
\textit{setuid} gesetzt ist.
\end{itemize}
Das setzen von \textit{setuid}, \textit{setgid} und \textit{sticky bit} wird per
\textit{chmod} erreicht. Es kann die Symbolische- als auch die Oktal-Notation
verwendet werden. Exemplarisch wird nachfolgend \textit{setuid} über die
Symbolische- als auch Oktal-Notation für die Datei hello-world.py gesetzt.
\begin{bashcode}
$ chmod 4755 hello-world-py
$ chmod u=+rws,g=+rx-w,o=+rx-w hello-world-py
\end{bashcode}
Die erweiterte Berechtigung \textit{setgid} verhält sich analog zu
\textit{setuid}, was Dateien betrifft. Es hat jedoch noch die Besonderheit, dass
wenn \textit{setgid} auf ein Verzeichnis gesetzt ist alle erstellten Dateien und
Verzeichnisse unterhalb des Verzeichnisses die Gruppe erben. Allerdings
\textbf{nicht} die Berechtigungen. Dies kann per \acrlongpl{acr:acl} realisiert
werden.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 7b:} Erstellen Sie das Verzeichnis \textit{/tmp/setgid}
und setzen Sie die Gruppe auf \textit{users}. Überprüfen Sie, ob
\textit{setgid} erfolgreich gesetzt wurde.
\item \textbf{Aufgabe 7c:} Erstellen Sie eine neue Datei als auch ein neues
Verzeichnis in \textit{/tmp/setgid}. Überprüfen Sie, ob die Gruppe
\textit{users} für die von ihnen erstellte Datei als auch Verzeichnis gesetzt
wurde.
\end{itemize}
Das \textit{sticky bit} wird auf Dateien ignoriert. Wird es allerdings auf ein
Verzeichnis gesetzt verhindert es, dass Benutzer Dateien und Verzeichnisse
löschen können für welche sie nicht als Besitzer hinterlegt sind.
% #>------------------------------------------------------------------------<#
\subsubsection{Access-Control-List}%
\label{sec:benutzer-gruppen-und-berechtigungen.dateiberechtigungen.acl}
Mit \acrfull{acr:acl} können Berechtigungen granularer vergeben werden. Sie
erweitern somit die Rechteverwaltung unter Linux und werden insbesondere dafür
verwendet, Berechtigungen für neu angelegte Dateien und Verzeichnisse innerhalb
eines Verzeichnisses zu vererben.
Unter Fedora muss das Paket \textit{acl} installiert sein, um die
Rechteverwaltung granularer einstellen zu können.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 8a:} Installieren Sie mit \textit{yum} das Paket
\textit{acl}, sofern dies nicht installiert ist.
\end{itemize}
Das Paket \textit{acl} enthält mehrere Programme, um \acrshortpl{acr:acl} auf
dem System verwalten zu können. Dies sind die wichtigsten:
\begin{itemize}[label={},itemsep=0pt]
\item \textit{setfacl:} Dient zum definieren von \acrshortpl{acr:acl} auf ein
Verzeichnis oder eine Datei
\item \textit{getfacl:} Liest definierte \acrshortpl{acr:acl} von einem
Verzeichnis oder einer Datei aus
\end{itemize}
Die Programme \textit{setfacl} und \textit{getfacl} folgen einer ähnlichen
Befehlsstruktur wie \textit{chmod}, \textit{chown} und \textit{chgrp}.
Hier ein Beispiel, um dem Benutzer \textit{christian} die Berechtigung
\textit{rwx} auf das Programm \textit{mybin} per \acrshort{acr:acl} einzuräumen.
\begin{bashcode}
$ setfacl -m "u:christian:rwx" mybin
\end{bashcode}
Ähnlich verhält sich das Programm, wenn man einer Gruppe oder Benutzern, welche
weder Besitzer noch Mitglieder einer Gruppe sind, Berechtigungen einräumen
möchte.
\begin{bashcode}
$ setfacl -m "g:christian:r-x" mybin
$ setfacl -m "o:r-x" mybin
\end{bashcode}
Führt man den Befehl \textit{ls -la} erneut aus, macht das \textit{+}-Zeichen
hinter der Attributzeichenkette auf die definierte \acrshort{acr:acl}
aufmerksam.
\begin{verbatim}
drwxr-xr-x. 2 markus users 40 29. Sep 21:48 hello-world
-rw-r--r--. 1 christian users 0 29. Sep 21:48 hello-world2
srw-rw----. 1 root docker 0 5. Okt 19:34 docker.sock
lrwxrwxrwx. 1 markus markus 38 14. Apr 11:32 .g -> .gnupg/
brw-rw----. 1 root disk 8 5. Okt 19:34 sda
crw--w----. 1 root tty 4 5. Okt 19:34 tty0
-rwx------+ 1 demo users 0 5. Okt 20:01 mybin
\end{verbatim}
Die definierte \acrshort{acr:acl} kann per \textit{getfacl} ausgelesen werden.
\begin{bashcode}
$ getfacl mybin
# file: mybin
# owner: demo
# group: users
user::rwx
user:christian:rwx
group::---
group:christian:r-x
mask::rwx
other::r-x
\end{bashcode}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 8b:} Erstellen Sie folgende Verzeichnisstruktur:
\textit{/tmp/acl-test/share}
\item \textbf{Aufgabe 8c:} Stellen Sie sicher, dass ausschließlich der
Benutzer \textit{root} und die Gruppe \textit{root} über die klassichen
Dateiberechtigungen Zugriff auf das Verzeichnis \textit{/tmp/acl-test} erhalten.
\item \textbf{Aufgabe 8d:} Erstellen Sie einen neuen Benutzer mit dem Namen
\textit{fuacl} und räumen Sie diesem per \acrshort{acr:acl} Berechtigungen
ein, Dateien und Verzeichnisse aus dem Verzeichnis \textit{/tmp/acl-test} zu
lesen, ändern und deren Inhalt aufzulisten. Überprüfen Sie die Einstellung!
\item \textbf{Aufgabe 8e:} Entziehen Sie dem Benutzer \textit{fuacl} die
Berechtigung Dateien und Verzeichnisse aus dem Verzeichnis
\textit{/tmp/acl-test/shared} zu lesen und aufzulisten. Überprüfen Sie die
Einstellung!
\item \textbf{Aufgabe 8f:} Stellen Sie sicher, dass neu erstellte Dokumente in
\textit{/tmp/acl-test} immer der Gruppe \textit{root} gehören und die
Berechtigung \textit{rwx} für Verzeichnisse und \textit{rw-} für Dateien
gesetzt werden. \textit{Tipp: setfact --default}. Überprüfen Sie die
Berechtigung durch erstellen eines neuen Dokuments.
\item \textbf{Aufgabe 8g:} Entfernen Sie ausschließlich jene
\acrshort{acr:acl}, welche vererbt wird.
\item \textbf{Aufgabe 8h:} Entfernen Sie rekursive alle \acrshortpl{acr:acl}.
\end{itemize}
% #>------------------------------------------------------------------------<#
\subsection{Praxisaufgabe: Verzeichnisstruktur mit Dateiberechtigungen erstellen}%
\label{sec:benutzer-gruppen-und-berechtigungen.praxis-task}
Sie befinden sich in folgender Situation:
Das Unternehmen indem Sie arbeiten wechselt aus Kostengründen von Windows
Sharepoint zu Samba. Ihr Vorgesetzter hat Sie daher gebeten Vorbereitungen für
den Umstieg zu treffen. Darunter auch die notwendige Verzeichnisstruktur für die
Abteilungen als auch die Benutzer und Gruppen zu erstellen, sowie Berechtigungen
den Vorgaben entsprechend anzupassen.
Folgende Beziehungen führt das Unternehmen zwischen Mitarbeiter und Abteilungen.
\begin{table}[H]
\centering
\begin{tabularx}{\textwidth}{X|X}
\textbf{Mitarbeiter} & \textbf{Abteilungen} \\
\hline\hline
Hugo McKinnock & Entwicklung \\
Hans Rakinzky & Entwicklung, System Administration \\
Marie Haseloff & Personalabteilung, Buchhaltung \\
Sophie Becker & Personalabteilung \\
Axel Tuller & System Administration \\
Tobias Moretti & Entwicklung, Qualitätssicherung \\
Lisa Meerkamp & Sekretärin \\
Manfred Krupp & Vorstand \\
\end{tabularx}
\end{table}
Die Verzeichnisstruktur ist unter \textit{/srv/documents} zu erstellen. Dabei
besitzt jede Abteilung ihr eigenes Verzeichnis. Innerhalb ihres Verzeichnisses
erhalten fast alle Abteilungen das Verzeichnis \textit{public} und
\textit{private}. Die Abteilung Entwicklung und Qualitätssicherung haben kein
Verzeichnis \textit{private}, da ihre Dokumente allen Benutzern im Unternehmen
zugänglich sein sollen. Dagegen besitzen die Abteilungen Sekreteriat als auch
Vorstand kein Verzeichnis \textit{public}, sondern ausschließlich
\textit{private}.
In den Verzeichnissen \textit{private} können ausschließlich Mitglieder der
Abteilung lesen und schreiben. Neu erstellte Dokumente gehören der Abteilung und
dem Benutzer \textit{root}. Ähnlich ist dies für das Verzeichnis
\textit{public}. Alle Benutzer können die Dateien oder Verzeichnisse öffnen.
Allerdings können nur Mitglieder der Abteilung neue Dokumente erstellen und
bearbeiten.
Bitte geben Sie die nötigen Befehle an, mit denen Sie die nachfolgenden Aufgaben
lösen.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 9a:} Erstellen Sie die Gruppen, beginnend mit der
\textit{GID} 2000.
\item \textbf{Aufgabe 9b:} Erstellen Sie die Benutzer, beginnend mit der
\textit{UID} 2000. Die Primärgruppe ist \textit{users}.
\item \textbf{Aufgabe 9c:} Verknüpfen Sie die Benutzer mit den Gruppen.
\item \textbf{Aufgabe 9d:} Erstellen Sie die beschriebene Verzeichnisstruktur.
\item \textbf{Aufgabe 9e:} Setzen Sie die beschriebenen Berechtigungen um.
\item \textbf{Aufgabe 9f:} Melden Sie sich unter dem Benutzer von Marie
Haseloff per \textit{sudo} an und überprüfen Sie folgende Berechtigungen:
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 9f$_1$:} Erstellen, bearbeiten und löschen von Dateien
und Verzeichnissen in der für Ihr, über die Abteilung, zugewiesenen
Verzeichnisse.
\item \textbf{Aufgabe 9f$_2$:} Neu erstellte Dokumente und Verzeichnisse
gehören der jeweiligen Abteilung. Verzeichnisse haben die
Gruppenberechtigung \textit{rwx}. Dateien haben die Gruppenberechtigung
\textit{rw-}.
\item \textbf{Aufgabe 9f$_3$:} Von Dateien und Verzeichnissen der Abteilung
Vorstand darf weder gelesen noch geschrieben als auch deren Inhalt gelistet
werden.
\item \textbf{Aufgabe 9f$_4$:} Dateien aus dem Verzeichnis \textit{public}
der Abteilung System Administration sind lesbar, aus dem Verzeichnis
\textit{private} nicht.
\end{itemize}
\end{itemize}

221
chapters/05-directory-structure.tex Normal file
View File

@ -0,0 +1,221 @@
% <#>-----------------------------------------------------------------------<#>
\section{Verzeichnisstrukturen}%
\label{sec:verzeichnisstrukturen}
Das Konzept der Verzeichnisstruktur von Unix-artigen Betriebssystemen ist
annähernd identisch. Es gibt jedoch Besonderheiten zwischen den einzelnen
Abspaltungen von Unix hinsichtlich Linux und BSD, als auch der jeweiligen
Distributionen und Abspaltungen: Debian, RHEL, OpenBSD etc. Da jedoch die
Vielfalt zu groß für dieses Kapitel wäre, werden diese hier nicht näher
behandelt.
% >---------------------------------------------------------------------------<
\subsection{/ (root directory, Wurzelverzeichnis)}%
\label{sec:verzeichnisstrukturen.root}
% NOTE: Missing reference to chapter where devices will be mounted
Das Wurzelverzeichnis \textit{/} ist die oberste Verzeichnisebene. Es enthält
alle weiteren Unterverzeichnisse und Dateien unabhängig, ob diese sich auf einem
physikalisch anderen Gerät befinden. Dazu später mehr.
% >---------------------------------------------------------------------------<
\subsection{/bin/}%
\label{sec:verzeichnisstrukturen.bin}
Systemrelevante Programme, beispielsweise jene, welche Bestandteil der GNU Core
Utility Collection sind werden in dem Verzeichnis \textit{/bin/} gespeichert.
Dies sind zum Beispiel \textit{chmod}, \textit{chown}, \textit{chgrp},
\textit{id}, \textit{cp}, \textit{mv} oder \textit{rm}. Im Regelfall sind alle
Programme, welche notwendig sind das System erfolgreich zu booten im Verzeichnis
\textit{/bin/} hinterlegt.
% >---------------------------------------------------------------------------<
\subsection{/boot/}%
\label{sec:verzeichnisstrukturen.boot}
In dem Verzeichnis \textit{/boot/} befindet sich der Linux Kernel. Der Linux
Kernel wird als Datei gespeichert. Im Dateinamen aller unterschiedlichen
Kernelversionen befindet sich in der Regel die folgende Zeichenkette, wenn je
nach Distribution diese nicht überschrieben wurde: \textit{vmlinux}.
% NOTE: Missing reference to chapter where linux system will be booted
Neben dem Kernel befindet sich in dem Verzeichnis passend zu den installierten
Kernelversionen noch die Datei \textit{initramdisk}. Sie wird in den
\acrshort{acr:ram} während des Bootvorgangs geladen und startet den Kernel. Mehr
zum Bootvorgang unter Linux in einem späteren Kapitel.
% >---------------------------------------------------------------------------<
\subsection{/boot/EFI/}%
\label{sec:verzeichnisstrukturen.efi}
Das Verzeichnis \textit{/boot/EFI} ist ausschließlich bei Systemen vorhanden,
welches statt der \acrshort{acr:bios} Bootmethode \acrshort{acr:uefi} verwendet.
Das Verzeichnis beinhalter die unterschiedlichen Bootloader. Beispielweise den
von Windows, GRUB oder systemd-boot.
Ratsam ist es daher das Verzeichnis \textit{/boot/EFI} als seperate Partition zu
behandeln, sodass wenn mehrere Systeme installiert sind ein und die selbe EFI
Partition verwendet werden kann. Dies hat den Vorteil, dass ausschließlich eine
Partition in der Firmware des Motherboards angeben werden muss, damit die
Firmware die entsprechenden Bootloader von den jeweiligen Systemen findet.
% >---------------------------------------------------------------------------<
\subsection{/dev/}%
\label{sec:verzeichnisstrukturen.dev}
Physische als auch virtuelle Peripheriegeräte, beispielsweise die physisch
verbaute oder dem Gastsystem zugewiesene virtuelle Festplattte, werden neben
anderen Geräten im Verzeichnis \textit{/dev/} als Datei abgebildet. Siehe
Kapitel
\ref{sec:benutzer-gruppen-und-berechtigungen.dateiberechtigungen.einfach}, um
aus der Attributszeichenkette erkennen zu können, bei welcher Datei es sich um
ein Blockdevice handelt.
Auf diese speziellen Dateien kann anschließend mit anderen Programmen
zugegriffen werden. Beispielsweise das Einbinden eines Blockgerätes (Festplatte)
an einen beliebigen Einbindungspunkt - siehe \textit{mount} Befehl.
% >---------------------------------------------------------------------------<
\subsection{/etc/}%
\label{sec:verzeichnisstrukturen.etc}
In dem Verzeichnis \textit{/etc/} sind Konfigurationsdateien von Programmen
enthalten. Im Regelfall werden diese durch die Entwickler bereitgestellt.
Beispielsweise durch Installation des entsprechenden \acrshortpl{acr:rpm}.
Sind keine Konfigurationsdateien für ein Programm im Verzeichnis \textit{/etc/}
vorhanden. Können diese auch unter \textit{/usr/} gespeichert sein. Ein
manuelles platzieren der Konfigurationsdateien unter \textit{/etc/} würde das
Standardverhalten des Programms übersteuern.
% >---------------------------------------------------------------------------<
\subsection{/home/}%
\label{sec:verzeichnisstrukturen.home}
Es ist das Standardverzeichnis für normale bzw. reale Benutzer. Dieses
Verzeichnis wird manchmal auch mit anderen Linux-Distributionen geteilt, sofern
das gleiche Heimatverzeichnis von mehreren Benutzern unterschiedliche
Distributionen verwendet werden soll.
% >---------------------------------------------------------------------------<
\subsection{/lib/}%
\label{sec:verzeichnisstrukturen.lib}
Bibliotheken, welche gemeinsam durch mehrere Programme, welche sich in den
Verzeichnissen \textit{/bin/} und \textit{/sbin} befinden, geteilt werden,
werden im Verzeichnis \textit{/lib} gespeichert.
% >---------------------------------------------------------------------------<
\subsection{/media/}%
\label{sec:verzeichnisstrukturen.media}
In dem Verzeichnis \textit{/media/} werden entfernbare Dateisysteme eingebunden.
Beispielsweise der USB-Stick, eine USB-Festplatte oder eine CD bzw. DVD, welche
sich im Laufwerk befindet.
Desktopmanager wie Gnome, Cinnamon, Xfce oder KDE übernehmen hier die Funktion,
das Gerät automatisch unter \textit{/media/} einzubinden.
% >---------------------------------------------------------------------------<
\subsection{/mnt/}%
\label{sec:verzeichnisstrukturen.mnt}
Andere Systempartitionen, beispielsweise die C: oder D: Partition von
Windowssystemen auf einem Dualboot System, werden unter \textit{/mnt/}
eingebunden. Im Regelfall auch nur temporär, beispielsweise wenn der
Systemadministrator versucht unter Linux auf die Windowspartitionen zu
zugreifen.
% >---------------------------------------------------------------------------<
\subsection{/opt/}%
\label{sec:verzeichnisstrukturen.opt}
Das Verzeichnis \textit{/opt} ist das Standardverzeichnis für proprietäre
Programme und steht für \textit{optional package tree}. In diesem Verzeichnis
legen daher im Regelfall proprietäre Programme Binär-, Konfigurations-, und
Bibliotheksdateien ab.
Beispielsweise, wenn man einen TeamSpeak 3 Server oder Druckertreiber von
Brother installieren möchte, werden diese unter \textit{/opt} installiert.
% >---------------------------------------------------------------------------<
\subsection{/root/}%
\label{sec:verzeichnisstrukturen.root}
Der Benutzer \textit{root} besitzt sein eigenes Heimatverzeichnis direkt
unterhalb des Wurzelverzeichnisses. Es ist das Verzeichnis \textit{/root/}. Es
wird gesondert geführt und ausschließlich der Benutzer \textit{root} besitzt
Berechtigungen von dem Verzeichnis zu lesen und zu schreiben als auch es
betreten zu können.
% >---------------------------------------------------------------------------<
\subsection{/run/}%
\label{sec:verzeichnisstrukturen.run}
Programme, welche ausgeführt werden und Informationen auslagern speichern diese
im Verzeichnis \textit{/run/}. Dies können beispielsweise Unix-Sockets oder auch
temporäre Einstellungsparameter sein, welche nur zur Laufzeit des Programms
vorhanden sind.
Die Dateien werden nicht im Verzeichnis \textit{/tmp/} gespeichert, da Dateien
und Verzeichnisse unter \textit{/tmp/} automatisch entfernt werden können.
Beispielsweise, wenn das System bemerkt der Speicherplatz geht zur Neige.
Der Dienst \textit{systemd-resolved} speichert als gutes Beispiel unter
\textit{/run/systemd/resolve/resolv.conf} die \textit{resolv.conf} Datei ab,
welche von \textit{/etc/resolv.conf} per symbolischen link referenziert wird.
% >---------------------------------------------------------------------------<
\subsection{/sbin/}%
\label{sec:verzeichnisstrukturen.sbin}
Das Verzeichnis \textit{/sbin} ist identisch zu dem Verzeichnis \textit{/bin}.
Es enthält jedoch ausschließlich Programme welche für den Benutzer \textit{root}
vorgesehen sind.
% >---------------------------------------------------------------------------<
\subsection{/srv/}%
\label{sec:verzeichnisstrukturen.srv}
Stellt das System beispielsweise Mail-, Web- oder andere Dienste bereit, werden
die persistenten Daten unter \textit{/srv/} gespeichert. Dieses Verzeichnis ist
nicht automatisch Bestandteil jeder Distribution. Es kann daher sein, das gerade
bei Distributionen, welche einen minimalistischen Ansatz fahren nicht vorhanden
ist.
% >---------------------------------------------------------------------------<
\subsection{/tmp/}%
\label{sec:verzeichnisstrukturen.tmp}
Das \textit{/tmp/} Verzeichnis ist der generelle Speicherort für temporäre
Dateien. Ältere Systeme verwenden eine eigene Partition für das Verzeichnis
\textit{/tmp/}, um die Größe zu limitieren. Neuere Systeme, welche systemd
verwenden, richten das Verzeichnis \textit{/tmp/} als
\nameref{sec:dateisysteme.tmpfs}
Dateisystem ein und limitieren dieses auf eine prozentuale Größe.
% >---------------------------------------------------------------------------<
\subsection{/usr/}%
\label{sec:verzeichnisstrukturen.usr}
Anwendungen und Dateien die von realen Benutzern verwendet werden, werden im
Gegensatz zu Anwendungen und Dateien welche vom System verwendet werden, unter
\textit{/usr/} gespeichert. Aus diesem Grund sind unterhalb von \textit{/usr/}
auch Verzeichnisse wie \textit{/usr/bin}, \textit{/usr/sbin} oder
\textit{/usr/lib} enthalten. Alle Unterverzeichnisse von \textit{/usr/} sind für
Benutzer nur lesbar und betretbar. Dateien sind in der Regel ebenfalls nur
lesbar eventuell noch ausführbar.
% >---------------------------------------------------------------------------<
\subsection{/var/}%
\label{sec:verzeichnisstrukturen.var}
Der Grundgedanke des Verzeichnisses \textit{/var/} ist, dass es das Gegenstück
zu \textit{/usr/} abbilden soll. Hier können Benutzer beliebig Dateien oder
Verzeichnisse erstellen. Allerdings sind können diese Eingeschränkt sein.
Ein gutes Beispiel sind Logdateien. Würden Logdateien eines Programms, welche
aus dem Verzeichnis \textit{/usr/bin} oder \textit{/usr/sbin} ausgeführt werden,
in das Verzeichnis \textit{/usr/} speichern, würde dies gegen das Konzept des
Verzeichnisses \textit{/usr/} sprechen. Aus diesem Grund werden Logdateien in
das Verzeichnis \textit{/var/log} gespeichert.

404
chapters/06-filesystems.tex Normal file
View File

@ -0,0 +1,404 @@
% <#>---------------------------------------------------------------------------<#>
\section{Dateisysteme}%
\label{sec:dateisysteme}
Je nach Kernel werden unterschiedliche Dateisysteme unterstützt. Bekannt von
Windows ist Ihnen bestimmt das \acrfull{acr:ntfs}. Linux unterstützt im
Gegensatz zum Windows NT Kernel nicht nur ein oder zwei Dateisysteme sondern
eine große Vielzahl, beispielsweise \acrshort{acr:ext3}, \acrshort{acr:ext4},
\acrshort{acr:btrfs}, \acrshort{acr:eCryptfs}, \acrshort{acr:reiser} oder XFS.
Jedes Dateisystem hat Stärken und Schwächen. Aus diesem Grund werden nicht alle
Dateisysteme detailiert betrachtet, sondern ausschließlich \acrshort{acr:btrfs},
welches für Fedora 33 als Standard Dateisystem angekündigt
ist\footcite{fedora33-btrfs-default} als auch kleinere Dateisysteme, welche
nicht direkt eine physische oder virtuelle Festplatte vorraussetzen.
% #>-------------------------------------------------------------------------<#
\subsection{BtrFS}%
\label{sec:dateisysteme.btrfs}
Das \acrshort{acr:btrfs} Dateisystem ist ein \acrlong{acr:cow} Dateisystem.
\acrshort{acr:cow} bedeutet, dass für Dateien, welche kopiert werden, nicht der
selbe Speicherplatz anfällt. Sie werden stattdessen nur referenziert. Dies hat
den Vorteil, das Speicherplatz eingespart werden kann. Im Umfeld von
systemorierntierten Programmiersprachen wie C, Rust oder Go, kann dies mit dem
Konzept von Pointern verglichen werden. Wobei statt Speicheradressen die
Dateisystemblöcke referenziert werden, welche die Datei im Dateisystem abbilden.
\acrshort{acr:btrfs} bietet mehrere Funktionen an, welche in dem Umfang kein
anderes Dateisystem anbietet. Hier einige Informationen über \acrshort{acr:btrfs}:
\begin{itemize}[itemsep=0pt]
\item Dynamisch wachsende Inodes
\item Verwaltung von Subvolumes
\item Erstellung von Snapshots pro Subvolume
\item Datenkompression auf Dateisystemebene
\item Dateisystemcheck und Defragmentierung während des Betriebs
\item Prüfsummenbasiert
\item Integrierte \acrshort{acr:raid} option, wobei nur \acrshort{acr:raid} 0
und 1 als stabil zu betrachten sind
\end{itemize}
% >---------------------------------------------------------------------------<
\subsubsection{Was ist genau BtrFS}%
\label{sec:dateisysteme.btrfs.erklaerung}
Eine \acrshort{acr:btrfs}-Partition stellt eine Volume dar, welches in mehrere
Subvolume unterteilt werden kann. Subvolumes stehen in ihrer Eigenschaft
zwischen Partitionen und Verzeichnissen. Partitionen haben eine feste Größe,
Subvolumes nicht, außer sie werden durch Quotas limitiert. Daher verhalten sich
Subvolumes ähnlich wie Verzeichnisse.
Im Verzeichnisbaum des Systems werden Subvolumes automatisch als Ordner
eingehängt. In Ubuntu-Derivaten und OpenSUSE hat es sich eingebürgert
Top-Level-Subvolumen mit einem vorangestellten \textit{@} zu benennen. Dies ist
eine reine Konvention unter den Nutzern dieser Linux-Derivate und formell nicht
nötig. Subvolumen bedürfen keiner speziellen Nomenklatur. Es ist sogar
hinderlich, da jedes Subvolumen welches anders heißt als wie vom System erwartet
explizit eingehängt werden muss.\footcite{was-ist-btrfs}
\acrshort{acr:btrfs} erlaubt zudem das Erstellen von Snapshots. Snapshots
representieren eine Momentaufnahme eines Subvolumes. Snapshots müssen auf der
selben \acrshort{acr:btrfs} Partition gespeichert werden wie das Subvolume.
Enthält ein Subvolume einen Snapshot, enthält der Snapshot nicht rekursiv alle
Snapshots, welche zum Zeitpunkt der Erstellung vorhanden waren. Da Snapshots
Momentaufnahmen sind, können diese sehr leicht zurück gespielt werden. Hier ist
allerdings zu beachten, dass ein Snapshot kein Backup im eigentlichen Sinne ist.
Backups werden auf physisch getrennte Geräte gespeichert, was bei Snapshots
nicht der Fall ist.
Dateien und Verzeichnisse, welche durch einen Snapshot kopiert werden, belegen
nicht zusätzlichen Speicherplatz. Sie werden nur von ein oder mehreren Quellen
referenziert. Folgende Abbildung beschreibt den Prozess und die Referenzierung:
\begin{figure}[H]
\centering
\includegraphics[width=1\textwidth]{img/btrfs-cow.png}
\caption{Referenzierung von Speicherblöcken}%
\label{fig:dateisysteme.btrfs.referenzierung-von-speicherbloecken}
\end{figure}
Erst wenn alle Referenzen gelöscht sind können die Dateisystemblöcke
überschrieben werden.
% >---------------------------------------------------------------------------<
\subsubsection{Step-By-Step}%
\label{sec:dateisysteme.btrfs.step-by-step}
Mit dem Befehl \textit{mkfs.btrfs} kann eine \acrshort{acr:btrfs} Dateisystem
auf einer leeren Partition erstellt werden. Mit dem Befehl \textit{parted} oder
\textit{fdisk} lassen sich Partitionen einer Festplatte bearbeiten,
beispielsweise um neue zu erstellen, zu löschen oder deren Größe anzupassen.
Bei der Erstellung eines \acrshort{acr:btrfs} Dateisystems wird zwischen Daten
und Metadaten unterschieden. Bei Daten handelt es um die Daten welche auf der
Festplatte gespeichert werden. Metadaten enthalten dagegen Informationen, welche
Datei durch welches Subvolume oder Snapshot referenziert wird. Für beide
Informationsträgertypen kann zwischen mehreren Profilen unterschieden werden. Es
können Beispielsweise die Daten auf einem \acrshort{acr:raid}-0 und die
Metadaten auf einem \acrshort{acr:raid}-1 gespeichert werden. Je nach
Einsatzszenario kann ein vordefiniertes Profil bei der Erstellung verwendet
werden. Das verwendete Profil lässt sich nachträglich nicht mehr ändern.
Neben den Profilen lassen sich auch weitere Informationen für die
\acrshort{acr:btrfs} Partition definieren. Beispielsweise das Label oder die
UUID.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 1a:} Binden Sie über ihren HyperVisor (HyperV,
\acrshort{acr:kvm} oder Virtual Box) zwei neue virtuelle Festplatten an ihre
VM. Beide virtuelle Festplatten sollen eine Größe von 5GB besitzen. Starten
Sie, nachdem Sie die virtuellen Festplatten der VM zugewiesen haben, die
Virtuelle Maschine und überprüfen Sie mit \textit{lsblk} (list block devices),
ob beide virtuelle Festplatten durch ihre VM erkannt wurden.
\item \textbf{Aufgabe 1b:} Welche unterschiedlichen Profile werden von dem
\acrshort{acr:btrfs} Dateisystem unterstützt?
\item \textbf{Aufgabe 1c:} Erstellen Sie eine neue Partition mit dem
Partitionsschema \textit{msdos}. Nutzen Sie zur Partitionierung entweder
\textit{parted} oder \textit{fdisk}.
\item \textbf{Aufgabe 1d:} Richten Sie ein neues \acrshort{acr:btrfs}
Dateisystem ein. Verwenden Sie dazu die beiden virtuellen Festplatten. Die
Daten als auch Metadaten sollen als \acrshort{acr:raid}-1 vor einem
Festplattenausfall geschützt werden. Verwenden Sie als Label
\textit{btrfs-raid-1}.
\end{itemize}
Physische als auch virtuelle Geräte können an unterschiedlichen Stellen im
Verzeichnisbaum eingebunden werden. Zum Einbinden eines Gerätes in den
Verzeichnisbaum wird der Befehl \textit{mount} verwendet. Die allgemeine Syntax
lautet:
\begin{bashcode}
$ mount [-t <typ>, -o <option>] <dev> <mountpoint>
# Beispiel, um die Partition vdb1 der virtuellen Festplatte /dev/vdb nach /mnt/vbd1 zu "mounten".
$ mount /dev/vdb1 /mnt/vdb1
\end{bashcode}
Weitere Informationen zum Einbinden von Geräten finden Sie in der Dokumentation:
\textit{man mount}.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 2a:} Erstellen Sie das Verzeichnis \textit{/mnt/btrfs}.
\item \textbf{Aufgabe 2b:} Ermitteln Sie, was die Optionen \textit{rw},
\textit{noatime}, \textit{compress}, \textit{ssd}, \textit{space\_cache} und
\textit{subvol} bedeutet, welche beim Einbinden eines \acrshort{acr:btrfs}
Dateisystems verwendet werden können.
\item \textbf{Aufgabe 2c:} Binden Sie das \acrshort{acr:btrfs}
\acrshort{acr:raid} Dateisystem unter \textit{/mnt/btrfs} ein. Entscheiden Sie
selbst, welche Optionen für Sie relevant sind.
\end{itemize}
Nach einem Neustart des Systems ist das \acrshort{acr:btrfs} Dateisystem nicht
mehr eingebunden. Sie müssen das Einbinden des Dateisystems per \textit{mount}
wiederholen oder einen Eintrag in die Datei \textit{/etc/fstab} vornehmen. Dazu
ermitteln Sie am besten per \textit{blkid} die UUID ihrer btrfs-raid Partition
und verweden diese in der \textit{fstab}, um die Partition automatisch nach
einem Neustart einzubinden. Weitere Informationen finden Sie unter folgendem
\href{https://wiki.archlinux.de/title/Fstab}{Link}.
Wie bereits in Kapitel \ref{sec:dateisysteme.btrfs.erklaerung} beschrieben
untersützt das \acrshort{acr:btrfs} Dateisystem Subvolumes. Auf dem kürzlich
erstellten \acrshort{acr:btrfs} \acrshort{acr:raid} Dateisystem sollen zukünftig
Bilder, Musiktitel, Podcasts und Videos gespeichert werden.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 3a:} Erstellen Sie für die Bilder, Musiktitel, Podcasts
und Videos ein Subvolume auf dem neuen \acrshort{acr:btrfs}
\acrshort{acr:raid} Dateisystem.
\item \textbf{Aufgabe 3b}: Überprüfen Sie, ob die Subvolumes erkannt wurden.
\item \textbf{Aufgabe 3c:} Löschen Sie das Subvolume Podcasts.
\item \textbf{Aufgabe 3d:} Erstellen Sie unterhalb der verbleibenden
Subvolumes das Verzeichnis \textit{.snapshots}.
\end{itemize}
Nachdem Sie nun die drei Subvolumes mit dem Unterverzeichnis \textit{.snapshots}
erstellt haben kommen wir an den Punkt Snapshots zu erstellen. Snapshots sind
Grundsätzlich nichts anderes als Subvolumes. Sie referenzieren auf die gleichen
Dateien, welches sich zum Zeitpunkt des Snapshots im Subvolume befanden. Die
Dateien innerhalb eines Snapshots lassen sich bearbeiten und modifizieren ohne
dabei die Dateien innerhalb des Subvolumes zu beeinträchtigen. Dies ist jedoch
nicht immer gewünscht, da dadurch ein Snapshot nicht mehr der Momentaufnahme
entspricht. Aus diesem Grund kann das nachträgliche Editieren von Dateien
innerhalb eines Snapshots unterbunden werden.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 4a:} Erstellen Sie einen \textit{read-only} Snapshot von
jedem Subvolume, um ein nachträgliches Editieren von Dateien in den Snapshots
zu unterbinden. Speichern Sie den Snapshot in das Verzeichnis
\textit{.snapshots} des jeweiligen Subvolumes mit dem Namensschema
\textit{$<nameSubvolume>.<jahr><monat><tag>T<stunde><minute>$} ab.
\item \textbf{Aufgabe 4b:} Überprüfen Sie, ob die Snapshots als Subvolumes
erkannt wurden.
\item \textbf{Aufgabe 4c:} Löschen Sie das Subvolume von dem Sie einen
Snapshot erstellt haben.
\item \textbf{Aufgabe 4d:} Stellen Sie mithilfe des Snapshots das Subvolume
wieder her.
\end{itemize}
Nun, ein Snapshot ist kein Backup. Ein Backup ist die Sicherung eines Zustands
auf einem anderen physischen Gerät, beispielsweise einer zweiten angeschlossenen
Festplatte oder einem entfernten System. Um ein Backup zu erstellen enthält das
Programm \textit{btrfs} den Unterbefehl \textit{send}. Damit kann ein Snapshot
in eine Datei exportiert werden. Neben dem Unterkommando \textit{send} enthält
es unter anderem auch das Unterkommando \textit{receive}, um Snapshots aus einer
Datei zu importieren.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 5a:} Exportieren Sie einen kürzlich erstellten Snapshot
per \textit{btrfs send} in eine Datei.
\item \textbf{Aufgabe 5b:} Löschen Sie den Snapshot.
\item \textbf{Aufgabe 5c:} Stellen Sie den gesicherten Snapshot aus der Datei
wieder her.
\item \textbf{Aufgabe 5d:} Kopieren Sie per \textit{scp} von dem SSH-Server
der Hochschule die Datei
\textit{/dozenten/peschm/linux\_ws2021/videos.20201027T223646.snapshot} in
ihre VM. Spielen Sie den Snapshot unter dem Subvolume \textit{videos} wieder
ein. Schauen Sie sich das darin enthaltene Video an ;) Eventuell muss das
Video auf ein anderes System kopiert werden, da ihre VM keinen Mediaplayer
besitzt.
\end{itemize}
Die Snapshots können nun durch ein Skript erstellt und gelöscht werden, als auch
das letzte Backup auf ein entferntes System oder eine zweite Festplatte
exportiert werden. Doch warum sollte man sich die Arbeit machen solch ein Skript
zu erstellen, wenn andere bereits ein Program daraus gemacht haben.
Mit dem Programm \textit{btrbk} können Snapshots und Backups je nach Szenario
verwaltet werden. Der Quellcode des Programms ist auf
\href{https://github.com/digint/btrbk}{github.com} verfügbar, dort sind neben
den Konfigurationsoptionen auch mögliche Szenarien, welche das Programm abdeckt,
beschrieben.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 6a:} Installieren Sie das Programm \textit{btrbk} mit
\textit{yum}.
\item \textbf{Aufgabe 6b:} Informieren Sie sich über die \textit{README.md}
Datei, welche möglichen Szenarien durch \textit{btrbk} abgedeckt werden.
\item \textbf{Aufgabe 6c:} Konfigurieren Sie \textit{btrbk}, dass von den
Subvolumes Bilder, Musiktitel und Videos stündlich ein Snapshot in das
jeweilige \textit{.snapshots} Verzeichnis erstellt wird. Eine
Beispielkonfiguration liegt unter \textit{/etc/btrbk}. Weitere Informationen
finden Sie in der ausführlich dokumentierten
\href{https://digint.ch/btrbk/doc/archive/}{Dokumentation}.
\item \textbf{Aufgabe 6d:} Passen Sie die Konfiguration so an, dass die
Snapshots der folgenden Ausbewahrungsrichtlinie entspricht. Die letzen 24
stündliche, 14 tägliche, 4 wöchentliche, 12 monatliche und jährliche Snapshots
sollen behalten werden, um dem Großvater-Vater-Kind Prinzip zu entsprechen.
\item \textbf{Aufgabe 6e:} Passen Sie ggfl. das Namensschema der Snapshots an,
sodass es dem Namensschema von Aufgabe 4a entspricht.
\item \textbf{Aufgabe 6f:} Starten Sie \textit{btrbk} per \textit{btrbk run -c
/etc/btrbk/btrbk.conf run} und überprüfen Sie in der Ausgabe als auch im
Dateisystem, ob die Snapshots erstellt wurden.
\end{itemize}
% #>-------------------------------------------------------------------------<#
\subsection{overlayfs}%
\label{sec:dateisysteme.overlayfs}
Overlayfs ermöglicht die Überlagerung eines Verzeichnisbaums mit einem anderen
Verzeichnisbaum. Alle Änderungen gehen in die höhere beschreibbare Ebene.
Dadurch können mehrere Verzeichnisbäume basieren auf unterschiedlichen und
wiederverwendbaren Ebenen abgebildet werden. Diese Art von Mechanismus wird
vorwiegend für Container Applikationen verwendet. Es gibt jedoch auch eine
Vielzahl anderer Verwendungsmöglichkeiten.
Um overlayfs anhand eines Beispiels einfacher zu erklären betrachten wir den
Entwicklungsprozess einer Applikation mit allen notwendigen Dateien. Notwendig
für die Ausführung der Applikation ist die Binärdatei (das eigentliche
Programm), die Konfigurationsdateien, das Logverzeichnis und die systemd unit
Dateien, welche beschreiben wie das Programm unter einem systemd basierenden
System gestartet werden soll. Optional können noch Plugins bereitgestellt
werden.
Alle Dateien bzw. Plugins werden im Entwicklungsprozess in einem eigenen
Verzeichnisbaum gespeichert. Jeder Verzeichnisbaum wird durch eine Ebene
repräsentiert. Dies entspricht einem modularem Aufbau, da die Verzeichnisbäume
individuell wiederverwendet oder ausgetauscht werden können.
Die folgende Abbildung beschreibt den modularen Aufbau der Applikation mit allen
notwendigen Ebenen. Jede Ebene (layer) wird lesend über die vorherige Ebene
überlagert. Links befindet sich die Applikation ohne Plugins, rechts mit
Plugins, welche zusätzlich als seperate Ebene abgebildet sind und nicht
verändert werden können. Die horizontale Linie markiert den Punkt, ab wann
unterschiedliche Ebenen verwendet werden. Die oberste Ebene (workspace) ist
beschreibbar, um Konfigurationsdateien anzupassen oder damit das Programm
Logeinträge in die Logdateien schreiben kann.
\begin{figure}[H]
\centering
\includegraphics[width=0.55\textwidth]{img/overlayfs.png}
\caption{Aufbau eines OverlayFS mit mehreren wiederverwendeten Ebenen}%
\label{fig:dateisysteme.overlayfs.aufbau-mit-mehreren-ebenen}
\end{figure}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 7a:} Erstellen Sie folgendes Arbeitsverzeichnis und
wechseln die dort hinein: \textit{/root/workspace/overlayfs}.
\item \textbf{Aufgabe 7b:} Erstellen Sie folgende Dateien und Verzeichnisse
unterhalb ihres Arbeitsverzeichnisses:
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 7b$_1$:} Die \glqq{}Binärdatei\grqq{}:\\
\textit{./lower\_0/usr/bin/mybin}.
\item \textbf{Aufgabe 7b$_2$:} Die globale Konfigurationsdatei:\\
\textit{./lower\_1/etc/mybin/config.json}.
\item \textbf{Aufgabe 7b$_3$:} Die Logdatei:\\
\textit{./lower\_2/var/log/mybin/info.log}
\item \textbf{Aufgabe 7b$_4$:} Die systemd unit Dateien:\\
\textit{./lower\_3/usr/lib/systemd/system/mybin.service}
\item \textbf{Aufgabe 7b$_5$:} Die Konfigurationsdatei für das sqlite Plugin:\\
\textit{./lower\_4/etc/mybin/conf.d/sqlite.config}
\item \textbf{Aufgabe 7b$_6$:} Die Konfigurationsdatei für das postgresql
Plugin:\\
\textit{./lower\_5/etc/mybin/conf.d/postgresql.config}
\end{itemize}
\end{itemize}
Um mehrere Verzeichnisbäume überlagernd einzubinden ist folgende allgemeine
Syntax notwendig:
\begin{bashcode}
$ mount -t overlay -o lowerdir=<path_lowerdir1>:<path_lowerdir2>:... ,upperdir=<path>,workdir=<path> overlayfs <path>
\end{bashcode}
Das Flag \textit{-t} gibt den Typ an. Mit dem Flag \textit{-o} werden Optionen
definiert. Der Option lowerdir kann eine Liste von Pfaden übergeben werden,
gerennt durch einen Doppelpunkt, um zu defineren welche Verzeichnisbäume
überlagert werden sollen. Dabei ist die Reihenfolge zu beachten. Upperdir
entspricht dem workspace der Abbildung, sprich das spätere beschreibbare
Verzeichnis. Als workdir muss der Pfad zu einem leeren Verzeichnis angegeben
werden, indem der Prozess für den Überlagerungsvorgang Dateien zwischenspeichern
kann. Das zweite Argument entspricht dem Pfad im Dateisystem, andem der
überlagerte Verzeichnisbaum eingebunden werden soll.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 7c:} Binden Sie mithilfe des \textit{mount} Befehls das
OverlayFS Dateisystem bestehend aus allen notwendigen Ebenen unter
\textit{./application} und \textit{./application\_plugins} ein, um einmal den
notwendigen Verzeichnisbaum für die Applikation mit und ohne Plugin ab zu
bilden. Vergewissern Sie sich, dass alle notwendigen Verzeichnisse vorhanden
sind. Verwenden Sie die unterschiedlichen Verzeichnisbäume bzw. Ebenen wieder.
\item \textbf{Aufgabe 7d:} Erstellen Sie unter \textit{./application} das
Verzeichnis \textit{hello-world}. Überprüfen Sie, ob das Verzeichnis in einer
der Ebenen, welche als lesende Verzeichnisbäume eingebunden wurden, erstellt
wurde.
\item \textbf{Aufgabe 7e:} Löschen Sie unter \textit{./application\_plugins}
die plugin Konfigurationsdateien. Überprüfen Sie anschließend ob in der
entsprechenden Ebene ebenfalls die Konfigurationsdatei gelöscht wurde. Diese
dürfte nach dem Konzept nicht gelöscht worden sein.
\end{itemize}
Dateisysteme von Container Applikationen sind genau nach diesem Konzept
aufgebaut. Die Stärke liegt jedoch nicht nur in dem modularen Dateisystemaufbau
oder der Isolierung von Ressourcen - sprich CPU, \acrshort{acr:ram}, Storage,
ect., sondern auch darin, dass die Ebenen sich leicht von einem System auf ein
anderes übertragen lassen. Man spricht bei diesem Abschnitt in der Entwicklung
einer Applikation von Deployment. Dabei gilt, dass die beste Software die
schlechteste sein kann, wenn der Anwender nicht in der Lage ist, sie ohne große
Umstände installieren oder ausführen zu können.
Container Runtimes wie containerd, crio oder runc bemächtigen sich der Funktion
Subvolumes des darunter liegenden BtrFS Dateisystems zu importieren bzw.
exportieren, da dadurch Verzeichnisbäume einfach von einem System auf ein
anderes kopiert werden können. Ebenen bzw. Layer werden dann als eigenständiges
Subvolume betrachtet.
Finden Container Runtimes auf dem System kein BtrFS Dateisystem vor, werden die
Verzeichnisbäume unterhalb eines Verzeichnisses im Dateisystem gespeichert.
Ähnlich wie es bei der Übung veranschaulicht wurde. Dies hat jedoch den
Nachteil, dass identische Dateien, welche in mehreren Ebenen bzw. Layern
wiederverwendet werden zusätzlichen Speicherplatz auf der Festplatte
verbrauchen.
% #>-------------------------------------------------------------------------<#
\subsection{tmpfs}%
\label{sec:dateisysteme.tmpfs}
\textit{tmpfs} ist ein Dateisystem im \acrshort{acr:ram}. Es wird gerne
verwendet, wenn große IO Operationen stattfinden oder das Dateisystem nur
während der Laufzeit des Systems benötigt wird.
Da dieses Dateisystem sich im \acrshort{acr:ram} befindet, sind sehr schnelle
Zugriffszeiten keine Seltenheit mehr. Bei einfachen Rechnern mit DDR4 kann man
schon mit 10GiB/Sekunde rechnen. Typischer Anwendungsfall ist, wenn ein Programm
durch einen Kompiler kompiliert wird und der Vorgang hohe I/O Operationen auf der
Festplatte verursacht. Hinsichtlich der verbauten Festplatte wird gerade dadurch
die Lebenszeit erheblich erhöht.
Mit dem folgenden Befehl wird ein neues Dateisystem mit einer Größe von 512MB im
\acrshort{acr:ram} erstellt. Dieses wird anschließend nach \textit{/mnt/tmpfs}
eingebunden. Mit dem Befehl \textit{findmnt} können die Optionen des
\textit{tmpfs} Dateisystems überprüft werden.
\begin{bashcode}
$ mkdir --parent /mnt/tmpfs
$ mount -t tmpfs -o rw,relatime,size=512M tmpfs /mnt/tmpfs
$ findmnt /mnt/tmpfs
TARGET SOURCE FSTYPE OPTIONS
/mnt/tmpfs tmpfs tmpfs rw,relatime,seclabel,size=524288k
\end{bashcode}
Dateien und Verzeichnisse, welche sich in einem tmpfs Dateisystem befinden sind
nach einem Neustart des Systems verloren. Sie sind nicht wiederherstellbar.

204
chapters/07-backups.tex Normal file
View File

@ -0,0 +1,204 @@
% <#>---------------------------------------------------------------------------<#>
\section{Backup}%
\label{sec:backup}
Sicherlich hat jeder schon einmal schmerzlichst erfahren müssen, wie ärgerlich
es ist, wenn Daten verloren gegangen sind und diese nicht durch ein Backup
gesichert wurden. Der Schmerz sitzt tief, wenn die Urlaubsbilder, Kinderfotos
oder andere wichtige Dokumente verloren sind. Man ärgert sich häufig über sich
selber, da man wusste, dass dieser Moment früher oder später mal eintreten würde
und man es bis dahin nicht geschafft hat ein Backup zu erstellen.
In Kapitel \nameref{sec:dateisysteme.btrfs} wurden Snapshots von Subvolumes
erzeugt. Dies Snapshots können nicht direkt als ein Backup betrachtet werden,
obwohl sie eine Momentaufnahme eines Subvolumes wiederspiegeln. Der Grund ist,
dass unter einem Backup die Sicherung eines Zustands auf einem anderen
Speichergerät verstanden wird. Dies kann beispielsweise auf eine andere
Festplatte oder ein Magnetband per Bandlesegerät realisiert werden.
Früher wurden Bandlesegeräte sehr häufig eingesetzt, um große Datenmengen zu
sichern. Diese Methode wird zunehmend ersetzt durch andere Technologien wie
Beispielsweise das exportieren und importieren von Snapshots. Dies muss nicht
zwingend ein BtrFS Dateisystem sein, es kann auch ein ZFS oder QCOW2 Dateisystem
sein. Aus der Zeit, in der Bandlaufgeräte vorwiegend Verwendung fanden, sind
unterschiedliche Backup Methoden entstanden.
Je nach Datenbestand wurden unterschiedliche Methoden angewand oder kombiniert,
um die Vorteile je nach Situation auszunutzen. Nachfolgend werden die einzelnen
Methoden näher erläutert.
% #>-----------------------------------------------------------------------------<#
\subsection{Inkrementelles Backup}%
\label{sec:backup.inkrementell}
Ein inkrementelles Backup setzt ein bestehendes Backup der Daten vorraus. Dies
kann ein Vollbackup, differentielles oder inkrementelles Backup sein. Es werden
ausschließlich die Daten gesichert, welche sich zum Zeitpunkt des letzten
Backups geändert haben. Zum Wiederherstellen des Datenbestandes werden somit
alle Backups benötigt, da die Änderungen sequenziell eingespielt werden müssen.
Dies führt beim dem Einsatz von Magnetbändern gerade dazu, dass Administratoren
panisch auf die Suche nach den Magnetbändern gehen, wenn Daten vergangener Jahre
wiedergerstellt werden müssen. Grund für die Aufregung ist, dass wenn ein Backup
oder Magnetband fehlt die Wiederherstellung der gesicherten Daten nicht möglich
ist.
Die folgende Abbildung beschreibt den Speicherverbrauch pro Wochentag und hebt
hervor, welche Änderungen in welchem inkrementellen Backup gesichert sind.
\begin{figure}[H]
\centering
\includegraphics[width=1\textwidth]{img/inkrementell-backup.png}
\caption{Inkrementelle Backups}%
\label{fig:backup.inkrementell}
\end{figure}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Vorteile:}
\begin{enumerate}[itemsep=0pt]
\item Sehr einfaches Verfahren
\item Niedriger Speicherbedarf. Die Backups sind wesentlich kleiner als
differentielle oder Vollbackups. Es werden daher auch Magnetbänder mit
geringerer Kapazität benötigt. Kosten können so gesenkt werden.
\item Das Erstellen der Sicherung ist im Vergleich zu den anderen Methoden
schneller erstellt, da nur die letzten Änderungen gesichert werden müssen.
\end{enumerate}
\item \textbf{Nachteile:}
\begin{enumerate}[itemsep=0pt]
\item Das Vollbackup und \textbf{alle} inkrementellen Backups sind
notwendig, um einen Zeitpunkt wiederherzustellen.
\end{enumerate}
\end{itemize}
% #>-----------------------------------------------------------------------------<#
\subsection{Differenzielles Backup}%
\label{sec:backup.differentiell}
Das differentielle Backup ist dem inkrementellen Backup sehr ähnlich. Es werden
jedoch nicht die Änderungen zu jedem letzten beliebigen Backup gesichert,
sondern ausschließlich zum letzten Vollbackup. Demnach ist zur Wiederherstellung
der Daten das letzte Vollbackup und das gewünschte differentielle Backup
notwendig. Die folgende Abbildung spiegelt wie Abbildung
\ref{fig:backup.inkrementell} den Speicherverbrauch pro Wochentag ab und hebt
hervor, welche Änderungen in welchem differenziellen Backups gesichert sind.
\begin{figure}[H]
\centering
\includegraphics[width=1\textwidth]{img/differentielles-backup.png}
\caption{Differenzielle Backups}%
\label{fig:backup.differentiell}
\end{figure}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Vorteile:}
\begin{enumerate}[itemsep=0pt]
\item Weniger Speicherbedarf als bei einem Vollbackup, aber mehr als bei
einem inkrementellen Backup
\item Zur Wiederherstellung wird nur das letzte Vollbackup und das
differentielle Backup zum gewünschten Zeitpunkt benötigt.
\end{enumerate}
\item \textbf{Nachteile:}
\begin{enumerate}[itemsep=0pt]
\item Dateien, die einmal verändert werden, müssen bei jedem differentiellen
Backup neu gesichert werden. Dadurch entsteht ein höheres Datenaufkommen.
\end{enumerate}
\end{itemize}
% #>-----------------------------------------------------------------------------<#
\subsection{Vollbackup}%
\label{sec:backup.vollbackup}
Bei einem Vollbackup wird der komplette Datenbestand gesichert. Um verlorene
Daten wiederherzustellen wird nur das entsprechende Vollbackup benötigt. Die
folgende Abbildung beschreibt das Wachstum der Vollbackups pro Tag.
\begin{figure}[H]
\centering
\includegraphics[width=1\textwidth]{img/vollbackups.png}
\caption{Vollbackups}%
\label{fig:backup.vollbackup}
\end{figure}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Vorteile:}
\begin{enumerate}[itemsep=0pt]
\item Sehr einfache Wiederherstellung
\item Nur das jeweilige Backup bzw. Band notwendig
\end{enumerate}
\item \textbf{Nachteile:}
\begin{enumerate}[itemsep=0pt]
\item Sehr hoher Speicherverbrauch
\item Um auf mehrere Versionen zurückgreifen zu können wird das jeweilige
Backup benötigt.
\end{enumerate}
\end{itemize}
% #>-----------------------------------------------------------------------------<#
\subsection{Großvater-Vater-Sohn Prinzip}%
\label{sec:backup.gvs-prinzip}
Das Großvater-Vater-Sohn Prinzip, auch Generationen Prinzip genannt, ist ein
Rotationsverfahren für Magnetbänder, um mit möglichst wenigen Magnetbändern den
Zugriff auf ältere Sicherungszustände zu gewährleisten.
Als Sohn-Sicherung werden die täglichen Sicherungen von Montag bis Donnerstag
beschrieben. Dies sind in der Regel inkrementelle Sicherungen. Die Sicherung,
welche Freitags erstellt wird, ist die erste Vater-Sicherung. Für die erste
Woche sind daher fünf Magnetbänder notwendig.
Wird nun bei der Vater-Sicherung ein differentielles Backup erstellt, sind die
Änderungen, welche in der Woche angefallen sind inkludiert. Dies bedeutet, dass
die Sicherungsbänder von Montag bis Donnerstag in der zweiten Woche
wiederverwendet und überschrieben werden können.
Daraus folgt, dass ein sechstes Band für die 2. Vater-Sicherung in der 2. Woche
notwendig ist. Dies geht so für die 3. und 4. Woche des Monats weiter. Es
resultiert daher für einen Monat, dass vier Sicherungsbänder für die
Sohn-Sicherungen und vier Sicherungsbänder für die Vater-Sicherungen notwendig
sind. Also insgesamt acht Bänder.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 1a:} Gehen Sie davon aus, dass zu Beginn des Monats ein
Vollbackup des vergangenen Monats existiert. Geben Sie tabellarisch oder
grafisch für den aktuellen Monat an, an welchen Tagen, welches Band und
Backup-Methode verwendet wird, um dem Vater-Sohn Prinzip zu entsprechen.
\end{itemize}
Am letzten Tag im Monat wird die Sohn- oder Vater-Sicherung durch die
Großvater-Sicherung ersetzt. Die Großvater-Sicherung ist im Regelfall ein
Vollbackup. Anschließend wird wieder mit der Sohn- und Vater-Sicherung für den
nächsten Monat fortgefahren. Da die Großvater-Sicherung alle Änderungen des
letzten Monats beinhaltet, kann die Sohn-Sicherung als auch die Vater-Sicherung
im nächsten Monat überschrieben werden. Daraus resultiert, dass zusätzlich 12
Bänder für jeden Monat benötigt werden. Insgesamt also 20 Bänder pro Jahr.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 1b:} Geben Sie für drei Monate tabellarisch oder
grafisch die Tage an, welches Band und Backup-Methode verwendet wird, um dem
Großvater-Vater Prinzip zu entsprechen.
\end{itemize}
% #>-----------------------------------------------------------------------------<#
\subsection{Praxisaufgabe: Die nette Kollegin}%
\label{sec:backup.praxisfall}
In dem Unternehmen, indem Sie tätig sind wird nicht Ende des Monats, sondern an
dem ersten Freitag im Monat, die Großvater-Sicherung erstellt. Die letzte
Großvater-Sicherung wurde vergangenen Freitag, den 6. November 2020, erstellt.
Eine Kollegin aus der Finanzabteilung hat Sie schriftlich informiert, dass der
letzte Praktikant ein Verzeichnis gelöscht hat, welches Sie nun benötigt. Das
Beschäftigungsverhältnis des Praktikanten fing vor drei Monaten, zwei Wochen und
einem Tagen, ausgehend von der letzen Großvater-Sicherung, an. Gehen Sie davon
aus, dass die Dateien zu diesem Zeitpunkt vorhanden waren.
Welche Bänder sind notwendig, um die Dateien und Verzeichnisse für die Kollegin
aus der Finanzabteilung wiederherzustellen?
Ihr Chef traut ihnen nun das Wiederherstellen von Daten zu. Prompt erhalten Sie
einen Anruf, dass die Daten welche sie wiederhergestellt haben nicht in der
Version vorliegt, welche die nette Kollegin erwartet hat. Sie hat sie angewiesen
die Daten vom 28. Oktober 2020 wiederherzustellen.
Welche Bänder sind notwendig, um die Daten und Verzeichnisse vom 28. Oktober
2020 wiederherzustellen?.

649
chapters/08-textprocessing.tex Normal file
View File

@ -0,0 +1,649 @@
% <#>---------------------------------------------------------------------------<#>
\section{Text Processing}%
\label{sec:text-processing}
Unter Text Processing versteht man das Einlesen, Filtern, Modifizieren und
Umleiten von Dateien oder Streams. Dieses Kapitel behandelt daher die gängigen
Programme, welche ein Linux Systemadministrator oder Entwickler als sein
Handwerkszeug betrachten würde.
Bevor jedoch die Programme erklärt werden, sind die Grundlagen von Umleitungen
und Befehlsverkettungen notwendig.
% <#>---------------------------------------------------------------------------<#>
\subsection{Umleitungen und Befehlsverkettungen}
\label{sec:text-processing.redirections}
Nachfolgend wird der Begriff Befehlsverkettung oder auch Kommandoverkettung
anhand von Syntax Beispielen näher erläutert.
\begin{itemize}[label={},itemsep=0pt]
\item \bashinline{cmd1 | cmd2} \\
Die \textit{Pipe} verbindet die Standard-Ausgabe (\textit{stdout}) eines
Programms mit der Eingabe (\textit{stdin}) eines anderen Programms.
\item \bashinline{cmd1 ; cmd2} \\
Führt erst das Programm \textit{cmd1} aus und anschließend das Programm
\textit{cmd2} - ganz egal, ob Programm \textit{cmd1} einen Fehler geworfen hat
oder nicht.
\item \bashinline{cmd1 && cmd2} \\
Jedes Programm übergibt zuletzt an das Betriebssystem einen sogenannten
Returncode (auch Errorlevel oder Exitlevel genannt). Bei einem Returncode 0
ist alles in Ordnung, bei einem Wert ungleich 0 trat ein Fehler auf. In diesem
Fall der Kombination wird \textit{cmd2} nur ausgeführt, wenn der Returncode
von \textit{cmd1} gleich 0 war.
\item \bashinline{cmd1 || cmd2} \\
Dies ist genau das Gegenteil. Das Programm \textit{cmd2} wird nur ausgeführt,
wenn der Returncode von \textit{cmd1} ungleich 0 war.
\item \bashinline{cmd1 & cmd2} \\
Das \&-Zeichen am Ende einer Befehlszeile veranlasst, dass das Programm in den
Hintergrund verlagert wird und ihnen die Prompt wieder zur Verfügung gestellt
wird. Dadurch ist es möglich über eine Session mehrere Befehle auszuführen.
Nichts anderes passiert hier. Das Programm \textit{cmd1} wird in den
Hintergrund verlagert. Das Programm \textit{cmd2} wird nach der Verlagerung
ausgeführt.
\end{itemize}
Neben den Befehlsverkettungen gibt es auch noch Umleitungen der Ein- und
Ausgabekanäle (\textit{stdin}, \textit{stdout}, \textit{stderr}).
\begin{itemize}[label={},itemsep=0pt]
\item \bashinline{cmd > /tmp/output.log} oder auch \bashinline{cmd 1> /tmp/output.log} \\
Die Standard-Ausgabe \textit{stdout} wird in die Datei \textit{/tmp/output.log}
geschrieben.
\item \bashinline{cmd >> /tmp/output.log} \\
Die Standard-Ausgabe \textit{stdout} wird an die Datei \textit{/tmp/output.log}
angehängt.
\item \bashinline{cmd 2> /tmp/output.log} \\
Die Standard-Fehlerausgabe \textit{stderr} wird an die Datei \textit{/tmp/error.log}
geschrieben.
\item \bashinline{cmd &> /tmp/complete.log} \\
Die Standard-Ausgabe \textit{stdout} und die -Fehlerausgabe \textit{stderr}
werden in die Datei \textit{/tmp/complete.log} geschrieben. geschrieben.
\item \bashinline{cmd < /tmp/input} \\
Die Standard-Eingabe \textit{stdin} erfolgt nicht durch die Tastatur, sondern
aus der Datei \textit{/tmp/input}.
\item \bashinline{cmd << EOT} \\
Die Standard-Eingabe wird nur bis zu der frei wählbaren Zeichenfolge EOT
gelesen und anschließend beendet. Man nennt diese Konstruktion HERE-Dokument.
Dazu später mehr.
\end{itemize}
% #>-----------------------------------------------------------------------------<#
\subsection{cat}
\label{sec:text-processing.cat}
Das Programm \textit{cat} konkateniert mehrere Dateien und schreibt diese auf
die Standard-Ausgabe \textit{stdout}. Nachfolgend einige Beispiele.
Die Ausgabe der Datei \textit{/etc/passwd}. Die Zeilen wurden gekürzt.
\begin{bashcode}
$ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
...
\end{bashcode}
Die Datei \textit{/etc/passwd} und \textit{/etc/group} werden zusammengeführt
und nach \textit{/tmp/user-and-groups} umgeleitet.
\begin{bashcode}
$ cat /etc/passwd /etc/group > /tmp/user-and-groups
\end{bashcode}
In dem folgenden Beispiel wird ein HERE-Dokument genutzt, um die Eingabe in eine
Datei umzuleiten.
\begin{bashcode}
$ cat > /tmp/my-here-document <<EOF
Hello,
this is my first here document.
EOF
\end{bashcode}
% #>-----------------------------------------------------------------------------<#
\subsection{wc}
\label{sec:text-processing.wc}
Mit Programm \textit{wc} lassen sich die Wörter, Zeilen oder Buchstaben von
einer Standard-Eingabe oder Dateien zählen. Das folgende Beispiel addiert die
Zeilen der Datei \textit{/etc/passwd} und \textit{/etc/group}.
\begin{bashcode}
$ wc --lines /etc/passwd /etc/group
42 /etc/passwd
62 /etc/group
104 total
\end{bashcode}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 1a:} Zählen Sie die Buchstaben und Wörter der Datei
\textit{/etc/services}. Definieren Sie die Quelle einmal per Pfad zur Datei und
ein anderes mal per Befehlsverkettung - \textit{Pipe}.
\end{itemize}
% #>-----------------------------------------------------------------------------<#
\subsection{date}
\label{sec:text-processing.date}
Mit dem Programm \textit{date} können Daten, basierend auf dem aktuellen oder
einem vordefinierten Datum, berechnet werden. Zusätzlich kann das Format anhand
eines Formatstrings bestimmt werden. Die einzelnen Formatattribute sind in der
Dokumentation von \textit{date} beschrieben. Schauen Sie sich für weitere
Informationen die Dokumentation an: \textit{man date}.
Nachfolgend einige Beispiele ein Datum basierend auf den Anforderungen zu
berechnen.
\begin{bashcode}
$ # Gibt das aktuelle Datum und die Uhrzeit aus
$ date '+%Y-%m-%d %H:%M:%S'
2020-11-14 16:35:07
$ # Gibt das Datum des letzten Montags aus
$ date --date 'last monday' '+%Y-%m-%d'
2020-11-09
$ # Berechnet das Datum des letzten Montags vor zwei Wochen
$ date --date 'last monday + 14 day ago' '+%Y-%m-%d'
2020-10-26
$ # Gibt das Datum des kommenden Montags aus
$ date --date 'next monday' '+%Y-%m-%d'
2020-11-16
$ # Berechnet das Datum des nächsten Montags in zwei Wochen
$ date --date 'next monday + 14 day' '+%Y-%m-%d'
2020-11-30
$ # Berechnet das Datum des letzten Montags in zwei Wochen
$ date --date 'last monday + 14 day' '+%Y-%m-%d'
2020-11-23
$ # Gibt das Datum und die Uhrzeit für die Zeitzone
$ # America/New_York aus
$ TZ=America/New_York date '+%Y-%m-%d %H:%M:%S %z'
2020-11-14 10:41:39 -0500
$ # Gibt das Datum, die Uhrzeit, Kalenderwoche und den Tag aus
$ date '+%A, %Y-%m-%d %H:%M:%S, KW %V'
Samstag, 2020-11-14 16:42:44, KW 46
$ # Addiert zwei Tage auf den 3. Oktober 2020
$ date --date '03 OCT 2020 + 2 day' '+%Y-%m-%d'
2020-10-05
$ # Addiert zwei Tage auf den 3. Oktober vor 5 Jahren.
$ date --date "03 OCT $(date --date '5 year ago' '+%Y') + 2 day" '+%Y-%m-%d'
2015-10-05
\end{bashcode}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 2a:} Berechnen Sie das Datum des kommenden Sonntags.
Verwenden Sie folgendes Format: \textit{2020-05-31}. Erkundigen Sie sich in
der Dokumentation über weitere Formatattribute.
\item \textbf{Aufgabe 2b:} Berechnen Sie das Datum des letzten Dienstags vor
einem Monat. Verwenden Sie folgendes Format: \textit{Dienstag, 2020-05-31, KW
22}
\item \textbf{Aufgabe 2c:} Berechnen Sie das Datum des Mittwochs der 44 KW vor
12 Jahren für die Zeitzone Africa/Mogadishu. \textit{KW 22, Dienstag, 15
November 2008}.
\end{itemize}
% #>-----------------------------------------------------------------------------<#
\subsection{sed}
\label{sec:text-processing.sed}
Das Programm \textit{sed} ist ein stream Editor, welcher zum Filtern,
Modifizieren und Löschen von Textstreams geeignet ist.
Das Programm bietet einen sehr großen Umfang an zusätzlichen Optionen an. Nicht
alle Optionen werden behandelt. Der Fokus liegt ausschließlich auf den gängigen
Optionen, welche öfters in der Praxis verwendet werden. Weitere Informationen zu
allen möglichen Optionen können über die Dokumentation abgerufen werden:
\textit{man sed}.
In dem folgenden Beispiel wird der Inhalt der Datei \textit{/etc/passwd} durch
\textit{sed} modifiziert und auf der Standard-Ausgabe ausgegeben. Die
Zeichenkette \textit{root} wird durch \textit{nobody} ersetzt. Vergleichen Sie
die ersten Zeilen der Ausgabe mit der ursprünglichen Datei.
Für komplexere Kriterien können Reguläre Ausdrücke verwendet werden. Falls Ihnen
Reguläre Ausdrücke fremd sind, informieren Sie sich bitte im Internet über
Reguläre Ausdrücke.
\begin{bashcode}
$ sed 's/root/nobody/g' /etc/passwd
nobody:x:0:0:nobody:/nobody:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
...
\end{bashcode}
Möchte man Reguläre Ausdrücke verwenden kann das Flag bzw. die Option
\textit{-e, --expression} verwendet werden. Allerdings hat diese Option den
Nachteil, dass Zeichen für Reguläre Ausdrücke maskiert werden müssen. Anders ist
dies bei dem Flag \textit{-E, -r, --regexp-extended}. Die Syntax der Regulären
Ausdrücke ist identisch zu der Syntax von \textit{grep} mit dem Flag
\textit{--perl-regexp} und sollte daher bevorzugt verwendet werden.
In dem folgenden Beispiel wird die Ausgabe umgeleitet in eine Datei.
\begin{bashcode}
$ sed 's/root/nobody/g' /etc/passwd > /tmp/passwd_modified
\end{bashcode}
Möchte man die selbe Datei anhand von Kriterien Filtern und Modifizieren bietet
sich die Option bzw. das Flag \textit{-i, --in-place} an. Die Änderungen werden
direkt in die Quelldatei übernommen.
In dem folgenden Beispiel wird die Zeile 5 bis 10 und die Zeile 12 aus der Datei
\textit{/tmp/passwd\_modified} entfernt.
\begin{bashcode}
$ sed --in-place '5,10d;12d' /tmp/passwd_modified
\end{bashcode}
Sicherlich fragen Sie sich nun was die Zeichen \textit{s/}, \textit{d} oder
\textit{/g} zu Beginn oder zum Ende der Bedingung bedeuten. Mit \textit{s/} wird
\textit{sed} mitgeteilt, dass eine Zeichenkette durch eine andere ersetzt werden
soll. Die Zeichen \textit{/g} bedeuten, dass der Ausdruck auf alle Treffer
angewendet werden soll. Eine andere Bedeutung für das \textit{g} ist
\glqq{}global\grqq{}. Nun, wofür \textit{d} steht können Sie sich nun schon
denken - \textit{delete}.
In dem folgenden Beispiel werden alle Zeilen aus der Datei \textit{/etc/passwd}
und \textit{/etc/group} entfernt, die mit der Zeichenkette \textit{root} beginnen.
\begin{bashcode}
$ sed --regexp-extended '/^root/d' /etc/passwd /etc/group
\end{bashcode}
Ein invert ist ebenfalls möglich. In dem folgenden Beispiel werden alle Zeilen
außer die fünfte Zeile entfernt.
\begin{bashcode}
$ sed '5!d' /etc/passwd
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
\end{bashcode}
Mithilfe von Gruppen, welche Reguläre Ausdrücke bereitstellen, können komplexe
Zeichenketten gruppiert und neu angeordnet werden. In dem folgenden Beispiel
wird die letzte Spalte der Datei \textit{/etc/passwd} an die erste Stelle
verschoben.
\begin{bashcode}
$ sed --regexp-extended 's/^(.*):(.*):(.*):(.*):(.*):(.*):(.*)$/\7:\1:\2:\3:\4:\5:\6/g' /etc/passwd
/bin/bash:root:x:0:0:root:/root
/sbin/nologin:bin:x:1:1:bin:/bin
/sbin/nologin:daemon:x:2:2:daemon:/sbin
...
\end{bashcode}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 3a:} Löschen Sie alle Zeilen, welche als Shell
\textit{/sbin/nologin} verwenden. Geben Sie die Ausgabe auf der
Standard-Ausgabe aus.
\item \textbf{Aufgabe 3b:} Löschen Sie alle Zeilen aus der Datei
\textit{/etc/passwd} und \textit{/etc/group}, welche mit \textit{root} oder
\textit{system} beginnen. Zählen Sie anschließend die Zeilen. Nutzen Sie dazu
die Umleitung von einem Programm zu einem anderen per \textit{Pipe}.
\item \textbf{Aufgabe 3c:} Bereinigen Sie die Datei \textit{/etc/services}.
Löschen Sie Kommentarzeilen und Zeilen welche leer sind. Manche Zeilen
enthalten am Ende Kommentare, entfernen Sie diese.
\item \textbf{Aufgabe 3d:} Suchen Sie in der Datei \textit{/etc/services} nach
Zeilen, welche mit dem Port 5 beginnen und vertauschen Sie den Port mit dem
Protokoll.
\end{itemize}
% #>-----------------------------------------------------------------------------<#
\subsection{grep}
\label{sec:text-processing.grep}
Das Programm \textit{grep} wird primär dazu verwendet Dateien oder Streams nach
Schlagwörtern zu filtern. Ähnlich wie bei \textit{sed} können auch hier nicht
alle Optionen oder Flags ausführlich in Detail behandelt werden. Aus diesem
Grund liegt der Fokus erneut auf den gängigen Optionen bzw. Flags aus der Praxis.
Das nachfolgende Beispiel filtert die Datei \textit{/etc/passwd} und
\textit{/etc/group} nach der Zeichenkette \textit{root} und hebt diese farblich
hervor.
\begin{bashcode}
$ grep --color root /etc/passwd /etc/group
/etc/passwd:root:x:0:0:root:/root:/bin/bash
/etc/passwd:operator:x:11:0:operator:/root:/sbin/nologin
/etc/group:root:x:0:
\end{bashcode}
In dem folgenden Beispiel wird ein Regulärer Ausdruck verwendet, um nach der
Zeichenkette \textit{root} oder \textit{sophie}, beginnend für jede Zeile, in
der Datei \textit{/etc/passwd} zu suchen.
\begin{bashcode}
$ grep --color --perl-regexp '^(root|sophie)' /etc/passwd
root:x:0:0:root:/root:/bin/bash
sophie:x:2003:100:Sophie Becker:/home/sophie:/bin/bash
\end{bashcode}
Manchmal möchte man allerdings nur die gefundenen Schlagwörter der Zeile
weiterverarbeiten. Dazu stellt das Programm \textit{grep} die Option
\textit{--only-matching} bereit. Nachfolgend wird der gleiche Befehl erneut
ausgeführt mit der Option.
\begin{bashcode}
$ grep --color --only-matching --perl-regexp '^(root|sophie)' /etc/passwd
root
sophie
\end{bashcode}
Sicherlicht kennen einige die folgende Situation. Unterhalb eines Verzeichnisses
liegen sehr viele Dokumente. Eines von diesen enthält einen Begriff, welcher
dort erklärt oder beschrieben wird. In dem nachfolgenden Beispiel werden alle
Dateien rekursiv geöffnet und nach den Schlagwörtern durchsucht. In der Ausgabe
ist der Dateiname und die Zeile als auch das Schlagwort enthalten, welches den
Treffer ausgelöst hat.
\begin{bashcode}
$ grep --color --recursive --perl-regexp '(btrfs|subvolume|snapshot)' ~/workspace/linux_ws2021
~/workspace/linux_ws2021/referenzen/bibliothek.bib: @online{fedora33-btrfs-default,
~/workspace/linux_ws2021/referenzen/bibliothek.bib: url = {https://fedoramagazine.org/btrfs-coming-to-fedora-33/},
~/workspace/linux_ws2021/referenzen/bibliothek.bib: @online{was-ist-btrfs,
\end{bashcode}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 4a:} Suchen Sie alle Zeilen aus der Datei
\textit{/etc/passwd} und \textit{/etc/group} herraus, welche nicht die
Zeichenketten \textit{root} und ihren aktuellen Benutzernamen enthalten.
Nutzen Sie zur Ermittlung ihres Benutzernamens die Umgebungsvariable
\textit{USER}.
\item \textbf{Aufgabe 4b:} Filtern Sie aus der Datei \textit{/etc/passwd} alle
Zeilen, welche mit \textit{system} beginnen. Leiten Sie die Ausgabe weiter an
\textit{sed}, um die Zeichenkette \textit{/sbin/nologin} durch
\textit{/bin/bash} zu ersetzen.
Kleiner Tipp: Statt \textit{/} können auch andere Zeichen, wie
\textit{\#} oder \textit{@}, als Trennung zwischen dem Such- und
Ersetzungspattern verwendet werden. Dies kann hilfreich sein, um ein escapen
von Verzeichnispfaden zu vermeiden.
\item \textbf{Aufgabe 4c:} Zählen Sie alle Zeilen der Datei
\textit{/etc/services}, welche das Protokoll tcp verweden.
\item \textbf{Aufgabe 4d:} Ermitteln Sie, ob in der Datei
\textit{/etc/services} noch andere Protokolle statt tcp und udp verwendet
werden. Gegen Sie die unbekannten Protokolle auf der Standard-Ausgabe aus.
\end{itemize}
% #>-----------------------------------------------------------------------------<#
\subsection{uniq}
\label{sec:text-processing.uniq}
Manchmal möchte man Treffer zählen. Beispielsweise wird eine Datei durchsucht
nach einem Schlagwort und man stellt sich die Frage, wie oft das Schlagwort in
der Datei verwendet wurde. Um diese Frage zu beantworten ist unter anderem
\textit{uniq} sehr helfreich, denn es kann Mehrfachvorkommen von Zeichenketten
vermeiden und ggfls. zählen.
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 5a:} Zählen Sie wie oft in der Datei
\textit{/etc/passwd} die Zeichkette \textit{root} verwendet wurde. Eventuell
ist es hilfreich \textit{grep} hinzuzuziehen.
\item \textbf{Aufgabe 5b:} Suchen Sie in der Datei \textit{/etc/services} nach
Diensten die nur einen Port bzw Protokoll benötigen. Nutzen Sie auch hier die
bereits kennengelernten Programme.
\end{itemize}
% #>-----------------------------------------------------------------------------<#
\subsection{column}
\label{sec:text-processing.column}
Manchmal erhält man Dateien, welche für das menschliche Auge unübersichtlich
formatiert sind. Das Programm \textit{column} kann hier insoweit Abhilfe
schaffen, dass die Eingabe in mehrere Spalten formatiert wird.
In dem folgenden Beispiel wird die Datei \textit{/etc/passwd} eingelesen, die
Spalten anhand des Trenners \textit{:} getrennt und als Tabelle auf der
Standard-Ausgabe ausgegeben.
\begin{bashcode}
$ column --separator ":" --table /etc/passwd
\end{bashcode}
Es können auch zusätzlich Kopfzeilen hinzugefügt werden. Im nächsten Beispiel
ist dies genau der Fall. Die Kopfzeile wird definiert und mit ausgegeben.
\begin{bashcode}
$ column --separator ":" \
--table \
--table-column "user,password,id,gid,comment,homedir,shell" /etc/passwd
\end{bashcode}
Wahrscheinlich wird das Programm \textit{column} häufiger verwendet, um Dateien
in json umzuwandeln. In dem folgenden Beispiel wird die Datei in json
umgewandelt.
\begin{bashcode}
$ column --separator ":" \
--table \
--table-name "passwd" \
--table-column "user,password,id,gid,comment,homedir,shell" \
--json /etc/passwd
\end{bashcode}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 6a:} Filtern Sie alle Zeilen aus der Datei
\textit{/etc/services}, welches das UDP-Protokoll verwenden und mit dem
Buchstaben \textit{n} beginnen. Teilen Sie die zweite Spalte auf in Port und
Protokoll. Die Ausgabe muss in ein json umgewandelt werden. Der Tabellenname
ist \textit{services} und die Spalten sollen \textit{service}, \textit{port}
und \textit{protocol} heißen. Speichern Sie die Ausgabe in die Datei
\textit{/tmp/services.json} ab.
\end{itemize}
% #>-----------------------------------------------------------------------------<#
\subsection{head und tail}
\label{sec:text-processing.head-und-tail}
Mit den bisherigen Programmen können wir schon einiges erreichen, doch fehlt es
an der Möglichkeiten die Ausgabe zu beschränken. Mit den Programmen
\textit{head} und \textit{tail} kann genau das erreicht werden. Beide Programme
schreiben auf die Standard-Ausgabe \textit{stdout}, wenn keine Umleitung
definiert ist.
Mit dem Programm \textit{head} können n Zeilen, beginnend ab der ersten Zeile,
ausgegeben werden. Das Programm \textit{tail} dagegen zählt ab der letzten
Zeile.
In dem nachfolgenden Beispiel werden die ersten drei Zeilen der Datei
\textit{/etc/passwd} ausgegeben.
\begin{bashcode}
$ head --lines=3 /etc/passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
\end{bashcode}
Das nächste Beispiel gibt die letzten drei Zeilen aus.
\begin{bashcode}
$ tail --lines=3 /etc/passwd
tobias:x:2005:100:Tobias Moretti:/home/tobias:/bin/bash
lisa:x:2006:100:Lisa Meerkamp:/home/lisa:/bin/bash
manfred:x:2007:100:Manfred Krupp:/home/manfred:/bin/bash
\end{bashcode}
Zusätzlich besitzt \textit{tail} die Möglichkeit alle Zeilen, beginnend ab der
n-ten Zeile, auszugeben. In dem folgenden Beispiel wird die Datei
\textit{/etc/passwd} ab der 35en Zeile ausgegeben. Die Ausgabe ist zusätzlich
noch einmal gekürzt.
\begin{bashcode}
$ tail --lines=+35 /etc/passwd
hugo:x:2000:100:Hugo McKinnock:/home/hugo:/bin/bash
hans:x:2001:100:Hans Rakinzsky:/home/hans:/bin/bash
marie:x:2002:100:Marie Haseloff:/home/marie:/bin/bash
sophie:x:2003:100:Sophie Becker:/home/sophie:/bin/bash
\end{bashcode}
Manche Programme, insbesondere Dienste, schreibe Log-Dateien, welche gerade für
Administratoren oder Entwickler interessant sein können. Um ausschließlich die
neusten Zeilen aus einer Logdatei zu erhalten bietet das Programm \textit{tail}
die Option \textit{-f, --follow} an. Dadurch wird veranlasst, dass stets neu
hinzukommende Zeilen direkt ausgegeben werden, ohne das das Programm erneut
gestartet werden muss.
% #>-----------------------------------------------------------------------------<#
\subsection{cut}
\label{sec:text-processing.cut}
Das Programm \textit{cut} ist genau das richtige Programm, um Spalten, getrennt
durch einen Trenner, auszuwählen. In dem nachfolgenden Beispiel wird
ausschließlich die erste Zeile der Datei \textit{/etc/passwd} ausgegeben.
\begin{bashcode}
$ cut --delimiter=":" --fields=1 /etc/passwd
root
bin
daemon
...
\end{bashcode}
Es ist auch möglich mehrere Spalten zu selektieren. In dem folgenden Beispiel
wird ausschließlich die zweite bis vierte und siebte Spalte selektiert.
\begin{bashcode}
$ cut --delimiter=":" --fields=2-4,7 /etc/passwd
x:0:0:/bin/bash
x:1:1:/sbin/nologin
x:2:2:/sbin/nologin
...
\end{bashcode}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 7a:} Nutzen Sie die bereits bekannten Programme, um die
Datei \textit{/etc/services} zu bereinigen. Lassen Sie sich anschließend nur
die Spalte mit den Ports und Protokollen anzeigen. Leiten Sie die Ausgabe in
die Datei \textit{/tmp/port-protocol} um.
\item \textbf{Aufgabe 7b:} Verwenden Sie die Programme \textit{echo},
\textit{cut}, \textit{cat}, \textit{tail} und \textit{head}, um die folgenden
Felder aus der Datei \text{/etc/passwd} zu selektieren. Spalte/Zeile: (1/1),
(3/7), (5/3), (7/4).
\end{itemize}
% #>-----------------------------------------------------------------------------<#
\subsection{sort}
\label{sec:text-processing.sort}
Um nach Spalten zu sortieren wird durch die GNU Core Utility Collection das
Programm \textit{sort} bereit gestellt. Dieses Programm kann nach mehreren
möglichen Optionen sortieren. Nach einfachem Text, nach Speichergrößen, Zahlen,
Monaten (JAN$<$DEC) oder Versionen. Weitere Optionen sind in der Dokumentation
beschrieben.
Das nächste Beispiel behandelt die Sortierung der Ausgabe des Programms
\textit{df}. Das Programm \textit{df} gibt Informationen über den gesamten,
freien und verbrauchten Speicherplatz der eingehängten Partitionen aus. Die
Ausgabe wird nach der dritten Spalte aufsteigend sortiert. Dazu wird die Option
bzw. das Flag \textit{-k, --key} übergeben. Durch dieses Flag kann die Spalte
zur Sortierung übergeben werden. Mittels tail wird zudem die Kopfzeile
abgeschnitten.
\begin{bashcode}
$ df | tail --lines +2 | sort --key 3 --numeric-sort
tmpfs 401876 0 401876 0% /run/user/0
tmpfs 2009384 4 2009380 1% /tmp
tmpfs 2009384 1068 2008316 1% /run
/dev/vda1 613184 8740 604444 2% /boot/efi
...
\end{bashcode}
Die Speichergrößen können auch abgerundet werden durch die gängigen
Speicherabkürzungen K (Kilobyte), M (Megabyte), G (Gigabyte), T (Terabyte) ect.
In dem folgenden Beispiel wird dazu die Option \textit{--human-readable} dem
Programm \textit{df} übergeben. Anschließend muss sort mitgeteilt werden, dass
die Spalte nun Speichergrößen mit ihren Abkürzungen enthält. Andernfalls
sortiert \textit{sort} falsch.
\begin{bashcode}
$ df --human-readable | tail --lines +2 | sort --key 3 --human-numeric-sort
tmpfs 393M 0 393M 0% /run/user/0
tmpfs 2,0G 4,0K 2,0G 1% /tmp
tmpfs 2,0G 1,1M 2,0G 1% /run
/dev/vda1 599M 8,6M 591M 2% /boot/efi
...
\end{bashcode}
In den beiden Beispielen wurde stets nach einer Spalte sortiert. Es ist jedoch
auch möglich eine Sortierreihenfolge zu definieren. Dies wird erreicht indem das
Flag \textit{-k, --key} mehrfach definiert wird. In dem folgenden Beispiel wird
erst nach dem Mountpoint sortiert und anschließend nach dem gesamten
Speicherplatz.
\begin{bashcode}
$ df --human-readable | tail --lines +2 | sort --key 6 --key 3h
/dev/vda4 17G 4,0G 13G 25% /
/dev/vda2 1014M 228M 787M 23% /boot
/dev/vda1 599M 8,6M 591M 2% /boot/efi
...
\end{bashcode}
Sicherlich fragen Sie sich nun, was der Buchstabe \textit{h} bei Angabe der
zweiten Spalte bedeutet. Es ist möglich \textit{sort} mitzuteilen welche Spalte
welches Format besitzt. Der Buchstabe \textit{h} bedeutet nichts weiteres als
\textit{human-numeric-sort}. Informieren Sie sich in der Dokumentation über die
anderen Buchstaben, um einer Spalte ein Schema zuzuweisen.
In dem folgenden Beispiel wird nach dem dritten Zeichen, der ersten Spalte
von der Ausgabe \textit{df}, absteigend sortiert.
\begin{bashcode}
$ df | tail --lines +2 | sort --reverse --key 1.3
devtmpfs 1989716 0 1989716 0% /dev
tmpfs 401876 0 401876 0% /run/user/0
tmpfs 2009384 4 2009380 1% /tmp
...
\end{bashcode}
\begin{itemize}[label={},itemsep=0pt]
\item \textbf{Aufgabe 8a:} Bereinigen Sie die Datei \textit{/etc/services} und
leiten die Ausgabe an \textit{sort} weiter. Sortieren Sie aufsteigend nach dem
Port, absteigend nach dem Protokoll und anschließend aufsteigend nach dem
Namen.
\item \textbf{Aufgabe 8b:} Sortieren Sie die Datei \textit{/etc/passwd} nach
der \textit{UID} und \textit{GID} absteigend. Anschließend nach dem
Benutzernamen.
\end{itemize}
% #>-----------------------------------------------------------------------------<#
\subsection{join}
\label{sec:text-processing.join}
Sicherlich kennen Sie das \textit{JOIN} Statement von SQL. Ähnlich zu dem
SQL-Statement verhält sich das Programm \textit{join}, jedoch mit einigen
Restriktionen.
\begin{itemize}[itemsep=0pt]
\item Die Spalten müssen nach dem Fremdschlüssel sortiert sein.
\item Beide Dateien müssen den gleichen Trenner verwenden.
\item Kann ein Fremdschlüssel nicht aufgelöst werden, wird eine Fehlermeldung
für die jeweilige Zeile ausgegeben.
\end{itemize}
Im folgenden Beispiel werden die Zeilen aus den Dateien \textit{/etc/passwd} und
\textit{/etc/group} über die Spalte \textit{GID} miteinander verbunden und
weitergeleitet. Dazu werden beide Dateien vorab sortiert. Können Fremdschlüssel
nicht aufgelöst werden wird die Fehlermeldung dazu nach \textit{/dev/null}
umgeleitet. Die Ausgabe wird anschließend noch einmal nach dem Benutzernamen
sortiert.
Informieren Sie sich in der Dokumentation über die Bedeutung der Optionen bzw.
Flags.
\begin{bashcode}
$ join -t ":" -1 3 -2 4 <(sort --field-separator=":" --key 3n /etc/group) <(sort --field-separator=":" --key 4n /etc/passwd) 2> /dev/null | sort --field-separator=":" --key 5
0:root:x::halt:x:7:halt:/sbin:/sbin/halt
0:root:x::operator:x:11:operator:/root:/sbin/nologin
0:root:x::root:x:0:root:/root:/bin/bash
...
\end{bashcode}

134
chapters/99-awk.tex Normal file
View File

@ -0,0 +1,134 @@
% ##########################################################################
% ############################ Übungsblatt AWK #############################
% ##########################################################################
\section{AWK}
\label{sec:awk}
% ############################### Aufgabe 01 ###############################
\subsection{Aufgabe}
\label{sec:awk.aufgabe01}
Geben Sie alle Zeilen der Datei \texttt{/bin/passwd} mithilfe von awk aus.
\subsubsection*{Lösung}
\label{sec:awk.aufgabe01.loesung}
% \inputbash{./awk/01-aufgabe.sh}
% ############################### Aufgabe 02 ###############################
\subsection{Aufgabe}
\label{sec:awk.aufgabe02}
Gebem Sie von allen Benutzern den username, badname und die login shell aus.
Greifen Sie dazu erneut auf die Datei \texttt{/etc/passwd} zu. Die Ausgabe soll
ähnlich wie die Tabelle \ref{tbl:awk.aufgabe02.beispielausgabe} aussehen.
\begin{table}[H]
\begin{tabularx}{\textwidth}{X|X|X}
\textbf{user} & \textbf{badname} & \textbf{shell} \\
\hline\hline
root & & \texttt{/bin/bash} \\
postfix & & \texttt{/bin/nologin} \\
markus & Markus Pesch & \texttt{/bin/bash} \\
$[$\dots$]$ & $[$\dots$]$ & $[$\dots$]$ \\
\end{tabularx}
\caption{AWK - Beispielsausgabe}
\label{tbl:awk.aufgabe02.beispielausgabe}
\end{table}
\subsubsection*{Lösung}
\label{sec:awk.aufgabe02.loesung}
% \inputbash{./awk/02-aufgabe.sh}
% ############################### Aufgabe 03 ###############################
\subsection{Aufgabe}
\label{sec:awk.aufgabe03}
Modifizieren Sie Aufgabe \ref{sec:awk.aufgabe02}, sodass nur Benutzer mit einer
UID größer gleich 1000 ausgegeben werden.
\subsubsection*{Lösung}
\label{sec:awk.aufgabe03.loesung}
% \inputawk{./awk/03-aufgabe.awk}
% \inputbash{./awk/03-aufgabe.sh}
% ############################### Aufgabe 04 ###############################
\subsection{Aufgabe}
\label{sec:awk.aufgabe04}
Gebe Sie alle Zeilen der Datei \texttt{/etc/passwd} zwischen fünf und zehn aus.
Ergänzen Sie die Tabelle um eine Spalte. Die neue Spalte enthält die
Zeilennummer.
\subsubsection*{Lösung}
\label{sec:awk.aufgabe04.loesung}
% \inputawk{./awk/04-aufgabe.awk}
% \inputbash{./awk/04-aufgabe.sh}
% ############################### Aufgabe 05 ###############################
\subsection{Aufgabe}
\label{sec:awk.aufgabe05}
Modifiziere Sie die Aufgabe \ref{sec:awk.aufgabe04}, sodass die logischen
Entscheidungen in eine Funktion ausgelagert werden.
\subsubsection*{Lösung}
\label{sec:awk.aufgabe05.loesung}
% \inputawk{./awk/05-aufgabe.awk}
% \inputbash{./awk/05-aufgabe.sh}
% ############################### Aufgabe 06 ###############################
\subsection{Aufgabe}
\label{sec:awk.aufgabe06}
Lesen Sie die Datei \texttt{credit\_master.csv} ein. Die Datei enthält
unerwünschte Leerzeichen. Korrigieren Sie diese Datensätze indem Sie die
unerwünschten Leerzeichen entfernen. Als boolsche Variablen sind ausschließlich
ja und nein akzeptabel. Entfernen Sie auch hier die Datensätze, deren boolsche
Variablen nicht übereinstimmen.
Die validen Datensätze sollen in die Datei
\texttt{csv/credit\_master\_cleaned.csv} gespeichert werden.
\subsubsection*{Lösung}
\label{sec:awk.aufgabe06.loesung}
% \inputawk{./awk/06-aufgabe.awk}
% \inputbash{./awk/06-aufgabe.sh}
% ############################### Aufgabe 06 ###############################
\subsection{Aufgabe}
\label{sec:awk.aufgabe07}
Lesen Sie die Datei \texttt{credit\_master\_cleaned.csv} ein. Erstellen Sie für
jede Zeile ein passendes SQL-Statement, um die Zeile in die Tabelle
\texttt{credit\_master} zu überführen. Geben Sie zu Beginn das SQL-Statement zum
erstellen der notwendigen Tabelle aus. Speichern Sie ihre SQL-Statements in der
Datei \texttt{credit\_master\_cleaned.sql} ab.
Ob Sie nun die SQL-Statements in der Oracle, Maria, MySQL, Postgres oder SQLite
Notation erstellen ist ihnen überlassen, jedoch verwenden Sie den passenden
boolschen Datentyp je nach Datenbank, um die boolschen Variablen zu überführen.
Verwenden Sie sofern möglich ihre eigene \texttt{credit\_master\_cleaned.csv} Datei.
\subsubsection*{Lösung}
\label{sec:awk.aufgabe07.loesung}
% \inputawk{./awk/07-aufgabe.awk}
% \inputbash{./awk/07-aufgabe.sh}

30
chapters/99-questions.tex Normal file
View File

@ -0,0 +1,30 @@
\section{Assessment Test}
\label{sec:assessment-test}
\subsection{Aufgabe}
\label{sec:assessment-test.aufgabe01}
Welche der folgenden namen sind shell Programme? (Wähle Sie alle, welche
zutreffen)
\begin{itemize}[itemsep=0pt]
\item Bash
\item Korn Shell
\item Born Shell
\item Dash
\item Z Shell
\end{itemize}
\subsection{Aufgabe}
\label{sec:assessment-test.aufgabe02}
Sie sind Administrator eines Linux Servers. Sie benötigen jene Logs seit dem 30
Mai, welche die IPv4 Adresse 192.168.10.42 enthalten. Das Datum wird in
englischer Notation gespeicher. Die Logs sind in \texttt{/var/log/messages}
gespeichert. Welche der folgenden \texttt{grep} Befehle ist der beste Befehl?
\begin{itemize}[itemsep=0pt]
\item \bashinline{grep "May 30?192.168.10.42" /var/log/messages}
\item \bashinline{grep "May 30.*192.168.10.42" /var/log/messages}
\item \bashinline{grep -i "May 30.*192.168.10.42" /var/log/messages}
\item \bashinline{grep -i "May 30?192.168.10.42" /var/log/messages}
\item \bashinline{grep -v "May 30.*192.168.10.42" /var/log/messages}
\end{itemize}