Kali Linux Root User aktivieren: Schritt-für-Schritt

3. Oktober 2025 Christian Tipps & Tricks
Kali Linux Root User aktivieren

In diesem kurzen Guide zeigen wir in klaren step-Anweisungen, wie Sie in kali linux den root‑Login sicher handhaben. Ziel ist, temporäre und dauerhafte Optionen verständlich darzustellen und Sicherheitsaspekte zu erläutern.

Moderne Installationen starten standardmäßig ohne direkten root‑Zugang und legen einen normalen user an. Administrative Aufgaben laufen über sudo, um security‑Risiken zu reduzieren.

Temporär erhöhen Sie Rechte mit Befehlen wie:

$ sudo su
$ su -
$ whoami

Für dauerhafte Nutzung setzen Sie ein Root‑Passwort und installieren bei Bedarf das Paket für grafische Logins. Beispiele:

$ sudo passwd
$ sudo apt install kali-root-login

Für SSH steuert die Direktive PermitRootLogin in /etc/ssh/sshd_config den Zugang; Standard ist prohibit-password. Nach Änderungen den Dienst neu starten:

$ grep PermitRootLogin /etc/ssh/sshd_config
$ sudo systemctl restart ssh

Hinweis: Das alte Default‑Passwort „toor“ gilt nicht mehr. Wir erklären im weiteren Verlauf, wie Sie Root‑Sessions minimieren und statt Passwort lieber Schlüssel‑Authentifizierung für Netzwerk‑login nutzen.

Warum und wann den Root-User in Kali Linux nutzen

Bevor Sie dauerhaft mit erhöhten Rechten arbeiten, lohnt sich eine klare Entscheidung, ob temporäre Elevation ausreicht oder ein dauerhafter Zugang sinnvoll ist.

Die Standard‑Policy moderner Versionen deaktiviert direkten root‑Login, um die Angriffsfläche zu reduzieren. Temporäre Rechte bieten oft eine bessere Balance zwischen Komfort und Sicherheit.https://www.youtube.com/watch?v=EVk5vq_0vkE

Suchintention klären: dauerhaft vs. temporär

Fragen Sie sich: Müssen Sie wiederholt administrative Tasks ausführen oder sind es einzelne Änderungen? Für einmalige Anpassungen ist sudo meist ausreichend.

Bei längeren Admin‑Sitzungen kann der root user Vorteile bieten, etwa bei umfangreichen Konfigurationsarbeiten oder automatisierten Tools, die keinen interaktiven sudo‑Flow unterstützen.

Sicherheit und Standard-Policy

  • Default-Einstellung verhindert direkten Login, um Fehlkonfigurationen zu vermeiden.
  • Dauerhafte Sessions beschleunigen Workflows, erhöhen jedoch das Risiko bei Fehlbedienung.
  • Temporäre Elevation reduziert das Risiko, da Sie den Kontext gezielt wechseln und wieder verlassen.

Als Entscheidungshilfe: use root nur dauerhaft, wenn Automatisierung oder wiederholte Low‑Level‑Änderungen den interaktiven sudo‑Flow stören. Andernfalls bleiben Sie im normalen account und nutzen sudo.

Konkrete Anpassungen wie ein gesetztes Root‑Passwort, die Option für GUI‑Login oder die PermitRootLogin‑Konfiguration für SSH werden in späteren Abschnitten erklärt. Alle Schritte sind reversibel; nach Abschluss empfiehlt sich die Rückkehr zum normalen account, um die security zu maximieren.

Weitere Hinweise zur SSH‑Konfiguration und Aktivierung finden Sie in einem passenden Guide zur Verbindungseinstellung: SSH aktivieren und absichern.

Kali Linux Root User aktivieren: Voraussetzungen, Risiken und Alternativen

Starten Sie mit einer schnellen Systemprüfung, damit spätere Änderungen sicher gelingen.

Voraussetzungen prüfen

Stellen Sie sicher, dass ein eingerichteter user vorhanden ist, Paketquellen aktiviert und das Netzwerk erreichbar ist. Nur so lassen sich nötige Pakete installieren.

Prüfen Sie die Umgebung mit einfachen commands:

$ whoami

$ sudo -v

$ sudo apt update

Temporär erhöhen statt dauerhaft

Nutzen Sie für einzelne Aufgaben sudo vor Befehlen. Für eine Shell verwenden Sie sudo su (fragt das Benutzerpasswort) oder su - (fragt das root password).

Siehe auch  Linux Port Forwarding mit Iptables

Beenden Sie eine erhöhte Session stets mit exit oder STRG+D, um das Risiko zu senken.

Sicherheits-Hinweise und Dateien

Für ein dauerhaftes root account setzen Sie zuerst ein starkes password mit:

$ sudo passwd

Für GUI-Login installiert das package kali-root-login, das u. a. /etc/pam.d/gdm-password und /etc/sddm.conf anpasst.

Begrenzen Sie die Zeit im root-Kontext, dokumentieren Änderungen und nutzen Logs sowie Versionskontrolle für kritische files.

Schritt-für-Schritt: Root-Account aktivieren und Passwort setzen

Die folgenden Schritte zeigen, wie Sie ein neues password setzen, das GUI‑login erlauben und den Zugang prüfen. Führen Sie jeden Befehl in einer Terminal‑Session aus und achten Sie auf korrekte Eingabe.

  1. Root‑Passwort setzen:


    $ sudo passwd
    [sudo] password for kali:
    New password:
    Retype new password:
    passwd: password updated successfullyDie Passwort‑Eingabe wird nicht angezeigt. Merken Sie sich das neue password sicher.

  2. GUI‑Login erlauben (GNOME/KDE/SDDM):$ sudo apt -y install kali-root-loginDieses package passt PAM‑ und Display‑Manager‑Dateien an. Danach ist ein direkter login mit dem root account möglich.


  3. Login testen und Konto verifizieren:Abmelden → Anmeldung als root mit dem gesetzten Passwort → im Terminal:
    $ whoamiDie Ausgabe sollte root zeigen. Beenden Sie die Session sofort nach Arbeiten mit exit oder STRG+D.

  4. Häufige Stolpersteine:

    • Das alte Default‑passwort „toor“ existiert nicht mehr.
    • Passwort‑Prompts zeigen beim Tippen keine Zeichen an — das ist normal.

Als Ergänzung für temporäre Rechte nutzen Sie alternative commands wie sudo su oder su -. Für tiefergehende Anpassungen und Beispiele siehe auch die Anleitung zur XBMC‑Konfiguration: XBMC‑Konfiguration.

Root-Login per SSH einrichten und absichern

Remote‑Zugriff auf ein administratives Konto verlangt klare Schritte. Prüfen Sie zuerst die aktuelle SSH‑Einstellung:

$ sudo grep PermitRootLogin /etc/ssh/sshd_config

Oft steht dort eine auskommentierte Zeile wie #PermitRootLogin prohibit-password. Die Direktive akzeptiert yes, prohibit-password, forced-commands-only oder no. Wählen Sie eine Option passend zum Einsatzzweck.

Schlüssel-Login bevorzugen

Richten Sie ein SSH‑Schlüsselpaar für das root account ein und pflegen Sie ~/.ssh/authorized_keys. Setzen Sie dann PermitRootLogin prohibit-password, um Logins nur per Key zu erlauben.

  • Konfiguration editieren: $ sudo nano /etc/ssh/sshd_config
  • Dienst neu starten: $ sudo systemctl restart ssh
  • Verifikation: $ man sshd_config | grep -C 1 PermitRootLogin

Falls Passwort‑Login kurzfristig nötig ist, ändern Sie auf yes und setzen das Feld danach zurück. Dokumentieren alle Änderungen in Ihren files und nutzen Fail2ban, Firewall‑Regeln und AllowUsers‑Blöcke zur Härtung.

Für eine Schritt‑für‑Schritt‑Anleitung zur SSH‑Konfiguration siehe die praktische Anleitung zum SSH aktivieren. Arbeiten Sie grundsätzlich mit sudo, wenn kein dauerhafter SSH‑Zugang zum administrativen Konto nötig ist.

Sicher weiterarbeiten: Best Practices für Root-Nutzung in der Praxis

Mit einfachen Regeln behalten Sie Kontrolle beim enabling root und minimieren Fehler.

Arbeiten Sie nur kurz mit erhöhten privileges und verlassen Sie die Session sofort:
$ exit.

Setzen Sie ein starkes password für das root account per:
$ sudo passwd, und rotieren Sie Passwörter regelmäßig.

Nutzen Sie SSH‑Keys statt Passwort für remote login und stellen Sie danach PermitRootLogin wieder restriktiv ein.

Versionieren Sie Änderungen in /etc mit Git, markieren Sie Commits mit Zweck und Zeit.

Siehe auch  Barrierefreie Technik - Wie moderne Geräte Hörgeschädigten helfen

Deinstallieren Sie unnötige packages für GUI‑Logins, wenn sie nicht gebraucht werden:

$ sudo apt purge kali-root-login.

Führen Sie regelmäßige Updates durch und auditieren Sie superuser‑Zugänge:

#!/usr/bin/env bash
# Kali: Auto-Updates + Superuser-Audit einrichten
# Ausführen als root

set -euo pipefail

# ---- Verzeichnisse ----
install -d -m 0750 /usr/local/sbin
install -d -m 0750 /var/log/auto_update
install -d -m 0750 /var/log/sudo_audit

# ---- Update-Skript ----
cat >/usr/local/sbin/kali-regular-update.sh <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

LOG_DIR="/var/log/auto_update"
LOG_FILE="$LOG_DIR/$(date +%F)-update.log"

{
  echo "===== KALI REGELMÄSSIGES UPDATE ====="
  echo "Zeitpunkt: $(date --iso-8601=seconds)"
  echo "Hostname:  $(hostname -f || hostname)"
  echo "-------------------------------------"
  apt-get update
  # Vollständiges Upgrade (inkl. Kernel & große Sprünge)
  DEBIAN_FRONTEND=noninteractive apt-get -y full-upgrade
  apt-get -y autoremove --purge
  apt-get -y autoclean
  echo "-------------------------------------"
  echo "Fertig: $(date --iso-8601=seconds)"
} | tee -a "$LOG_FILE"

# Optional: Neustart nur wenn Kernel/Essentials betroffen (Kommentar entfernen, wenn gewünscht)
# if [ -f /var/run/reboot-required ]; then
#   systemctl reboot
# fi
EOF
chmod 0750 /usr/local/sbin/kali-regular-update.sh

# ---- Audit-Skript ----
cat >/usr/local/sbin/kali-sudo-audit.sh <<'EOF'
#!/usr/bin/env bash
set -euo pipefail

OUT_DIR="/var/log/sudo_audit"
OUT_FILE="$OUT_DIR/$(date +%F)-superuser-audit.txt"
TMP="$(mktemp)"
trap 'rm -f "$TMP"' EXIT

exec >"$TMP" 2>&1

echo "===== SUPERUSER / SUDO AUDIT ====="
echo "Zeitpunkt:  $(date --iso-8601=seconds)"
echo "Hostname:   $(hostname -f || hostname)"
echo "OS:         $(grep PRETTY_NAME /etc/os-release | cut -d= -f2 | tr -d \")"
echo

echo "== Mitglieder der Gruppe 'sudo' =="
getent group sudo || true
echo

echo "== Mitglieder der Gruppe 'adm' (Logzugriff) =="
getent group adm || true
echo

echo "== Alle Accounts mit UID 0 (Root-Äquivalent) =="
awk -F: '$3==0 {printf "- %s (Shell: %s)\n",$1,$7}' /etc/passwd
echo

echo "== Sudoers-Dateien & Berechtigungen =="
namei -om /etc/sudoers || true
for f in /etc/sudoers.d /etc/sudoers.d/*; do
  [ -e "$f" ] && namei -om "$f"
done
echo

echo "== Einträge mit NOPASSWD (passwortloses sudo) =="
grep -R --line-number --with-filename -E '(^|[[:space:]])NOPASSWD([[:space:]]|:|,|$)' /etc/sudoers /etc/sudoers.d 2>/dev/null || echo "Keine NOPASSWD-Regeln gefunden."
echo

echo "== SSH Root-Login Einstellung(en) =="
grep -HiE '^\s*PermitRootLogin' /etc/ssh/sshd_config /etc/ssh/sshd_config.d/*.conf 2>/dev/null || echo "Kein explizites PermitRootLogin gefunden (Default: meist 'prohibit-password')."
echo

echo "== Letzte Sudo-Verwendungen (30 Tage) =="
# Journal vorhanden?
if journalctl --version >/dev/null 2>&1; then
  journalctl --since "30 days ago" -g "sudo:" 2>/dev/null || true
  echo
  echo "== 'su' / Root-Wechsel (30 Tage) =="
  journalctl --since "30 days ago" -g "session opened for user root" 2>/dev/null || true
else
  # Fallback über auth.log
  zgrep -hEi 'sudo:|session opened for user root|su\[' /var/log/auth.log* 2>/dev/null | tail -n 500 || true
fi
echo

echo "== Letzte Logins der Sudo-User =="
SUDO_USERS=$(getent group sudo | awk -F: '{print $4}' | tr -s ',' ' ' || true)
if [ -n "${SUDO_USERS:-}" ]; then
  # lastlog -u erwartet durch Leerzeichen getrennte Liste
  lastlog -u $SUDO_USERS || true
else
  echo "Keine Mitglieder in der Gruppe 'sudo' gefunden."
fi
echo

echo "== Anomalien: systemweite Accounts mit Login-Shell =="
awk -F: '($3<1000 && $7 ~ /(bash|zsh|sh)$/){printf "- %s (UID %s, Shell %s)\n",$1,$3,$7}' /etc/passwd || true
echo

install -m 0640 "$TMP" "$OUT_FILE"
echo "Audit geschrieben nach: $OUT_FILE"
EOF
chmod 0750 /usr/local/sbin/kali-sudo-audit.sh

# ---- systemd Unit + Timer: Updates (wöchentlich) ----
cat >/etc/systemd/system/kali-regular-update.service <<'EOF'
[Unit]
Description=Kali: Wöchentliches System-Update
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
ExecStart=/usr/local/sbin/kali-regular-update.sh
Nice=10
IOSchedulingClass=best-effort
IOSchedulingPriority=6
EOF

cat >/etc/systemd/system/kali-regular-update.timer <<'EOF'
[Unit]
Description=Kali: Wöchentliches System-Update (Timer)

[Timer]
OnCalendar=Sun *-*-* 03:05:00
RandomizedDelaySec=45m
Persistent=true

[Install]
WantedBy=timers.target
EOF

# ---- systemd Unit + Timer: Audit (täglich) ----
cat >/etc/systemd/system/kali-sudo-audit.service <<'EOF'
[Unit]
Description=Kali: Tägliches Superuser-/Sudo-Audit
After=systemd-user-sessions.service

[Service]
Type=oneshot
ExecStart=/usr/local/sbin/kali-sudo-audit.sh
Nice=10
IOSchedulingClass=best-effort
IOSchedulingPriority=6
EOF

cat >/etc/systemd/system/kali-sudo-audit.timer <<'EOF'
[Unit]
Description=Kali: Tägliches Superuser-/Sudo-Audit (Timer)

[Timer]
OnCalendar=*-*-* 03:10:00
RandomizedDelaySec=30m
Persistent=true

[Install]
WantedBy=timers.target
EOF

# ---- Aktivieren & einmalig starten ----
systemctl daemon-reload
systemctl enable --now kali-regular-update.timer
systemctl enable --now kali-sudo-audit.timer

# Optionale Einmalläufe jetzt starten:
systemctl start kali-regular-update.service || true
systemctl start kali-sudo-audit.service   || true

echo "Setup fertig.
- Update-Logs:   /var/log/auto_update/YYYY-MM-DD-update.log
- Audit-Reports: /var/log/sudo_audit/YYYY-MM-DD-superuser-audit.txt
- Timer prüfen:  systemctl list-timers | grep kali-
"
Über Christian 415 Artikel
34 Jahre alt, gebürtig aus Cuxhaven und bekennender Kaffeejunkie :-). Ich interessiere mich schon seit meiner Kindheit für Technik. Dieses Interesse übertrage ich in meinem beruflichen Leben sowie im Privaten. Viel Spaß beim Stöbern!
Webseite