# chmod — Dateirechte verwalten

> Praxis-Guide zu chmod: Dateirechte in oktaler und symbolischer Notation setzen, rekursiv arbeiten und 777 als Sicherheitsrisiko vermeiden.

Source: https://www.jpkc.com/db/cheatsheets/files-text/chmod/

<!-- PROSE:intro -->
`chmod` (change mode) steuert, wer eine Datei oder ein Verzeichnis lesen, schreiben und ausführen darf – getrennt für Eigentümer (`u`), Gruppe (`g`) und alle anderen (`o`). Im Alltag brauchst du es, um ein Skript ausführbar zu machen (`chmod +x`), einen privaten SSH-Schlüssel mit `600` abzusichern oder Webserver-Dateien auf `644`/`755` zu setzen. Du kannst Rechte oktal (`chmod 755`) oder symbolisch (`chmod u+x`) angeben: Oktal setzt alle Bits absolut, symbolisch verändert gezielt einzelne. Wichtig fürs Sicherheitsbewusstsein: `chmod 777` öffnet eine Datei für jeden zum Schreiben und Ausführen – das ist fast nie nötig und ein echtes Risiko. Bei `chmod -R` gilt zudem Vorsicht, weil Rechte rekursiv über ganze Bäume verteilt werden.
<!-- PROSE:intro:end -->

## Oktalmodus (numerisch)

`chmod 755 <file>` — Eigentümer: rwx, Gruppe: r-x, Andere: r-x. Standard für ausführbare Dateien und Verzeichnisse.

```bash
chmod 755 script.sh
```

`chmod 644 <file>` — Eigentümer: rw-, Gruppe: r--, Andere: r--. Standard für reguläre Dateien.

```bash
chmod 644 index.html
```

`chmod 600 <file>` — Eigentümer: rw-, Gruppe: ---, Andere: ---. Private Dateien, nur der Eigentümer kann lesen/schreiben.

```bash
chmod 600 ~/.ssh/id_ed25519
```

`chmod 700 <directory>` — Eigentümer: rwx, Gruppe: ---, Andere: ---. Privates Verzeichnis, nur der Eigentümer hat Zugriff.

```bash
chmod 700 ~/.ssh
```

`chmod 664 <file>` — Eigentümer: rw-, Gruppe: rw-, Andere: r--. Gemeinsame Dateien, bei denen auch die Gruppe schreiben darf.

```bash
chmod 664 shared-doc.txt
```

`chmod 775 <directory>` — Eigentümer: rwx, Gruppe: rwx, Andere: r-x. Gemeinsames Verzeichnis, in dem die Gruppe schreiben darf.

```bash
chmod 775 /var/www/shared/
```

`chmod 400 <file>` — Eigentümer: r--, Gruppe: ---, Andere: ---. Nur lesbar für den Eigentümer, kein Zugriff für andere.

```bash
chmod 400 secret.key
```

`chmod 444 <file>` — Eigentümer: r--, Gruppe: r--, Andere: r--. Nur lesbar für alle.

```bash
chmod 444 LICENSE
```

`chmod 000 <file>` — Keine Rechte für niemanden. Nur root kann die Datei weiterhin erreichen.

```bash
chmod 000 locked-file.txt
```

## Oktal-Referenz

`0 = --- (keine Rechte)` — Kein Lese-, Schreib- oder Ausführungsrecht.

```bash
chmod 700 dir/  # Others get 0 = ---
```

`1 = --x (nur ausführen)` — Nur Ausführungsrecht. Bei Verzeichnissen: durchlaufen, aber nicht auflisten.

```bash
chmod 711 cgi-bin/  # Others get 1 = --x
```

`2 = -w- (nur schreiben)` — Nur Schreibrecht. Allein selten genutzt.

```bash
chmod 722 dropbox/  # Others get 2 = -w-
```

`4 = r-- (nur lesen)` — Nur Leserecht.

```bash
chmod 744 script.sh  # Others get 4 = r--
```

`5 = r-x (lesen + ausführen)` — Lesen und ausführen. Standard für Andere bei ausführbaren Dateien und Verzeichnissen.

```bash
chmod 755 app.bin  # Others get 5 = r-x
```

`6 = rw- (lesen + schreiben)` — Lesen und schreiben. Standard für den Eigentümer bei regulären Dateien.

```bash
chmod 644 data.txt  # Owner gets 6 = rw-
```

`7 = rwx (lesen + schreiben + ausführen)` — Volle Rechte. Standard für den Eigentümer bei ausführbaren Dateien und Verzeichnissen.

```bash
chmod 755 deploy.sh  # Owner gets 7 = rwx
```

## Symbolischer Modus

`chmod u+x <file>` — Fügt dem Eigentümer Ausführungsrecht hinzu (u = user/Eigentümer).

```bash
chmod u+x script.sh
```

`chmod g+w <file>` — Fügt der Gruppe Schreibrecht hinzu (g = group/Gruppe).

```bash
chmod g+w shared.txt
```

`chmod o-rwx <file>` — Entzieht allen anderen sämtliche Rechte (o = others/Andere).

```bash
chmod o-rwx private.conf
```

`chmod a+r <file>` — Fügt allen Leserecht hinzu (a = all: Eigentümer + Gruppe + Andere).

```bash
chmod a+r README.md
```

`chmod u+rwx,g+rx,o+rx <file>` — Setzt mehrere Rechte auf einmal über kommagetrennte Ausdrücke.

```bash
chmod u+rwx,g+rx,o+rx deploy.sh
```

`chmod u=rwx,g=rx,o=rx <file>` — Setzt exakte Rechte mit = (ersetzt Bestehendes). Entspricht 755.

```bash
chmod u=rwx,g=rx,o=rx script.sh
```

`chmod u=rw,go=r <file>` — Setzt den Eigentümer auf rw, Gruppe und Andere auf nur lesen. Entspricht 644.

```bash
chmod u=rw,go=r config.yml
```

`chmod +x <file>` — Fügt allen Ausführungsrecht hinzu (Kurzform, ohne 'a').

```bash
chmod +x install.sh
```

`chmod -w <file>` — Entzieht allen das Schreibrecht. Macht die Datei schreibgeschützt.

```bash
chmod -w important.conf
```

`chmod u+s <file>` — Setzt das setuid-Bit. Die Datei läuft mit den Rechten des Eigentümers, egal wer sie ausführt.

```bash
chmod u+s /usr/local/bin/my-tool
```

`chmod g+s <directory>` — Setzt das setgid-Bit. Neue Dateien im Verzeichnis erben dessen Gruppe.

```bash
chmod g+s /var/www/shared/
```

`chmod +t <directory>` — Setzt das Sticky-Bit. Nur die jeweiligen Eigentümer dürfen ihre Dateien in diesem Verzeichnis löschen.

```bash
chmod +t /tmp/
```

## Rekursive & Verzeichnisoperationen

`chmod -R 755 <directory>` — Setzt Rechte rekursiv auf ein Verzeichnis und seinen gesamten Inhalt.

```bash
chmod -R 755 /var/www/html/
```

`chmod -R u+rwX,go+rX,go-w <directory>` — Setzt Rechte rekursiv. Das große X vergibt das Ausführungsrecht nur für Verzeichnisse und bereits ausführbare Dateien.

```bash
chmod -R u+rwX,go+rX,go-w /var/www/html/
```

`find <directory> -type f -exec chmod 644 {} +` — Setzt Rechte nur auf Dateien (nicht Verzeichnisse) innerhalb eines Baums.

```bash
find /var/www/html/ -type f -exec chmod 644 {} +
```

`find <directory> -type d -exec chmod 755 {} +` — Setzt Rechte nur auf Verzeichnisse (nicht Dateien) innerhalb eines Baums.

```bash
find /var/www/html/ -type d -exec chmod 755 {} +
```

`find <directory> -type f -name '*.sh' -exec chmod +x {} +` — Macht alle Shell-Skripte innerhalb eines Verzeichnisbaums ausführbar.

```bash
find ./scripts/ -type f -name '*.sh' -exec chmod +x {} +
```

## Spezialbits (oktal)

`chmod 4755 <file>` — Setzt setuid (4) + Eigentümer rwx, Gruppe r-x, Andere r-x. Die Datei läuft mit den Rechten des Eigentümers.

```bash
chmod 4755 /usr/local/bin/my-tool
```

`chmod 2755 <directory>` — Setzt setgid (2) + Standard-Verzeichnisrechte. Neue Dateien erben die Gruppe.

```bash
chmod 2755 /var/www/shared/
```

`chmod 1777 <directory>` — Setzt das Sticky-Bit (1) + volle Rechte für alle. Nutzer dürfen nur eigene Dateien löschen.

```bash
chmod 1777 /tmp/
```

`chmod 6755 <file>` — Setzt setuid- (4) und setgid-Bit (2) zugleich. 4+2=6.

```bash
chmod 6755 /usr/local/bin/special-tool
```

## Rechte anzeigen

`ls -l <file>` — Zeigt die Dateirechte in symbolischer Form (z. B. -rwxr-xr-x).

```bash
ls -l script.sh
```

`ls -la <directory>` — Zeigt die Rechte aller Dateien, auch der versteckten.

```bash
ls -la ~/.ssh/
```

`stat <file>` — Zeigt ausführlichen Dateistatus inklusive Rechten in oktaler und symbolischer Form.

```bash
stat script.sh
```

`stat -c '%a %n' <file>` — Zeigt nur die oktalen Rechte und den Dateinamen (Linux).

```bash
stat -c '%a %n' *.sh
```

`stat -c '%A %a %n' <file>` — Zeigt symbolische Rechte, oktale Rechte und den Dateinamen.

```bash
stat -c '%A %a %n' /var/www/html/*
```

`namei -l <path>` — Zeigt die Rechte jeder Komponente entlang eines Dateipfads. Hilfreich beim Debuggen von Zugriffsproblemen.

```bash
namei -l /var/www/html/index.php
```

## Häufige Rechte-Muster

`chmod 644 <file>` — Standard für Web-Dateien (HTML, CSS, JS, Bilder). Eigentümer kann bearbeiten, alle können lesen.

```bash
chmod 644 style.css
```

`chmod 755 <directory>` — Standard für Web-Verzeichnisse. Eigentümer voller Zugriff, Andere dürfen auflisten und durchlaufen.

```bash
chmod 755 /var/www/html/
```

`chmod 600 <file>` — Private SSH-Schlüssel, Zugangsdaten, .env-Dateien. Nur der Eigentümer kann lesen/schreiben.

```bash
chmod 600 .env
```

`chmod 700 <directory>` — SSH-Verzeichnis, private Konfigurationsverzeichnisse. Nur der Eigentümer hat Zugriff.

```bash
chmod 700 ~/.gnupg
```

`chmod 644 ~/.ssh/authorized_keys` — authorized_keys muss vom Eigentümer und von sshd lesbar sein.

```bash
chmod 644 ~/.ssh/authorized_keys
```

`chmod 600 ~/.ssh/config` — SSH-Konfigurationsdatei. Muss privat sein, um korrekt zu funktionieren.

```bash
chmod 600 ~/.ssh/config
```

`chmod 755 <script>` — Ausführbare Skripte und Binärdateien. Eigentümer voller Zugriff, Andere dürfen lesen und ausführen.

```bash
chmod 755 deploy.sh
```

`chmod 640 <file>` — Log- und Konfigurationsdateien. Eigentümer liest/schreibt, Gruppe liest, Andere kein Zugriff.

```bash
chmod 640 /etc/app/database.conf
```

## Optionen & Flags

`chmod -v <mode> <file>` — Ausführlicher Modus. Gibt für jede verarbeitete Datei eine Meldung aus.

```bash
chmod -v 644 *.html
```

`chmod -c <mode> <file>` — Wie ausführlich, meldet aber nur, wenn tatsächlich eine Änderung erfolgt.

```bash
chmod -c 755 scripts/*.sh
```

`chmod --reference=<ref_file> <file>` — Setzt die Rechte auf die einer Referenzdatei.

```bash
chmod --reference=template.conf new.conf
```

`chmod -R --preserve-root <mode> <directory>` — Verhindert versehentliche rekursive Änderungen am Wurzeldateisystem.

```bash
chmod -R --preserve-root 755 /var/www/
```

## Eigentümer & umask

`chown <user>:<group> <file>` — Ändert Eigentümer und Gruppe einer Datei.

```bash
chown www-data:www-data index.php
```

`chown -R <user>:<group> <directory>` — Ändert Eigentümer und Gruppe rekursiv für einen Verzeichnisbaum.

```bash
chown -R www-data:www-data /var/www/html/
```

`chgrp <group> <file>` — Ändert nur die Gruppe einer Datei.

```bash
chgrp developers project.conf
```

`umask` — Zeigt die aktuelle Dateierstellungsmaske. Sie bestimmt die Standardrechte neuer Dateien.

```bash
umask
```

`umask 022` — Setzt die umask so, dass neue Dateien 644 und neue Verzeichnisse 755 erhalten.

```bash
umask 022
```

`umask 077` — Setzt eine restriktive umask. Neue Dateien erhalten 600, neue Verzeichnisse 700.

```bash
umask 077
```

<!-- PROSE:outro -->
## Fazit

`chmod` ist das zentrale Werkzeug, um Zugriffsrechte präzise zu steuern – im Alltag reichen meist eine Handvoll Muster: `644` für Dateien, `755` für Verzeichnisse und ausführbare Skripte, `600`/`700` für private SSH- und Zugangsdaten. Greife zu symbolischer Notation (`u+x`, `go-w`), wenn du nur einzelne Bits ändern willst, und zu oktaler, wenn du den Zustand komplett festlegst. Aus Sicherheitssicht zwei Faustregeln: Vergib `777` praktisch nie – es erlaubt jedem Schreiben und Ausführen –, und sei bei `chmod -R` vorsichtig, weil es Rechte über ganze Bäume verteilt; nutze das große `X` oder getrennte `find`-Läufe, um Dateien und Verzeichnisse unterschiedlich zu behandeln. Rechte regeln nur den Zugriff – wem etwas gehört, bestimmst du mit `chown`.

## Weiterführende Links

- [GNU Coreutils: chmod](https://www.gnu.org/software/coreutils/manual/html_node/chmod-invocation.html) – offizielle Referenz zu allen Optionen (englisch)
- [ubuntuusers-Wiki: chmod](https://wiki.ubuntuusers.de/chmod/) – deutschsprachige Einführung zu Rechten und Notation
- [Wikipedia: Dateirechte (Unix)](https://de.wikipedia.org/wiki/Dateirechte) – Hintergrund zum Rechtemodell mit Beispielen
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [chown](https://www.jpkc.com/db/cheatsheets/files-text/chown/) – Eigentümer und Gruppe einer Datei ändern
- [ls](https://www.jpkc.com/db/cheatsheets/files-text/ls/) – Rechte mit ls -l anzeigen
- [stat](https://www.jpkc.com/db/cheatsheets/files-text/stat/) – Rechte detailliert in oktaler und symbolischer Form anzeigen