🧭 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?

# 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?

# 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:

# 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:

# 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:

# 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?

# 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?

$ 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?

# Zeigt aktuellen Username
$ whoami
keksmann

Anwendungsfall:

# 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

# 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

# Eigene Gruppen
$ groups
keksmann sudo docker

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

Befehl 4: ls -la - Dateien mit Rechten

# 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:

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):

# 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):

# 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):

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

# ⚠️ VORSICHT: Ändert ALLE Dateien rekursiv!

Befehl 6: chown - Owner ändern

Syntax:

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:

# 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:

# 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

# 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 ✅

# 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 ❌

# 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:

# 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:

# 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:

$ 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:

# 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:

-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:

# 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

Übung 4: Secure Secrets

Aufgabe:
Simuliere das Absichern eines API-Keys.

Schritte:

# 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:

$ 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:

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

Ursache:
Datei hat kein x (execute) Flag.

Diagnose:

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

Lösung:

# 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:

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

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

Diagnose:

$ 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):

# 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:

$ 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:

# Mit sudo
$ sudo chown keksmann file.txt

Fehler 4: SSH Key wird nicht akzeptiert

Symptom:

$ ssh server
Permission denied (publickey).

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

Diagnose:

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

Lösung:

# 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:

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

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

Diagnose:

$ 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:

# 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:

# 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
• Nächster Pfad: Hostinformation →

Extern

• Linux File Permissions Explained
• chmod Calculator
• Understanding 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:

# 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:

# 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

# 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

# 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

# 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

# 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

Version: 1.0
Letzte Änderung: 2024-12-06
Maintainer: Crumbforest Core Team
Feedback: GitHub Issues | Discord

Navigation:
← Zurück: Vektor-Übersicht | Weiter: Pfad 2: Hostinformation →

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