Solution Complète : Operation End Game (TryHackMe)

Table des matières

1. Reconnaissance
2. Énumération des services
3. Analyse des données
4. Détection des menaces
5. Analyse forensique
6. Investigation avancée
7. Réponse aux incidents

---

Reconnaissance

Étape 1 : Accès à la machine

Connexion SSH :

ssh <username>@<IP_CIBLE>

Alternative avec mot de passe :

ssh -o StrictHostKeyChecking=no <username>@<IP_CIBLE>

Explications :
- -o StrictHostKeyChecking=no : Accepte automatiquement la clé d'hôte

Étape 2 : Énumération du système

Commandes de base :

# Informations système
uname -a
cat /etc/os-release
cat /etc/issue

# Utilisateur actuel
whoami
id
groups

# Répertoire courant
pwd
ls -la

# Vérifier les droits sudo
sudo -l

Étape 3 : Vérification des fichiers d'accueil

Commandes :

# Chercher les flags ou indices
ls -la
cat README
cat note.txt
cat flag.txt

# Chercher les fichiers spéciaux
find ~ -name "*.txt" -o -name "*.md" -o -name "flag*"

# Vérifier le bureau
ls -la ~/Desktop/
ls -la ~/Documents/

Résultat attendu :

Operation End Game - Forensic Challenge
Start your investigation from here...

---

Énumération des services

Étape 4 : Scan des services actifs

Commandes :

# Processus en cours d'exécution
ps aux
ps aux | grep -v grep | head -20

# Services
systemctl status
systemctl list-units --type service

# Ports en écoute
netstat -tulpn
ss -tulpn
netstat -tulpn | grep LISTEN

# Connexions réseau
netstat -an
ss -an
ss -an | grep ESTABLISHED

Étape 5 : Recherche de fichiers suspects

Commandes :

# Fichiers modifiés récemment
find / -mtime -7 2>/dev/null | head -50
find / -mtime -1 2>/dev/null | head -50

# Fichiers accessibles en temps réel
find / -mmin -60 2>/dev/null

# Fichiers exécutables suspects
find / -type f -executable 2>/dev/null | grep -v "/bin\|/sbin\|/usr"

# Fichiers cachés
find ~ -name ".*" -type f
ls -la ~/

# Fichiers dans /tmp
ls -la /tmp/
ls -la /var/tmp/
ls -la /dev/shm/

Étape 6 : Vérification des répertoires courants

Commandes :

# Répertoire home
ls -la ~/
find ~ -type f -not -path '*/\.*'

# Bureau et documents
ls -la ~/Desktop/
ls -la ~/Documents/
ls -la ~/Downloads/

# Répertoires temps réel
ls -la /tmp/
ls -la /var/tmp/

# Répertoires système
ls -la /var/www/
ls -la /var/log/
ls -la /root/

---

Analyse des données

Étape 7 : Examen des logs système

Fichiers de logs importants :

# Logs système
tail -100 /var/log/syslog
tail -100 /var/log/auth.log
tail -100 /var/log/kern.log

# Logs d'authentification
last
lastlog
w
who

# Logs d'accès SSH
tail -100 /var/log/auth.log | grep ssh
grep "Failed password" /var/log/auth.log

# Logs Apache (si serveur web)
tail -100 /var/log/apache2/access.log
tail -100 /var/log/apache2/error.log

Chercher les connexions suspectes :

# Connexions SSH
grep "sshd" /var/log/auth.log
grep "sshd" /var/log/auth.log | grep "Failed"
grep "sshd" /var/log/auth.log | grep "Accepted"

# Sessions sudo
grep "sudo" /var/log/auth.log

# Changements de mot de passe
grep "password changed" /var/log/auth.log

Étape 8 : Analyse des utilisateurs

Commandes :

# Lister tous les utilisateurs
cat /etc/passwd
cat /etc/passwd | cut -d: -f1

# Utilisateurs avec shell
grep -E ":/bin/(bash|sh)" /etc/passwd

# Utilisateurs système vs utilisateurs réels
grep -E ":[0-9]{4,}:" /etc/passwd

# Utilisateurs dans les groupes sudo
grep -E "^sudo:" /etc/group
getent group sudo

# Utilisateurs avec clés SSH
for user in $(cut -f1 -d: /etc/passwd); do
    if [ -d "/home/$user/.ssh" ]; then
        echo "Clés SSH trouvées pour: $user"
        ls -la /home/$user/.ssh/
    fi
done

Chercher les utilisateurs suspects :

# Comptes créés récemment
stat /etc/shadow | grep Modify
stat /etc/passwd | grep Modify

# Utilisateurs modifiés
lastlog

# Utilisateurs actifs
w
users

Étape 9 : Analyse des processus

Commandes :

# Tous les processus
ps aux

# Processus par utilisateur
ps aux | grep <username>

# Arborescence des processus
pstree

# Processus avec leurs fichiers ouverts
lsof

# Fichiers ouverts par un processus
lsof -p <PID>

# Ports ouverts avec processus
lsof -i

# Fichiers réseau
lsof -i -P -n | grep LISTEN

Chercher les processus suspects :

# Processus sans parent visible
ps aux | grep -v "PPID"

# Processus exécutés depuis /tmp
ps aux | grep /tmp

# Processus cachés (zombie)
ps aux | grep defunct

# Processus d'arrière-plan
jobs -l
bg

Étape 10 : Analyse des tâches cron

Commandes :

# Cron du root
sudo crontab -l

# Cron de l'utilisateur
crontab -l

# Tous les crons
for user in $(cut -f1 -d: /etc/passwd); do
    echo "=== Crontab de $user ==="
    crontab -u $user -l 2>/dev/null
done

# Fichiers cron
cat /etc/crontab
ls -la /etc/cron.d/
ls -la /etc/cron.daily/
ls -la /etc/cron.hourly/
ls -la /etc/cron.weekly/
ls -la /etc/cron.monthly/

# Analyser les tâches cron
grep CRON /var/log/syslog
grep CRON /var/log/auth.log

---

Détection des menaces

Étape 11 : Recherche de rootkits et malwares

Commandes :

# Vérifier les binaires système modifiés
find /bin -newer /boot 2>/dev/null
find /sbin -newer /boot 2>/dev/null
find /usr/bin -newer /boot 2>/dev/null
find /usr/sbin -newer /boot 2>/dev/null

# Chercher les fichiers modifiés
find / -mtime -1 2>/dev/null | grep -v /proc | grep -v /sys

# Fichiers suspects
strings /bin/* | grep -i "shell\|backdoor\|malware"

# Rootkits courants
chkrootkit
rkhunter --check --report-warnings-only

# Analyser les binaires
file /bin/bash
ls -la /bin/bash
stat /bin/bash

Étape 12 : Vérification des permissions SUID/SGID

Commandes :

# Fichiers SUID
find / -perm -4000 -type f 2>/dev/null

# Fichiers SGID
find / -perm -2000 -type f 2>/dev/null

# Fichiers SUID/SGID suspects
find / -perm -4000 -o -perm -2000 2>/dev/null | grep -v "/bin\|/sbin\|/usr"

# Vérifier les permissions
ls -la /usr/bin/sudo
ls -la /bin/su
ls -la /usr/bin/passwd

# Comparer avec les bases de données
debsums -c

Étape 13 : Analyse des connexions réseau

Commandes :

# Connexions actives
netstat -an
ss -an

# Connexions établies
netstat -an | grep ESTABLISHED
ss -an | grep ESTABLISHED

# Connexions en écoute
netstat -tulpn
ss -tulpn

# Connexions suspectes
lsof -i -P -n | grep LISTEN

# Résolutions DNS
cat /etc/hosts
cat /etc/resolv.conf

# Cache DNS
systemd-resolve --statistics

Étape 14 : Recherche de backdoors et droits d'accès

Commandes :

# SSH autorisées
cat ~/.ssh/authorized_keys
cat /root/.ssh/authorized_keys

# Fichiers sudo
cat /etc/sudoers
cat /etc/sudoers.d/*

# Groupes avec privilèges
getent group sudo
getent group wheel
getent group admin

# Shells autorisés
cat /etc/shells

# Accès FTP
cat /etc/vsftpd.conf 2>/dev/null

# Accès telnet/rsh
ls -la /etc/rsh*

---

Analyse forensique

Étape 15 : Examen des fichiers système critiques

Commandes :

# Fichiers modifiés
stat /etc/passwd
stat /etc/shadow
stat /etc/sudoers
stat /etc/hosts

# Vérifier l'intégrité
debsums
apt list --installed | md5sum

# Fichiers système
ls -la /etc/
ls -la /boot/

# Permissions système
find / -perm -777 2>/dev/null | head -20

# Fichiers monde-accessible
find / -perm -002 -type f 2>/dev/null | head -20

Étape 16 : Analyse du système de fichiers

Commandes :

# Espace disque
df -h
du -sh /*

# Fichiers grands
find / -type f -size +100M 2>/dev/null

# Fichiers récemment modifiés
find / -mtime -7 2>/dev/null | sort
find / -mtime -1 2>/dev/null | sort

# Recherche par taille
find / -size +50M -size -100M 2>/dev/null

# Récupérer les inodes modifiés
find / -inum <inode> 2>/dev/null

Étape 17 : Analyse des fichiers de configuration

Commandes :

# Fichiers de configuration modifiés
find /etc -mtime -7 2>/dev/null

# SSH configuration
cat /etc/ssh/sshd_config
diff /etc/ssh/sshd_config /etc/ssh/sshd_config.original 2>/dev/null

# Résolveur DNS
cat /etc/resolv.conf
cat /etc/resolvconf.conf 2>/dev/null

# Apache/Nginx
cat /etc/apache2/apache2.conf 2>/dev/null
cat /etc/nginx/nginx.conf 2>/dev/null

# MySQL/PostgreSQL
cat /etc/mysql/my.cnf 2>/dev/null
cat /etc/postgresql/main/postgresql.conf 2>/dev/null

Étape 18 : Analyse des scripts de démarrage

Commandes :

# Startup scripts
ls -la /etc/init.d/
ls -la /etc/rc*.d/

# Systemd services
ls -la /etc/systemd/system/
ls -la /lib/systemd/system/

# Cron jobs
cat /etc/crontab
ls -la /etc/cron.d/

# Bash startup
cat ~/.bashrc
cat ~/.bash_profile
cat /etc/bashrc
cat /etc/profile

---

Investigation avancée

Étape 19 : Analyse des logs avec grep

Commandes :

# Chercher tous les accès SSH réussis
grep "Accepted" /var/log/auth.log
grep "Accepted password" /var/log/auth.log

# Chercher les tentatives échouées
grep "Failed password" /var/log/auth.log
grep "Invalid user" /var/log/auth.log

# Chercher les changements sudo
grep "sudo" /var/log/auth.log | grep "COMMAND="

# Chercher les utilisateurs créés
grep "new user" /var/log/syslog
grep "useradd" /var/log/auth.log

# Chercher les services redémarrés
grep "Starting\|Started" /var/log/syslog

# Chercher les erreurs
grep "ERROR\|ERROR" /var/log/auth.log

Étape 20 : Timeline reconstruction

Commandes :

# Obtenir les timestamps de tous les fichiers
find / -type f -newermt "2023-01-01" ! -newermt "2023-12-31" 2>/dev/null

# Créer une timeline
find / -type f -printf "%T@ %p\n" 2>/dev/null | sort -n

# Logs par date
grep "Jan 15" /var/log/auth.log
grep "2023-01-15" /var/log/auth.log

# Events autour d'une date
journalctl --since "2023-01-15 10:00:00" --until "2023-01-15 12:00:00"

Étape 21 : Analyse des sessions utilisateur

Commandes :

# Historique des connexions
last -f /var/log/wtmp
last -f /var/log/btmp

# Sessions actuelles
w
who
who -a

# Historique de connexion détaillé
lastlog

# Sessions shell
history
cat ~/.bash_history
cat ~/.zsh_history

# Historique tous les utilisateurs
for user in $(cut -f1 -d: /etc/passwd); do
    if [ -f /home/$user/.bash_history ]; then
        echo "=== $user ==="
        cat /home/$user/.bash_history | tail -10
    fi
done

Étape 22 : Analyse des données suspectes

Commandes :

# Fichiers encodés
find / -type f -exec file {} \; 2>/dev/null | grep -i "encoded\|compressed"

# Fichiers binaires suspects
find / -type f -executable ! -path "*/bin/*" ! -path "*/sbin/*" ! -path "*/usr/*" 2>/dev/null

# Scripts shell suspects
find / -type f -name "*.sh" ! -path "*/bin/*" ! -path "*/sbin/*" ! -path "*/usr/*" 2>/dev/null

# Archive suspectes
find / -type f \( -name "*.tar" -o -name "*.zip" -o -name "*.rar" -o -name "*.7z" \) 2>/dev/null | grep -v "backup\|archive"

# Données encodées en base64
grep -r "^[A-Za-z0-9+/]*=" / 2>/dev/null | head -20

---

Réponse aux incidents

Étape 23 : Identification des IOCs (Indicators of Compromise)

Commandes :

# Rechercher les hashes suspects
md5sum /usr/bin/* > /tmp/system_hashes.txt

# Chercher les adresses IP suspectes
grep -r "192.168\|10.0\|172.16" /var/log/ 2>/dev/null

# Chercher les domaines suspects
grep -r "malware\|badhost\|attacker" /var/log/ 2>/dev/null

# Chercher les ports suspects
grep -r "6667\|8080\|4444\|5555" /var/log/ 2>/dev/null

# Chercher les chemins de fichiers suspects
grep -r "/tmp\|/dev/shm\|/var/tmp" /var/log/auth.log

Étape 24 : Recherche d'indices en mémoire

Commandes :

# Dumper la mémoire (si droits root)
sudo dd if=/dev/mem of=/tmp/memory.dump
sudo cat /proc/kcore > /tmp/memory.dump

# Analyser avec volatility
volatility -f memory.dump imageinfo
volatility -f memory.dump pslist
volatility -f memory.dump netscan

# Chercher les strings suspectes en mémoire
strings /dev/mem | grep -i "password\|backdoor\|shell"

Étape 25 : Récupération des flags

Commandes :

# Chercher les flags
find / -name "*flag*" 2>/dev/null
find / -name "*hint*" 2>/dev/null
find / -name "*answer*" 2>/dev/null

# Chercher dans les fichiers communs
cat ~/.bash_history | grep -i "flag\|answer"
cat /home/*/.bash_history | grep -i "flag\|answer"

# Chercher dans les logs
grep -r "flag\|answer" /var/log/ 2>/dev/null

# Chercher les fichiers texte
find / -type f -name "*.txt" -o -name "*.md" 2>/dev/null

# Chercher les données cachées
find / -name ".*" -type f 2>/dev/null

Étape 26 : Récolte des preuves

Commandes :

# Créer un répertoire de preuves
mkdir -p /tmp/evidence

# Copier les logs système
cp /var/log/auth.log /tmp/evidence/
cp /var/log/syslog /tmp/evidence/
cp /var/log/kern.log /tmp/evidence/

# Copier les fichiers de configuration
cp -r /etc/ssh /tmp/evidence/
cp /etc/sudoers* /tmp/evidence/

# Exporter les utilisateurs et groupes
cat /etc/passwd > /tmp/evidence/passwd.txt
cat /etc/shadow > /tmp/evidence/shadow.txt
cat /etc/group > /tmp/evidence/group.txt

# Exporter les processus
ps aux > /tmp/evidence/processes.txt
netstat -tulpn > /tmp/evidence/netstat.txt

# Créer une archive
tar -czf /tmp/evidence.tar.gz /tmp/evidence/

Étape 27 : Génération du rapport

Informations à inclure :

# Informations système
echo "=== Informations Système ===" > /tmp/rapport.txt
uname -a >> /tmp/rapport.txt
cat /etc/os-release >> /tmp/rapport.txt

# Utilisateurs
echo -e "\n=== Utilisateurs ===" >> /tmp/rapport.txt
cat /etc/passwd >> /tmp/rapport.txt

# Processus suspects
echo -e "\n=== Processus ===" >> /tmp/rapport.txt
ps aux >> /tmp/rapport.txt

# Logs
echo -e "\n=== Logs d'authentification ===" >> /tmp/rapport.txt
tail -100 /var/log/auth.log >> /tmp/rapport.txt

# Connexions réseau
echo -e "\n=== Connexions réseau ===" >> /tmp/rapport.txt
netstat -an >> /tmp/rapport.txt

# Afficher le rapport
cat /tmp/rapport.txt

---

Cheat Sheet Rapide

Énumération système

# Informations système
uname -a
cat /etc/os-release

# Utilisateurs et groupes
cat /etc/passwd
cat /etc/group
whoami
id

# Processus et services
ps aux
systemctl list-units --type service
netstat -tulpn

# Logs
tail -100 /var/log/auth.log
tail -100 /var/log/syslog
last

Analyse forensique

# Fichiers modifiés
find / -mtime -7 2>/dev/null
find / -mmin -60 2>/dev/null

# Permissions suspectes
find / -perm -4000 2>/dev/null
find / -perm -777 2>/dev/null

# Fichiers cachés
find ~ -name ".*" -type f
ls -la ~/

# Cron jobs
crontab -l
for user in $(cut -f1 -d: /etc/passwd); do crontab -u $user -l 2>/dev/null; done

Détection de menaces

# Processus suspects
ps aux | grep -v grep
lsof -i

# Connections réseau
netstat -an
ss -an
netstat -tulpn

# Fichiers suspects
find / -type f -executable ! -path "*/bin/*" ! -path "*/sbin/*" ! -path "*/usr/*" 2>/dev/null

# SSH authorisées
cat ~/.ssh/authorized_keys
cat /root/.ssh/authorized_keys

Investigation avancée

# Timeline
find / -type f -printf "%T@ %p\n" 2>/dev/null | sort -n

# Historique utilisateur
cat ~/.bash_history
cat ~/.zsh_history
history

# Logs filtrés
grep "Accepted" /var/log/auth.log
grep "sudo" /var/log/auth.log
grep "Failed" /var/log/auth.log

# Recherche de flags
find / -name "*flag*" 2>/dev/null
grep -r "flag\|answer" /var/log/ 2>/dev/null

---

Outils essentiels

Outil	Utilité	Commande
ps	Lister les processus	ps aux
netstat	Connexions réseau	netstat -tulpn
ss	Socket statistics	ss -tulpn
lsof	Fichiers ouverts	lsof -i
find	Recherche de fichiers	find / -mtime -7
grep	Recherche dans les fichiers	grep "pattern" /file
tail	Voir la fin des fichiers	tail -100 /var/log/auth.log
strings	Extraire des strings	strings /bin/bash
file	Type de fichier	file /bin/bash
stat	Métadonnées de fichier	stat /etc/passwd
journalctl	Logs systemd	journalctl -xe
chkrootkit	Détection rootkit	chkrootkit

---

Résumé de la méthodologie

Phase 1 : Reconnaissance (5-10 min)

1. Accès à la machine
2. Vérifier les fichiers d'accueil
3. Énumération système basique
4. Identifier les services actifs

Phase 2 : Énumération (10-15 min)

5. Fichiers modifiés récemment
6. Processus actifs
7. Connexions réseau
8. Tâches cron et startup

Phase 3 : Détection de menaces (15-20 min)

9. Vérifier les logs d'authentification
10. Chercher les utilisateurs suspects
11. Vérifier les permissions SUID
12. Chercher les backdoors

Phase 4 : Analyse forensique (20-30 min)

13. Timeline des événements
14. Examiner les fichiers système critiques
15. Analyser l'historique utilisateur
16. Rechercher les IOCs

Phase 5 : Investigations avancées (30-45 min)

17. Rechercher les données suspectes
18. Analyser les fichiers cachés
19. Vérifier les connexions établies
20. Chercher les flags

Phase 6 : Reporting (45-60 min)

21. Documenter les findings
22. Récupérer les preuves
23. Générer le rapport
24. Soumettre les réponses

---

Points clés pour Operation End Game

✅ À retenir :
- C'est une investigation forensique, pas une attaque
- Chercher méthodiquement les indices dans les logs
- Les timestamps sont cruciaux
- Vérifier les fichiers de configuration modifiés
- Analyser les processus et les connexions réseau
- Les utilisateurs suspects sont clés à identifier
- Les tâches cron et startup scripts peuvent contenir des backdoors

⚠️ Attention :
- Ne pas modifier les fichiers (forensique)
- Utiliser les commandes de lecture seule quand possible
- Copier les preuves dans un répertoire séparé
- Documenter chaque découverte
- Vérifier les timestamps plutôt que les noms de fichiers

🎯 Ordre recommandé :
1. Lire le briefing/instructions du challenge
2. Énumération du système et identification des services
3. Vérifier les logs d'authentification
4. Identifier les utilisateurs suspects
5. Chercher les processus et tâches malveillants
6. Analyser les connexions réseau
7. Vérifier les fichiers de configuration modifiés
8. Chercher les backdoors et droits d'accès
9. Compiler les findings et répondre aux questions

---

Points d'investigation spécifiques

Utilisateurs

# Chercher les utilisateurs créés récemment
grep -E "^[^:]*:[^:]*:[5-9][0-9]{3}:" /etc/passwd

# Utilisateurs avec shell
grep -E ":/bin/(bash|sh)" /etc/passwd

# Clés SSH autorisées
find / -name "authorized_keys" 2>/dev/null

Processus malveillants

# Processus non-standard
ps aux | awk '{print $11}' | sort -u | grep -v "/bin\|/sbin\|/usr"

# Processus avec état "Z" (zombie)
ps aux | grep Z

# Processus sans parent
ps -o ppid= -p $$

Backdoors communs

# Vérifier sudo
grep "NOPASSWD" /etc/sudoers*

# SSH clés
find / -name "authorized_keys" -o -name "id_rsa" 2>/dev/null

# Cron backdoors
for user in $(cut -f1 -d: /etc/passwd); do
    echo "=== $user ==="
    crontab -u $user -l 2>/dev/null
done

# Startup scripts modifiés
ls -laR /etc/init.d/ /etc/systemd/system/

Logs suspects

# Rechercher les connexions non-autorisées
grep "sshd" /var/log/auth.log | grep "Failed password"
grep "sshd" /var/log/auth.log | grep "Accepted"

# Rechercher les changements système
grep "sudo" /var/log/auth.log
grep "COMMAND=" /var/log/auth.log

# Rechercher les utilisateurs créés
grep "new user\|useradd" /var/log/auth.log

---

Commandes Linux utiles pour l'investigation

# Navigation et fichiers
find / -name "*.txt" 2>/dev/null
find / -type f -mtime -7 2>/dev/null
find / -type f -executable ! -path "*/bin/*" 2>/dev/null

# Analyse de contenu
strings <fichier>
hexdump -C <fichier>
file <fichier>
stat <fichier>

# Recherche et filtrage
grep -r "pattern" /path/
grep -E "regex" /path/
grep -i "case-insensitive" /path/

# Utilisateurs et permissions
cat /etc/passwd
cat /etc/group
ls -la <fichier>
stat <fichier>

# Processus et réseau
ps aux
pstree
lsof -i
netstat -an
ss -an

# Logs
tail -n 100 <logfile>
head -n 100 <logfile>
less <logfile>
journalctl -xe

# Système
uname -a
cat /etc/os-release
systemctl status
systemctl list-units --type service

# Sécurité
sudo -l
id
groups <username>
who
w
last

---

Réponses aux questions typiques

Questions d'identification

• Quel utilisateur a créé le compte malveillant ?
• Chercher dans /var/log/auth.log pour "useradd"

• Vérifier les timestamps

• Quels sont les processus malveillants en cours ?

• Analyser ps aux en détail

• Chercher les processus sans chemin standard

• Quels fichiers ont été modifiés ?

• Utiliser find / -mtime -X
• Vérifier les timestamps avec stat

Questions d'accès

• Comment l'attaquant a-t-il obtenu l'accès ?
• Chercher dans /var/log/auth.log les connexions SSH

• Vérifier les clés autorisées

• Quels credentials ont été utilisés ?

• Analyser les tentatives de connexion
• Chercher les changements de mot de passe

Questions de détection

• Y a-t-il une porte dérobée (backdoor) ?
• Vérifier les clés SSH autorisées
• Chercher les cron jobs suspects

• Vérifier les permissions sudo

• Quel est le nom de l'utilisateur malveillant ?

• Chercher dans les logs
• Vérifier les fichiers de configuration modifiés

---

Ressources supplémentaires

Documentation

• Linux Forensics : https://digital-forensics.sans.org/
• SANS Log Analysis : https://www.sans.org/reading-room/
• Linux Security : https://linux.die.net/
• Man pages : man <command>

Outils avancés

• Volatility : Analyse mémoire
• Rekall : Cadre forensique
• YARA : Détection de patterns
• Splunk : Analyse de logs

Apprentissage

• TryHackMe : https://tryhackme.com/
• HackTheBox : https://www.hackthebox.com/
• Digital Forensics : https://www.cybrary.it/

---

Conclusion

Operation End Game est un challenge d'investigation forensique qui teste :
1. Les compétences d'énumération système
2. L'analyse de logs et timeline
3. L'identification des utilisateurs et processus malveillants
4. La détection des backdoors et droits d'accès
5. La documentation et reporting des findings

Les points clés de succès :
- Énumération minutieuse de tous les indices
- Création d'une timeline des événements
- Identification précise des menaces
- Documentation détaillée des preuves
- Réponses précises aux questions du challenge

Bonne chance avec votre investigation !