> For the complete documentation index, see [llms.txt](https://hacking-notes.jord4n.pro/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hacking-notes.jord4n.pro/de/post-exploitation/linux-persistence.md).

# Linux-Persistenz

Persistenz ist die Post-Exploitation-Phase, in der der Zugriff nach der ersten Shell reproduzierbar gemacht wird. Bei realen Einsätzen verwenden Sie diese Techniken nur, wenn sie ausdrücklich im Scope sind, dokumentieren Sie jede Änderung und entfernen Sie jede Persistenz vor Abschluss des Tests.

{% hint style="warning" %}
Persistenz verändert Benutzerkonten, Anmeldepfade, geplante Aufgaben, Startdateien oder Web-Roots. Behandeln Sie jeden Befehl als Labor- oder autorisierte Prüfungsmaßnahme und führen Sie für jede Änderung eine Bereinigungsnotiz.
{% endhint %}

## Schnellübersicht

| Methode                         | Beste Verwendung                                                       | Hauptnachweis                                                        |
| ------------------------------- | ---------------------------------------------------------------------- | -------------------------------------------------------------------- |
| Manipulation von Benutzerkonten | Kontrollierte Persistenz im Labor oder Wiederherstellungstests.        | `/etc/passwd`, `/etc/shadow`, `/etc/group`, sudoers-Drop-in-Dateien. |
| SSH-autorisierte Schlüssel      | Zuverlässiger schlüsselbasierter Zugriff für einen bekannten Benutzer. | `~/.ssh/authorized_keys`, Dateiberechtigungen, SSH-Protokolle.       |
| Cron-Jobs                       | Wiederholen Sie harmlose Validierungsbefehle nach Zeitplan.            | `/etc/crontab`, `/etc/cron.d/*`, Benutzer-Crontab.                   |
| Startskripte                    | Ausführung nach Neustart oder Dienststart.                             | `/etc/rc.local`, systemd-Units, Profildateien.                       |
| Shell-Profile                   | Beim interaktiven Login auslösen.                                      | `.bashrc`, `.profile`, `/etc/profile`.                               |
| Validierung des Webzugriffs     | Schreibbare Web-Roots und serverseitige Ausführung sicher bestätigen.  | Web-Root-Datei, Zugriffsprotokolle, Webserver-Benutzer.              |

## Manipulation von Benutzerkonten

Das Erstellen eines kontrollierten Kontos ist auffällig, leicht zu erkennen und in der Regel nur in Laboren oder wenn die Einsatzregeln dies ausdrücklich erlauben, akzeptabel.

### Neuen privilegierten Benutzer erstellen

```bash
useradd -m -s /bin/bash assessment-user
usermod -aG sudo assessment-user
passwd assessment-user
```

Debian/Ubuntu:

```bash
adduser assessment-user sudo
```

CentOS/RHEL:

```bash
usermod -aG wheel assessment-user
```

### Einen vorhandenen Benutzer ändern

```bash
usermod -s /bin/bash user
usermod -aG sudo user
echo "user ALL=(ALL:ALL) ALL" > /etc/sudoers.d/user
chmod 440 /etc/sudoers.d/user
passwd user
```

### Validieren und bereinigen

```bash
id assessment-user
groups assessment-user
sudo -l -U assessment-user
```

Bereinigung:

```bash
deluser assessment-user sudo 2>/dev/null
userdel -r assessment-user
rm -f /etc/sudoers.d/user
```

## SSH-Persistenz

SSH-Schlüssel-Persistenz ist sauberer als Passwortänderungen, aber in der Integritätsüberwachung von Dateien und in SSH-Protokollen dennoch sehr sichtbar.

### Autorisierte Schlüssel

Für einen normalen Benutzer:

```bash
mkdir -p /home/user/.ssh
echo "ssh-rsa AAAAB3NzaC1yc2EA... assessment-key" >> /home/user/.ssh/authorized_keys
chmod 700 /home/user/.ssh
chmod 600 /home/user/.ssh/authorized_keys
chown -R user:user /home/user/.ssh
```

Für root, nur wenn ausdrücklich autorisiert:

```bash
mkdir -p /root/.ssh
echo "ssh-rsa AAAAB3NzaC1yc2EA... assessment-key" >> /root/.ssh/authorized_keys
chmod 700 /root/.ssh
chmod 600 /root/.ssh/authorized_keys
```

### Zusätzlicher SSH-Port

Das Hinzufügen eines zweiten Ports ist auffällig und sollte klar dokumentiert werden:

```bash
echo "Port 22" >> /etc/ssh/sshd_config
echo "Port 2222" >> /etc/ssh/sshd_config
systemctl restart sshd
```

Validierung:

```bash
ss -tuln | grep ':22\|:2222'
ssh -i id_rsa user@target -p 2222
```

Bereinigung:

```bash
sed -i '/Port 2222/d' /etc/ssh/sshd_config
systemctl restart sshd
```

## Cron-Persistenz

Cron-Persistenz ist in Laboren nützlich, da sie leicht zu demonstrieren und leicht zu entfernen ist. In realen Umgebungen werden Cron-Jobs oft überwacht.

### Systemweiter Cron

```bash
echo "* * * * * root /opt/assessment/validate-access.sh" >> /etc/crontab
```

### Benutzer-Cron

```bash
(crontab -l 2>/dev/null; echo "* * * * * /opt/assessment/validate-access.sh") | crontab -
```

### `/etc/cron.d`

```bash
echo "* * * * * root /opt/assessment/validate-access.sh" > /etc/cron.d/system-update
chmod 644 /etc/cron.d/system-update
```

Bereinigung:

```bash
crontab -l | grep -v '/opt/assessment/validate-access.sh' | crontab -
rm -f /etc/cron.d/system-update
sed -i '/validate-access.sh/d' /etc/crontab
```

## Startskripte

Start-Persistenz läuft nach dem Start oder während der Initialisierung von Login/Sitzung.

### `rc.local`

```bash
cat > /etc/rc.local <<'EOF'
#!/bin/bash
/opt/assessment/validate-access.sh &
exit 0
EOF
chmod +x /etc/rc.local
```

### Shell-Profile

Benutzerprofil:

```bash
echo "nohup /opt/assessment/validate-access.sh >/dev/null 2>&1 &" >> ~/.bashrc
```

Globales Profil:

```bash
echo "nohup /opt/assessment/validate-access.sh >/dev/null 2>&1 &" >> /etc/profile
```

Bereinigung:

```bash
sed -i '/validate-access.sh/d' ~/.bashrc
sed -i '/validate-access.sh/d' /etc/profile
rm -f /etc/rc.local
```

## Validierung des Webzugriffs

Ein schreibbarer Web-Root kann reproduzierbaren Zugriff ermöglichen, wenn der Server hochgeladenen Code ausführt. Speichern Sie keine live Web-Shell-Payloads in Notizen; dokumentieren Sie stattdessen den Pfad, die Laufzeitumgebung, die Validierungsanfrage, Protokolle und die Bereinigung.

### Sicheres Dokumentationsmuster

| Feld                | Beispiel                                                                                         |
| ------------------- | ------------------------------------------------------------------------------------------------ |
| Web-Root            | `/var/www/html/` oder `/srv/www/`                                                                |
| Schreibbarer Pfad   | `/var/www/html/images/`                                                                          |
| Laufzeitumgebung    | PHP, Python CGI, ASPX, JSP                                                                       |
| Testdateiname       | Ein klar gekennzeichneter Prüfungsdateiname                                                      |
| Validierungsanfrage | Eine harmlose Anfrage, die serverseitige Ausführung belegt, z. B. die Rückgabe der aktuellen UID |
| Bereinigungsbefehl  | Exakter Löschbefehl und zu prüfende Protokollpfade                                               |

### Bereitstellungs-Checkliste

```bash
ls -la /var/www/ /srv/www/ 2>/dev/null
find /var/www /srv/www -type d -writable 2>/dev/null
find /var/www /srv/www -type f -mtime -1 -ls 2>/dev/null
```

Die Validierung sollte die Ausführung mit der möglichst wenig invasiven Aktion belegen und die Datei danach sofort entfernen.

Bereinigung:

```bash
rm -f /path/to/authorized-test-file
find /var/www /srv/www -type f -mtime -1 -ls 2>/dev/null
grep -R "authorized-test" /var/log/apache2 /var/log/httpd /var/log/nginx 2>/dev/null
```

## Notizen zum Reporting

Festhalten:

1. Verwendete genaue Persistenzmethode.
2. Geänderte Dateipfade.
3. Benutzer, Gruppe und Berechtigungen vorher und nachher.
4. Validierungsbefehl und Ergebnis.
5. Bereinigungsbefehl und Bestätigung.

## Schnelle Bereinigungs-Checkliste

```bash
grep -R "assessment-key\|validate-access.sh\|authorized-test" /etc /home /root /var/www /srv/www 2>/dev/null
find /etc/cron* -type f -mtime -7 -ls 2>/dev/null
find /var/www /srv/www -type f -mtime -7 -ls 2>/dev/null
last
journalctl -u ssh -n 100 2>/dev/null
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://hacking-notes.jord4n.pro/de/post-exploitation/linux-persistence.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
