> 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/fr/post-exploitation/linux-persistence.md).

# Persistance Linux

La persistance est la phase post-exploitation où l’accès est rendu répétable après le premier shell. Dans des engagements réels, n’utilisez ces techniques que lorsqu’elles sont explicitement dans le périmètre, documentez chaque changement et supprimez toute persistance avant de clôturer le test.

{% hint style="warning" %}
La persistance modifie les comptes utilisateurs, les chemins de connexion, les tâches planifiées, les fichiers de démarrage ou les racines web. Traitez chaque commande comme une action de labo ou d’évaluation autorisée et conservez une note de nettoyage pour chaque changement que vous effectuez.
{% endhint %}

## Carte rapide

| Méthode                            | Meilleure utilisation                                                                  | Preuve principale                                                       |
| ---------------------------------- | -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| Manipulation de compte utilisateur | Persistance contrôlée en labo ou test de récupération.                                 | `/etc/passwd`, `/etc/shadow`, `/etc/group`, compléments sudoers.        |
| Clés autorisées SSH                | Accès fiable par clé pour un utilisateur connu.                                        | `~/.ssh/authorized_keys`, permissions des fichiers, journaux SSH.       |
| Tâches cron                        | Répéter des commandes de validation bénignes selon un calendrier.                      | `/etc/crontab`, `/etc/cron.d/*`, crontab utilisateur.                   |
| Scripts de démarrage               | Exécution après redémarrage ou démarrage du service.                                   | `/etc/rc.local`, unités systemd, fichiers de profil.                    |
| Profils de shell                   | Déclenchement à la connexion interactive.                                              | `.bashrc`, `.profile`, `/etc/profile`.                                  |
| Validation de l’accès web          | Confirmer en toute sécurité les racines web inscriptibles et l’exécution côté serveur. | Fichier de la racine web, journaux d’accès, utilisateur du serveur web. |

## Manipulation de compte utilisateur

Créer un compte contrôlé est bruyant, facile à détecter et généralement acceptable uniquement en labo ou lorsque les règles d’engagement l’autorisent explicitement.

### Créer un nouvel utilisateur privilégié

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

### Modifier un utilisateur existant

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

### Valider et nettoyer

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

Nettoyage :

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

## Persistance SSH

La persistance par clé SSH est plus propre que les changements de mot de passe, mais reste très visible dans la surveillance d’intégrité des fichiers et les journaux SSH.

### Clés autorisées

Pour un utilisateur normal :

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

Pour root, uniquement si cela est explicitement autorisé :

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

### Port SSH secondaire

Ajouter un second port est bruyant et doit être clairement documenté :

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

Validation :

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

Nettoyage :

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

## Persistance Cron

La persistance via cron est utile en labo parce qu’elle est facile à démontrer et à supprimer. Dans les environnements réels, les tâches cron sont souvent surveillées.

### Cron système

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

### Cron utilisateur

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

Nettoyage :

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

## Scripts de démarrage

La persistance au démarrage s’exécute après le boot ou pendant l’initialisation de la connexion/session.

### `rc.local`

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

### Profils de shell

Profil utilisateur :

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

Profil global :

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

Nettoyage :

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

## Validation de l’accès web

Une racine web inscriptible peut fournir un accès répétable si le serveur exécute le code téléversé. Ne stockez pas de charges actives de web shell dans les notes ; documentez plutôt le chemin, le runtime, la requête de validation, les journaux et le nettoyage.

### Modèle de documentation sûre

| Champ                  | Exemple                                                                                     |
| ---------------------- | ------------------------------------------------------------------------------------------- |
| Racine web             | `/var/www/html/` ou `/srv/www/`                                                             |
| Chemin inscriptible    | `/var/www/html/images/`                                                                     |
| Runtime                | PHP, Python CGI, ASPX, JSP                                                                  |
| Nom de fichier de test | Un nom de fichier d’évaluation clairement indiqué                                           |
| Requête de validation  | Une requête bénigne qui prouve l’exécution côté serveur, par exemple retourner l’UID actuel |
| Commande de nettoyage  | Commande exacte de suppression et chemins des journaux à examiner                           |

### Liste de vérification du déploiement

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

La validation doit prouver l’exécution avec l’action la moins intrusive possible, puis supprimer immédiatement le fichier.

Nettoyage :

```bash
rm -f /path/to/authorized-test-file
find /var/www /srv/www -type f -mtime -1 -ls 2>/dev/null
grep -R "assessment-key\|validate-access.sh\|authorized-test" /var/log/apache2 /var/log/httpd /var/log/nginx 2>/dev/null
```

## Notes de rapport

Enregistrer :

1. La méthode de persistance exacte utilisée.
2. Les chemins de fichiers modifiés.
3. Utilisateur, groupe et permissions avant et après.
4. La commande de validation et le résultat.
5. La commande de nettoyage et la confirmation.

## Liste de contrôle rapide du nettoyage

```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/fr/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.
