# Sudo deinstallieren
## 1) Ziel & Hintergrund Auf Systemen wie Kali/Debian existiert immer ein **Root-Account**. `sudo` ist ein Komfort- und Kontrollwerkzeug, um Root-Rechte selektiv an normale Benutzer zu delegieren. Diese Anleitung stellt um auf das klassische Modell: **kein `sudo`**, Adminzugriff nur über **`su -`** mit Root-Passwort.
## 2) Auswirkungen & Trade-offs
AspektMit `sudo`Mit `su -` (ohne `sudo`)
BerechtigungenFeingranular delegierbarAlles oder nichts über Root-Passwort
NachvollziehbarkeitPro-User-Logging möglichWeniger granular; Fokus auf Auth-Logs
KomfortBefehlsweise ElevationBewusster Wechsel in Root-Shell
AngriffsflächeZusätzliche Binary & PolicyWeniger Komponenten, ein Geheimnis (Root-PW)
**Merke:** Wer bereits Root-Rechte hat, kann immer das Root-Passwort ändern – unabhängig davon, ob `sudo` installiert ist. Sicherheit entsteht hier primär durch *Zugriffskontrolle*, *Härtung* und *Auditing*.
## 3) Vorbereitung (Root & Backup) 1. **Sicherstellen, dass Root aktiviert ist und ein Passwort hat**: ``` # falls aktuell noch sudo vorhanden ist: sudo passwd root # ab dann: su - ``` 2. **Backups der sudo-Konfiguration**: ``` mkdir -p /root/backup-sudo-files cp -a /etc/sudoers /root/backup-sudo-files/ 2>/dev/null || true cp -a /etc/sudoers.d /root/backup-sudo-files/ 2>/dev/null || true ```
## 4) `sudo` entfernen (Paket oder manuell) ### 4.1 Paketzuordnung prüfen ``` which sudo ls -l /usr/bin/sudo dpkg -S /usr/bin/sudo 2>/dev/null || echo "Kein dpkg-Eintrag (manuell installiert)" ``` ### 4.2 Falls als Paket installiert ``` apt update apt purge -y sudo sudo:arm64 || true apt autoremove -y ``` ### 4.3 Falls *nicht* paketverwaltet (manuell installiert)
**Vorsicht:** Nur löschen, wenn sichergestellt ist, dass `sudo` nicht von dpkg verwaltet wird.
``` cp -a /usr/bin/sudo /root/backup-sudo # Sicherung rm -v /usr/bin/sudo # Entfernen # optional: visudo entfernen, falls vorhanden [ -e /usr/bin/visudo ] && rm -v /usr/bin/visudo ```
## 5) Bereinigen von Gruppen & Resten ``` # Benutzer aus sudo-Gruppe entfernen (Beispiel: jj) deluser jj sudo # sudo-Gruppe ggf. ganz entfernen getent group sudo && delgroup sudo || true ```
Optional: `su` auf bestimmte Gruppe beschränken (`pam_wheel`) Damit nur Mitglieder einer bestimmten Gruppe (z. B. `wheel`) `su` benutzen dürfen: ``` groupadd wheel 2>/dev/null || true gpasswd -a deinadmin wheel # PAM anpassen (Zeile aktivieren): sed -i 's|^#\s*auth\s\+required\s\+pam_wheel.so\s\+use_uid|auth required pam_wheel.so use_uid|' /etc/pam.d/su ``` Damit ist *nicht* jeder lokale User zu `su` berechtigt.
## 6) Verifikation & Funktionstests ``` # Existenz prüfen command -v sudo || echo "sudo nicht gefunden (erwartet)" # als normaler Benutzer: sudo sollte scheitern sudo id || echo "OK: sudo nicht verfügbar" # Rootwechsel via su - su - -c 'id && whoami' ```
**Tipp:** Prüfe die Logs: `/var/log/auth.log` (oder Journal) sollte `su`-Events zeigen.
## 7) Warum das der Sicherheit hilft - **Reduzierte Angriffsfläche:** Entfernt eine zusätzliche, setuid-fähige Binary (`/usr/bin/sudo`) und deren Policy/Parser. - **Einheitliches Geheimnis:** Nur das Root-Passwort erlaubt Privilege Escalation. Kein Nebeneingang über falsch konfigurierte `sudoers`-Regeln. - **Bewusster Admin-Kontext:** Klare Trennung: normale Arbeit als User, gezielter Wechsel in eine Root-Login-Shell.
**Trade-off:** Du verlierst feingranulare Delegation und pro-User-Audit auf Befehlsebene. Das kompensierst du mit Auth- und `su`-Logging und ggf. `pam_wheel` (siehe nächster Abschnitt).
## 8) Zusätzliche Härtung (Best Practices) ### 8.1 SSH ``` # /etc/ssh/sshd_config anpassen: PermitRootLogin prohibit-password # Root nur per Key; oder 'no' wenn du Root-SSH ganz verbietest PasswordAuthentication no # globale Passwort-Logins aus (nur Keys) PubkeyAuthentication yes ChallengeResponseAuthentication no UsePAM yes # danach: systemctl restart ssh ```
Wenn du Root-SSH doch per Passwort brauchst Dann setze `PermitRootLogin yes` und erzwinge starke Passwörter + Fail2Ban. Besser ist dennoch: SSH-Keys + ggf. 2FA (PAM/Google Authenticator).
### 8.2 Passwortrichtlinien ``` # Beispiel: libpam-pwquality nutzen apt install -y libpam-pwquality # /etc/security/pwquality.conf anpassen (Minimallänge, Klassen, etc.) ``` ### 8.3 Auditing & Log-Monitoring ``` apt install -y auditd auditctl -l | cat # su/Passwort-Events erscheinen in /var/log/auth.log bzw. journalctl -u ssh -u systemd-logind ``` ### 8.4 Brute-Force-Schutz ``` apt install -y fail2ban # jail.local anpassen, insbesondere für sshd; dann: systemctl enable --now fail2ban ``` ### 8.5 `su` einschränken (PAM Wheel) Siehe Abschnitt 5: Nur Mitglieder von `wheel` dürfen `su` verwenden.
## 9) Rollback (sudo wiederherstellen) 1. **Neuinstallation**: ``` apt update apt install -y sudo ``` 2. **Benutzer berechtigen**: ``` usermod -aG sudo # neue Gruppenmitgliedschaft gilt nach neuem Login ``` 3. **Konfiguration prüfen**: ``` visudo # Syntaxcheck & Policy anpassen ```
## 10) Anhang: Ein-Befehl-Variante (vorsichtig!) Führt Backup, Entfernung (Paket oder manuell) und Gruppenbereinigung in einem Rutsch aus. Vorher lesen! ``` bash -c ' set -euo pipefail echo ">>> Backup"; mkdir -p /root/backup-sudo-files; cp -a /etc/sudoers /root/backup-sudo-files/ 2>/dev/null || true; cp -a /etc/sudoers.d /root/backup-sudo-files/ 2>/dev/null || true; SUDO_BIN="$(command -v sudo || true)"; if [ -n "$SUDO_BIN" ]; then echo ">>> Gefunden: $SUDO_BIN"; dpkg -S "$SUDO_BIN" &>/dev/null && { echo ">>> Paketverwaltet: apt purge"; apt update; apt purge -y sudo sudo:arm64 || true; apt autoremove -y; } || { echo ">>> Nicht paketverwaltet: manuell entfernen"; cp -a "$SUDO_BIN" /root/backup-sudo-files/; rm -v "$SUDO_BIN"; [ -e /usr/bin/visudo ] && rm -v /usr/bin/visudo || true; }; else echo ">>> sudo nicht im PATH"; fi # Beispielbenutzer anpassen: if getent group sudo &>/dev/null; then deluser jj sudo || true; delgroup sudo || true; fi echo ">>> Fertig." ' ```
**Achtung:** Passe den Benutzernamen `jj` im Script an deine Umgebung an.