COISP 1

Certificación de seguridad ofensiva Nivel 1

www.hackingmexico.one
PHKERVIRTUAL

Alejandro Torres Ramírez

w w w . b a c t e r i a s . m x

PHKV
Todos los nombres propios de programas, sistemas operativos, equipos, etcétera, que aparezcan en este libro
son marcas registradas de sus respectivas compañías u organizaciones.

Reservados todos los derechos. El contenido de esta obra está protegido por la ley, que establece penas de prisión y/o
multas, además de las correspondientes indemnizaciones por daños y prejuicios, para quienes reprodujesen, plagiaren,
distribuyeren o comunicasen públicamente, en todo o en parte, una obra literaria, artística o científica, o su
trasformación, interpretación o ejecución artística fijada en cualquier tipo de soporte o comunicada a través de cualquier
medio, sin la preceptiva autorización.

© Edición HackingMexico, 2016

Ciudad De México

Impreso México

Proyecto gestionado por HackingMexico: www.hackingmexico.one

PHKV
A mis padres, a toda la familia Torres Ramírez por todo lo que hicieron por mí, hasta la fecha.

A mi amigo Raúl Robles por su recorrido y enorme noble labor que hizo al fundar HackingMexico, sobre todo
lo que aporto para la comunidad informática en México,
QEPD.
 PHKV

TABLA DE CONTENIDOS
Capítulo 1: Hacking de Aplicaciones Web

❖ La seguridad ofensiva y el pentesting como colegas ...................................................... 12

❖ ¿Qué es una Distro para pentesting y cual escoger? ...................................................... 13
❖ Preparando nuestro laboratorio virtual ................................................................................
15
▪ Instalación de nuestras distros para pentesting: Parrot Security OS y Kali .................................... 15 ▪
Instalación de OWASP Broken Web Application Project ............................................................ 20
❖ Introducción al pentesting en aplicaciones web .............................................................. 22
❖ Herramientas importantes en Kali/Parrot ............................................................................. 23

Recopilación de Información. ................ 24

❖ Encontrando Hosts ...................................................................................................................

24 ❖ Escaneo e identificación de servicios con Nmap
.............................................................. 26
▪ Uso de Zenmap para recopilar información .......................................................................................... 28
❖ Conociendo a nuestra máquina para pruebas, OWASP Broken Web Apps ................ 29
❖ Uso de Firebug para alterar comportamiento de una aplicación Web ........................ 30

Crawlers y Spiders ............................33

❖ Uso de crawlers con ZAP y búsqueda de directorios ....................................................... 33

❖ Utilizando Spiders con Burp Suite .......................................................................................... 36
❖ Alteración de paquetes mediante el repetidor de Burp Suite ...................................... 40
Identificando Vulnerabilidades ...............42

❖ Identificando una Inyección SQL a base de errores ........................................................ 43

❖ Uso de Tamper Data para la alteración de paquetes o “requests” ............................. 45
❖ Escáneres automatizados ………………….…………………………………………………….47
❖ Encontrando vulnerabilidades con Nikto ............................................................................ 47

PHKV
❖ Uso OWASP-ZAP para identificar fallos de seguridad ........................................................ 50
❖ Módulo Wmap en Metasploit ................................................................................................
53

Explotación ...................................57
❖ Ataques por fuerza bruta ....................................................................................................... 57
▪ Elaboración de Wordlists (diccionarios) con Cewl .................................................................................. 58 ▪
Elaboración de Wordlists (diccionarios) con John the Ripper ............................................................... 60 ▪
Ataque por fuerza bruta mediante THC-Hydra ........................................................................................ 61 ▪
Ataque por fuerza bruta mediante OWASP-ZAP ..................................................................................... 65

❖ Inyección SQL mediante SQLmap ....................................................................................... 69

▪ ¿Qué es una inyección SQL y como se lleva a cabo? ................................................................................ 69

❖ Clasificación de ataques. ...................................................................................................... 76

❖ Ataques Sql-injection ............................................................................................................................................ 76
• Sqli (Sql-inyection) ByPass ........................................................................................................................ 76
• Google Dorks ............................................................................................................................................. 78
❖ Havij ........................................................................................................................................................................ 81

• Sqli con Havij ............................................................................................................................................. 82

❖ URL de tipo semántico .................................................................................................................................. 90
• Re-direccionamiento ............................................................................................................................... 92
• Ejercicios Web ........................................................................................................................................... 93
❖ XSS en sitios web ............................................................................................................................................... 93
• Caso de XSS persistente ............................................................................................................................ 95
• Mandando a mostrar un XSS (múltiples formas) ................................................................................... 95

Clickjacking ................................... 97
❖ Despistando mediante acortadores...................................................................................98
❖ Método de ocultación de barra de estado.……………………………………..…………..99
 ❖ Forzando un clic..................................................................................................................101

PHKV
Local File Inclusion (LFI) .................. 103 ❖ Shell
php..............................................................................................................................105 ❖
Ataque DDos. ……………………………………………………………………………………111

Capítulo 2: SPOOFING

❖ Introducción Spoofing…………………………………………………………………………...113

• Web Spoofing………………………………………………………………………………………………..…114 •
Mail Spoofing………………………………………………………………………………………………......114 •
Preparando nuestro entorno de trabajo…………………………………………………………………114 •
Requerimientos mínimos……………………………………………………………………………………..115 •
Herramientas necesarias………………………………………………………………………………….....115 •
Notepad ++…………………………………………………………………………………………………….115 •
FileZilla FTP Client………………………………………………………………………………………………115 •
Hosting…………………………………………………………………………………………………………..116

❖ Creando un Scam………………………………………………………………………………..116

• Montando un scam en localhost………………………………………………………………………..…123 •

Subir un Scam a un servidor web…………………………………………………………………………..126

❖ Email Spoofing …………………………………………..………………………………………..131

• Enviando un email suplantado……………………………………………………………………………..132

❖ Spoofing
Facebook………………………………………………………………………………137

• Obteniendo contraseñas localmente…………………………………………………………………….142 •

Generador de Plantillas………………………………………………………………………………………143 •
Generador de plantillas personalizado…………………………………………………………………...146

❖ Herramienta de Administración Remota (RAT)……………………………………………..160

• Preparando nuestro entorno de trabajo…………………………………………………………………161 •

Abriendo puertos Modem Telmex…………………………………………………………………………162 •
Configurando el RAT………………………………………………………………………………………….171

Capítulo 3: METASPLOIT Framework y ATAQUES MAN IN THE MIDDLE (m i t

PHKV
m)

❖ Introducción. ..........................................................................................................................
 177
▪ ¿Por qué Metasploit? .................................................................................................................................. 177

Familiarizándonos con el Framework ........................................ 178

❖ Comandos básicos de Metasploit. .....................................................................................

179

Recopilación de información ........................................................ 184

❖ Recopilación de información de forma pasiva. ............................................................ 184

▪ Whois ..............................................................................................................................................................
184 ▪ Dnsenum
........................................................................................................................................................ 185 ▪ DMitry
(Deepmagic Information Gathering Tool) .................................................................................. 187

❖ Recopilación de información de forma activa. ......................................................................

189
▪ Escaneos desde el Framework de Metasploit ....................................................................................... 189
▪ Uso de Nmap desde Metasploit ............................................................................................................... 190
▪ Identificando Hosts activos en nuestra red ............................................................................................. 190
▪ Enumeración de puertos y servicios.......................................................................................................... 191
▪ Escaneos de tipo “Stealth” (Cautelosos) ................................................................................................ 192
▪ Spoofing de nuestra IP y colocar señuelos en los escaneos ............................................................... 193

❖ Configuracion de la MSF DB e importación de escaneos ..............................................

194

Explotación utilizando el framework .................................... 199

❖ Conceptos básicos ..................................................................................................................
199 ▪ Exploits y Payloads
...................................................................................................................................... 199 ❖ Intrusion sin
Interacción ...................................................................................................................... 201
PHKV
▪ Denegacion de servicios (DoS) hacia Windows 7
................................................................................... 201

❖ Intrusiones con Interacción

............................................................................................................... 206
▪ Intrusion en Windows 7 mediante Internet Explorer 8 ............................................................................ 206
▪ Explotación ....................................................................................................................................................
209 ▪ ¿Qué es el meterpreter?
............................................................................................................................. 210 ▪ Evasión de antivirus y
explotación de Windows 8.1 ................................................................................ 213 ▪ Uso de Veil
Evasion ....................................................................................................................................... 215 ▪
Configuracion de nuestro payload malicioso y obtención de explotación ...................................... 216 ▪
Escalada de privilegios a nivel administrativo (AUTHORITY SYSTEM) en Windows 8.1 ........................ 222
 ▪ ¿Qué es el User Access Control? (UAC) ................................................................................................... 222
▪ Bypass del UAC ..............................................................................................................................................
223
❖ Uso de Armitage ......................................................................................................................
228
▪ Iniciando Armitage .......................................................................................................................................
228 ▪ Explorando Armitage e identificación de hosts
....................................................................................... 230 ▪ Preparando el ataque al host o hosts
encontrados ............................................................................... 233
▪ Explotación de Windows XP SP3 mediante Armitage ............................................................................ 234

❖ Post-Explotación
....................................................................................................................... 238 ▪
Manteniendo el Acceso (Persistencia) ..................................................................................................... 238 ▪
Creación de un Backdoor Persistente ....................................................................................................... 238
▪ Extracción de información y monitoreo del equipo comprometido ................................................... 242
▪ Uso de un Keysniffer ......................................................................................................................................
242
▪ Captura de Screenshots, monitoreo del sistema comprometido ....................................................... 244 ▪
Exploración de los directorios del sistema ................................................................................................ 246

Ataques Man in the Middle (MITM) .................... 248

❖ Introducción
............................................................................................................................... 248 ❖
Ataque de ARP Spoofing / Poisoning ....................................................................................
249
▪ Ettercap .........................................................................................................................................................
250
PHKV
▪ ¿Qué es el Sniffing unificado? Y la configuracion de nuestro ataque ............................................... 251

❖ Actuar como MITM e intercepción de tráfico con un analizador de red ......................

255
▪ Wireshark .......................................................................................................................................................
255

❖ Modificando datos entre el cliente y el servidor .. .............................................................

259
▪ Elaboración de scripts para crear filtros de Ettercap ........................................................................... 260

❖ Bypass de HTTPS y SSL ...............................................................................................................

265
▪ ¿Qué es el HTTPS?......................................................................................................................................... 265
▪ Obtención de passwords mediante SSLStrip ...........................................................................................
265

Capítulo 4: HACKEO DE DISPOSITIVOS Móviles

❖ Introducción ...........................................................................................................................
270
 Dispositivos iOS .......................................................................................... 271

❖ Extracción y análisis de información. ................................................................................

271
▪ Preparando lo necesario ............................................................................................................................ 271
▪ Respaldo de iTunes ..................................................................................................................................... 271

❖ Descifrando Respaldo de iTunes con Elcomsoft Password Breaker ...............................

274
▪ ¿Qué es un Keychain? ............................................................................................................................... 277

❖ Instalación de SQLite Manager. .........................................................................................

279
❖ Trabajando con la información y las bases de datos de WhatsApp ...........................
279
❖ Extracción de Metadatos en fotografías. .........................................................................
284
▪ ¿Qué son los metadatos? Y sus Tipos ........................................................................................................ 284
▪ Tipos de Metadatos ..................................................................................................................................... 284
▪ Exiftool .................................................................................................................................
286 ▪

PHKV
Exiv2 ...................................................................................................................................
287
❖ Explotación vía remota mediante protocolo SSH. .........................................................
288
▪ Herramientas .................................................................................................................................................
289 ▪ ¿Que es el protocol SSH? Y como aprovecharnos de el
..................................................................... 291 ▪ Explotación y robo de Información almacenada del
dispositivo ...................................................... 292

Dispositivos Android .............................................................................. 302

❖ Introducción. .........................................................................................................................
302
❖ Explotación mediante apk infectada y control remoto del dispositivo. ................................
302
▪ Herramientas .................................................................................................................................................
302
▪ Elaboración de Apk maliciosa mediante Msfpayload y explotación del dispositivo ...................... 303 ▪
Interacción remota con dispositivo mediante meterpreter ................................................................. 307

❖ Añadiendo certificados a las Apk´s Maliciosas. ..............................................................

314
▪ Herramientas .................................................................................................................................................
314 ▪ Uso de Apktool
............................................................................................................................................. 315 ▪ Certificados
 y Private Keys ......................................................................................................................... 319 ▪ Uso de
Zipalign y Signapk .......................................................................................................................... 321 ▪
Explotación del dispositivo .........................................................................................................................
324
Capítulo 5: CRACKING

Introducción…………………………………..……………………………………………………..326
• Languaje ensamblador………………………………….……………………………..................................291 •
Conceptos básicos……………………………………………………………………………………………..291 •
Registros del procesador………………………………………………………………………………………326 •
Registros de base…………………………………………………………..……………………………………327 •
Registros de índice………………………………………………………………………………………………327 •
Instrucciones básicas………………………………………………………………..………………………….329 •
Conociendo nuestro entorno de trabajo………………………………..…………………………………332

❖ OllyDbg
……………………………………………………………………………………………....232

• Configurando OllyDbg…………………………………………………………………………………………233 •
Partes de OllyDbg……………………………………………………………………………………..………...235 •
Analizando nuestros primeros ejecutables……………………………………………………..………….340 •
Crackme 0 – Noob.exe………………………………………………..……………………………………….340
PHKV
• Crackme.exe………………………………………………………………………………………………..……354 •
Crackme 2.exe…………………………………………………………………………………………………..366 •
Crackme 3.exe…………………………………………………………………………………………………..374

❖ Creación de un parche………………………………………………………………………….391

❖ Cracking en
.NET…………………………………..………………………………………………..399

• Introducción……………………………………………………………………………..…………….…………399 •
¿Qué es .NET?..........................................................................................................................................399 • El
CLR, Common Language Runtime……………………………………………….…….…………….…..400
• El CTS, Common Type
System…………………………………………………………….……………….….400
• Prueba Cracking Login.exe…………………….……………………………………………………………..401 •
Herramientas…………………………………………………………………………………………………..…401 •
Ejemplo #2 LoginVB.exe………..………………………………………………………………………….…..407 •
Serial.exe………………………..…………………………………………………………………………..…….411

❖ Cracking en
Java…………………………………………………………………………………..415

• Introducción………………………………………………………………………………...……………………416 •
SimplePasswordCheck.class………………………………………………………………………..…………423 •
Ejercicio Crackme01.jar…………………………………………………………………...……………...……425 •
Construyendo Keygen en Java………………………………………………………………..…………….427

❖ Cracking .apk
(Android)………………………………………………………………..…………432
 • Introducción……………………………………………………………………………………………….……..432 •
Preparando nuestro entorno de trabajo……………………………………….…………………………..433 •
Advanced Apk Tool…………………….………………………………………………………………………433 •
Dex2jar……………………………………………………………………………………………………….……333 •
Ejercicio Crackme1.apk…………………………………………………………………………...…..………433

¿Hacia quienes va dirigido este libro?

Este libro va dirigido al grupo de pentester e informáticos profesionales, como a principiantes
y demás gente que quiere familiarizarse con la seguridad informática y los demás factores
que la implican, adoptando la metodología de la seguridad ofensiva para la protección de
sistemas, como también familiarizarse con el uso de herramientas para pentesting, este libro
requiere conocimientos básicos en informática.

PHKV
Lo que necesitarás para este libro:
Se hará uso de varias máquinas virtuales y demás software que constituirá nuestro
laboratorio virtual para pentesting, para para poder realizar los ejercicios necesitarás lo
siguiente:

▪ Nuestras maquinas atacantes serán: Kali, Windows y Parrot OS

▪ Las maquinas víctimas: Windows XP SP2/SP3, Windows 7, Windows 8/8.1

▪ Software para virtualización: VMware Workstation, la versión más reciente, en el caso

de usuarios con Mac, se utilizará VMware Fusion, todo el demás software requerido
será mencionado a lo largo de las lecturas.

▪ Hardware: Tu maquina debe contar al menos con 4GB de RAM, 90GB libres en HDD, y
procesador Core i3 o superior.
 Lo que se cubre en nuestro libro:

CAPITULO 1: PENTESTING EN APLICACIONES WEB: En este capítulo se cubrirá la configuración

necesaria para nuestro laboratorio para pentesting en aplicaciones web, como también la
recogida de información con múltiples herramientas, la identificación de vulnerabilidades en
servidores y aplicaciones web, ataques de fuerza bruta y explotando vulnerabilidades como

PHKV
inyecciones SQL, Clickjacking y demás ataques, todos guiados paso a paso y a detalle
usando las herramientas incluidas en el repertorio de las distros para pentesting que
usaremos.

Capítulo 2: spoofing: En este capítulo explicaremos las diferentes técnicas de spoofing de las
cuales un atacante, generalmente con usos maliciosos o de investigación, se hace pasar
por una entidad distinta a través de la falsificación de los datos en una comunicación y de
esta forma robar credenciales de acceso usando de ejemplo robo de cuentas en redes
sociales. Se puede englobar dentro de spoofing cualquier tecnología de red susceptible de
sufrir suplantaciones de identidad.

Capítulo 3: METASPLOIT Framework Y ATAQUES Man i n the Middle: En este apartado se harán las
configuraciones necesarias para trabajar en nuestro laboratorio virtual, incluyendo la
mención del software requerido para ello, asi como la se hará la introducción tanto teórica
como practica a la recopilación de información y sus distintas maneras de realizarla,
también se demostrará el potencial del Framework de Metasploit, con múltiples pruebas y
ejercicios, cada uno guidados paso a paso. Asi como también ataques MITM y el uso de las
herramientas para poder hacer sniffing, capturar credenciales e interceptar tráfico.

CAPITULO 4: HACKEO DE DISPOSITIVOS MOVILES: Después de la introducción y de habernos

familiarizado con el Framework de Metasploit y demás herramientas, pasaremos al
pentesting hacia dispositivos móviles, en este apartado es en donde abarcaremos las 2
plataformas más populares: Android y iOS, sobre ambas se realizaran numerosas pruebas
guiadas a detalle, el hackeo de dispositivos móviles es un tema extenso, al cual nosotros le
daremos un enfoque práctico para entender de una mejor forma como se lleva a cabo.

CAPITULO 5: CRACKING: En este último capítulo se demostrará al lector algunas maneras de

romper protecciones de software y aplicar ingeniería inversa (reversing) a aplicaciones para
descompilar su código y entender cómo funciona, para así poder burlar las restricciones de
un software, el libro provee al lector un toque completamente práctico sobre múltiples
técnicas, damostrando cómo los crackers explotan las técnicas del reversing para romper los
esquemas de protección de copias de software, profundizando en el uso de las
herramientas para llevar a cabo esto.

La seguridad ofensiva y el pentesting

como colegas

Hoy en día la seguridad de la información es algo vital y de suma importancia

para todos los que hacemos uso de dispositivos que almacenen información o
nos permitan estar conectados con lo demás, ya sea usuarios promedio,
expertos, y en mayor importancia compañías o empresas, estas dos últimas
PHKV
tienen como prioridad proteger su información e infraestructura, lo cual se
pone a prueba realizando un Pentesting por su traducción al español: prueba
de penetración. Esta metodología se lleva de la mano con la seguridad
ofensiva la cual tiene la de adentrarse en la forma de pensar del atacante,
entendiendo asi como es que se llevan a cabo los ataques, realizarlos,
entenderlos, comprender que es lo que implican y demás factores que se
involucran, para asi poder protegernos de estos ataques, o podamos asegurar
de forma óptima nuestra información o la de la empresa que nos contrató.

En Hacking Mexico estamos totalmente focalizados en nuestra filosofía la cual

es proveer guía al lector o estudiante para realizar Pentesting de la forma más
practica posible, mostrando asi las numerosas ventajas de la seguridad
ofensiva al hacer uso de técnicas eficaces de hacking a diferentes entornos,
en una estrategia de demostración paso a paso. Adoptando el enfoque
anterior, podemos realizar pentesting mediante un acercamiento más
provechoso, con la intención de conseguir la identificación de potenciales
fallos de seguridad, vectores de ataque o posibles amenazas para el sistema
al que se audita gracias a las herramientas que se proporcionan en las
 distribuciones seguridad, probando en nuestros propios sistemas, ya sea en
laboratorio virtual, en equipos auténticos, o en la infraestructura de la empresa
o compañía que nos contrate. El proceso de realización del pentesting es
llevado a cabo por profesionales que pueden identificar la clase de fallo de
seguridad o vulnerabilidades de las que estén en busca los atacantes para asi
aprovecharse de ellas. Estas personas pretenden ser hackers genuinos que
buscan realizar actos perjudiciales, conseguir el acceso a los sistemas o
infraestructura, hay ocasiones en las que el software o las herramientas
automatizadas para identificar amenazas no funcionan con ciertos vectores
de ataque. Es por esto que uno de los mayores beneficios del proceso de un
pentesting más complejo y robusto es que las técnicas y procedimientos de
estos pentesters hacen más riguroso el proceso de evaluación, para asi
obtener la detección de estas posibles aproximaciones.

Lo que hace tan ventajoso a pentesting de forma proactiva, es que el

“hackearse asi mismo” nos permite romper las barreras de seguridad que
existen en las múltiples plataformas para sistemas asi poder descubrir estos
fallos de seguridad, evaluarlos, explotarlos al máximo para después corregirlos
antes de que atacante con intenciones no benéficas se aproveche de estos
fallos, entre demás ventajas de realizar este proceso, es por esta razón que las
PHKV
compañías hacen este proceso para que no sean víctimas de un atacante
genuino o alguien ajeno a su personal.

VENTAJAS DE LA SEGURIDAD OFENSIVA:

✦ Los expertos en ella identifican debilidades o fallos que son imposibles de

detectar por sistemas de seguridad automatizados
✦ En base a la infraestructura de un Sistema, se puede determinar los diferentes
vectores de Ataque aplicables a ella.
✦ La realización frecuente de pruebas hace que la protección y seguridad e la
infraestructura este en constante mejora.
✦ El encontrar múltiples debilidades que juntas lleven a una amenaza de alto
riesgo.
✦ Demuestra el riesgo real de las Vulnerabilidades o fallos de seguridad
encontrados
¿Qué es una distribución para pentesting?
y ¿Cuál escoger?
 Existen múltiples distribuciones (distros) de seguridad, cada una con sus
ventajas y desventajas, unas más populares y usadas que otras por los
auditores de seguridad, pentesters o principiantes, las más comunes son
Backtrack y Kali Linux, siento esta ultima la sucesora de la anterior y
evolucionando por completo a un nuevo entorno realizando mejoras
consiguiendo una óptima experiencia para los usuarios, estas distribuciones se
utilizan para poder realizar auditorías de seguridad, con el apoyo de
numerosas herramientas que permiten esto. Es cierto que no hay una sola
distro sobre el cual podamos hacer pentesting de una forma eficaz, es por eso
que en este libro haremos de la distribución para pentesting Parrot Security OS,
al igual que haremos uso de Kali

Puesto a que Parrot no es muy común y no hay mucha información acerca de

su uso para pruebas, la ventaja de esta distribución es que está basada en
Debian, lo que quiere decir que funciona igual que Kali, una de las principales
ventajas de hacer uso de esta distro es que contiene más herramientas y es la
distribución por excelencia en cuanto al anonimato, privacidad y criptografía

PHKV
dentro del repertorio de estas, se puede encontrar una amplia gama de
herramientas para estos propósitos.

VENTAJAS:

✦ Mayor número de herramientas contenidas en la distribución, ya sea en

privacidad y mayor número de herramientas que Kali en el repertorio de
forense.
✦ Menor consumo de recursos del equipo, ya que se considera un Sistema
Operativo liviano o “Lightweight” aun siendo asi la versión Full, entre las
mejoras esta que: No requiere aceleración gráfica, 16GB de espacio
recomendados, Requiere un CPU dual core de 1Ghz para funcionar a la
perfección y un mínimo de 512 MB en RAM.
✦ Es una distribución para pentesting orientada al Cloud, su ventaja es que
puede ser desplegado en donde sea, cuando sea, como su atributo es ser
liviano, tiene un uso mayormente provechoso, permitiéndonos asi controlar
un ambiente virtualizado de forma remota.

Estas distribuciones estas orientadas principalmente al ámbito profesional en el

sector de la ciberseguridad. El objetivo primordial de estos es realizar
 pentesting o pruebas de penetración los distintos dispositivos y sistemas
informáticos.

Preparando nuestro laboratorio virtual.

Instalación de nuestras distribuciones para pentesting: Parrot Security
OS y Kali Linux.
Luego de una breve introducción a la Distro que será de mayor uso en este
libro, nuestro siguiente paso es la instalación de la distribución.
A diferencia de Kali, Parrot no tiene imágenes virtuales ya hechas listas para
montarse en el software de virtualización de nuestra preferencia, solo dispone
de imágenes en formato .iso por lo que tendremos que descargar una ya sea

PHKV
la edición Full o la edición Lite, esta última es una versión aún más ligera y
portable, ya que no trae todas las herramientas precargadas, se encuentran el
su página oficial de Parrot en la sección de
descargas: https://www.parrotsec.org/download.fx Pasos
de Instalación:
❖ Descargar la imagen en formato ISO
❖ Descargar e instalar la version de prueba por 30 días o comprar la licencia de
uso de VMware Workstation o VMware Fusion en el caso de Mac. ❖ Ya instalado
el software, abrimos VMware y hacemos clic en “Create a New Virtual
Machine”:
 Imagen 1.1: Visualización de VMware.

❖ En la nueva ventana escogemos el tipo de instalación, en este caso será

típica, ya escogida hacemos clic en Next:

Imagen 1.2: Opción de configuración que escogeremos.

❖ El siguiente paso es escoger el medio de instalación, en este caso se trata de

una imagen ISO, por lo que escogeremos la opción de “installer disc image
file (iso)” lo que nos permitirá navegar hasta el directorio donde tengamos
nuestra imagen ISO:

PHKV

Imagen 1.3: Botón “Browse” para buscar nuestra imagen ISO.

❖ Hacemos clic en Next, lo que sigue es escoger el Sistema operativo, hay veces
en las que VMware reconoce la arquitectura y Sistema operativo que
compone al .iso, pero en este caso no, por lo que nosotros tendremos que
especificarlo, en este caso el Sistema es Linux con la version Debian 8 de
arquitectura de 64 bits :
❖ Seguido aparecerá otra ventana donde le asignaremos un nombre y un
directorio de locación a nuestra máquina virtual, en este caso se le asignó
“Parrot OS” como nombre y el directorio por Default que se muestra:

Imagen 1.4: Selección de version y arquitectura de nuestro S.O.

Imagen 1.5: Nombrando nuestra máquina virtual y seleccionada la locación en donde se instalará.

❖ Luego asignaremos un espacio en disco para la máquina virtual, lo

recomendado son 20GB, tu puedes asignarle más, también indicaremos que
queremos almacenar el disco virtual como un solo archivo:

PHKV

Imagen 1.6: Espacio de disco duro que se le asignará a la VM y almacenando el disco virtual como un solo archivo.
❖ Después asignarlo hacemos clic en Next y veremos la última ventana donde
se muestra la configuración con la que se creará la VM (virtual machine), es
importante que la configuración del adaptador de red esté en NAT:

Imagen 1.7: Vista previa de la configuracion con la que

se creará la VM.

❖ Hacemos clic en Finish y la maquina estará creada:

Imagen 1.8: Máquina virtual ya creada.

❖ Hecho esto hacemos clic en “Power this virtual Machine”, al iniciar

aparecerán múltiples opciones, escogemos “Install” y después “Install with
GTK GUI” donde se hará uso de la interfaz gráfica para la instalación:

PHKV
 Imagen 1.9: Selección de método de
instalación.

Imagen 1.1.0: Selección de lenguaje.

❖ Estando aquí, ya se pueden seguir los pasos de una instalación común de

Linux.
❖ Al terminar, podremos iniciar con el usuario y password que se proporciona en
los pasos de la instalación por medio gráfico, daremos por terminado el
proceso de instalación y ya podremos hacer uso de nuestra distribución para
pentesting, las variables más comunes de loggeo son: root/toor. Donde “root”
es el usuario y “toor” el password, en el proceso de instalación tú puedes
configurar el usuario y contraseña a tu gusto:
 Imagen 1.1.1: Interfaz de Loggeo.

PHKV
❖ Ya iniciando sesión, asi luce la GUI de Parrot OS:

Imagen 1.1.2: Aspecto de Parrot Security OS.

❖ Otra manera de realizar esta la instalación del Sistema es mediante un

dispositivo “Booteable”, puede ser una USB, visita este URL para seguir las
instrucciones:
https://www.parrotsec.org/doc/create-a-boot-device.fx

❖ En el caso de Kali Linux, podemos descargar una imagen virtual ya elaborada,

puesto a que se esta utilizando VMware como entorno virtual para nuestro
laboratorio de pentesting, escogeremos la puede ser en VirtualBox o VMware,
no necesariamente tenemos que realizar el procedimiento de la primera
instalación para Kali, podemos encontrar las imágenes en forma “pre-built” o
ya construidas visitando el siguiente URL: https://www.offensive
security.com/kali-linux-vmware-virtualbox-imagedownload/

❖ Al finalizar la descarga del archivo en .rar o 7zip, lo extraemos en el directorio

de nuestra preferencia, cuando finalicé, habrá un archivo con extensión .vmx
que es el formato con el que VMware gestiona las máquinas virtuales una vez
finalizadas.
 Imagen 1.1.3: Archivo con extensión .vmx

PHKV
❖ Al ejecutarlo se abre VMware y está lista para su uso:

Imagen 1.1.4: Distribución de Kali lista para usarse.

Instalación de OWASP Broken Web Application Project.

Haremos uso del OWASP Broken Web Applications Project, que es
un servidor vulnerable para realizar nuestros ejercicios, este se
puede conseguir en el repertorio de descargas de la página de
OWASP: https://www.owasp.org Otra forma es visitando el siguiente
enlace, donde también podemos realizar la descarga de la
máquina virtual para pruebas:
https://sourceforge.net/projects/owaspbwa/files/
• Ya después de finalizar la descarga, descomprimimos el rar, en
este libro se trabajará con la version 1.2 de BWA (Broken Web
Apps).

Imagen 1.1.5: Archivos que contienen a OWASP BWA.

• Ya descomprimido abrimos el archivo con extensión .vmx para

usarlo en VMware.
 • Al Imagen 1.1.6: Archivo con extensión .vmx que inicializará la VM de OWASP BWA abrirlo se
mostrará listo para correr en VMware, como también sus variables
de loggeo se encuentran en la descripción de la VM (virtual
machine) asi como también al iniciar la VM se indica la dirección
para ingresar al servidor desde el navegador en nuestra distro para
pentesting:

PHKV

Imagen 1.1.6 y 1.1.7: VM de OWASP BWA creada e iniciada, en donde se muestran su acceso.

• Ya estando ambas máquinas virtuales encendidas y el adaptador de red

configurado en modo NAT, podemos hacer la recolección de información
para poder irnos sumergiendo en las distintas fases del test de intrusión. Para
cambiar el adaptador de red, dentro de nuestra VM en VMware en la parte
superior hacemos clic en el menú desplegable “VM” después en “Settings”,
“Network Adapter” y dentro escogemos el de tipo “NAT” y hacemos clic en
“OK” para finalizar. Si queremos explorar el repertorio de aplicaciones web
dentro de esta VM, solo basta con ingresar la IP de esta VM en el navegador
web de nuestra preferencia y entrar.
 Pentesting en Aplicaciones web.
El “Web Pentesting” es una forma proactiva de hacer “testing” a las
aplicaciones web mediante la simulación de un ataque que tiene gran
similitud con un ataque real que podría ocurrir en un día determinado. Vamos
a utilizar las herramientas proporcionadas en Kali Linux para lograrlo.

PHKV
Kali Linux, Parrot Security OS, Backtrack y demás distros son utilizadas por
profesionales de la seguridad para llevar a cabo las tareas de seguridad
ofensivas.
Estas distribuciones vienen con un gran repertorio de herramientas de hacking
que están listas para su uso con todos los requisitos previos instalados. Vamos a
profundizar en las herramientas y como se utilizan para realizar Pentesting a las
aplicaciones web que son vulnerables a los principales defectos que se
encuentran en las aplicaciones web hoy en día en el mundo real.

Daremos un vistazo a los dos de los tipos comunes en la mayoría de ataques a

las aplicaciones web, la inyección de SQL y ataques cross-site scripting (XSS)
ambos de estos ataques son causados porque en la aplicación la entrada del
usuario no se encuentra configurada adecuadamente. Durante la fase de
pruebas, se pueden utilizar diferentes entradas (inputs) que un atacante podría
utilizar para explotar el campo de entrada en el formulario web y probarlo
desde el punto de vista del atacante, en lugar de esperar a que el intruso se
aproveche de ella y luego remediarlo, como suele ocurrir hoy en día.

Hay casos en los que los servidores de seguridad de red y dispositivos de proxy
nunca fueron diseñados para bloquear tales intrusiones; que necesitan para
probar las aplicaciones hasta qué punto el atacante podría hacerlo y eso es
exactamente lo que vamos a cubrir.

Herramientas importantes en Parrot

 Security OS / Kali.
Una vez en Kali o Parrot, la mayoría de herramientas con las que trabajaremos
la mayor parte del tiempo se encuentran en la categoría “Web Application
Análisis”:

PHKV

Imagen 1.1.8: Repertorio de Herramientas incluidas en Parrot, mostrando la categoría de “Análisis de Aplicaciones

Las que utilizaremos se dividen en 3 categorías:

❖ Web Application Proxies

❖ Web Crawlers and Directory Browsing/ Bruteforce
❖ Web Vulnerability Scanners

PROXIES DE APLICACIONES WEB.

Un proxy HTTP es una de las herramientas importantes en el kit de un Pentester
para la auditoria de aplicaciones web y en las distros con las que trabajaremos
se incluyen varias herramientas de este tipo. Es un software que se coloca en
medio del canal de comunicación del navegador y el sitio web, interceptando
el tráfico que fluye entre estos

WEB CRAWLERS & SPIDERS.

 Algunas aplicaciones ocultan los directorios web que un usuario normal que
interactúan con la aplicación web no ve. Los “Rastreadores web” tratan de
encontrar las guías ocultas dentro de una aplicación web, lo que los hace
realmente útiles son que recopilan mayor información y esto nos permite realizar un
pentest más provechoso

ESCANERÉS DE APLICACIONES WEB.

Después la recopilación de información, se procede a realizar la búsqueda de
vulnerabilidades en las aplicaciones web, en las distros con las que
trabajaremos hay una variedad de herramientas de este tipo para realizar la
intrusión.

PHKV

Recopilación de información
En un escenario de Pentesting de una red, el reconocimiento/recopilación de
información es la fase donde los Pentesters deben identificar todos los activos
en los sistemas de red, firewalls y IPS (Sistema de prevención de intrusos)
también obtener información sobre la compañía, la red hasta incluso los
empleados. En nuestro caso, en el Pentesting de aplicaciones web, esta
etapa será todo acerca de conocer a la aplicación, la base de datos, los
usuarios, el servidor, y la relación entre la aplicación y nosotros.

Encontrando Hosts.

Cuando nos encontramos en la fase de “information gathering” o recopilación

de información, es de gran utilidad contar con herramientas que nos permitan
encontrar Hosts, “Devices” o equipos en la red que nos encontremos, esto
puede llevarse a cabo de 2 formas, ya sea utilizando herramientas
automatizadas o configurando nosotros nuestro escaneo.

En las distribuciones de seguridad existe un extenso repertorio de herramientas

que pueden hacer este trabajo, asi como también existen otras que no están
incluidas en etas distros y tenemos que instalaras por nuestra cuenta, para
nuestra ventaja, Parrot contiene ya precargada una herramienta llamada
Angry IP Scanner, la cual no se encuentra en Kali, esta nos permite encontrar
dispositivos “Alive” o Funcionando en el rango de IP que nosotros
especifiquemos, aunque la herramienta lo coloca por Default.

La podemos encontrar en el menú principal de la distro; en Applications,

Parrot, Most Used Tools, AngryIP Scanner. O también el Applications, Parrot,
Information gathering, Live Host Identification, AngryIP Scanner:

Imagen 1.1.9: Ubicación de “Angry IP Scanner”.

PHKV
NOTA: Nuestra máquina virtual OWASP BWA debe estar encendida y
configurada en modo NAT para que este en la misma red que la maquina
atacante.

❖Ya ubicada la herramienta de Angry IP Scanner abrimos y verificamos que

nuestro rango de IP sea el correcto y hacemos clic en Start:

Imagen 1.2.0: Configuración por defecto al abrir “Angry IP Scanner”.

❖Al finalizar nos mostrará in aviso de que el escaneo ha finalizado,

indicándonos el número de “Hosts Alive” que se encontraron, en este caso

fueron 4 :
Imagen 1.2.1: Resultados arrojados por Nmap.

❖Volviendo a la herramienta se mostrará un listado de los Host escaneados, los

“Dead” y “Alive”, indicaremos que los queremos ordenar por nombre, para
identificar más rápido estos Hosts funcionando:
 Imagen 1.2.2: Ordenando los Hosts por su nombre.

❖Podemos ver que se muestra “Alive” nuestra VM OWASP, donde nos indica su
IP, nombre del HOST y demás:
PHKV

Imagen 1.2.3: Host de OWASP BWA encontrado.

Angry IP Scanner es una herramienta automatizada que nos permite encontrar

Host Funcionales que estén dentro de nuestro rango de IP, lo que es de gran
utilidad ya que nos ahorra tiempo al hacer escaneos de nuestras redes.

Escaneo e identificación de servicios con

Nmap.
Nmap es una herramienta que nos permite hacer “information gathering” o
recopilación de información, así como encontrar puertos abiertos (cerrados si
así también lo queremos), obtener las versiones de los servicios que están
corriendo en los hosts remotos y demás funciones y tareas que se pueden
llevar a cabo con la herramienta, esto gracias a su extenso repertorio de
parámetros de configuración para establecer en los escaneos a realizar.

•Una vez ambas VMs iniciados, la maquina atacante (Parrot) y la maquina

objetivo (OWASP BWA) en Parrot que es la distro para Pentesting abrimos una
terminal de comandos, en donde ejecutaremos el siguiente comando: nmap
– sV -O “IP de maquina vulnerable”, con esto haremos un escaneo al host que
es nuestra maquina OWASP, presionamos Enter y veremos cómo se lleva a
 cabo el escaneo y muestra la información relevante solicitada por los
parámetros de configuración, donde “sV” muestra la información de los
servicios ejecutándose en los puertos abiertos, y “O” habilita la detección del
Sistema Operativo del host a escanear.

PHKV

Imagen 1.2.4: Información encontrada por Nmap.

• Vemos que el sistema es un Linux con Kernel 2.6, Apache versión 2.2.14,
PHP 5.3.2 y demás detalles sobre el sistema dentro de este Host.

Nmap es un escáner que trabaja mayormente con puertos, lo que significa

que envía paquetes, o peticiones de tipo UDP o TCP hacia el host para poder
realizar el trabajo, el comando que ejecutamos fue la forma más simple de
hacerlo, puesto que hay muchas formas de conseguirlo, ya sea de esta
manera o de forma cautelosa.
• Para ver el listado completo de comandos para uso con Nmap, se pueden
mostrar Con el comando “-h” o “help” podemos ver todas las opciones de
uso para nmap (y cualquier otra herramienta en la distribución).

Lista de comandos de uso común en Nmap:

Nmap
Parámetro de Función.

-sS Realiza un escaneo de tipo SYN, en donde se lleva a cabo un escaneo más cauteloso o
 de tipo “Stealth”

-sV Este parámetro indica que en el escaneo se identifiquen los servicios que estén en
ejecución en los puertos abiertos en el Host.

-p Indica el rango de puertos que abarcará el escaneo de un Host, Ejemplo: nmap –sV “IP
del Host” –p 1-4444
PHKV

-F Realiza un escaneo más rápido de puertos que el escaneo por default.

-O Este parámetro trata de identificar el sistema operativo que está corriendo en el Host a
escanear.

-sn Deshabilita el escaneo de puertos.

Uso de Zenmap para recopilar información.

Como vimos con Nmap, es una herramienta que nos permite realizar la
recopilación de información de uno o muchos hosts que configuremos junto
con sus parámetros de uso de la herramienta, la ventaja de este es que tiene
numerosas opciones para la configuración de un escaneo. Haremos una
demostración con Zenmap, que es una version más completa de Nmap que
cuenta con una amigable interfaz gráfica de fácil uso, para abrirla podemos
encontrarla en el repertorio de Information Gathering en el menú de Parrot o
simplemente podemos abrir una terminal de comandos y escribir “zenmap”
para iniciarlo

❖Para realizar un escaneo de todo el rango de nuestra IP, basta con ingresar
en el campo de la IP, nuestra IP, y en el último identificador de host
escribimos: “0/24” para realizar el escaneo del host 1 al 255.

❖En el tipo de escaneo escogeremos el “Quick Scan plus”, al escogerlo se

muestran los parámetros de configuración que implican ese tipo de escaneo.
Ya configuradas ambas opciones (IP y Tipo de Escaneo) hacemos clic en

Scan para iniciar:

 Imagen 1.2.5: Configuracion del rango que abarcará el escaneo, asi como el tipo de escaneo que se utilizará.

❖Al terminar se arrojaran los resultados del escaneo, indicando lo que pueden
demostrar los parámetros de configuración involucrados en el escaneo, asi
como un mejor informe acerca de los resultados:
PHKV

Imagen 1.2.6: Resultados obtenidos por el escaneo realizado mediante Zenmap.

Conociendo a nuestra maquina para

pruebas, OWASP Broken Web Apps
Después de haber finalizado con su descarga e instalación en nuestro
laboratorio para pentesting y haber realzado una sencilla recopilación de
información, es momento de familiarizarnos con ella, como se comentó antes,
OWASP Broken Webs App, es un proyecto que está enfocado a que su uso se
exclusivamente para realizar pentesting en un ambiente de simulación, en
donde se pueden realizar pruebas en la gran variedad de aplicaciones web
dañadas intencionalmente que hay dentro de la VM, que es lo que la hace
bastante provechosa. Entre lo que podemos hacer con ella se encuentra:
♦ Probar diferentes herramientas automatizadas para una tarea concreta
♦ Probar técnicas manuales para aproximaciones.

♦ Realizar Ataques y pruebas a las aplicaciones cuantas veces queramos para entender
mejor como es que se lleva a cabo esto.

♦ Entender la seguridad web desde un enfoque práctico.

♦ Probar herramientas de análisis de Aplicaciones web

PHKV

Imagen 1.2.7: Ingreso a la VM de OWASP BWA desde el navegador web, solo colocando
la IP de la VM OWASPBWA.

Podemos ver que se ingresó correctamente, asi como también vemos

anotaciones acerca de la descripción y uso de esta máquina, como también
indica el que hay un listado con las aplicaciones web dañadas
intencionalmente con las que se puede trabajar y realizar pruebas:

Imagen 1.2.8: Listado de Aplicaciones que contienen más aplicaciones para la realizar
Imagen 1.2.9: Aplicaciones que proporcionan un ambiente más real para las simulaciones

Uso de Firebug para alterar

comportamiento de una aplicación Web.
Firebug es una extensión para navegadores que nos permite analizar los
componentes que están dentro de una página web, ya sean tablas, frames,
clases y demás. Haremos este análisis a una página web que está dentro de
nuestra maquina vulnerable (OWASP Broken Web Application), teniendo
corriendo ambas maquinas, Parrot y OWASP, en Parrot entraremos desde
 “Mantra” que es un navegador con muchas extensiones ya instaladas para
análisis y auditoria web, en Parrot ya está precargado, por lo que solo hay que

PHKV
iniciarlo, se puede encontrar en el menú de Parrot o lo podemos iniciar con el
comando “owasp-mantra-ff”:

Imagen 1.3.0: Iniciando el Navegador “Mantra” desde la terminal de comandos.

• Ya iniciado, nos abrirá un nuevo navegador junto con todos los “add-ons” o
extensiones para análisis web, desde este navegador ingresaremos a nuestro
servidor OWASP, colocando la dirección IP de esta máquina virtual en la barra
del navegador, dentro entraremos a la aplicación de “WackoPicko”

• La dirección IP cambiará en tu laboratorio para pentesting:

Imagen 1.3.1: Vista de como luce el navegador “Mantra” y la ubicación de algunas de sus herramientas.

• Dentro de la página hacemos clic derecho en el campo de “Check this File” y

seleccionamos “Inspeccionar elemento con Firebug” y nos mostrara el código
fuente, posicionándonos en la parte del campo o lugar donde decidimos
realizar la inspección:
 PHKV

Imagen 1.3.2: Vista del código fuente mediante Firebug.

• Vemos que hay un “type=Hidden” en el primer input, podemos interactuar con

esto, hacemos doble clic y lo sustituimos por “text” y cambiara el input, donde
ahora aparece el valor de carga permitido para archivos. Aquí modificamos
el comportamiento básico de la página web, en vez de que se utilice un
input, aparece una caja de texto con una cifra:

Imagen 1.3.2: alteración de elementos con el uso de Firebug.

• Firebug nos permite analizar los elementos y poder modificarlos, así para alterar
la forma en el que el navegador los interpreta, asi dándonos cuenta de los
fallos o vulnerabilidades que tienen estas aplicaciones web, que
comúnmente ocurren al momento del desarrollo de estas mismas, la
herramienta es de gran ayuda al momento de que nosotros exploremos de
forma manual las aplicaciones y asi encontrar estos puntos débiles.

NOTA: Si la página es recargada, se mostrará la versión original generada por el servidor.

 PHKV

Crawlers y spiders.
Como parte de la fase de recopilacion de información, en una prueba de
penetración web, tendremos que navegar por cada link o URL incluido en una
página web y mantener un registro de cada archivo que se muestra por ella.
Existen herramientas llamadas “Crawlers y Spiders”, estas nos ayudan a
automatizar tareas de este tipo. Estas herramientas lo que hacen es navegar
por una página web siguiendo todos los enlaces y referencias a archivos
externos o incluso descargar una página para posteriormente realizar un
análisis a esta.

Crawlers: Nos muestran donde está localizada la información, a diferencia con

los spiders, los Crawlers solo enumeran la información que encuentran,
navegan a través de los objetos y los enumeran para arrojarlos en un listado o
reporte.

Uso de crawler con ZAP y búsqueda de

directorios.

ZAP es una herramienta desarrollada por el grupo de OWASP, esta nos permite
realizar múltiples tareas relacionadas con la auditoria y pentesting web, entre
ellas escaneos en busca de vulnerabilidades y fallos de seguridad, recopilar
información acerca de un dominio y de más. Es esta aproximación la usaremos
para encontrar todos los archivos y demás contenido que este dentro de un
dominio, esto con el fin de obtener un panorama mayor acerca de lo que
contiene un dominio.

• Configuraremos el proxy de nuestro navegador web para que funcione junto

con ZAP, ya sea Iceweacel o Mantra. Esto se hace con la finalidad de que
nuestro navegador web trabaje junto con la herramienta, ya sea ZAP, Burp
Suite, etc.
Puesto que estas herramientas están diseñadas para que trabajen junto con
el navegador web, todo el tráfico que pase a través de este navegador el
proxy lo interceptará, para hacer cualquier tipo de prueba con estas
 herramientas, el proxy del navegador web debe de estar configurado para
trabajar con el Proxy de la Herramienta.

PHKV
Para configurarlo se hace lo siguiente:

• Abrimos nuestro navegador web, puede ser Iceweacel o Mantra, dentro de

ellos, en la parte superior, nos dirigimos a “Edit”, “Preferences”, “Advanced” y
“Settings”. Dentro estableceremos usar un “Proxy manual” con la
configuración siguiente, en donde colocaremos el “localhost” como proxy
HTTP, con el puerto 8080, que es donde corre el servicio HTTP, y
estableceremos usar este servidor proxy para todos los protocolos, y hacemos
clic en ok para terminar :

Imagen 1.3.3: Configuración que se establecerá en el proxy de nuestro navegador.

• Hecho esto, abriremos ZAP desde la terminal de comandos, ejecutando

“owasp- zap”

• Dentro, abrimos la pestaña Tools, después Options, En el listado escogemos

Forced Browse, y después select file. En donde buscaremos un wordlist, para
hacer uso de la búsqueda de directorios, el diccionario se encuentra en
usr/share/wordlists/dirbuster En donde escogeremos el directory-listlowercase
2.3small.txt y hacemos clic en Open, después en OK, y nos mostrará una
alerta de que el archivo fue instalado, hacemos clic en OK de nuevo:
 PHKV

Imagen 1.3.4: Selección del diccionario para realizar el “Crawling”.

• En nuestro navegador, navegaremos a la página de WackoPicko. Y en ZAP, se

mostrará la estructura del host o sitio web que visitamos, mostrando esta
estructura hacemos clic derecho en WackoPicko:

Imagen 1.3.5: Opción para poder hacer la búsqueda de los Directorios.

• Hacemos clic en Attack y luego en Forced Browser Directory. Se Mostrarán

todos los archivos en el sitio web o host que decidamos analizar, esto puede
tomar tiempo, de pendiendo la Aplicación web que se esté analizando:
 Imagen 1.3.6: Resultados encontrados al finalizar el “Crawling”.

PHKV
• Dentro de la terminal donde iniciamos el proxy, también se muestra el progreso
de búsqueda de directorios y archivos mediante la técnica de “Forced
Browse Directory”:

Imagen 1.3.7: Resultados mostrados en la Terminal desde donde se inicializó OWASP ZAP

• El proxy (ZAP) no envía directamente los request hacia el servidor, el proxy

hace un forward o sigue los requests que estamos que se envían, no se
analizan del todo.
El proceso funciona así: escogemos un diccionario que su finalidad sea el
encontrar directorios e información y lo configuramos para usarlo hacia ese
host, si los archivos (palabras) que vienen en ese “wordlist” (diccionario) o
lista, existen en la aplicación web, se mostrarán en la pestaña de la
“Exploración Forzada de Directorios”

Utilizando un spider con Burp suite.

 Spiders: Un spider es una herramienta que busca a través un lugar completo
todos los enlaces y referencias que haya ahí, encontrando lo relevante a cada
enlace, dentro el objeto en particular en el que se encuentre, si hay alguno
otro o un enlace, lo seguirá, es decir, busca entre la información y enlaces
demás información relacionada.

Burp es una herramienta que quizás es la preferida cuando se trata del análisis
del comportamiento de una aplicación web, puesto que trae muchas
PHKV
funciones y una interfaz gráfica de fácil uso, ya que aún estamos en la parte
de recopilación de información, lo utilizaremos para hacer “crawling” a una
aplicación web.
• Hay que configurar el Proxy de nuestro navegador web, para que funcione
con BURP.
• Abrimos Burp Suite, se encuentra en: Análisis de aplicaciones web, Proxies de
aplicaciones web y Burp Suite:

Imagen 1.3.8: Una de las 2 Ubicaciones de Burp Suite en el repertorio de Herramientas.

• A diferencia de ZAP, este proxy tiene la configuración predeterminada para

interceptar todas las solicitudes de la navegación, así interrumpiendo la
navegación continua, para evitar estas interrupciones, en BURP, abrimos la
pestaña de “Proxy” después la de “Intercept”, estará sombreada la opción
“Intercept is on” apagamos el Interceptor, quedará así:

Imagen 1.3.9: Pestañas Proxy e intercept, mostrando el Botón “intercept is off”.

• Luego en navegamos a la página de “Bodegeit”, que es una aplicación que

 está incluida en el repertorio de OWASP, se consigue ingresar colocando la IP
en el navegador web como se mencionó antes. (El URL será diferente por la
IP)
• Al ingresar a la página de Bodegeit, vemos como se visualizan los paquetes o
información que el proxy encuentra.

PHKV

Imagen 1.3.9: Paquetes capturados por Burp Suite.

• Usaremos un spider que tiene Burp para seguir todos los enlaces en los que
naveguemos. Hacemos clic derecho en nuestro host:

Imagen 1.4.0: Opción de “Spider” hacia el sitio seleccionado.

• Al iniciar, el proxy preguntará si queremos añadir un objeto en específico a la

configuración del spider, le diremos que sí, puesto que este trae algunos ya
precargados, en nuestro caso, como hay una forma de loggeo en la
aplicación de Bodegeit y la “araña” la encontró, nos pedirá las credenciales
de este login, le daremos valores a esto cuando Burp pregunte por las
credenciales, nuestros valores serán: prueba en el username y prueba en el
password
 Imagen 1.4.1: Formulario de loggeo encontrado por la opción “Spider”.

PHKV
• Al hacer Submit el Spider seguirá con su trabajo, seguido de esto, nos pedirá
de nuevo que ingresemos el usuario y contraseña para el registro que está en
la página, ignoraremos esto presionando el botón de “Ignore this form”.

• El progreso del Spider podemos verlo en la pestaña de “Spider” dentro de

Burp, la pausaremos simplemente haciendo clic en el botón de “Spider is
running” el cual pasará a “spider is paused”:

Imagen 1.4.2: Estatus del progreso de la función del “Spider”.

• Si queremos revisar los resultados obtenidos por el Spider, en la pestaña de

Target, abrimos “Site Map” y dentro estará lo que se haya encontrado e
interpretado dependiendo la configuración previa.
 Imagen 1.4.3: Paquete enviado y las cookies asociadas al envío de ese paquete.

PHKV
A diferencia de otros Spiders, este funciona de una forma más cautelosa y
diferente, podemos seguir con nuestra navegación y el spider seguirá
alojando los resultados en otro lado.

Alteración de paquetes mediante el repetidor

de Burp Suite.

Retomando el punto anterior del spider, ya obtenidos los resultados,

utilizaremos una función llamada “Repeater”, esta es verdaderamente útil al
hacer testing de las aplicaciones web en busca de vulnerabilidades, asi uno
puede ver como la aplicación reacciona a varios “inputs” o entradas
mediante el envío de paquetes hacia esa entrada de datos..

• En la pestaña Target, escogemos Site Map, buscamos el login form que se

detectó y lo mandaremos a l Repeater:
 Imagen 1.4.3: Uso del repetidor en el paquete seleccionado

• Hecho esto nos dirigimos a la pestaña del Repeater para ver qué es lo que
sucede con él, en el lado de Request está la información que enviamos, y en
donde aparecen los valores asignados a las variables de loggeo. Hacemos
clic en Go para poder ver la reacción del servidor en el lado derecho donde
dice Response:

PHKV

Imagen 1.4.4: Enviando petición del paquete hacia el servidor para ver su respuesta de este.

Imagen 1.4.5: Respuesta asociada a la petición de Loggeo.

• Después de haber utilizado el Repeater y realizar el envío de paquetes, vemos

cual es la respuesta de la aplicación a esto: “You supplied an invalid name or
 password”, esto afirmándonos que ese es el mansaje en caso del ingreso de
credenciales erróneas. Ahora verifiquemos si este campo está del todo bien
configurado para autenticar valores.
• Si escogemos la pestaña Render, podemos ver la aplicación web como si
estuviésemos en el navegador:

Imagen 1.4.6: Vista de la página donde reside el paquete del que se envió petición.

PHKV

• Alteraremos el envío de paquetes hacia la aplicación, en lugar de la palabra

prueba coloquemos una comilla simple en el campo del password: (‘) , y
hacemos clic en Go para ver el resultado:
 Imagen 1.4.7: Identificación de una posible vulnerabilidad sobre Inyección SQL a base de errores

• Esta herramienta nos permite probar manualmente diferentes entradas o

“inputs” en distintos escenarios para la misma solicitud o request y analizar la
respuesta por parte del servidor que da a cada una de ellas.

Identificando vulnerabilidades
Después de haber utilizado varias herramientas de recopilación de información
y haber encontrado posibles puntos débiles dentro de algunas aplicaciones
web, lo que se hará a continuación será utilizar herramientas automatizadas
PHKV
para encontrar vulnerabilidades en las aplicaciones web a las que queremos
hacer un Pentesting. Esta parte es de suma importancia, ya que aquí se
determinan los numerosos factores que implican los vectores de ataque que
nos permitirán realizar algo perjudicial a una aplicación web o a un servidor
completo, aquí es donde la información arrojada al principio en la recolección
y la información que se obtiene aquí nos permiten aproximarnos más a la
explotación de nuestro objetivo

Identificando Inyección SQL a base de

errores
Los errores de inyección son el problema más común en cuanto a la seguridad
de las aplicaciones web, esto se debe a la mala configuración de las bases de
datos implementadas en estas aplicaciones y ya sea por medidas de
seguridad inadecuadas.

Este ataque se lleva a cabo cuando el atacante inyecta comandos en las

 entradas de datos o “inputs” o en algún otro parámetro donde se establece
comunicación con el servidor que hospeda al sistema gestor de bases de
datos, con sus respectivas bases de datos, que son con las que trabaja la
aplicación.
En esta prueba verificaremos la existencia de este tipo de inyección en una
entrada de datos. Probaremos en una aplicación llamada Damn Vulnerable
Web Application (DVWA) que está dentro de nuestra Máquina Virtual OWASP
BWA, en la categoría de Training Applications:

Imagen 1.4.8: Acceso a DVWA

• Nos loggeamos en DVWA, y en la columna del lado izquierdo, escogemos “SQL

Injection” en donde nos aparcera un input cualquiera en donde se puede
ingresar información, en este caso un número de identificación (ID):

PHKV

Imagen 1.4.9: Repertorio de aplicaciones dentro de DVWA y mostrando a SQL

I j ti
• Ingresaremos un número, en este caso es el 6, y veremos cómo nos muestra
información relevante a ello, se muestran un Primer nombre y un apellido,
obviamente ficticios:
 Imagen 1.5.0: Busca de un usuario con su número.

• Ahora, agregaremos unas simples comillas a un costado para verificar si arroja

errores de validación en las consultas:

PHKV

Imagen 1.5.1: Error de validación de datos.

• No hubo errores, lo que tenemos aquí es una posible Inyección SQL, se puede
intentar con números distintos, ahora ejecutaremos comandos basicos que
funcionan como vectores de ataque en el “input” o entrada de datos: ‘ or
‘1=’1 La ejecución de comandos en situaciones como esta es de gran
utilidad ya que lejos de arrojarnos un error de validación como el anterior, se
pueden mostrar mayores cosas como más usuarios, información diferente o
incluso las tablas en esta base de datos. Al ejecutar el comando anterior se
muestran todos los nombres que están dentro de la tabla relacionada al ID,
aquí ya sabemos con certeza que tenemos un problema de inyecciones SQL,
ya que no está autenticado correctamente el ingreso de datos en ese input:
 La inyección de Imagen 1.5.2: Información obtenida de la base de datos. SQL toma lugar cuando
la entrada de datos o “input” no tiene validación o la configuración correcta
al hacer una consulta en la base de datos, esto permitiéndonos la ejecución
comandos referentes a la base datos que se use. Lejos de ver un simple listado
de usuarios, este ataque puede ser mucho más peligroso, puede comprometer
un servidor por completo y manipularlo al gusto de atacante/s… como se verá
más adelante.
Uso de Tamper Data para alterar paquetes
Dentro del repertorio de herramientas de Mantra, no encontramos con Tamper
Data que nos perimite visualizar, entender y manipular partes o parámetros a
los que a simple vista no tenemos acceso en la aplicación web.

PHKV
• En el navegador Mantra, abrimos la pestaña Dentro de la pestaña “Tools”, nos
dirigimos al menú desplegable de “Application Auditing” y escogemos
“Tamper Data” :

Imagen 1.5.3: Uso de Tamper Data.

• En el listado de las aplicaciones del servidor OWASP BWA, se encuentra Damn

Vulnerable Application (DVWA), abrimos el link de esta, y en Tamper Data se
muestran los requests o paquetes enviados al servidor:
 Imagen 1.5.4: Retención de paquetes por Tamper Data.

• Hecho esto, Para ver la reacción de Tamper Data al hacer un intento de

loggeo dentro de la aplicación de DVWA, hacemos clic en “Start Tamper”, e
ingresaremos credenciales ficticias para hacer esta prueba
(ficticio/punchsecurity):

Imagen 1.5.6: Botón para comenzar el Tampering

• Nos mostrará una ventana preguntando si queremos seguir haciendo

“Tampering”, quitaremos la selección de “Continue Tampering” y presionamos
“Tamper”:

PHKV

Imagen 1.5.7: Intercepción del paquete relacionado con el Login.

• Volviendo a la herramienta, nos muestra la información antes de ser enviada

al servidor, asi permitiéndonos modificarla:

Imagen 1.5.8: Detalles del paquete retenido y modificación de este.

• Si nosotros cambiamos los valores de las variables “username” y “password”
por los que son auténticos y presionamos ok, ingresaremos como cualquier
otro usuario. Tamper Data “captura” los requests antes de enviarse al servidor,
esto con la finalidad de alterar el contenido de alguna variable, y asi
identificar posibles fallos o vulnerabilidades.

Escáneres Automatizados

La identificación de vulnerabilidades puede ser un proceso tedioso y tardado

o habrá veces que resulte lo contrario, pero es de suma importancia realizarlo,
ya que nos permite identificar las amenazas o vulnerabilidades a la/s que
nuestro objetivo está expuesto o es susceptible. Ya sea que estas herramientas
estén en busca de un malware en específico o en fallos de configuración que
hacen que la seguridad se comprometa, esto es ventajoso ya que hay cosas
que las soluciones antivirus pueden no detectar, permitiendo asi que los
vectores de
PHKV
ataque sean más fáciles de hallarse para llevar a cabo un ataque o este sea
más susceptible a funcionar. En un pentest es muy útil el recurrir herramientas
que en un determinado periodo de tiempo nos permitan identificar el mayor
número de vulnerabilidades que tenga una aplicación web, es por esto que
los escáneres de vulnerabilidades nos ayudan a encontrar alguna o múltiples
formas de explotar una vulnerabilidad, asi como son de gran ayuda debido a
que realizan la tarea de encontrar todos o la mayoría de los fallos de
seguridad existentes en el objetivo a escanear, asi como también existen
distintos tipos de escaneos, dependiendo a nuestras necesidades o lo que
queramos llevar a cabo. La mayoría de los escáneres categorizan las
amenazas en 3 tipos: De bajo, mediano, y alto riesgo.

Encontrando vulnerabilidades con Nikto.

Es una herramienta que ya viene instalada en nuestra distro para Pentesting,
funciona mediante línea de comandos y nos permite realizar escaneos los
hosts objetivo, entre la información que nos puede proporcionar se encuentra:
La configuración del servidor, versiones HTTP, Sistemas gestores de bases de
 datos configurados dentro, revisa las versiones actuales de los servicios que
estén corriendo en este host, prueba con muchos objetos “peligrosos” o
perjudiciales para el objetivo, asi identificando las posibles vulnerabilidades o
fallos de seguridad con los que este cuente. Utilizaremos Nikto para realizar un
escaneo a una aplicación de nuestro servidor vulnerable.

• Abrimos una Terminal de comandos y escribimos: “nikto -h” para que nos
muestre los múltiples parámetros de configuración:

Imagen 1.5.9: Opciones de configuración y Modo de uso de Nikto.

• A continuación, escribimos el siguiente comando: “nikto –h

192.168.28.129/WackoPicko/ –o ScanWacko.html”, donde “h” indica la
PHKV
dirección del host, y “o” el archivo de salida (output), que generaremos, se
nombró como “ScanWacko.html”, esto es opcional, se le puede proporcionar
el nombre que sea. En este caso será guardado como un archivo .HTML para
posteriormente revisarlo en nuestro navegador web. Veremos cómo se realiza
el escaneo y veremos información relevante acerca del host, o incluso del
servidor, esto tomará unos minutos:
 Imagen 1.6.0: Información del host recopilada por Nikto.

• Al terminar, se muestra la fecha en que se hizo el escaneo y el tiempo que

tomo realizarlo, nuestro archivo de salida (output) se guarda por default en
“root” en donde podremos consultarlo para ver el contenido que el escáner

reportó:
Imagen 1.6.1: Resultados obtenidos por Nikto exportados en formato .HTML

• Contenido dentro del reporte generado con extensión .html

PHKV

Imagen 1.6.2:
Visualización de reporte en el Navegador Web.

Imagen 1.6.3: Estadísticas del escaneo y tiempo que tomo para llevarse a cabo.
 En nuestro reporte podremos ver la información recopilada sobre el host,
varios resúmenes acerca de distintas asi como también las vulnerabilidades
encontradas. Como se menciona antes, también hay múltiples
configuraciones para realizar nuestros escaneos, utilizando el comando “nikto
–h”.

Uso de OWASP-ZAP para identificar fallos

de seguridad.

Previamente usado, ZAP nos permite realizar varias tareas tiene muchas
herramientas, entre ellas un escáner automatizado, el cual nos permite realizar
escaneos más a fondo que algunas otras herramientas gracias a su extensa
variedad de funcionalidades, asi como la generación de reportes, en este
ejercicio utilizaremos el escáner.
PHKV
• Configuramos el proxy de nuestro navegador para que funcione junto con
ZAP.
• Abrimos OWASP – ZAP desde la terminal de comandos o el menú de
aplicaciones
• Dentro de nuestro navegador web entramos a nuestra maquina OWASP ZAP,
nos dirigimos a la página de Cyclone:

Imagen 1.6.4: Aplicación “Cyclone”.

• Como ya navegamos a Cyclone, ZAP ha monitoreado nuestro tráfico y lo

colocó en sus registros, haremos clic derecho en la carpeta de Cyclone,
después en la parte de “Attack” escogemos “Active Scan”:
• En
la nueva ventana que se abrió, hacemos un “Check” en donde dice “Show
Advanced options”, para poder habilitar el uso de las tecnologías que
queremos que el escáner vaya en búsqueda de, vemos que se habilitaron las
pestañas de “Input Vector” , “Custom Vectors”, “Technology” y “Policy” ,
abriremos la de Technology y dentro seleccionaremos las tecnologías que
queremos que se habiliten en la búsqueda de escaneo:

Imagen 1.6.5: Opciones avanzadas y sus pestañas habilitadas.

PHKV

Imagen 1.6.6: Selección de tecnologías que el escaneo tomará en cuenta.

• Lo que se especificó en la configuración del escaneo fue que en la categoría

de bases de datos (DB), se escogió los gestores que el escáner estará en
búsqueda de, los lenguajes de programación que tomará en cuenta el
escáner, los sistemas operativos a detectar y los Web Services que se tomarán
en cuenta, al terminar (puede tomar unos minutos) vemos cómo se van
agregando los resultados al árbol de información de ZAP:
•
 Imagen 1.6.7: Resultados del escaneo realizado con OWASP ZAP.

• Una vez terminado el proceso, abrimos las pestaña de “alerts” para ver
información relevante sobre las posibles vulnerabilidades encontradas en la
aplicación web gracias al escaneo que se realizó junto con las tecnologías
que habilitamos para la búsqueda:

Imagen 1.6.8: Pestaña “Alerts” donde se mostrarán los respectivos fallos de seguridad.

PHKV
• Para realizar la generación y exportación de un reporte de los resultados
obtenidos, en la barra de herramientas superior escogemos “Report” y luego
en “Generate HTML Report”, no necesariamente se tiene que generar en
formato HTML, hay múltiples extensiones tanto en ZAP como en demás
escáneres. Seguido de escoger la extensión del archivo de salida,
escogeremos el directorio donde se guardara nuestro output (Reporte) y el
nombre que se le quiera poner, para posteriormente abrirlo con nuestro
navegador web preferencial:

Imagen 1.6.9: Guardando nuestro reporte en formato .HTML

• Abrimos el archivo con nuestro navegador web, en donde vendrá toda la

información generada en el reporte del escaneo:
Imagen 1.7.0: Visualización del reporte en nuestro navegador web.
 Con OWASP-ZAP se pueden realizar escaneos en búsqueda de
vulnerabilidades y generar reportes en múltiples extensiones, los escaneos
funcionan mientras la herramienta navega y abre links o mientras hace
pequeños ataques para definir
PHKV
la presencia de vulnerabilidades, obvio un escaneo es más cauteloso que el
otro.

Módulo de Wmap en Metasploit.

Lejos de las interfaces gráficas y los escáneres automatizados y volviendo a la
línea de comandos, una herramienta ventajosa es Wmap, que es un módulo
dentro de Metasploit que nos permite encontrar vulnerabilidades en las
aplicaciones web. Esto es de suma ventaja ya que podemos realizar el
escaneo desde el framework de Metasploit, teniendo así a la mano los
resultados de escaneo para trabajar con ellos ahí mismo o guardarlos en las
bases de datos del framework para posteriormente consultarlos.

• Para trabajar con Metasploit, es necesario inicializar la base de datos del

Framework, puesto a que la herramienta tiene como gestor de bases de
datos a PostgreSQL, hay que inicializar el servicio de este para que evitemos
errores en el uso de este, esto se hace desde una terminal de comandos
ejecutando el comando: “ service postgresql start ”, después revisamos su
funcionamiento con “ service postgresql status ” , ejecutamos también los
comandos “msfdb init” y “msfdb start”, con estos iniciaremos la base de datos
que está configurada en el framework, la contraseña puede ser cualquiera si
 es la primera vez de uso:

Imagen 1.7.1: Inicialización del servicio de PostgreSQL y revisión de su estatus.

PHKV
Imagen 1.7.2: Creación de las bases de datos.

• Ya hecho esto, iniciamos el framework con el comando “msfconsole” o desde

el menú de aplicaciones, en la categoría de Explotación, escogemos
“Metasploit Framework”, luego de haber iniciado, se nos mostrará la
información acerca de la version actual del framework y lo que contiene, ya
iniciado, cargamos el módulo de Wmap, escribiendo “load wmap”,
presionamos Enter :

Imagen 1.7.3: Moduló “Wmap” cargado.

• Con los comandos “help” visualizamos la lista de los modos de uso para el
modulo en el que estamos dentro:
 Imagen 1.7.4: Opciones de uso para Wmap.

• Con el comando “wmap_sites” visualizamos el listado de opciones para los

sitios agregados a la lista para escaneo:

PHKV
Imagen 1.7.5: Parámetros
de configuracion para la
opción i

• Añadiremos un sito para el escaneo, en esta caso se escaneará la aplicación

de peruggia, también está disponible en el repertorio de aplicaciones de
nuestra maquina OWASP, ejecutamos: “wmap_sites -a
http://192.168.28.129/peruggia/” (la dirección varía). Donde “-a” indica que
se añade a la lista la url que especificamos

Imagen 1.7.6: Host añadido.

• Luego de haber sido creado el sitio, para mostrar la lista de hosts o URLs
añadidos utilizamos el comando “ wmap_sites -l”:

Imagen 1.7.7: Host enlistado en el registro de direcciones.

• Seleccionamos nuestro objetivo (target) para el escaneo, utilizando el
comando “wmap_targets -d 0” donde “d” es nuestro “Id”:

Imagen 1.7.8: Carga de Host para su escaneo.

• Hecho esto correremos el modulo ejecutando el comando “ wmap_run –e “

(Puede tomar un largo tiempo)

PHKV

Imagen 1.7.9: Comenzando las pruebas y escaneo en el host especificado.

• Después de una larga espera (en el caso del escaneo de este sitio), para ver
el listado de vulnerabilidades, utilizamos los comando “vulns” para entrar al
módulo donde se encuentran las vulnerabilidades del host especificado y el
comando “wmap_vulns –l” para visualizar todas la vulnerabilidades o fallos de
seguridad identificados en el proceso de escaneo para ese host (el listado de
las vulnerabilidades puede variar):
 Imagen 1.8.0: Uso del comando “vulns” para enumerar en un
listado las vulnerabilidades encontradas.

PHKV
Wmap funciona mediante el apoyo de los demás módulos de Metasploit para
poder realizar el escaneo y enviar los resultados a la base de datos, el
framework integra estos módulos, así entrando a cada directorio o enlace
dentro de la aplicación y realizar un escaneo más profundo del host
especificado en los parámetros de configuración.

Explotación.

Luego de haber hacho recopilación de información, haber alterado el

comportamiento de algunas aplicaciones web, usado escáneres
automatizados, es momento de realizar fuerza bruta por distintas formas, asi
como la elaboración de diccionarios para el propósito de esto.
Posteriormente podremos aprovechar algún defecto o punto débil dentro de
alguna aplicación web para asi poder llevar a cabo algún ataque más
complejo y asi obtener acceso a las partes restringidas de las aplicaciones,
en este apartado se demostrará paso a paso la realización de los ataques
con mayor número de incidencia en las aplicaciones web, asi como el
familiarizarnos con distintas herramientas para llevar a cabo estos ataques.

Ataques por Fuerza Bruta.

 Es común que las formas de loggeo que nos encontremos online sean
vulnerables por múltiples razones a este tipo de ataques. Estos consisten en
que un atacante o atacantes configuren determinados valores dentro de las
herramientas para conseguir esto. Existen 2 tipos de ataques en esta
categoría:

• Por Diccionario o “Wordlist”: Es donde se involucra un listado de palabras o

combinación que serán usadas para el propósito del ataque, estos
diccionarios se pueden hacer de forma manual, construirlos con una
herramienta o conseguirlos por un tercero, el detalle está en que a diferencia
del método tradicional, solo se trabajará con las combinaciones disponibles o
existentes en el diccionario que se vaya a utilizar.
• El otro tipo es el tradicional: Aqui es donde se involucra un algoritmo que
prueba con todas las combinaciones posibles hasta dar con la correcta. Este
tipo de ataques suelen toma tiempo, ya sean minutos, horas, días, meses, o
PHKV
incluso años, dependiendo de la complejidad de la contraseña que otorgue
el acceso que se esté buscando, asi como demás factores que intervienen en
esto, como la cantidad de letras, símbolos, números, tipo de cifrado que se
utilizando (64 bits, 128 bits o 256) mientras mayor sea este número, más
complejo será cifrado y por consecuente mayor será el tiempo de obtención
de este password.
Este tipo de ataques comúnmente están dirigidos a un servicio de
autenticación, comúnmente son enviados por la funcionalidad de los métodos
GET y POST realizando múltiples peticiones o “requests” al servidor. En esta
parte del capítulo realizaremos varias pruebas donde se demostrará como
crear diccionarios, alterarlos y usarlos para llevar a cabo estos ataques.

Elaboración de Wordlists (diccionarios) mediante Cewl.

Al momento de analizar alguna aplicación web, encontramos nombres o

algunas otras palabras utilizadas por la organización, esto puede ser de suma
importancia ya que con estas palabras se pueden hacer listas (diccionarios)
para realizar ataques de fuerza bruta, y una herramienta que puede hacer
este trabajo es Cewl.

• Abrimos una terminal de comandos y ejecutamos : “ cewl - -help ” para

 mostrar las opciones de uso de la herramienta:

Imagen 1.8.1: Opciones de configuración y modo de uso de “Cewl”

PHKV
• La manera en que haremos la lista o diccionario será analizando una
aplicación web, en este caso tomaremos como ejemplo a la página de
WackoPicko, en donde se recopilarán todas las palabras o combinaciones
que estén dentro para después agregarlas a esta lista, de donde sacaremos
la lista que queremos, ejecutamos: “cewl –w cewl_Wacko.txt –c –m 5
http://192.168.28.129/WackoPicko/” Donde “–w” especificará el archivo de
salida, “-c” contará el total de veces que una palabra se encuentre y “-m” es
el mínimo de dígitos que se establecerá para la búsqueda de palabras.(La
dirección cambia depende de la IP de su máquina vulnerable):

Imagen 1.8.2: Configuración de comando para construir un diccionario basado en el contenido dentro del dominio
id

• Ejecutado con éxito y creada la lista, vamos a su ubicación (root por defecto),
abrimos el archivo, aparecerá con el nombre que se le haya dado, y lo
abrimos. Se mostrará la lista generada tras el análisis de la aplicación y
posteriormente utilizaremos esta lista para hacer un ataque de tipo Fuerza
Bruta.
 Imagen 1.8.3: Contenido del diccionario elaborado con Cewl.

PHKV
Elaboración de diccionarios con John the Ripper.

Puede que sea el “password cracker” favorito de todos los pentesters y

hackers, puesto que tiene muchas funciones, entre el uso de diccionarios y
fuerza bruta, se puede adaptar a otro diccionario para buscar las palabras o
combinaciones que “el escogería” para realizar el ataque, esto aplicando
reglas a los diccionarios y modificándolos, esto lo haremos en base al
diccionario anteriormente obtenido para tener uno más extenso.

• Mencionado antes, John tiene la opción de mostrar las palabras que el usaría
para hacer el ataque. Ejecutamos el siguiente comando: john --stdout -
wordlist=cewl_Wacko.txt :

Imagen 1.8.4: Configuracion del comando para hacer

uso de “john” en conjunto con un diccionario.
• John tiene la opción de cambiar de varias formas cada password de la lista
para asi poder tener un diccionario más completo, al comando anterior le
agregamos la opción “ - - rules ”, este parámetro establece las reglas de john
para extender el tamaño del diccionario:

Imagen 1.8.5: Aplicación de las “reglas de John” hacia el diccionario proporcionado.

• Ejecutado y terminado, vemos como se añaden números a los passwords de la

lista anterior, para así tener un diccionario más extenso, Los números después
de la coma, es el número de combinaciones que hay con ese password,
vemos que este nuevo diccionario tiene más passwords que el anterior, este
cuenta con 3496 combinaciones o passwords, mientras que el primero
contaba solo con 428:
PHKV

Imagen 1.8.6: Combinación de palabras y numerosas exitosa, aumentando asi el tamaño de nuestro
diccionario, con 3496 palabras.

El uso principal de John the Ripper no es generar diccionarios, es el cracking

de passwords, lo cual hace muy bien. Lo que hicimos aquí fue alagar o
extender un diccionario, así como adaptarlo a passwords usados por usuarios
modernos, que es lo que hace la función de las reglas, mediante un algoritmo
añadir ciertas combinaciones a las palabras para que resulte más eficiente el
diccionario al disponer de un mayor número de combinaciones para los
intentos, asi como también aproximándose a la complejidad de los passwords
en caso de que se necesite.

Ataque por fuerza bruta mediante THC-Hydra.

 Después de habernos familiarizado un poco con los diccionarios y su creación,
es momento de pasar al uso de herramientas para realizar fuerza bruta. Hydra
es una herramienta que es considerablemente rápida, fácil de usar y flexible,
ya que puede ser utilizada en las plataformas de Windows y Linux como
también soporta varios tipos de protocolos.

Hydra es una herramienta que nos permite crackear contraseñas de servicios

de tipo login, es una herramienta que crackea passwords en línea, es decir,
encuentra passwords de un servicio de networking. En este ejercicio
accederemos por medio de fuerza bruta a una página de loggeo usando
Hydra.

• Nos dirigimos a Damn Vulnerable Web Application (El link Puede variar):

PHKV

Imagen 1.8.7: Formulario de loggeo de DVWA.

• Abrimos una terminal y haremos un diccionario con Cewl, el cual como se
mencionó antes recopilará la info útil de la página actual para hacer el
diccionario, en este caso, haremos primero una lista de usuarios, ejecutamos
el comando y abrimos él .txt generado:

Imagen 1.8.8: Configuración de comando para obtención de diccionario en base al contenido del dominio especificado.

• Ya
abierto el file, vemos las palabras recopiladas de la página para nuestra lista de
usuarios, nosotros le agregaremos unas cuantas, de forma manual añadimos los
7 usuarios que están seleccionados, les quitaremos los números, dejando
solamente las comas al costado de cada palabra, quedando asi el archivo:
 Imagen 1.8.9: Adición manual de combinaciones a nuestro diccionario.

• Para analizar el envío de datos funciona y entender la solicitud de loggeo,

utilizaremos un Web Application Proxy, para lograr esto. Para esto, vamos a
PHKV
hacer uso de un sniffer/proxy, en este caso utilizaremos Burp suite,
configuraremos el proxy de nuestro navegador para que funciones junto con
Burp suite. En la pestaña de “Edit” escogemos “Preferences” dentro hacemos
clic en “Advanced” después en “Networking” y hacemos clic en “Settings” y
establecemos la siguiente configuración:

Imagen 1.9.0: Configuración del proxy en nuestro navegador web.

• Luego de configurar esto, abrimos Burp Suite para que empiece a interceptar
el tráfico y paquetes que se envían: Dejando listo esto, navegamos a la
aplicación de DVWA, dentro, en la forma de loggeo enviamos un usuario y
password errorenos.

Imagen 1.9.1: Loggeo con credenciales ficticias.

• Una vez hecho esto, nos dirigimos a Burp, como ya está interceptando el
tráfico, ya vemos que es lo que se está enviando, hacemos clic en la pestaña
de Proxy, donde se mostrarán las variables con las que trabaja el proceso de
loggeo, que son: “username” , “password” y “Login”

PHKV

Imagen 1.9.2: Intercepción de paquete asociado al intento de loggeo.

• Ya vimos cómo es que funciona, estamos listos para realizar el ataque, asi que
ejecutaremos el siguiente comando:
hydra 192.168.28.129 http-form-post
"/dvwa/login.php:username=^USER^&password=^PASS^&Login=Login:login.ph
p" -L cewl_users.txt -e ns -u -t 2 -w 15 -o resultadoBruteForceHydraDVWA.txt

• Donde http-form-post indica que el ataque será contra una forma HTTP con
solicitudes de tipo POST.
• -L es la lista que se usara para los usuarios
• -e ns se indica para usar el nombre de usuario como contraseña y también
intenta dejando el campo de la contraseña vacío.
• -u este parámetro se usa para comenzar las iteraciones con los usuarios y no
con los passwords, asi evitando el bloqueo de la cuenta si se presentará el caso.
• -t 2 Significa que vamos a usar 2 “threads” (hilos) al mismo tiempo, así sin hacer
flooding del servidor.
• -o será para indicar el nombre de nuestro archivo de salida.
Al ejecutarlo comienza el proceso de envío de peticiones, comprobando cual
o cuales son las credenciales correctas para completar este loggeo, asi como
también se muestra el archivo de salida generado por la herramienta, este se
guarda por default en la locación de “root”:

PHKV

Imagen 1.9.3: ataque completado y obtención de usuarios y passwords correctos para el loggeo.

Imagen 1.9.4: Usuario “admin” loggeado.

En resumen, lo que hicimos fue analizar el request de loggeo para saber cómo
funcionaba y como estaba constituido, esto gracias al proxy que utilizamos
que fue Burp Suite para después realizar un ataque de fuerza bruta con Hydra
mediante los parámetros de configuración adecuados y una lista de usuarios
que ya teníamos y que modificamos, como se vio, hicimos uso de Hydra y sus
funciones como cracker de passwords de servicios online.

Ataque por fuerza bruta mediante OWASP-ZAP.

 ZAP es una herramienta gratuita que nos permite hacer pruebas en
aplicaciones web, asi como ataques con Fuzzers, web spiders, puede servir
como crawler y asi como también como escáner de vulnerabilidades.
Antes de comenzar se necesita tener abierto ZAP se inicia con el comando:
owasp-zap, y configurar nuestro navegador para que el proxy pueda trabajar
junto con él. En este caso el navegador que usaremos será el Owasp-Mantra
que es básicamente un Firefox con Add-Ons o extensiones precargadas para

PHKV
poder hacer testing de aplicaciones web. Estas herramientas ya vienen
instaladas en la distro de Parrot.
• Abrimos el navegador y nos dirigimos a Damn Vulnerable Web Application, nos
loggeamos y dentro escogemos la pestaña de Brute Force que será donde
realizaremos el Ejercicio:

Imagen 1.9.5: Formulario de loggeo para la realización de pruebas.

• Como ya tenemos el proxy funcionando en este navegador al igual que

tenemos corriendo ZAP, ingresaremos un usuario y password erróneo para
analizar cómo trabaja el servicio de loggeo, en donde nos arrojará el
siguiente mensaje:

• Nos dirigimos a ZAP, puesto a que el proxy está capturando el tráfico y

paquetes, podremos visualizar las credenciales invalidas que ingresamos en la
forma del loggeo, en el lado izquierdo del proxy aparecen los sitios de los que
se recibieron “requests”, escogemos el correcto, en este caso el que
contenga
las variables del loggeo, hacemos clic derecho en él, nos dirigimos a “Attack”
y escogemos “Fuzz”:
Imagen 1.9.6: Intercepción de paquetes realizada por Burp Suite, en donde esta seleccionado el que contiene los
valores enviados por el loggeo.
 PHKV
• Al hacer esto se abrirá un pestaña nueva, seleccionamos el lugar donde va el
password, en este caso seleccionaremos el password erróneo, que será el
lugar donde se realizara este Fuzzing, ya seleccionado hacemos clic en

“Add”:
Imagen 1.9.7: Selección de vector en donde se realizará el Fuzzing.

• Hecho el clic en Add, buscaremos el Wordlists que usaremos, en este caso se

encuentra en usr/share/wordlists/ y usaremos el que se llama “fasttrack”:

Imagen 1.9.8: Selección de fuzzer “fasttrack”.

• Ya seleccionado nos mostrará la locación del “fuzzer” para poder usarlo, y

hacemos clic en “Start Fuzzer”. Comenzará el Fuzzing y al terminar, veremos
una lista de los Fuzzers reflejados y los payloads que se muestran, hacemos
clic, en el de “admin”:
 Imagen 1.9.9: Ubicación del fuzzer obtenido, donde se encuentran las credenciales.

PHKV
• Al seleccionarlo se mostrará un parte del código con la que se hace
interacción, como también la respuesta que se obtiene con ese payload,
donde nos muestra las credenciales válidas.

Imagen 1.10.1: Obtención de las credenciales legítimas, junto con demás detalles sobre esta petición

• Volvemos a DVWA, en la pestaña de Brute Force e ingresamos los datos, en

donde ya nos dará acceso correcto:

NOTA: Aquí se utilizó Firebug y se cambió el tipo de campo para la contraseña fuese
visible.
Lo que hicimos aquí en este ejercicio fue hacer uso de un Web proxy (ZAP) y
poder analizar el funcionamiento del servicio de loggeo en el ejercicio de
Brute Force en DVWA, así enviando un Fuzzer al campo de del password para
que inyectará el vector de ataque antes seleccionado. Y así mostrando los
Fuzzers

PHKV
reflejados junto con los payloads que dieron resultado, en este caso fue el de
“admin”.
Un fuzzer o también Fuzzing es una técnica de pruebas de software utilizado
para descubrir los errores de codificación y los agujeros de seguridad en el
software, sistemas operativos o una red mediante la introducción de
cantidades masivas de datos aleatorios al sistema provocando incluso que
este caiga.

Inyección SQL mediante SQLmap.

¿Qué es una inyección SQL y como se lleva acabo?

Es un ataque que está dirigido a las bases de datos, en donde se lleva a cabo
la inyección de vectores de ataque en un input especificado, este fallo de
seguridad o vulnerabilidad se deben comúnmente a que la entrada de datos
o inputs no autentican de forma correcta el ingreso de datos (como se vio
anteriormente)aquí es donde un atacante puedea provecharse para realizar
acciones perjudiciales, este tipo de ataques pueden llegar a ser bastante
comprometedores, en la mejor situación, acceso a información sensible, en el
peor de los caso, comprometer por completo un host o servidor.

Este tipo de ataques pueden ser de proceso muy laborioso, ya que los factores
a considerar pueden ser numerosos, en nuestras distros para Pentesting
(Kali/Parrot) se incluye una herramienta que facilita este proceso, SQLmap. Esta
es una de las herramientas opensource más poderosas para pentesters que
automatiza el proceso de búsqueda y explotación de inyección SQL, para
robar datos o capturar a un host remoto. Lo que hace sqlmap diferente de
otras herramientas para la explotación de inyecciones SQL, sqlmap es capaz
no sólo de encontrar un fallo de seguridad, sino que también explotarlo en su
totalidad, además tiene una gran funcionalidad, que va desde la posibilidad
de determinar el sistema de gestor de base de datos (DBMS), realizar volcados
(copias) de los datos y puede terminar con la obtención del acceso al sistema
 con la capacidad para acceder a archivos en el host y ejecutar comandos
arbitrarios en el servidor .

Utilizaremos esta herramienta para poder explotar esta vulnerabilidad.

PHKV
• Navegamos a:
“http://192.168.28.129/mutillidae/index.php?page=userinfo.php” (La dirección
varia). En donde veremos una forma de loggeo, la cual atacaremos.

Imagen 1.10.2: Formulario de loggeo dentro de la aplicación.

• Ingresaremos un usuario y password ficticios, en este caso será: “usuario” y

“sqlinject”.
• Presionamos Enter y obviamente nos devolverá un error de autenticación, y

copiamos el enlace URL que está en la barra de herramientas:

Imagen 1.10.3: URL del navegador.

• Abrimos una terminal de comandos y escribimos: “sqlmap –h” para ver el

modo de uso de la herramienta:
 Imagen 1.10.4: Opciones de configuración y modo de uso para “sqlmap”.

PHKV
• Viendo el modo de uso y escogiendo los parámetros de configuración
adecuados, ejecutaremos el siguiente comando, la dirección puede cambiar:
“sqlmap –u "192.168.28.129/mutillidae/index.php?page=user
info.php&username=usuario&password=sqlinject&user-info-php
submitbutton=View+Account+Details" -p username --current-user --current
db”.

En donde “-u” indica el URL, “-p” el parámetro username, donde se inyectaran

los vectores de ataque, “--current-user” indica que se trabaje con ese usuario
y “--current-db” que se realice todo en la base d datos actual, escribimos el
comando tal cual y está escrito y lo ejecutamos:
 Imagen 1.10.5: Ejecución del comando y comienzo del proceso de inyección.

• Comenzado el proceso de inyección, nos indica que el método “GET” del

parámetro “username” puede ser inyectable, asi como también nos muestra
el posible SGBD.

• Nos muestra que el parámetro o método “GET” podría ser inyectable o

vulnerable a XSS (Cross-site-scripting). Vemos también que afirma que el SGBD
es MySQL, y nos pregunta si queremos seguir probando payloads para los
demás SGBD, le diremos que sí, escribiendo “Y” y presionando Enter:

PHKV

Imagen 1.10.6: Especificando si queremos continuar con la revisión en busca de demás GDBD.
• El proceso de continuará, hasta que se confirma que el método “GET” es
inyectable y es a base de errores:

Imagen 1.10.7: Indicación de que el parámetro GET “username” puede ser inyectable.

• Seguido de esto, nos indica que el objetivo URL tiene 7 columnas inyectables
en su BD. Al igual que el parámetro “GET” es una consulta de tipo “UNION” y
tiene de 1 a 20 columnas inyectables en esa BD:

.Imagen 1.10.8: Afirmación de que el URL objetivo y el método GET es

inyectable, asi como indicando información sobre esto.

PHKV
• También nos arroja información acerca del servidor, asi como también sobre la
base de datos, incluido el nombre de ella y del usuario actual:

Imagen 1.10.9: Información sobre el servidor donde se hospedan las bases de datos, asi como el usuario
y base de datos actual.
• Ejecutaremos el comando anterior, solo que con unos cambios, al terminar “–
p username” le agregaremos: “-D nowasp” y “--tables”. Donde “-D” es el
nombre de la BD, y “--tables” para que nos muestre las tablas.
SQLmap tiene un registro, dentro de él se almacena la info o el estado
anterior de la inyección, así podremos retomar el punto en el que la dejamos
sin tener que comenzar de nuevo:

Imagen 1.11.1: Continuación desde el punto anterior de inyección.

• Nos muestra las tablas que están dentro de la base de datos que
seleccionamos, para posteriormente visualizar la información dentro de ellas:

PHKV

Imagen 1.11.2: Lista de tablas disponibles en la base de datos “nowasp”

• Para visualizar la información de la tabla de “credit cards” cambiaremos algo

 al final de nuestro comando, retomará el punto anterior como se mencionó y
además dejará el archivo de volcado en el directorio que se encuentra
debajo de la información de la tabla:

Imagen 1.11.3: Ejecución de comando para conseguir un volcado de la tabla indicada, “credit_cards”.

Imagen 1.11.4: Volcado o copia de la información realizada con éxito, asi como su ubicación de su directorio donde se
almacena.

PHKV
• Lo mismo se hace con la tabla de “accounts” solo se cambia el comando y se
ejecuta:

Imagen 1.11.5: Volcado realizado a la tabla “accounts”.

• Se retoma el punto anterior y se visualiza la información solicitada mediante las

indicaciones de los comandos:
 Imagen 1.1.6: Contenido de la tabla “accounts”.

• Al igual que antes, la información volcada se guardará en un directorio:

Lo que hicimos
Imagen 1.11.7: Ubicación del directorio que contiene la copia que se realizó de la información.

aquí fue encontrar un input o entrada de datos vulnerable, ya que su

autenticación de entrada de información no era del todo adecuada, y nos
aprovechamos de esto gracias SQL, que como se mencionó es una
herramienta que automatiza el proceso de detección de demás
vulnerabilidades en el lugar de ataque que estamos indicando mediante línea
de comandos, asi como identifico este error, lo explotó en su totalidad hasta
conseguir lo indicado; desde el robo de información, hasta comprometer por
completo el host o servidor donde se hospeda esta o estas bases de datos,
este
PHKV
es un solo ejemplo de los demás ejercicios que se realizaran acerca de
pentesting en aplicaciones web, ya sea local u online.

Clasificación de ataques.
Ataques Sql-injection.

❖ La inyección de código SQL es una de las vulnerabilidades más comunes en

aplicaciones PHP. Una vulnerabilidad de SQL Injection requiere dos fallas por
parte del programador:

• Fallas en el filtrado de los datos.

• Fallas en el escapado de los datos al enviarlos a la base de datos (escapado
 de salida).

❖ Ataque a logs o accesos de usuarios.

• La autenticación es el proceso por el cual la identidad de un usuario en el

sistema es validada. Comúnmente el procedimiento involucra un nombre de
usuario y una contraseña a revisar. Una vez autenticado el usuario es
registrado (logeado) como un usuario que se ha autenticado. Muchas
aplicaciones tienen recursos que son accesibles sólo para los usuarios
autenticados, recursos que son accesibles únicamente para los
administradores y recursos totalmente públicos.

Sqli (Sql-inyection) ByPass.

En algún momento nosotros hemos hecho un login bypass para entrar

mediante una sql-injection.

• Nuestro Código Vulnerable sería algo como este:

PHKV

1. <?php
2.
3. $user = $_POST [ 'username' ] ;
4.
5. $pass = md5 (
$_POST [ 'password' ])
; 6. 7. $result =
m ysql_query ( "
SELECT * FROM "
. $tabla .
"login
WHERE username = ' $user
 ' AND password = '
$pass '" )
8.

9. or die ( "<p><i>"
. mysql_error
() . "</i></p>\n");

10.
11. ?>

Ahora el código está logueando mal el user y la pass, no está bien el código,
entonces si nosotros pusiéramos en el login: username : admin ' or ' 1=1
password : xxxxx

• Lo que haríamos nosotros sería transformar la petición en básicamente esto:

$result = mysql_query("SELECT * FROM " . $tabla . "login WHERE username = 'admin' '
or ' 1=1 AND password = 'xxxxx'")
Ahora nosotros solo tendríamos que poner un usuario que exista y entraríamos
como tal.

Para aquellos que solo sabían que si ponían la inyección entraban ya saben
porque es y bueno para evitar esto pasaríamos al anexo de como fortificar tus
formularios y base de datos.

• Ahora veamos como poder encontrar una web que tenga ese tipo de
ataque mediante su formulario:

Encontrando una página web vulnerable:

¿Ahora metamos un usuario y password para poder verificar si entra o no?:

PHKV