\documentclass[a4paper,11pt]{article} \usepackage{ngerman} \usepackage[latin1]{inputenc} \setlength\parskip{\medskipamount} \setlength\parindent{0pt} \begin{document} % Benutzer_und_Berechtigungskonzepte % Copyright H. Degenhardt, J. Meinhold, M. Kleine % Lizenz: GFDL % % $Name: $ % $Revision: 1.5.2.19 $ % $Source: /cvsroot/selflinux/tutorial/userbasics/konzepte_basic/nutzer_unter_linux/nutzer_unter_linux,v $ % SelfLinux-0.7.2 % % Diese Datei ist Teil von SelfLinux http://www.selflinux.de % %%% $Id: nutzer_unter_linux,v 1.5.2.19 2003/04/19 22:13:57 motw_1 Exp $ \title{Benutzer- und Berechtigungskonzepte unter Linux} \author{H. Degenhardt} %\url{mailto:heiko.degenhardt@pingos.schulnetz.org} \author{J. Meinhold} %\url{mailto:j.meinhold@imail.de} \author{M. Kleine} %\url{mailto:kleine_matthias@gmx.de} \maketitle %\ref{../index.tex} %\ref{konzepte_basic1.tex} Basiskonzepte für Benutzer \ref{Benutzer_und_Berechtigungskonzepte} \par{Layout} Matthias Hagedorn %\url{mailto:herbert_kw@t-online.de} \par{Lizenz} GFDL \tableofcontents{} \section{Einleitung} \label{d20e78} \par Die Nutzung von Informationssystemen ist üblicherweise mit einem Zugangssystem verbunden, welches die Verwendung des Systems auf eine bekannte Benutzergruppe beschränkt, Daten über die registrierten Benutzer speichert und die Verteilung der Ressourcen auf die Benutzer steuert. Häufig ist die Konzeption des Zugangssystems für den einzelnen Benutzer transparent - außer seinem Benutzernamen und einem Paßwort benötigt der Benutzer kaum weitere Kenntnisse, um das System in Anspruch zu nehmen. Für die Arbeit mit einem Linux-System sollten Sie sich dennoch einige elementare Kenntnisse über dessen Benutzer- und Berechtigungskonzept aneignen. \par Die Notwendigkeit für diese Konzepte ergibt sich für Linux aus seiner Mehrbenutzerfähigkeit. Ein erster wichtiger Aspekt ist der Schutz des Systems vor den Handlungen seiner Benutzer. Weiterhin müssen auch die einen Benutzer vor den Handlungen der anderen geschützt werden. Und schließlich darf bei allem Schutz des Systems und der Benutzer voreinander das Miteinander-Arbeiten nicht allzusehr erschwert werden. Um all dies zu gewährleisten, bedarf es eines feinkörnigen Systems der Einschränkungen und Erlaubnisse. Dieses System ideal an die jeweiligen Gegebenheiten anzupassen, ist die Aufgabe des Systemverwalters. Es bleibt zu hoffen, daß er diese Aufgabe in Absprache mit den Benutzern vornimmt. \par Dieser Text ist derzeit in fünf Hauptabschnitte gegliedert. Im ersten Abschnitt Was ist ein Benutzer? wird erläutert, was einen Benutzer unter Linux ausmacht. Der zweite Abschnitt Benutzertypen behandelt die Unterschiede zwischen Standardbenutzern, Systembenutzern und dem Superuser root. Abschnitt drei Benutzerklassen: user, group und others widmet sich den für das Berechtigungskonzept zentralen Benutzerklassen unter Linux. In Abschnitt vier Berechtigungstypen: Lesen, Schreiben und Ausführen werden die Berechtigungstypen für diese Benutzerklassen im Detail ausgeführt. Abschnitt fünf schließlich beschreibt überblicksweise die für die Benutzerverwaltung zentralen Konfigurationsdateien. \par Die Autoren sind sich der Tatsache bewußt, daß damit wesentliche Themen, die in dieses Kapitel gehören, noch nicht abgehandelt wurden. Es ist geplant, diese Abschnitte in der kommenden SelfLinux-Release nachzureichen. \section{Was ist ein Benutzer?} \label{d20e123} \subsection{Benutzername und Paßwort} \label{d20e130} \par Ein Zugang oder {\bf Account} besteht in der Informationstechnik aus einer Benutzername/Paßwort-Kombination. Von einer weiteren Verkomplizierung des Zugangssystems, etwa durch Einsatz von Verschlüsselungstechnologien aus Gründen erhöhter Sicherheitsanforderungen, soll in diesem Kapitel nicht die Rede sein. \par Erwartungsgemäß melden Sie sich auch bei Linux durch die Angabe Ihres Benutzernamens und des zugehörigen Paßwortes an. Mehr muß der Anwender im allgemeinen nicht wissen. Aus Systemsicht sind jedoch noch einige weitere Attribute Ihres Accounts interessant. \subsection{Benutzer-Id (UID) und Gruppen-Id (GID)} \label{d20e147} \par Während Sie üblicherweise einfach einen Benutzernamen angeben, um sich auf einen bestimmten Benutzer zu beziehen, verwendet Linux intern lediglich eine Identifikationsnummer, die sogenannte UID ({\bf User-Id}). Betrachten Sie die (verkürzte) Ausgabe des folgenden Kommandos: \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ id \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} uid=500(matthias)\end{scriptsize} \end{tt} \linebreak \par In Klammern sehen Sie den vertrauten Benutzernamen, hier {\bf matthias}. Die UID beträgt 500. Für interne Zwecke findet nahezu ausschließlich die UID Verwendung. Selbst wenn Sie Kommandos absetzen, welche den Benutzernamen als Parameter erwarten, findet zunächst ein Mapping des Namens auf die UID statt, bevor die gewünschte Aktion ausgeführt wird. Umgekehrt sollten Sie sich nicht täuschen lassen, wenn Ihnen ein Kommando den Benutzernamen anstelle der UID liefert. Betrachten Sie z.B. die folgende (wiederum etwas komprimierte) Ausgabe: \begin{tt} \begin{scriptsize} user@linux / \$ ps -aux \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} USER\verb+ +\verb+ +\verb+ + PID %CPU %MEM\verb+ + VSZ\verb+ +RSS TTY\verb+ +\verb+ +\verb+ +STAT START\verb+ + TIME COMMAND\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} root\verb+ +\verb+ +\verb+ +\verb+ + 1\verb+ +0.0\verb+ +0.0\verb+ + 448\verb+ + 64 ?\verb+ +\verb+ +\verb+ +\verb+ +S\verb+ +\verb+ +Jun21\verb+ + 0:07 init [3]\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} root\verb+ +\verb+ +\verb+ +\verb+ + 2\verb+ +0.0\verb+ +0.0\verb+ +\verb+ + 0\verb+ +\verb+ +0 ?\verb+ +\verb+ +\verb+ +\verb+ +SW\verb+ + Jun21\verb+ + 0:00 [keventd]\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} nobody\verb+ +\verb+ + 650\verb+ +0.0\verb+ +0.1\verb+ +5680\verb+ +716 ?\verb+ +\verb+ +\verb+ +\verb+ +S\verb+ +\verb+ +Jun21\verb+ + 0:00 /usr/sbin/in.identd -e\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} nobody\verb+ +\verb+ + 653\verb+ +0.0\verb+ +0.1\verb+ +5680\verb+ +716 ?\verb+ +\verb+ +\verb+ +\verb+ +S\verb+ +\verb+ +Jun21\verb+ + 0:01 /usr/sbin/in.identd -e\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} lp\verb+ +\verb+ +\verb+ +\verb+ + 746\verb+ +0.0\verb+ +0.1\verb+ +1944\verb+ +712 ?\verb+ +\verb+ +\verb+ +\verb+ +S\verb+ +\verb+ +Jun21\verb+ + 0:00 lpd Waiting\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} matthias 15971\verb+ +0.0\verb+ +0.2\verb+ +2528 1188 tty1\verb+ +\verb+ + S\verb+ +\verb+ +01:09\verb+ + 0:00 /bin/sh/usr/X11R6/bin/startx\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} matthias 16097\verb+ +0.0\verb+ +0.3\verb+ +2816 1576 pts/1\verb+ +\verb+ +S\verb+ +\verb+ +01:09\verb+ + 0:00 /bin/bash\end{scriptsize} \end{tt} \linebreak \par In der ersten Spalte listet {\bf ps} bereitwillig die vertrauten oder weniger vertrauten Namen diverser Benutzer (root, nobody, lp, matthias) auf. Das System verwaltet allerdings die Prozesse nicht unter den Benutzernamen, sondern ausschließlich unter deren UID's. {\bf ps} hat hier eigenständig ein Mapping von den UID's auf die Benutzernamen vorgenommen. \par Neben der UID ist jedem Benutzer eine weitere Nummer zugeordnet, die sogenannte {\bf Gruppen-ID} (GID). Auch diese Nummer liefert das {\bf id} Kommando (hier die etwas längere, aber immer noch verkürzte Ausgabe): \begin{tt} \begin{scriptsize} user@linux / \$ id \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} uid=500(matthias) gid=100(users)\end{scriptsize} \end{tt} \linebreak \par Jeder Prozeß trägt UID und GID seines Erzeugers. Wie diese beiden Kennzahlen bei der Ermittlung von Berechtigungen verwendet werden, wird später im Detail erläutert. \subsection{Nach der Anmeldung - die Shell} \label{d20e271} \par Nach der Anmeldung möchte sich der Benutzer in einer Umgebung wiederfinden, welche ihm das Arbeiten ermöglicht. Erfolgt die Anmeldung nicht über ein grafisches Login-Werkzeug, so wird für gewöhnliche Benutzer eine Shell gestartet. Um welche Shell es sich handelt, wird dabei für jeden Benutzer einzeln festgelegt. In der Tat kann man für einzelne Benutzer auch festlegen, daß sie keine Shell erhalten - z.B. wenn man sie temporär vom System aussperren möchte oder wenn für einzelne Benutzer generell keine Shell-Umgebung ermöglicht werden soll. Wie später noch gezeigt wird, kann dies sehr sinnvoll sein und kommt durchaus häufig vor. \subsection{Das Heimatverzeichnis} \label{d20e282} \par Die Login-Shell startet im sogenannten Heimatverzeichnis des Benutzers. Dieses und alle seine Unterverzeichnisse ''gehören'' dem Benutzer. Was genau damit gemeint ist, wird in einigen Augenblicken erläutert. Im wesentlichen bietet das Heimatverzeichnis seinem Besitzer Platz für die Ablage von Dateien, welche meist oder auschließlich von ihm verwendet werden. Neben den Arbeitsdateien und -verzeichnissen selbst liegen im Heimatverzeichnis noch eine Reihe (meist unsichtbarer) Dateien, welche applikationsspezifische Einstellungen des Benutzers enthalten. Es ist somit der Dreh- und Angelpunkt der Aktivitäten des Benutzers - eine gewohnte, vor anderen Benutzern geschützte Umgebung. \subsection{Was ist nun also ein Benutzer?} \label{d20e293} \par Benutzername und Paßwort, UID, Login-Programm (üblicherweise eine Shell) und Heimatverzeichnis sind es also, die zusammengenommen einen Benutzer auf einem Linux-System ausmachen. All diese Daten werden in einer zentralen Benutzerdatei verwaltet. Bevor diese näher beschrieben wird, folgt eine Einteilung der auf einem Linux-System möglichen Benutzer in Benutzertypen. \section{Benutzertypen} \label{d20e311} \par Hier nochmals die verkürzte Ausgabe eines {\bf ps} Kommandos auf meinem System: \begin{tt} \begin{scriptsize} user@linux / \$ ps -aux \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} USER\verb+ +\verb+ +\verb+ + PID %CPU %MEM\verb+ + VSZ\verb+ +RSS TTY\verb+ +\verb+ +\verb+ +STAT START\verb+ + TIME COMMAND\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} root\verb+ +\verb+ +\verb+ +\verb+ + 1\verb+ +0.0\verb+ +0.0\verb+ + 448\verb+ + 64 ?\verb+ +\verb+ +\verb+ +\verb+ +S\verb+ +\verb+ +Jun21\verb+ + 0:07 init [3]\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} root\verb+ +\verb+ +\verb+ +\verb+ + 2\verb+ +0.0\verb+ +0.0\verb+ +\verb+ + 0\verb+ +\verb+ +0 ?\verb+ +\verb+ +\verb+ +\verb+ +SW\verb+ + Jun21\verb+ + 0:00 [keventd]\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} nobody\verb+ +\verb+ + 650\verb+ +0.0\verb+ +0.1\verb+ +5680\verb+ +716 ?\verb+ +\verb+ +\verb+ +\verb+ +S\verb+ +\verb+ +Jun21\verb+ + 0:00 /usr/sbin/in.identd -e\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} nobody\verb+ +\verb+ + 653\verb+ +0.0\verb+ +0.1\verb+ +5680\verb+ +716 ?\verb+ +\verb+ +\verb+ +\verb+ +S\verb+ +\verb+ +Jun21\verb+ + 0:01 /usr/sbin/in.identd -e\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} lp\verb+ +\verb+ +\verb+ +\verb+ + 746\verb+ +0.0\verb+ +0.1\verb+ +1944\verb+ +712 ?\verb+ +\verb+ +\verb+ +\verb+ +S\verb+ +\verb+ +Jun21\verb+ + 0:00 lpd Waiting\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} matthias 15971\verb+ +0.0\verb+ +0.2\verb+ +2528 1188 tty1\verb+ +\verb+ + S\verb+ +\verb+ +01:09\verb+ + 0:00 /bin/sh/usr/X11R6/bin/startx\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} matthias 16097\verb+ +0.0\verb+ +0.3\verb+ +2816 1576 pts/1\verb+ +\verb+ +S\verb+ +\verb+ +01:09\verb+ + 0:00 /bin/bash\end{scriptsize} \end{tt} \linebreak \par Die Benutzer {\bf root}, {\bf nobody}, {\bf lp} und {\bf matthias} sind als Inhaber der jeweiligen Prozesse gelistet. Ich darf Ihnen jedoch versichern, daß zum Zeitpunkt dieses Kommandos lediglich ein einziger Benutzer auf dem System angemeldet war, nämlich der Benutzer {\bf matthias}. Die Tatsache, daß dennoch einige Prozesse auf dem System unter der Kennung anderer Benutzer laufen, zeigt bereits an, daß es verschiedene Typen von Benutzern geben muß. Gewöhnlichen Benutzern wäre es nämlich unmöglich, ohne vorherige Anmeldung einen Prozeß zu starten. Wir unterscheiden daher drei Benutzertypen: Erstens den Systemverwalter oder Superuser {\bf root}, zweitens alle Standardbenutzer und drittens die Systembenutzer. \subsection{root} \label{d20e375} \par Der Benutzer {\bf root} ist mit allen Rechten ausgestattet, die ihm die Administration (bei Unachtsamkeit natürlich auch die Beschädigung!) des Systems erlauben. Diesem auch als {\bf Superuser} bezeichneten Account ist immer die UID {\bf 0} zugeordnet: \begin{tt} \begin{scriptsize} root@linux \~{}/ \# id \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} uid=0(root) gid=0(root) Gruppen=0(root) [...]\end{scriptsize} \end{tt} \linebreak \par Dieser Account dient ausschließlich Eingriffen in die Konfiguration des Systems und sollte nur dann verwendet werden, wenn kein anderer Account die für eine Aufgabe notwendigen Rechte innehat. {\bf Der unter Einsteigern beliebteste Fehler ist es, sich zunächst ausschließlich als root anzumelden.} Da nach der Systeminstallation ohnehin noch häufig administrative Aufgaben erledigt werden müssen, wird es als lästig empfunden, permanent zwischen einem Benutzer- und dem Superuser-Account hin- und herzuwechseln. Die Bequemlichkeit wird oft mit einer Beschädigung des Systems bezahlt. \par Es gibt Prozesse, die immer unter der Kennung des Superusers laufen und auch laufen müssen. Das einfachste Beispiel ist der Prozeß {\bf init}, der auch in der obigen Ausgabe erscheint. {\bf init} ist der erste Prozeß, der nach dem Booten des Kernels die Kontrolle übernimmt und wird daher auch als ''Vater aller Prozesse'' bezeichnet. Dies drückt sich in der Prozeß-ID 1 aus. Da zum Zeitpunkt des Startens von {\bf init} freilich noch kein Benutzer auf dem System angemeldet sein kann, andererseits aber jedem Prozeß eine gültige Benutzerkennung zugeordnet sein muß, und da {\bf init} des weiteren zur Erledigung seiner Aufgaben mit weitreichenden Rechten ausgestattet sein muß, läuft {\bf init} unter der Kennung des Superusers {\bf root}. Daß dies nicht nur für {\bf init} gilt, zeigt das folgende Kommando: \begin{tt} \begin{scriptsize} root@linux \~{}/ \# ps aux | grep root \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} root\verb+ +\verb+ +\verb+ +\verb+ + 1\verb+ +0.0\verb+ +0.0\verb+ + 448\verb+ + 76 ?\verb+ +\verb+ +\verb+ +\verb+ +S\verb+ +\verb+ +Oct25\verb+ + 0:07 init \linebreak [...] \linebreak root\verb+ +\verb+ +\verb+ +\verb+ + 4\verb+ +0.0\verb+ +0.0\verb+ +\verb+ + 0\verb+ +\verb+ +0 ?\verb+ +\verb+ +\verb+ +\verb+ +SW\verb+ + Oct25\verb+ + 0:01 [keventd] \linebreak [...] \linebreak root\verb+ +\verb+ +\verb+ + 602\verb+ +0.0\verb+ +0.1\verb+ +1356\verb+ +552 ?\verb+ +\verb+ +\verb+ +\verb+ +S\verb+ +\verb+ +Oct25\verb+ + 0:01 /sbin/syslogd \linebreak [...] \linebreak root\verb+ +\verb+ +\verb+ +1651\verb+ +0.0\verb+ +0.6\verb+ +4856 3232 ?\verb+ +\verb+ +\verb+ +\verb+ +S\verb+ +\verb+ +Oct25\verb+ + 0:08 /usr/sbin/cupsd \linebreak [...] \linebreak root\verb+ +\verb+ +\verb+ +2063\verb+ +0.0\verb+ +0.0\verb+ +1260\verb+ +\verb+ +4 tty1\verb+ +\verb+ + S\verb+ +\verb+ +Oct25\verb+ + 0:00 /sbin/mingetty --noclear tty1 \linebreak [...]\end{scriptsize} \end{tt} \linebreak \par Diese nach Prozeßnummern geordnete, verkürzte Liste zeigt im oberen Bereich zunächst den Vater aller Prozesse {\bf init}. Danach folgen kernelnahe Prozesse, welche bereits früh während des Bootvorganges gestartet werden. Später kommen einige Dienst- und Serverprozesse hinzu, darunter der Log-Dämon {\bf syslogd}, der Druckdienst {\bf cupsd} sowie einige Terminalprozesse ({\bf mingetty's}), welche das Einloggen auf den verschiedenen Konsolen ermöglichen. All diese Prozesse wurden nicht etwa von einem eingeloggten Benutzer {\bf root} gestartet, sondern automatisch beim Hochfahren des Systems - allerdings unter der Kennung von {\bf root}, d.h. mit UID {\bf 0}. \subsection{Systembenutzer} \label{d20e485} \par Je nach System kann eine Vielzahl von Prozessen und Diensten erwünscht sein, die bereits beim Hochfahren des Systems verfügbar sein sollen. Nicht jeder dieser Prozesse benötigt jedoch die volle Rechteausstattung des Superusers. Man möchte natürlich so wenige Prozesse wie nur möglich unter einer {\bf root} Kennung starten, da die weitreichenden Rechte solcher Prozesse unnötige Möglichkeiten für Mißbrauch und Beschädigung des Systems liefern. \par Ein Systembenutzer-Account ist in diesem Sinne ein Benutzer-Account, der jedoch (nahezu) ausschließlich zur Ausführung von Programmen unter einer speziellen Benutzerkennung verwendet wird. Kein menschlicher Benutzer meldet sich normalerweise unter einem solchen Account an. Die oben bereits gezeigte Ausgabe eines {\bf ps} Kommandos zeigt zwei häufige Beispiele: Der Drucker-Dämon {\bf lpd} wurde unter der Benutzerkennung {\bf lp} gestartet. Zwei Prozesse werden unter der Kennung des Benutzers {\bf nobody} gelistet. {\bf nobody} wird generell dann von Prozessen als Benutzerkennung verwendet, wenn nur ein Minimum an Rechten vergeben werden soll. Da {\bf nobody} (laut Konvention, aber keineswegs notwendigerweise) keiner Gruppe angehört, wird er gewöhnlich der Benutzerklasse {\bf others} angehören und somit die geringstmöglichen Rechte besitzen. Mehr zu Benutzerklassen folgt unten. \par Ein Blick in die zentrale Benutzerdatei (Details zu dieser Datei folgen später) zeigt, daß vielen Systembenutzern explizit keine Shell zugeordnet wird: \begin{tt} \begin{scriptsize} root@linux \~{}/ \# cat /etc/passwd | grep false \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} firewall:x:41:31:Firewall account:/var/lib/firewall:/bin/false\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} postfix:x:51:51:Postfix daemon:/var/spool/postfix:/bin/false\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} mysql:x:60:2:MySQL database admin:/var/lib/mysql:/bin/false\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} dpbox:x:61:56:DpBox account:/var/spool/dpbox:/bin/false\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} zope:x:64:2:Zope daemon:/var/lib/zope:/bin/false\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} vscan:x:65:65534:Vscan account:/var/spool/vscan:/bin/false\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} wnn:x:66:100:Wnn system account:/var/lib/wnn:/bin/false\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} pop:x:67:100:POP admin:/var/lib/pop:/bin/false\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} perforce:x:68:60:Perfoce admin:/var/lib/perforce:/bin/false\end{scriptsize} \end{tt} \linebreak \par Das Programm {\bf /bin/false} beendet sich ohne weitere Arbeit selbst, sodaß ein gewöhnlicher Login als einer der aufgeführten Benutzer nicht zu einer Shellsession führen kann. Prozesse unter dieser Kennung werden somit nicht von einer Benutzershell gestartet, sondern über andere Mechanismen, die noch zu besprechen sein werden. \par Es soll jedoch nochmals ausdrücklich erwähnt werden, daß die Unterscheidung zwischen Systembenutzern und Standardbenutzern willkürlich ist und nicht durch das Linux-Rechtesystem selbst festgelegt wird. Es hilft jedoch beim Verständnis diverser Rechtekonzepte, wenn man sich der Tatsache bewußt ist, daß es zahlreiche Benutzer-Accounts gibt, welche ausschließlich im Zusammenhang mit bestimmten Diensten verwendet werden. \subsection{Standardbenutzer} \label{d20e575} \par Dies ist der {\bf normale} Benutzer-Account, unter welchem jeder überlicherweise arbeiten sollte. \section{Benutzerklassen: user, group und others} \label{d20e593} \par Aus der Sicht des Systems existieren drei Benutzerklassen, wenn entschieden werden soll, ob die Berechtigung für einen Dateizugriff existiert oder nicht. Soll beispielsweise eine Datei gelöscht werden, so muß das System ermitteln, ob der Prozeß, welcher die Datei löschen möchte, das erforderliche Recht besitzt: \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ rm testdatei \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} rm: Entfernen (unlink) von ''testdatei'' nicht möglich: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \par In diesem Fall wurde dem {\bf rm} Kommando der beabsichtigte löschende Zugriff auf die Datei verwehrt - der ausführende Benutzer hatte nicht das Recht, die Datei zu löschen. Um diese Entscheidung zu treffen, verwendet das System das Konzept der Benutzerklassen. Drei Benutzerklassen werden unterschieden: {\bf user}, {\bf group} und {\bf others}. Jede dieser Benutzerklassen ist wiederum in ein Lese-, Schreib- und Ausführrecht unterteilt. Diese werden im folgenden als Berechtigungsklassen bezeichnet. Somit ergibt sich folgende Körnung für die einfachen Zugriffsrechte einer Datei: %table \begin{tabular}{|l|l|} \hline \begin{minipage}{60mm} {\bf user-read} \end{minipage} & \begin{minipage}{60mm} Leserecht für Dateieigentümer \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf user-write} \end{minipage} & \begin{minipage}{60mm} Schreibrecht für Dateieigentümer \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf user-execute} \end{minipage} & \begin{minipage}{60mm} Ausführrecht für Dateieigentümer \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf group-read} \end{minipage} & \begin{minipage}{60mm} Leserecht für Gruppe des Dateieigentümers \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf group-write} \end{minipage} & \begin{minipage}{60mm} Schreibrecht für Gruppe des Dateieigentümers \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf group-execute} \end{minipage} & \begin{minipage}{60mm} Ausführrecht für Gruppe des Dateieigentümers \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf other-read} \end{minipage} & \begin{minipage}{60mm} Leserecht für alle anderen Benutzer \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf other-write} \end{minipage} & \begin{minipage}{60mm} Schreibrecht für alle anderen Benutzer \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf other-execute} \end{minipage} & \begin{minipage}{60mm} Ausführrecht für alle anderen Benutzer \end{minipage} \\ \hline \end{tabular} Tabelle 1: Einfache Zugriffsrechte für Dateien. \par Benutzerklassen sind also eng mit der Eigentümerschaft von Dateien verbunden. Jede Datei und jedes Verzeichnis ist sowohl einem Benutzer (einer UID) als auch einer Gruppe (einer GID) zugeordnet. UID und GID gehören zur elementaren Verwaltungsinformation von Dateien und Verzeichnissen und werden in der sogenannten {\bf Inode} gespeichert. \par Beim Zugriff auf eine Datei werden nun UID und GID des zugreifenden Prozesses mit UID und GID der Datei verglichen. Ist {\bf other-read} gesetzt, darf jeder Benutzer lesend zugreifen und ein weiterer Vergleich erübrigt sich. Ist lediglich {\bf group-read} gesetzt, muß der Zugreifende mindestens der Gruppe des Dateieigentümers angehören, d.h. eine identische GID aufweisen. Ist ausschließlich {\bf user-read} gesetzt, so darf nur der Eigentümer selbst die Datei lesen. {\bf root} ist von dieser Einschränkung freilich ausgenommen. (''Ich bin root, ich darf das!''). \section{Berechtigungsklassen: Lesen, Schreiben und Ausführen} \label{d20e797} \par Da unter Unix letztlich alle Ein- und Ausgabeoperationen mit denselben Systemrufen vorgenommen werden, hat sich der Ausspruch {\bf Alles ist eine Datei!} etabliert. Beispielsweise sind auch Verzeichnisse letztlich - wie alle anderen Einträge im Dateisystem - eine besonderer Typ Datei. Weitere Typen sind etwa Character- und Blockdevices, benamte Pipes, reguläre Dateien, symbolische Links und Sockets. Für jeden dieser Dateitypen haben die unterschiedlichen Rechte (Lesen, Schreiben und Ausführen) eine unterschiedliche Bedeutung. \par Im Sinne einer minimalistischen Philosophie wurde dennoch die Abstraktion vorgenommen, alle diese unterschiedlichen Operationen unter dem Begriff der Datei zusammenzufassen und einheitliche Zugriffsmethoden bereitzustellen. Sowohl für den Entwickler wie auch für den Administrator bedeutet diese Abstraktion eine Vereinfachung seiner Aufgaben. Beispielsweise erfolgt die Vergabe des Leserechtes für reguläre Dateien auf exakt dieselbe Weise wie die Vergabe des Leserechtes für ein Sounddevice. \par Da die Bedeutung der Lese-, Schreib- und Ausführrechte für die einzelnen Dateitypen im einzelnen besser bei den verschiedenen Spezialthemen besprochen werden kann, sollen im folgenden lediglich die unterschiedlichen Bedeutungen dieser Rechte für reguläre Dateien und Verzeichnisse erläutert werden. Reguläre Dateien sind Dateien mit definierten Dateiformaten, darunter etwa gewöhnliche Textdateien, Bildformate, Sounddateien, aber auch Programmdateien (Executables). Die Anzahl an Dateiformaten füllt ganze Enzyklopädien. Verzeichnisse sind Dateien, die einen Katalog von Dateien und Unterverzeichnissen enthalten können. \subsection{Lesen} \label{d20e818} \subsubsection{Leserecht für Dateien} \label{d20e825} \par Für Datendateien aller Art, wie z.B. Textdateien, Bilder usw., leuchtet das Leserecht unmittelbar ein: Die Datei kann zur Ansicht geöffnet und ihr Inhalt angezeigt oder abgespielt werden. Für Programmdateien ist das Leserecht weniger intuitiv verständlich. Manchen mag es überraschen, daß für die Ausführung eines Programms nicht das Leserecht gesetzt sein muß: \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ su \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} Password: (Eingabe)\linebreak\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} root@linux \~{}/ \# chmod a-r /bin/echo \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} root@linux \~{}/ \# ls -l /bin/echo \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} --wx--x--x\verb+ +\verb+ +1 root\verb+ +\verb+ + root\verb+ +\verb+ +\verb+ +\verb+ + 7064 2002-09-09 20:05 /bin/echo\end{scriptsize} \end{tt} \linebreak \linebreak \begin{tt} \begin{scriptsize} \linebreak root@linux \~{}/ \# exit \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ echo hallo \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} hallo\end{scriptsize} \end{tt} \linebreak \par Mittels des {\bf chmod} Kommandos wurde der Programmdatei des {\bf echo} Kommandos temporär das Leserecht entzogen. Dennoch ist {\bf echo} weiterhin verwendbar. Für manchen erscheint dies widersprüchlich, da zur Ausführung eines Programmes schließlich die Programmdatei {\bf eingelesen} werden muß. Dies ist jedoch nicht notwendig. Das Laden eines Programmes ist sowohl technisch als auch konzeptionell ein völlig anderer Vorgang als das Lesen einer Datei. Daß {\bf root} eine Sonderstellung einnimmt, zeigen übrigens die folgenden Kommandos: \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ wc /bin/echo \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} wc: /bin/echo: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ su \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} Password: (Eingabe)\linebreak\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} root@linux \~{}/ \# wc /bin/echo \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \verb+ +\verb+ + 36\verb+ +\verb+ + 234\verb+ +\verb+ +7064 /bin/echo\end{scriptsize} \end{tt} \linebreak \linebreak \begin{tt} \begin{scriptsize} \linebreak root@linux \~{}/ \# chmod a+r /bin/echo \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} root@linux \~{}/ \# exit \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ wc /bin/echo \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \verb+ +\verb+ + 36\verb+ +\verb+ + 234\verb+ +\verb+ +7064 /bin/echo\end{scriptsize} \end{tt} \linebreak \par Trotz fehlendem Leserecht durfte {\bf root} mittels des {\bf wc} Kommandos die Datei {\bf lesen}, nämlich die Anzahl der Zeilen, Worte und Zeichen in der Datei zählen (eine nicht unbedingt sinnvolle Aktion, die hier nur zur Demonstration der Sonderstellung von root durchgeführt wurde). Der angemeldete Standardbenutzer durfte {\bf wc} nicht auf die Datei anwenden und erhielt einen Berechtigungsfehler. \subsubsection{Leserecht für Verzeichnisse} \label{d20e929} \par Da Verzeichnisse keine Daten im eigentlichen Sinne enthalten, sondern lediglich Information über Dateien und Unterverzeichnisse, hat das Leserecht hier freilich eine andere Bedeutung. Das klassische Kommando zum Auslesen von Verzeichnisinformation ist {\bf ls}. Betrachten wir ein Verzeichnis {\bf testdir}, das eine Textdatei {\bf textfile} und das Programm {\bf tipptrainer} enthält. \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ ls -l | grep testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} drwxr-xr-x\verb+ +\verb+ +2 matthias users\verb+ +\verb+ +\verb+ +\verb+ + 104 2002-11-05 23:43 testdir\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ ls -l testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} insgesamt 408\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} -rw-r--r--\verb+ +\verb+ +1 matthias users\verb+ +\verb+ +\verb+ +\verb+ +\verb+ + 0 2002-11-05 23:43 testfile\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} -rwxr-xr-x\verb+ +\verb+ +1 matthias users\verb+ +\verb+ +\verb+ +417072 2002-11-05 23:43 tipptrainer\end{scriptsize} \end{tt} \linebreak \par Das erste Kommando zeigt die aktuellen Berechtigungen für das Testverzeichnis. Die Leserechte sind für alle drei Benutzerklassen gesetzt. Folglich ist das zweite Kommando beim Auslesen des Verzeichnisses erfolgreich und gibt den Verzeichnisinhalt aus. Das Entfernen des Leserechtes hat ebenfalls den erwarteten Effekt: \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ chmod a-r testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ ls -l testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} ls: testdir: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \par Es ist jedoch wichtig festzuhalten, daß damit keineswegs das Leserecht für die enthaltene Dateien entfernt wurde: \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ ls -l testdir/testfile \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} -rw-r--r--\verb+ +\verb+ +1 matthias users\verb+ +\verb+ +\verb+ +\verb+ +\verb+ + 0 2002-11-05 23:43 testdir/testfile\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ cat testdir/testfile \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} Dies ist eine Testdatei.\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ testdir/tipptrainer \& \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} [1] 7761\end{scriptsize} \end{tt} \linebreak \par Es dürfen sowohl die Berechtigungen der Testdatei wie auch ihr Inhalt ausgelesen werden. Das Programm {\bf tipptrainer} läßt sich ebenfalls problemlos starten. Das Entfernen des Leserechtes für ein Verzeichnis wirkt sich also keineswegs auf die Dateien und Unterverzeichnisse aus, welche in dem Verzeichnis abgelegt sind. Es ist wichtig, dies zu verstehen, da ansonsten die Illusion entstehen könnte, mit dem Entfernen des Leserechtes für ein Verzeichnis schütze man auch dessen Inhalt vor dem Zugriff. \par Es ist hilfreich, sich ein Verzeichnis als einen Katalog vorzustellen: Sein Inhalt ist eine Liste der Knoten, die sich innerhalb des Dateibaumes unterhalb des Verzeichnisses befinden. Das Leserecht ermöglicht das Auslesen der Kataloginformation, beispielsweise mittels des {\bf ls} Kommandos. Ein Entfernen des Leserechtes verbietet zwar das Auslesen des Kataloges, nicht aber den Zugriff auf die katalogisierten Inhalte. \par Das Leserecht eines Verzeichnisses hat auch keinerlei Auswirkung darauf, ob Verzeichnisinhalte gelöscht oder angelegt werden dürfen. Da bei diesen Operationen kein lesender, sondern ein schreibender Zugriff auf den ''Kataloginhalt'' erfolgt, spielt das Leserecht hier keine Rolle: \begin{tt} \begin{scriptsize} user@linux / \$ rm testdir/testfile \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux / \$ touch testdir/testfile2 \end{scriptsize} \end{tt} \linebreak \par Eine interessante Ausnahme bildet die Verwendung von Wildcards: \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ rm testdir/* \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} rm: Entfernen von ''testdir/*'' nicht möglich: Datei oder Verzeichnis nicht gefunden\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ chmod a+r testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ rm testdir/* \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ ls -l testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} insgesamt 0\end{scriptsize} \end{tt} \linebreak \par Um den {\bf *} durch Dateinamen zu ersetzen, welche schließlich dem {\bf rm} Kommando übergeben werden, muß die Shell lesend auf das Verzeichnis zugreifen können. Da kein Leserecht gesetzt war, liefert dieser Zugriff kein Ergebnis und das {\bf rm} Kommando schlägt mangels übergebener Argumente (d.h. Dateinamen) fehl. Nach Vergabe des Leserechtes wird der {\bf *} durch die Dateinamen im Testverzeichnis ersetzt und diese an das {\bf rm} Kommando zum Löschen übergeben. Die Verwendung von Wildcards zur Dateinamensubstituation erfordert folglich ein Leserecht für das betroffene Verzeichnis. \subsection{Schreiben} \label{d20e1079} \subsubsection{Schreibrecht für Dateien} \label{d20e1086} \par Das Schreibrecht für reguläre Dateien ist ebenso intuitiv verständlich wie das Leserecht. Ist dieses Recht gesetzt, darf die Datei überschrieben oder weiterer Inhalt an sie angehängt werden. Das Schreiben auf Spezialdateien wie z.B. Sockets, Framebuffer oder Gerätedateien erfordert ebenfalls ein hundsgemeines Schreibrecht. Insbesondere wenn man solche Dateien selbst erzeugt hat (z.B. um ein ungewöhnliches Gerät in das System zu integrieren) sollte man nicht vergessen, das Schreibrecht zu setzen - ein trivialer Umstand, der schon so manche Arbeitsstunde gekostet hat. \subsubsection{Schreibrecht für Verzeichnisse} \label{d20e1097} \par Erwartungsgemäß bezieht sich das Schreibrecht für Verzeichnisse auf das Anlegen und Löschen von Dateien in Verzeichnissen. Ohne Schreibrecht ist weder das eine noch das andere möglich. \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ ls -l | grep testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} drwxr-xr-x\verb+ +\verb+ +2 matthias users\verb+ +\verb+ +\verb+ +\verb+ +\verb+ +48 2002-11-06 00:08 testdir\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ touch testdir/testfile \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ chmod a-w testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ rm testdir/testfile \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} rm: Entfernen von ''testdir/testfile'' nicht möglich: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ touch testdir/testfile2 \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} touch: Erzeugen von ''testdir/testfile2'': Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \par Eine andere Bedeutung kommt dem Schreibrecht für Verzeichnisse nicht zu. Insbesondere benötigt man kein Schreibrecht in einem Verzeichnis, um eine darin enthaltene Datei oder auch nur deren Rechte zu ändern. Da diese Information direkt in die Datei bzw. deren Inode geschrieben wird, ist das Schreibrecht des Verzeichnisses ohne Belang: \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ echo hallo \verb+>+ testdir/testfile \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ chmod +r testdir/testfile \end{scriptsize} \end{tt} \linebreak \subsection{Ausführen} \label{d20e1148} \subsubsection{Ausführrecht für Dateien} \label{d20e1155} \par Programme und Skripte sind es, die ausgeführt werden können. Programme liegen in Binärformaten vor - unter Linux hat sich das {\bf Executable and Linking Format} (ELF) durchgesetzt, aber auch andere Formate werden unterstützt. Skripte werden von Interpretern ausgeführt und liegen in Textformat vor. \par Bei Programmen, d.h. Dateien in einem ausführbaren Binärformat, liegt die Sache einfach. Ist das Ausführrecht gesetzt, darf das Programm aufgerufen und ausgeführt werden. Zunächst wird die Berechtigung geprüft und danach versucht, das Programm zu laden. Diese Reihenfolge zeigt der Versuch, eine Datei eines nicht ausführbaren Binärformates auszuführen, hier ein Gif-Bild: \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ ls -l ./test.gif \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} -rw-r--r--\verb+ +\verb+ +1 matthias users\verb+ +\verb+ +\verb+ + 15568 2002-11-07 15:03 ./test.gif\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ test.gif \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} bash: ./cervisia-einstellungen.gif: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ chmod +x cervisia-einstellungen.gif \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ ./test.gif \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} bash: ./test.gif: cannot execute binary file\end{scriptsize} \end{tt} \linebreak \par Bei Skripten muß feiner differenziert werden. Welcher Interpreter für ein Skript gestartet wird, ist durch die erste Zeile eines Skriptes hinter dem sogenannten Shebang (amerikanisch ''the whole shebang'' für der ganze Plunder) definiert. Die Bezeichnung ''Shebang'' ist vermutlich von ''shell bang'' abgeleitet. Es handelt sich um die Zeichenfolge {\bf \#!}, z.B. \begin{tabular}{|l|} \hline \begin{tt} Beispiel \end{tt} \\ \hline \begin{minipage}{130mm} \begin{scriptsize} \begin{verbatim} #! /bin/sh # kommando1 kommando2 ... \end{verbatim} \end{scriptsize} \end{minipage} \\ \hline \end{tabular} \par In der ersten Zeile findet sich der Shebang nebst Angabe des zu verwendenden Interpreters. Im obigen Fall ist {\bf /bin/sh} definiert, es könnten dort auch andere Shells oder Interpreter verschiedener Skriptsprachen wie Perl oder Tcl verwendet werden. \par Weshalb wird dies hier überhaupt erläutert? Der Grund ist, daß Skripte auf verschiedene Weisen aufgerufen werden können und es von dieser Aufrufart abhängt, in welcher Weise sich das Ausführrecht auswirkt. Als Beispiel soll das folgende Skript dienen: \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ pwd \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} /home/matthias\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ cat testscript.sh \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \#! /bin/sh\end{scriptsize} \end{tt} \linebreak \linebreak\begin{tt} \begin{scriptsize} echo ''Hallo!''\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ ls -l testscript.sh \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} -rw-r--r--\verb+ +\verb+ +1 matthias users\verb+ +\verb+ +\verb+ +\verb+ +\verb+ +24 2002-11-07 23:04 testscript.sh\end{scriptsize} \end{tt} \linebreak \par Wie zu sehen, referenziert das Skript auf {\bf /bin/sh} als Interpreter, gibt im Falle einer Ausführung die Zeichenfolge ''Hallo!'' aus und besitzt derzeit keinerlei Ausführrechte. Trotzdem kann es auf verschiedene Weisen ausgeführt werden: \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ sh testscript.sh \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} Hallo!\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ source testscript.sh \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} Hallo!\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ . testscript.sh \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} Hallo!\end{scriptsize} \end{tt} \linebreak \par Versucht man jedoch, das Skript namentlich aufzurufen, scheitert dies an der mangelnden Berechtigung. Hier die drei verschiedenen Möglichkeiten, das zu tun: \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ testscript.sh \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} bash: ./testscript.sh: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ ./testscript.sh \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} bash: ./testscript.sh: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ /matthias/testscript.sh \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} bash: /home/matthias/testscript.sh: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \par Zuerst durch simple Angabe des Namens (das {\bf .} Verzeichnis muß hierfür in {\bf PATH} aufgeführt sein), dann relativ, dann absolut. In allen drei Fällen fehlt das Ausführrecht. \par Der Unterschied kann so erklärt werden. Geben Sie ein Kommando ein, so prüft die Shell, ob für dieses Kommando die Berechtigung zur Ausführung besteht. Dabei stellt jeweils das erste Wort Ihrer Eingabezeile das Kommando dar, die restlichen Worte bilden die Parameter. In den drei Beispielen unter Verwendung von {\bf sh}, {\bf source} und {\bf .} wird also die Berechtigung dieser drei Kommandos geprüft und nicht diejenige des Skriptes selbst. Der Skriptname wird dann nur noch als Parameter an das Kommando übergeben und von diesem entsprechend behandelt. In diesem Fall muß nur noch das Leserecht gesetzt sein, denn das Kommando muß die Datei natürlich zumindest einlesen können: \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ chmod -r testscript.sh \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ sh testscript.sh \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} testscript.sh: testscript.sh: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \par Referenzieren Sie hingegen das Skript in einer der drei genannten Arten direkt unter der Ausnutzung des Shebang-Mechanismus, prüft die Shell das Ausführungrecht und verweigert u.U. die Ausführung. Das Leserecht muß freilich auch hier bestehen - Ausführen impliziert für Skripte (im Gegensatz zu Programmdateien) vorheriges Einlesen! \subsubsection{Ausführrecht für Verzeichnisse} \label{d20e1341} \par Das Ausführrecht für Verzeichnisse bezeichnet das elementare Recht, dieses Verzeichnis zu betreten. Hier das grundlegende Beipiel: \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ chmod -x testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ ls -l | grep testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} drw-r--r--\verb+ +\verb+ +2 matthias users\verb+ +\verb+ +\verb+ +\verb+ +\verb+ +48 2002-11-07 23:50 testdir\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ cd testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} bash: cd: testdir: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ chmod +x testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ cd testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/testdir/ \$ pwd \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} /home/matthias/testdir\end{scriptsize} \end{tt} \linebreak \par Das ''Betreten'' eines Verzeichnisses ist jedoch allgemeiner zu verstehen als das bloße Wechseln des {\bf current working directory}. Es ist vielmehr die grundlegende Voraussetzung für alle weiteren Operationen auf dem Verzeichnis und seinen Inhalten. Lesen von Dateien, Anlegen und Löschen von Dateien und auch Ausführen von Dateien in einem Verzeichnis erfordern ein Ausführrecht auf diesem Verzeichnis. Dies gilt übrigens rekursiv auch für alle Unterverzeichnisse und deren Inhalte. \par {\bf Auslesen des Verzeichnisses:} \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ ls testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} testscript.sh\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ chmod -x testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ ls testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} ls: testdir/testscript.sh: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \par {\bf Lesen einer Datei:} \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ chmod +x testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ echo ''Neue Testdatei.'' \verb+>+ testdir/lesetest.txt \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ cat testdir/lesetest.txt \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} Neue Testdatei.\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ chmod -x testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ cat testdir/lesetest.txt \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} cat: testdir/lesetest.txt: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \par {\bf Anlegen und Löschen einer Datei:} \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ touch testdir/testfile \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} touch: Erzeugen von ''testdir/testfile'': Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ rm testdir/lesetest.txt \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} rm: Aufruf von lstat für ''testdir/lesetest.txt'' nicht möglich: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ chmod +x testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ touch testdir/testfile \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ rm testdir/lesetest.txt \end{scriptsize} \end{tt} \linebreak \par {\bf Ausführen einer Datei:} \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ ls -l testdir/testscript.sh \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} -rwxr-xr-x\verb+ +\verb+ +1 matthias users\verb+ +\verb+ +\verb+ +\verb+ +\verb+ +25 2002-11-07 23:56 testdir/testscript.sh\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ ./testdir/testscript.sh \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} Hallo!\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ chmod -x testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ ./testdir/testscript.sh \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} bash: ./testdir/testscript.sh: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \par {\bf Auch für Unterverzeichnisse die Einschränkungen wirksam:} \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ mkdir testdir/subdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ touch testdir/subdir/testfile \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ ls testdir/subdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} testfile\end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} \linebreak user@linux \~{}/ \$ chmod -x testdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} user@linux \~{}/ \$ ls testdir/subdir \end{scriptsize} \end{tt} \linebreak \begin{tt} \begin{scriptsize} ls: testdir/subdir: Keine Berechtigung\end{scriptsize} \end{tt} \linebreak \par Damit soll die ausführliche Behandlung der Dateirechte hier abgeschlossen werden. Wie zu erkennen ist, ergeben sich aus dem an sich einfachen Konzept aus drei Benutzerklassen ({\bf user}, {\bf group}, {\bf others}) und drei Berechtigungsklassen ({\bf read}, {\bf write}, {\bf execute}) durchaus komplexe Zusammenhänge und Möglichkeiten zur Abstufung von Berechtigungen. Die Kombination der verschiedenen Rechte und ihre Anwendung auf unterschiedliche Dateitypen (wobei hier bereits eine Einschränkung auf reguläre Dateien und Verzeichnisse vorgenommen wurde) bietet ein breites Experimentierfeld und ist immer wieder für Überraschungen gut. \par Am besten spielen Sie selbst einmal mit den vielfältigen Möglichkeiten, um eine gewisse Intuition im Umgang mit den Rechten zu gewinnen. Für die Zusendung besonders interessanter Beispiele sind die Autoren dankbar und werden sie gerne in dieses Kapitel aufnehmen. \par Richten Sie nun - nach einer angemessenen Pause - Ihre Aufmerksamkeit auf die zentralen Benutzerdateien im Rahmen der Benutzerkonzeption. \section{Die zentralen Benutzerdateien} \label{d20e1564} \par Um das Kapitel abzurunden und Ihnen einen Einblick in die Registratur von Benutzern unter Linux zu geben, werden im folgenden die zentralen Benutzerdateien beschrieben, welche alle notwendige Informationen über Benutzernamen, Paßwörter, Gruppenzugehörigkeiten und andere Benutzerattribute enthalten. Den Abschluß bildet ein Verweis ein System zur zentralen Benutzerverwaltung in Netzwerken, das NIS (Network Information System). \par Die Dateien zur Benutzerverwaltung finden Sie unter Linux im Verzeichnis {\bf /etc}. Es handelt sich dabei um die Dateien {\bf /etc/passwd}, {\bf /etc/shadow} und {\bf /etc/group}. \par An dieser Stelle sei nochmals darauf hingewiesen, daß die meisten Linux-Distributionen komfortable Werkzeuge zur Benutzerverwaltung mitliefern und es auch eine Reihe von Befehlen gibt, die für die Benutzerverwaltung gedacht sind. Diese werden in diesem Kapitel nicht erläutert. Hier soll grundlegendes Wissen über den Aufbau, Inhalt und Funktionen der Dateien erläutert werden, die für die Benutzerverwaltung unter Linux von Bedeutung sind. \subsection{Die Datei /etc/passwd} \label{d20e1596} \par Die Datei {\bf /etc/passwd} ist die zentrale Benutzerdatenbank. \par Mit {\bf cat /etc/passwd} können Sie einen Blick in diese zentrale Benutzerdatei werfen. Hier werden jetzt alle Benutzer des Systems aufgelistet. Zu beachten ist, daß hier alle Benutzertypen eingetragen sind, also vom {\bf root} über die Systembenutzer bis zu den Standardbenutzern. \par Der Eintrag eines Benutzers hat generell folgende Syntax: %table \begin{tabular}{|l|} \hline \begin{minipage}{60mm} {\bf Username : Password : UID : GID : Info : Home : Shell} \end{minipage} \\ \hline \end{tabular} %table \begin{tabular}{|l|l|} \hline \begin{minipage}{60mm} {\bf Username} \end{minipage} & \begin{minipage}{60mm} das ist der Benutzername in druckbare Zeichen, meistens in Kleinbuchstaben \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf Password} \end{minipage} & \begin{minipage}{60mm} hier steht verschlüsselt das Paßwort des Benutzers (bei alten Systemen); heutzutage steht da ein {\bf x}, das bedeutet daß das Paßwort in der Datei {\bf /etc/shadow} steht; möglich ist es noch, den Eintrag leer zu lassen, dann erfolgt der Login ohne Paßwortabfrage (in der Datei {\bf /etc/shadow} muß dann an Stelle des verschlüsselten Paßwortes ein {\bf *} stehen) \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf UID} \end{minipage} & \begin{minipage}{60mm} {\bf User-Id} des Benutzers; die Zahl hier sollte größer als 100 sein, weil die Zahlen unter 100 für Systembenutzer vorgesehen sind, weiterhin muss die Zahl aus technischen Gründen kleiner als 64000 sein \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf GID} \end{minipage} & \begin{minipage}{60mm} {\bf Group-Id} des Benutzers; auch hier muss die Zahl wie bei der UID kleiner als 64000 sein \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf Info} \end{minipage} & \begin{minipage}{60mm} hier können mehr Einträge stehen, wie z.B. der vollständige Name des Benutzers und persönliche Angaben (Telefonnummer, Abteilung, Gruppenzugehörigkeit u.ä.) \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf Home} \end{minipage} & \begin{minipage}{60mm} das Heimatverzeichnis des Benutzers bzw. das Startverzeichnis nach dem Login \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf Shell} \end{minipage} & \begin{minipage}{60mm} die ''vorgeschlagene'' Shell, die nach dem Login gestartet wird, bleibt dieses Feld frei, dann wird die Standardshell {\bf /bin/sh} gestartet \end{minipage} \\ \hline \end{tabular} \par Hier ein Beispiel für einen Systembenutzer: \begin{tt} \begin{scriptsize} uucp:x:10:14:Unix-to-Unix CoPy system:/etc/uucp:/bin/bash\end{scriptsize} \end{tt} \linebreak \par Der Benutzer heißt uucp, das Paßwort ist in der Datei {\bf /etc/shadow} gespeichert ({\bf x}), die UID ist 10, die GID 14, als Bezeichnung trägt es den Namen ''Unix-to-Unix CoPy system'', das Startverzeichnis nach dem Login ist {\bf /etc/uucp}, und die vorgeschlagene Shell ist die {\bf bash}. \subsection{Die Datei /etc/shadow} \label{d20e1779} \par Bei früheren Versionen von Linux speicherte man die die Paßwörter direkt in die {\bf passwd}-Datei. Allerdings war es durch einen sogenannten {\bf Wörterbuchangriff} und der Hilfe des linuxeigenen Programmes {\bf crypt} möglich, diese Paßwörter in vielen Fällen zu entschlüsseln und auszulesen. \linebreak Deshalb hat man die Datei {\bf /etc/shadow} eingeführt, in der die Angaben über die Paßwörter durch ein spezielles System besser geschützt waren. \par Der Eintrag in diese Datei erfolgt nach einem ähnlichen Schema, wie in der Datei {\bf /etc/passwd}: %table \begin{tabular}{|l|} \hline \begin{minipage}{60mm} {\bf Username : Password : DOC : MinD : MaxD : Warn : Exp : Dis : Res} \end{minipage} \\ \hline \end{tabular} %table \begin{tabular}{|l|l|} \hline \begin{minipage}{60mm} {\bf Username} \end{minipage} & \begin{minipage}{60mm} das ist der Benutzername in druckbare Zeichen, meistens in Kleinbuchstaben \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf Password} \end{minipage} & \begin{minipage}{60mm} hier steht verschlüsselt das Paßwort des Benutzers; wenn hier ein {\bf *} (Sternchen) steht, dann bedeutet das, das kein Passwort vorhanden bzw. eingetragen ist \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf DOC} \end{minipage} & \begin{minipage}{60mm} {\bf Day of last change}; der Tag an dem das Paßwort zuletzt geändert wurde; Besonderheit hier: es wird ab dem 1.1.1970 gezählt \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf MinD} \end{minipage} & \begin{minipage}{60mm} Minimale Anzahl der Tage, die das Paßwort gültig ist \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf MaxD} \end{minipage} & \begin{minipage}{60mm} Maximale Anzahl der Tage, die das Paßwort gültig ist \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf Warn} \end{minipage} & \begin{minipage}{60mm} die Anzahl der Tage vor Ablauf der Lebensdauer, ab der vor dem Verfall des Paßwortes zu warnen ist \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf Exp} \end{minipage} & \begin{minipage}{60mm} hier wird festgelegt, wieviele Tage das Paßwort trotz Ablauf der MaxD noch gültig ist \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf Dis} \end{minipage} & \begin{minipage}{60mm} bis zu diesem Tag (auch hier wird ab dem 1.1.1970 gezählt) ist der Benutzer-Account gesperrt \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf Res} \end{minipage} & \begin{minipage}{60mm} {\bf Reserve}, dieses Feld hat momentan keine Bedeutung \end{minipage} \\ \hline \end{tabular} \par Es folgt wieder ein Beispiel: \begin{tt} \begin{scriptsize} selflinux:/heSIGnYDr6MI:11995:1:99999:14:::\end{scriptsize} \end{tt} \linebreak \par Der Benutzer heißt selflinux, das Paßwort lautet verschlüsselt ''/heSIGnYDr6MI'', es wurde zuletzt geändert, als 11995 Tage seit dem 1.1.1970 vergangen waren. Das Paßwort ist minimal 1 Tag gültig, maximal 99999 Tage (was man als ''immer'' deuten kann - 99999 Tage sind ca. 274 Jahre). Es soll ab 14 Tage vor Ablauf des Paßwortes gewarnt werden. Die anderen Werte sind vom Administrator nicht definiert und bleiben daher leer. \subsection{Die Datei /etc/groups} \label{d20e1959} \par In dieser Datei finden Sie die Benutzergruppen und ihre Mitglieder. In der Datei {\bf /etc/passwd} wird mit der GID eigentlich schon eine Standardgruppe für den Benutzer festgelegt. Hier in der {\bf /etc/group} können Sie weitere Gruppenzugehörigkeiten definieren. Das hat in der Praxis vor allem in Netzwerken eine große Bedeutung, weil Sie so in der Lage sind, z.B. Gruppen für Projekte oder Verwaltungseinheiten zu bilden. Für diese Gruppen kann man dann entsprechend die Zugriffsrechte einstellen. Dies hat dann wiederum den Vorteil, daß man die Daten gegen eine unbefugte Benutzung absichern kann. \par Der Eintrag einer Gruppe in die Datei sieht so aus: %table \begin{tabular}{|l|} \hline \begin{minipage}{60mm} {\bf Groupname : Password : GID : Usernames (Mitgliederliste)} \end{minipage} \\ \hline \end{tabular} %table \begin{tabular}{|l|l|} \hline \begin{minipage}{60mm} {\bf Groupname} \end{minipage} & \begin{minipage}{60mm} der Name der Gruppe in druckbare Zeichen, auch hier meistens Kleinbuchstaben \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf Password} \end{minipage} & \begin{minipage}{60mm} die Besonderheit hier ist, wenn das Paßwort eingerichtet ist, können auch Nichtmitglieder der Gruppe Zugang zu den Daten der Gruppe erhalten, wenn ihnen das Paßwort bekannt ist. Ein {\bf X} sagt hier aus, das das Paßwort in {\bf /etc/shadow} abgelegt ist. Der Eintrag kann auch entfallen, dann ist die Gruppe nicht durch ein Paßwort geschützt und in die Gruppe kann aber auch ein Benutzer wechseln, der nicht in diese Gruppe eingetragen ist. \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf GID} \end{minipage} & \begin{minipage}{60mm} {\bf Group-Id} der Gruppe \end{minipage} \\ \hline \begin{minipage}{60mm} {\bf Usernames} \end{minipage} & \begin{minipage}{60mm} hier werden die Mitglieder der Gruppe eingetragen. Diese sind durch ein einfaches Komma getrennt. \end{minipage} \\ \hline \end{tabular} \par Für einen korrekten Eintrag in die {\bf /etc/group} reicht eigentlich der Groupname und die GID aus. Damit ist die Gruppe dem System bekannt gemacht. Die Felder für das Paßwort und die Usernames können frei bleiben. \par Wenn allerdings ein Benutzer in mehr als einer Gruppe (außer in seiner Standardgruppe, welche in der {\bf /etc/passwd} fesgelegt wurde) Mitglied sein soll, so muß er in die entsprechenden Gruppen eingetragen werden. Wollen Sie, daß mehrere Mitglieder in einer Gruppe zusammenarbeiten und diese Gruppe ist nicht die Standardgruppe dieser Mitglieder, dann müssen Sie ebenfalls jedes dieser Mitglieder in die gewünschte Gruppe eintragen. \linebreak Nochmal zur besseren Veranschaulichung mit anderen Worten. Soll der Benutzer nur in seiner Standardgruppe bleiben, ist kein Eintrag in die /etc/group notwendig. Hier reicht der Eintrag in die /etc/passwd völlig aus, weil ja dort die Standardgruppe schon mit angegeben wird. Nur wenn der Benutzer in weiteren bzw. mehreren Gruppen Mitglied sein soll, dann muss das in die etc/group-Datei eingetragen werden. \linebreak Für Paßwörter gilt das oben in der Tabelle gesagte. \par Hier sehen Sie ein Beispiel für einen Eintrag: \begin{tt} \begin{scriptsize} dialout:x:16:root,tatiana,steuer,selflinux\end{scriptsize} \end{tt} \linebreak \par Sie sehen eine Gruppe mit der GID ''16'' und den Namen dialout. (Zur Information: dialout erlaubt es normalen Benutzern einen {\bf ppp}-Verbindungsaufbau zu starten, normalerweise hat nur {\bf root} dieses Recht). Das {\bf x} bedeutet hier, daß das Paßwort in {\bf /etc/shadow} abgelegt ist. Da in {\bf /etc/shadow} hier bei Password ein {\bf *} steht, ist also kein Passwort für die Gruppe vorhanden (Das bedeutet wiederum, das nur die eingetragenen Mitglieder Zugang zu dieser Gruppe haben). Mitglieder der Gruppe sind: root, tatiana, steuer, selflinux. \subsection{Das Verzeichnis /etc/skel} \label{d20e2126} \par Dieses Verzeichnis hat mit der Benutzerverwaltung im engeren Sinn nichts zu tun. Es soll hier aber trotzdem erwähnt werden, weil in diesem Verzeichnis haben Sie die Möglichkeit, die ''Erstausstattung'' an Konfigurationsdateien, die ein neuer Benutzer erhalten soll, festzulegen. Das heißt dann, wenn Sie einen neuen Benutzer einrichten, können Sie durch einfaches Kopieren des Verzeichnisses {\bf /etc/skel} dem neuen Nutzer eine vorgefertigte, einheitliche Umgebung bereit stellen. \par In der Praxis wird von dem {\bf /etc/skel}-Verzeichnis sehr oft Gebrauch gemacht, denn sie müssen nur einmal dieses Verzeichnis anlegen und können dann eine große Anzahl von Benutzern auf einfache Weise einrichten. Bei den meisten Linux-Distributionen wird dieses Verzeichnis schon standardmäßig angelegt und kann dann nach den eigenen Wünschen verändert werden. \subsection{Network Information Service (NIS)} \label{d20e2146} \par Wenn mehrere Linux- und Unix-Systeme in einem Netzwerk auf gemeinsame Ressourcen zurückgreifen wollen, muß dann sichergestellt sein, daß die Benutzer- und Gruppenkennungen aller Rechner in diesem Netzwerk miteinander harmonieren und es zu keinen Konflikten kommt. Das ist die Aufgabe von dem Network Information Service (NIS). \par Sie können NIS als Datenbanksystem verstehen, der Zugriff auf die Dateien {\bf /etc/passwd}, {\bf /etc/shadow} und {\bf /etc/group} in dem gesamten angeschlossenen Netzwerk ermöglicht. \ref{inhalt.tex} \end{document}