# Dateiberechtigungen - chmod und chown

Verwaltung von Zugriffsrechten, Eigentümern und Gruppen in Linux.

## Rechte-System in Linux

Jede Datei hat:
- **Eigentümer (Owner)** - der Benutzer, dem die Datei gehört
- **Gruppe (Group)** - eine Benutzergruppe
- **Zugriffsrechte** für drei Bereiche:
  - **u** (user) = Eigentümer
  - **g** (group) = Gruppe
  - **o** (others) = Andere

Jeder Bereich hat drei Rechte:
- **r** (read) = Lesen (4)
- **w** (write) = Schreiben (2)
- **x** (execute) = Ausführen (1)

## Rechte anzeigen

```bash
ls -l datei.txt
```

Ausgabe:
```
-rw-r--r-- 1 alice developers 1234 Nov 7 10:00 datei.txt
```

- Position 1: Dateityp (`-` = Datei, `d` = Verzeichnis, `l` = Link)
- Position 2-4: User-Rechte (`rw-`)
- Position 5-7: Group-Rechte (`r--`)
- Position 8-10: Other-Rechte (`r--`)
- `alice` = Eigentümer
- `developers` = Gruppe

## chmod - Zugriffsrechte ändern

### Symbolische Notation

```bash
chmod [ugoa][+-=][rwx] datei
```

**Rechte hinzufügen:**
```bash
chmod u+x script.sh         # Eigentümer: ausführbar
chmod g+w datei.txt         # Gruppe: schreibbar
chmod o+r datei.txt         # Andere: lesbar
chmod a+x script.sh         # Alle: ausführbar
```

**Rechte entfernen:**
```bash
chmod u-x script.sh         # Eigentümer: nicht ausführbar
chmod g-w datei.txt         # Gruppe: nicht schreibbar
chmod o-r datei.txt         # Andere: nicht lesbar
```

**Rechte setzen (überschreiben):**
```bash
chmod u=rw,g=r,o= datei.txt    # User: rw, Group: r, Others: keine
chmod a=r datei.txt            # Alle: nur lesen
```

### Numerische Notation (Oktal)

Rechte als dreistellige Oktalzahl:

| Wert | Rechte | Bedeutung |
|------|--------|-----------|
| 0 | `---` | Keine Rechte |
| 1 | `--x` | Ausführen |
| 2 | `-w-` | Schreiben |
| 3 | `-wx` | Schreiben + Ausführen |
| 4 | `r--` | Lesen |
| 5 | `r-x` | Lesen + Ausführen |
| 6 | `rw-` | Lesen + Schreiben |
| 7 | `rwx` | Alle Rechte |

**Häufige Kombinationen:**
```bash
chmod 644 datei.txt        # rw-r--r-- (Standard für Dateien)
chmod 755 script.sh        # rwxr-xr-x (Standard für Scripts)
chmod 700 privat.key       # rwx------ (Nur Eigentümer)
chmod 600 ~/.ssh/id_rsa    # rw------- (SSH-Schlüssel)
chmod 777 verzeichnis      # rwxrwxrwx (Alle Rechte - UNSICHER!)
```

Beispiel: `chmod 755` bedeutet:
- User: 7 (rwx)
- Group: 5 (r-x)
- Others: 5 (r-x)

### Rekursiv

```bash
chmod -R 755 /pfad/zum/verzeichnis
```

**Nur Verzeichnisse oder nur Dateien:**
```bash
find . -type d -exec chmod 755 {} +    # Alle Verzeichnisse
find . -type f -exec chmod 644 {} +    # Alle Dateien
```

### Spezielle Rechte

**Sticky Bit** (nur Eigentümer kann löschen):
```bash
chmod +t /tmp               # Symbolic
chmod 1777 verzeichnis      # Numeric (rwxrwxrwt)
```

**SUID** (läuft mit Rechten des Eigentümers):
```bash
chmod u+s /usr/bin/passwd   # Symbolic
chmod 4755 datei            # Numeric (rwsr-xr-x)
```

**SGID** (neue Dateien erben Gruppe):
```bash
chmod g+s verzeichnis       # Symbolic
chmod 2755 verzeichnis      # Numeric (rwxr-sr-x)
```

### Praktische Beispiele

**Script ausführbar machen:**
```bash
chmod +x meinscript.sh
./meinscript.sh
```

**SSH-Verzeichnis absichern:**
```bash
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_rsa
chmod 644 ~/.ssh/id_rsa.pub
chmod 600 ~/.ssh/authorized_keys
```

**Web-Verzeichnis:**
```bash
chmod -R 755 /var/www/html
find /var/www/html -type f -exec chmod 644 {} +
find /var/www/html -type d -exec chmod 755 {} +
```

**Projekt-Verzeichnis:**
```bash
chmod -R u+rwX,g+rX,o-rwx projektordner
```

(`X` = ausführbar nur für Verzeichnisse)

## chown - Eigentümer und Gruppe ändern

### Grundsyntax

```bash
chown [OPTIONEN] EIGENTÜMER[:GRUPPE] DATEI
```

### Eigentümer ändern

```bash
chown alice datei.txt
```

### Eigentümer und Gruppe ändern

```bash
chown alice:developers datei.txt
```

### Nur Gruppe ändern

```bash
chown :developers datei.txt
```

Oder mit `chgrp`:
```bash
chgrp developers datei.txt
```

### Rekursiv

```bash
chown -R alice:developers /pfad/zum/verzeichnis
```

### Von anderem Benutzer übernehmen

```bash
chown --reference=referenzdatei zieldatei
```

### Praktische Beispiele

**Web-Server Verzeichnis:**
```bash
sudo chown -R www-data:www-data /var/www/html
```

**Home-Verzeichnis korrigieren:**
```bash
sudo chown -R alice:alice /home/alice
```

**Nach Copy von Root:**
```bash
sudo cp /root/datei.txt /home/alice/
sudo chown alice:alice /home/alice/datei.txt
```

**Nur Dateien, nicht Verzeichnisse:**
```bash
find /pfad -type f -exec chown alice:developers {} +
```

**Nur bei Bedarf ändern:**
```bash
find /pfad ! -user alice -exec chown alice {} +
find /pfad ! -group developers -exec chgrp developers {} +
```

### Symbolische Links

Standardmäßig ändert `chown` das Ziel des Links:

```bash
chown alice symlink  # ändert Ziel
chown -h alice symlink  # ändert nur den Link selbst
```

## Kombinierte Anwendung

### Berechtigungen komplett setzen

```bash
sudo chown -R www-data:www-data /var/www/html
sudo find /var/www/html -type d -exec chmod 755 {} +
sudo find /var/www/html -type f -exec chmod 644 {} +
```

### Projekt-Setup

```bash
sudo chown -R alice:developers /opt/projekt
chmod -R u+rwX,g+rwX,o-rwx /opt/projekt
```

### Backup wiederherstellen

```bash
sudo tar -xpf backup.tar.gz  # -p bewahrt Rechte
sudo chown -R alice:alice /home/alice/restored/
```

## Berechtigungen prüfen

```bash
ls -l datei.txt              # Einfache Ansicht
stat datei.txt               # Detaillierte Info
getfacl datei.txt            # ACLs anzeigen (falls gesetzt)
```

## Eigentümer-ID statt Name

```bash
chown 1000:1000 datei.txt    # Verwendet UID und GID direkt
```

UIDs anzeigen:
```bash
id alice                     # UID und GIDs von alice
```

## Fehler vermeiden

### Rekursive Änderungen testen

```bash
# Erst anzeigen
find /pfad -ls

# Dann ändern
sudo chown -R alice:developers /pfad
```

### NIEMALS auf Root-Verzeichnis

```bash
# GEFÄHRLICH - bricht System
sudo chown -R user:user /              # NIEMALS!
sudo chmod -R 777 /                    # NIEMALS!

# Nur eigene Verzeichnisse
sudo chown -R user:user /home/user
```

### Zu permissive Rechte

```bash
# FALSCH - macht alles ausführbar
chmod -R 777 verzeichnis    # NICHT verwenden!

# RICHTIG - differenziert
find verzeichnis -type d -exec chmod 755 {} +
find verzeichnis -type f -exec chmod 644 {} +
```

### Systemdateien

```bash
# Wichtige Systemdateien sollten root gehören
ls -l /etc/passwd /etc/shadow
# -rw-r--r-- 1 root root ... /etc/passwd
# -rw-r----- 1 root shadow ... /etc/shadow
```

## Mit sudo

`chown` erfordert meist Root-Rechte:

```bash
sudo chown root:root /etc/wichtig.conf
sudo chmod 644 /etc/wichtig.conf
```

Ohne sudo:
```bash
# Nur eigene Dateien
chmod 644 meine_datei.txt

# chown nur als root
chown alice datei.txt  # Permission denied (außer eigene Datei)
```

## Zusammenfassung

| Befehl | Zweck | Beispiel |
|--------|-------|----------|
| `chmod` | Rechte ändern | `chmod 755 script.sh` |
| `chown` | Eigentümer ändern | `chown alice:developers file` |
| `chgrp` | Nur Gruppe ändern | `chgrp developers file` |
| `ls -l` | Rechte anzeigen | `ls -l file` |
| `stat` | Details anzeigen | `stat file` |

**Standard-Rechte:**
- Dateien: `644` (rw-r--r--)
- Scripts: `755` (rwxr-xr-x)
- Verzeichnisse: `755` (rwxr-xr-x)
- Private Dateien: `600` (rw-------)

## Siehe auch

- [[IT-Know-How/Linux/BASH Basics/find]] - Dateien mit bestimmten Rechten/Eigentümern finden
- [[IT-Know-How/Linux/BASH Basics/ls]] - Rechte und Eigentümer anzeigen
- [[IT-Know-How/Linux/BASH Basics/Symlinks]] - Links bleiben bei chown erhalten
- [[IT-Know-How/Linux/BASH Basics/tar]] - Rechte in Archiven bewahren
- [[IT-Know-How/Linux/BASH Basics/rsync]] - Rechte bei Synchronisation