# 🧭 Crumbpage 01: Linux User, Gruppen & Rechte

**Subtitle:** *Wer bin ich, was darf ich - die Identität im Wald*  
**Pfad:** 1 von 8  
**Schwierigkeit:** ⭐⭐ (Einsteiger-freundlich)  
**Zeit:** ~2-3 Stunden  
**Voraussetzungen:** Keine - das ist der Start!

> *"Jeder Wanderer braucht einen Namen, jeder Name braucht Rechte, und jede Datei einen Beschützer."* 🌲

---

## 📋 Was du in diesem Pfad lernst

```
✓ User-Identität im Linux-System
✓ Home-Verzeichnis und wichtige Pfade
✓ Gruppen und ihre Bedeutung
✓ Das Rechte-System (rwx)
✓ Berechtigungen ändern (chmod, chown, chgrp)
✓ Sichere Praktiken für User-Management
```

---

## 🎯 Lernziele

Nach diesem Pfad kannst du:

- [ ] Deine User-ID und Gruppen identifizieren
- [ ] Dateiberechtigungen lesen und verstehen
- [ ] Berechtigungen sicher ändern
- [ ] Den Unterschied zwischen Owner, Group und Others erklären
- [ ] Häufige Permission-Fehler selbst beheben

---

## 🌱 Grundkonzepte

### Konzept 1: Du im System - Identität

**Was ist das?**

Jeder Prozess und jede Aktion in Linux hat eine **Identität**:
- Einen **User** (UID = User ID)
- Eine oder mehrere **Gruppen** (GID = Group ID)
- Einen **Home-Ordner** (dein persönlicher Platz)

**Warum ist das wichtig?**

```bash
# Ohne Identitäts-System:
Jeder könnte alles lesen, ändern, löschen → Chaos! 💥

# Mit Identitäts-System:
Jeder hat seinen Bereich, klare Grenzen → Ordnung! ✅
```

**Wie funktioniert es?**

```bash
# Wer bin ich?
$ whoami
keksmann

# Detaillierte Info
$ id
uid=1000(keksmann) gid=1000(keksmann) groups=1000(keksmann),27(sudo),100(users)

# Was bedeutet das?
uid=1000          → Deine eindeutige User-ID
gid=1000          → Deine primäre Gruppe
groups=...        → Alle Gruppen, in denen du Mitglied bist
```

---

### Konzept 2: Das Home-Verzeichnis

**Was ist das?**

Dein **Home** ist dein persönlicher Ordner im System:

```bash
# Wo ist mein Home?
$ echo $HOME
/home/keksmann

# Alternative
$ pwd  # wenn du gerade dort bist
/home/keksmann

# Schnell nach Hause
$ cd    # ohne Argument → direkt nach $HOME
$ cd ~  # ~ ist Abkürzung für $HOME
```

**Struktur eines typischen Home:**

```
/home/keksmann/
├── .bashrc           # Shell-Konfiguration
├── .ssh/             # SSH-Keys (wichtig!)
│   ├── id_rsa        # Private Key (GEHEIM!)
│   ├── id_rsa.pub    # Public Key (teilbar)
│   └── authorized_keys
├── .config/          # App-Konfigurationen
├── Documents/        # Deine Dokumente
├── Downloads/        # Downloads
└── projects/         # Deine Projekte
```

**⚠️ Wichtig:**

```bash
# Dateien die mit . beginnen sind "hidden"
$ ls          # Zeigt NICHT .bashrc, .ssh, etc.
$ ls -a       # Zeigt ALLES (a = all)
$ ls -la      # Zeigt ALLES mit Details
```

---

### Konzept 3: Gruppen - Gemeinsam stark

**Was ist das?**

Gruppen erlauben es, **mehreren Usern gemeinsam Zugriff** zu geben:

```bash
# Meine Gruppen anzeigen
$ groups
keksmann sudo docker www-data

# Was bedeutet das?
keksmann  → Meine persönliche Gruppe
sudo      → Darf sudo verwenden (Admin-Rechte)
docker    → Darf Docker nutzen
www-data  → Kann Webserver-Dateien lesen
```

**Warum ist das wichtig?**

```bash
# Scenario: Webseite bearbeiten
# Ohne Gruppe:
- Nur root darf Webseite ändern → Unsicher!

# Mit Gruppe:
- User ist in Gruppe 'www-data'
- Webseiten-Ordner gehört www-data
- Mehrere User können sicher zusammenarbeiten ✅
```

---

### Konzept 4: Das rwx-System

**Was ist das?**

Jede Datei/Ordner hat **3 Berechtigungs-Ebenen**:

```
r = read    (lesen)
w = write   (schreiben)
x = execute (ausführen)
```

Für **3 Kategorien** von Usern:

```
u = user   (Owner/Besitzer)
g = group  (Gruppe)
o = others (Alle anderen)
```

**Wie liest man das?**

```bash
$ ls -l myscript.sh
-rwxr-xr-- 1 keksmann developer 1024 Dec 06 15:30 myscript.sh
│││││││││
││││││││└─ others: r-- (nur lesen)
│││││└──── group: r-x (lesen, ausführen)
│││└────── user: rwx (alles)
││└──────── Anzahl Links
│└───────── Owner: keksmann
└────────── File Type (- = regular file)
```

**Visualisierung:**

```
-rwxr-xr--
 │  │  │
 │  │  └─── Others:  r-- (read only)
 │  └────── Group:   r-x (read, execute)
 └───────── User:    rwx (read, write, execute)
```

**Bei Ordnern:**

```
drwxr-xr-x 2 keksmann developer 4096 Dec 06 15:30 mydir/
│
└─ d = directory

Ordner-Rechte:
r = Darf Inhalte listen (ls)
w = Darf Dateien erstellen/löschen
x = Darf in Ordner wechseln (cd)
```

---

## 🔧 Praktische Befehle

### Befehl 1: `whoami` - Wer bin ich?

```bash
# Zeigt aktuellen Username
$ whoami
keksmann
```

**Anwendungsfall:**
```bash
# In Skripten prüfen ob root
if [ "$(whoami)" != "root" ]; then
    echo "Bitte als root ausführen!"
    exit 1
fi
```

---

### Befehl 2: `id` - Detaillierte Identität

```bash
# Vollständige User-Info
$ id
uid=1000(keksmann) gid=1000(keksmann) groups=1000(keksmann),27(sudo),999(docker)

# Nur UID anzeigen
$ id -u
1000

# Nur GID anzeigen
$ id -g
1000

# Info über anderen User
$ id root
uid=0(root) gid=0(root) groups=0(root)
```

---

### Befehl 3: `groups` - Meine Gruppen

```bash
# Eigene Gruppen
$ groups
keksmann sudo docker

# Gruppen eines anderen Users
$ groups www-data
www-data : www-data
```

---

### Befehl 4: `ls -la` - Dateien mit Rechten

```bash
# Detaillierte Datei-Auflistung
$ ls -la
total 48
drwxr-xr-x  5 keksmann keksmann 4096 Dec  6 15:30 .
drwxr-xr-x 20 root     root     4096 Dec  1 10:00 ..
-rw-------  1 keksmann keksmann  220 Dec  1 09:00 .bash_history
-rw-r--r--  1 keksmann keksmann  807 Dec  1 09:00 .bashrc
drwx------  2 keksmann keksmann 4096 Dec  2 12:00 .ssh
-rwxr-xr-x  1 keksmann keksmann  512 Dec  6 15:30 myscript.sh
-rw-r--r--  1 keksmann keksmann 1024 Dec  5 14:20 notes.txt

# Nur Dateien mit bestimmtem Muster
$ ls -l *.txt
-rw-r--r-- 1 keksmann keksmann 1024 Dec  5 14:20 notes.txt

# Nur Verzeichnisse
$ ls -ld */
drwx------ 2 keksmann keksmann 4096 Dec  2 12:00 .ssh/
```

---

### Befehl 5: `chmod` - Rechte ändern

**Syntax:**

```bash
chmod [WHO][OPERATOR][PERMISSIONS] file

WHO:
u = user (owner)
g = group
o = others
a = all (u+g+o)

OPERATOR:
+ = hinzufügen
- = entfernen
= = exakt setzen

PERMISSIONS:
r = read
w = write
x = execute
```

**Beispiele (Symbolisch):**

```bash
# User: executable hinzufügen
$ chmod u+x script.sh

# Group: write entfernen
$ chmod g-w document.txt

# Others: alle Rechte entfernen
$ chmod o-rwx secret.txt

# Allen: read geben
$ chmod a+r public.txt

# Exakt setzen: User=rwx, Group=rx, Others=r
$ chmod u=rwx,g=rx,o=r file.txt
```

**Beispiele (Numerisch):**

```bash
# Jede Permission ist eine Zahl:
r = 4
w = 2
x = 1

# Kombinationen addieren:
rwx = 4+2+1 = 7
rw- = 4+2+0 = 6
r-x = 4+0+1 = 5
r-- = 4+0+0 = 4
--- = 0+0+0 = 0

# Beispiele:
chmod 755 script.sh
      │││
      ││└─ Others: r-x (5)
      │└── Group:  r-x (5)
      └─── User:   rwx (7)

chmod 644 document.txt
      │││
      ││└─ Others: r-- (4)
      │└── Group:  r-- (4)
      └─── User:   rw- (6)

chmod 600 secret.txt
      │││
      ││└─ Others: --- (0)
      │└── Group:  --- (0)
      └─── User:   rw- (6)

chmod 700 private_folder/
      │││
      ││└─ Others: --- (0)
      │└── Group:  --- (0)
      └─── User:   rwx (7)
```

**Rekursiv (für Ordner):**

```bash
# Alle Dateien in Ordner ändern
$ chmod -R 755 my_folder/

# ⚠️ VORSICHT: Ändert ALLE Dateien rekursiv!
```

---

### Befehl 6: `chown` - Owner ändern

**Syntax:**

```bash
chown [OWNER][:GROUP] file

# Beispiele:
chown keksmann file.txt              # Nur Owner ändern
chown keksmann:developer file.txt    # Owner und Group
chown :developer file.txt            # Nur Group ändern
```

**Praktische Beispiele:**

```bash
# Website-Ordner an Webserver übergeben
$ sudo chown -R www-data:www-data /var/www/html/

# Datei übernehmen
$ sudo chown keksmann:keksmann downloaded_file.txt

# Nur Group ändern (siehe nächster Befehl)
$ sudo chown :developer project_folder/
```

**⚠️ Wichtig:**

```bash
# chown braucht meist sudo (wenn du nicht Owner bist)
$ chown keksmann file.txt        # ❌ Permission denied
$ sudo chown keksmann file.txt   # ✅ Funktioniert
```

---

### Befehl 7: `chgrp` - Nur Group ändern

```bash
# Group ändern
$ chgrp developer file.txt

# Rekursiv
$ chgrp -R www-data /var/www/project/

# Ist gleichbedeutend mit:
$ chown :www-data /var/www/project/
```

---

## 💡 Best Practices

### DO ✅

```bash
# 1. Skripte executable machen
$ chmod +x myscript.sh
$ ./myscript.sh  # Kann jetzt direkt ausgeführt werden

# 2. Secrets schützen
$ chmod 600 ~/.ssh/id_rsa         # Nur Owner kann lesen
$ chmod 700 ~/.ssh/                # Nur Owner kann zugreifen

# 3. Shared Folders
$ sudo chgrp developers /opt/shared
$ sudo chmod 770 /opt/shared       # Group kann voll zugreifen

# 4. Web-Content
$ sudo chown -R www-data:www-data /var/www/html/
$ sudo chmod 755 /var/www/html/    # Ordner: alle können lesen
$ sudo chmod 644 /var/www/html/*.html  # Dateien: nur Owner schreibt
```

### DON'T ❌

```bash
# 1. NIEMALS alles auf 777 setzen
$ chmod -R 777 /  # 💀 EXTREM GEFÄHRLICH!

# Warum? 777 bedeutet:
# - Jeder kann alles lesen, schreiben, ausführen
# - Zero Security
# - Perfekt für Hacker

# 2. Nicht als root arbeiten wenn nicht nötig
$ sudo chmod 777 important_file  # ❌ Overkill
$ chmod 755 important_file       # ✅ Ausreichend

# 3. Keine Secrets mit group/other-Rechten
$ chmod 644 api_key.txt  # ❌ Group + Others können lesen
$ chmod 600 api_key.txt  # ✅ Nur Owner kann lesen

# 4. Nicht blind rekursiv
$ chmod -R 777 folder/   # ❌ Alles unsicher
# Besser: Gezielt einzelne Dateien/Ordner
```

---

## 🎓 Hands-On Übungen

### Übung 1: Lerne dich selbst kennen

**Aufgabe:**  
Finde heraus wer du bist, wo dein Home ist, und in welchen Gruppen du Mitglied bist.

**Schritte:**

```bash
# Schritt 1: Username
$ whoami

# Schritt 2: Detaillierte Info
$ id

# Schritt 3: Gruppen
$ groups

# Schritt 4: Home-Verzeichnis
$ echo $HOME
$ cd ~
$ pwd

# Schritt 5: Hidden Files im Home
$ ls -la ~
```

**Erwartetes Ergebnis:**

```
$ whoami
keksmann

$ id
uid=1000(keksmann) gid=1000(keksmann) groups=1000(keksmann),27(sudo)

$ groups
keksmann sudo

$ echo $HOME
/home/keksmann
```

---

### Übung 2: Test-Dateien erstellen und Rechte verstehen

**Aufgabe:**  
Erstelle Test-Dateien und lerne Rechte zu lesen.

**Schritte:**

```bash
# Schritt 1: Test-Ordner erstellen
$ mkdir ~/rechte-test
$ cd ~/rechte-test

# Schritt 2: Verschiedene Dateien erstellen
$ touch public.txt
$ touch private.txt
$ touch script.sh

# Schritt 3: Rechte anschauen
$ ls -l

# Schritt 4: Rechte setzen
$ chmod 644 public.txt   # Alle können lesen
$ chmod 600 private.txt  # Nur ich kann lesen
$ chmod 755 script.sh    # Alle können lesen/ausführen

# Schritt 5: Ergebnis prüfen
$ ls -l
```

**Erwartetes Ergebnis:**

```bash
$ ls -l
-rw-r--r-- 1 keksmann keksmann 0 Dec  6 15:30 public.txt
-rw------- 1 keksmann keksmann 0 Dec  6 15:30 private.txt
-rwxr-xr-x 1 keksmann keksmann 0 Dec  6 15:30 script.sh
```

---

### Übung 3: Symbolische vs. Numerische chmod

**Aufgabe:**  
Setze die gleichen Rechte einmal symbolisch, einmal numerisch.

**Schritte:**

```bash
# Datei erstellen
$ touch test1.txt
$ touch test2.txt

# Symbolisch: User=rw, Group=r, Others=r
$ chmod u=rw,g=r,o=r test1.txt

# Numerisch: 644 (rw-r--r--)
$ chmod 644 test2.txt

# Vergleichen
$ ls -l test*.txt
```

**Erwartetes Ergebnis:**

```bash
-rw-r--r-- 1 keksmann keksmann 0 Dec  6 15:30 test1.txt
-rw-r--r-- 1 keksmann keksmann 0 Dec  6 15:30 test2.txt
# Beide identisch!
```

**Lösungsweg:**

<details>
<summary>Klick hier für detaillierte Erklärung</summary>

```bash
# 644 ausrechnen:
User:   rw- = 4+2+0 = 6
Group:  r-- = 4+0+0 = 4
Others: r-- = 4+0+0 = 4
Ergebnis: 644

# Symbolisch:
u=rw  → User kann read+write
g=r   → Group kann nur read
o=r   → Others kann nur read
```

</details>

---

### Übung 4: Secure Secrets

**Aufgabe:**  
Simuliere das Absichern eines API-Keys.

**Schritte:**

```bash
# Schritt 1: "API Key" Datei erstellen
$ echo "super-secret-api-key-123" > ~/api_key.txt

# Schritt 2: Standard-Rechte anschauen (meist 644)
$ ls -l ~/api_key.txt

# Schritt 3: Rechte lockern (FALSCH!)
$ chmod 644 ~/api_key.txt
$ cat ~/api_key.txt  # Jeder in Group kann lesen!

# Schritt 4: Richtig absichern
$ chmod 600 ~/api_key.txt
$ ls -l ~/api_key.txt

# Schritt 5: Testen (als anderer User würde cat fehlschlagen)
```

**Erwartetes Ergebnis:**

```bash
$ ls -l ~/api_key.txt
-rw------- 1 keksmann keksmann 25 Dec  6 15:30 /home/keksmann/api_key.txt
        └─ Nur Owner kann lesen/schreiben!
```

---

## 🐛 Häufige Fehler & Lösungen

### Fehler 1: "Permission denied" beim Ausführen

**Symptom:**

```bash
$ ./myscript.sh
bash: ./myscript.sh: Permission denied
```

**Ursache:**  
Datei hat kein `x` (execute) Flag.

**Diagnose:**

```bash
$ ls -l myscript.sh
-rw-r--r-- 1 keksmann keksmann 512 Dec  6 15:30 myscript.sh
          └─ Kein 'x' vorhanden!
```

**Lösung:**

```bash
# Execute-Recht hinzufügen
$ chmod +x myscript.sh

# Oder numerisch
$ chmod 755 myscript.sh

# Jetzt funktioniert es
$ ./myscript.sh
Hello World!
```

---

### Fehler 2: "Permission denied" beim Lesen

**Symptom:**

```bash
$ cat secret.txt
cat: secret.txt: Permission denied
```

**Ursache:**  
Du bist nicht Owner, oder Datei hat kein `r` Flag für deine Kategorie.

**Diagnose:**

```bash
$ ls -l secret.txt
-rw------- 1 root root 100 Dec  6 15:30 secret.txt
│││││││││
│└─ User (root): rw-
└── Group (root): ---
    Others: ---

# Du bist nicht root → Kein Zugriff!
```

**Lösung (wenn du zugriffsberechtigt sein solltest):**

```bash
# Option 1: Owner auf dich ändern (braucht sudo)
$ sudo chown keksmann:keksmann secret.txt

# Option 2: Datei in 'developers' Gruppe und du bist Mitglied
$ sudo chgrp developers secret.txt
$ sudo chmod 640 secret.txt  # Group kann lesen
```

---

### Fehler 3: "Operation not permitted" bei chown

**Symptom:**

```bash
$ chown keksmann file.txt
chown: changing ownership of 'file.txt': Operation not permitted
```

**Ursache:**  
Nur root oder der aktuelle Owner darf Owner ändern.

**Lösung:**

```bash
# Mit sudo
$ sudo chown keksmann file.txt
```

---

### Fehler 4: SSH Key wird nicht akzeptiert

**Symptom:**

```bash
$ ssh server
Permission denied (publickey).
```

**Ursache oft:**  
SSH-Keys haben falsche Rechte (zu offen).

**Diagnose:**

```bash
$ ls -la ~/.ssh/
-rw-rw-rw- 1 keksmann keksmann 1679 Dec  1 10:00 id_rsa  # ❌ ZU OFFEN!
```

**Lösung:**

```bash
# Private Keys müssen 600 sein
$ chmod 600 ~/.ssh/id_rsa
$ chmod 644 ~/.ssh/id_rsa.pub
$ chmod 700 ~/.ssh/

# Jetzt sollte SSH funktionieren
$ ssh server
```

---

### Fehler 5: "Cannot create directory: Permission denied"

**Symptom:**

```bash
$ mkdir /opt/myapp
mkdir: cannot create directory '/opt/myapp': Permission denied
```

**Ursache:**  
Du hast keine Write-Rechte im Parent-Verzeichnis.

**Diagnose:**

```bash
$ ls -ld /opt
drwxr-xr-x 5 root root 4096 Dec  1 10:00 /opt
        │││
        │││ Others: r-x (kein 'w'!)
        ││└─ Group: r-x
        │└── User (root): rwx
```

**Lösung:**

```bash
# Option 1: Mit sudo
$ sudo mkdir /opt/myapp

# Option 2: Owner/Group ändern (einmalig)
$ sudo chown keksmann:developers /opt
$ mkdir /opt/myapp  # Jetzt funktioniert es

# Option 3: Im eigenen Home arbeiten
$ mkdir ~/myapp
```

---

## 🔍 Troubleshooting Checkliste

Wenn du Permissions-Probleme hast:

```bash
# 1. Bin ich der richtige User?
$ whoami
$ id

# 2. Was sind die aktuellen Rechte?
$ ls -la /path/to/file

# 3. Wer ist Owner?
$ ls -l /path/to/file
-rw-r--r-- 1 OWNER GROUP ...
              ↑     ↑

# 4. Bin ich in der Group?
$ groups | grep GROUP_NAME

# 5. Was brauche ich? (read/write/execute)
$ # Lesen?   → Need 'r'
$ # Schreiben? → Need 'w'
$ # Ausführen/CD? → Need 'x'

# 6. Kann ich die Rechte ändern?
$ chmod ... file    # Als Owner
$ sudo chmod ... file  # Mit Admin-Rechten

# 7. Muss ich Owner ändern?
$ sudo chown USER:GROUP file
```

---

## 🎯 Skill-Check

Bevor du zum nächsten Pfad gehst:

**Grundlagen:**
- [ ] Ich kann `whoami` und `id` benutzen
- [ ] Ich verstehe was UID/GID bedeutet
- [ ] Ich weiß wo mein $HOME ist
- [ ] Ich kann hidden files anzeigen (`ls -la`)

**Rechte lesen:**
- [ ] Ich kann `-rwxr-xr--` interpretieren
- [ ] Ich verstehe den Unterschied zwischen File und Directory Rechten
- [ ] Ich erkenne Owner, Group und Others in `ls -l` output

**Rechte setzen:**
- [ ] Ich kann `chmod` symbolisch nutzen (u+x, g-w, etc.)
- [ ] Ich kann `chmod` numerisch nutzen (755, 644, etc.)
- [ ] Ich verstehe wann ich `chown` vs. `chgrp` nutze

**Security:**
- [ ] Ich weiß warum 777 gefährlich ist
- [ ] Ich kann Secrets richtig absichern (600)
- [ ] Ich nutze `sudo` nur wenn nötig

**Troubleshooting:**
- [ ] Ich kann "Permission denied" Fehler debuggen
- [ ] Ich weiß wie ich die Checkliste anwende

**Wenn 12/12 ✅**: Du bist ready für Pfad 2!  
**Wenn <12 ✅**: Wiederhole die Übungen

---

## 📚 Weiterführende Links

### Intern (Crumbforest)
- [Admin-Vektor Übersicht](crumbforest-admin-vektor.md)
- [Nächster Pfad: Hostinformation →](crumbpage-02-hostinfo.md)

### Extern
- [Linux File Permissions Explained](https://www.redhat.com/sysadmin/linux-file-permissions-explained)
- [chmod Calculator](https://chmod-calculator.com/)
- [Understanding Linux Users and Groups](https://www.linode.com/docs/guides/linux-users-and-groups/)

---

## 💭 Deine Notizen

**Was war neu für mich?**

```
[Platz für deine Notizen]
```

**Was war schwierig?**

```
[Platz für deine Notizen]
```

**Eigene chmod-Beispiele die ich brauche:**

```bash
# Beispiel:
chmod 755 /path/to/my/script.sh  # Mein Use-Case: ...
```

---

## 🦉 Crystal Owl's Weisheit

```
      🦉
     /💙\
    /_||_\
   /  ||  \
  
"Rechte sind wie Schlüssel zu Türen.
 Gib nicht jedem jeden Schlüssel.
 
 Ein 600er Schloss schützt Geheimnisse.
 Ein 755er Schloss teilt Wissen sicher.
 Ein 777er Schloss? Das ist keine Tür mehr,
 das ist ein Tor zur Katastrophe."
```

**Krümel-Tipp:**

```bash
# Erstelle dir ein chmod-cheatsheet
$ cat > ~/chmod-cheatsheet.txt << 'EOF'
### Mein chmod Cheatsheet ###

Skripte executable:      chmod +x script.sh
Secrets verstecken:      chmod 600 api_key.txt
SSH Keys:                chmod 600 ~/.ssh/id_rsa
Web-Content (Ordner):    chmod 755 /var/www/html/
Web-Content (Dateien):   chmod 644 /var/www/html/*.html
Shared Dev Folder:       chmod 770 /opt/shared/

Nie verwenden:           chmod 777 (alles offen!)
EOF

$ chmod 600 ~/chmod-cheatsheet.txt  # Selbst auch schützen!
```

---

## 🎮 Bonus: Advanced Topics

<details>
<summary>Klick für fortgeschrittene Themen</summary>

### SetUID und SetGID Bits

```bash
# SetUID (Set User ID):
# Datei wird mit Owner-Rechten ausgeführt, egal wer sie startet
$ chmod u+s /usr/bin/passwd
$ ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root ...
    ↑ 's' statt 'x'

# Numerisch: 4755 (4 = SetUID Bit)
$ chmod 4755 binary

# SetGID (Set Group ID):
# Für Ordner: Neue Dateien erben die Group des Ordners
$ chmod g+s /shared/project/
$ chmod 2775 /shared/project/  # 2 = SetGID Bit
```

### Sticky Bit

```bash
# Auf Ordnern: Nur Owner kann eigene Dateien löschen
# Perfekt für /tmp und shared folders
$ chmod +t /shared/public/
$ chmod 1777 /shared/public/  # 1 = Sticky Bit

$ ls -ld /tmp
drwxrwxrwt ...
         ↑ 't' = Sticky Bit
```

### ACLs (Access Control Lists)

```bash
# Feinere Kontrolle als rwx
$ setfacl -m u:keksmann:rwx file.txt   # Specific user
$ setfacl -m g:developers:r-x file.txt # Specific group
$ getfacl file.txt                     # ACLs anzeigen
```

### Immutable Files

```bash
# Datei kann nicht geändert/gelöscht werden (auch nicht von root!)
$ sudo chattr +i important.conf
$ sudo chattr -i important.conf  # Wieder änderbar machen
$ lsattr important.conf          # Attribute anzeigen
```

</details>

---

**Version:** 1.0  
**Letzte Änderung:** 2024-12-06  
**Maintainer:** Crumbforest Core Team  
**Feedback:** [GitHub Issues](#) | [Discord](#)

---

**Navigation:**  
[← Zurück: Vektor-Übersicht](crumbforest-admin-vektor.md) | [Weiter: Pfad 2: Hostinformation →](crumbpage-02-hostinfo.md)

---

*🌲 Glückwunsch! Du hast den ersten Pfad gemeistert. Der Wald liegt vor dir.* 🦉💙
