Banner 1

XSS en aplicaciones web Flash (XSF)

0 comentarios
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

Mirror1Mirror2



Saludos!

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

AGRADECIMIENTOS TOTALES A: overflow.

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

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

0 comentarios
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

0 comentarios
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

0 comentarios
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
  1. HANDLE WINAPI OpenProcess(
  2. __in  DWORD dwDesiredAccess,
  3. __in  BOOL bInheritHandle,
  4. __in  DWORD dwProcessId
  5. );
Abre el proceso especificando su PID en dwProcessId, con los privilegios deseados. Retorna un manejador
al proceso, o NULL en caso de error.
VirtualAllocEx:
  1. LPVOID WINAPI VirtualAllocEx(
  2. __in      HANDLE hProcess,
  3. __in_opt  LPVOID lpAddress,
  4. __in      SIZE_T dwSize,
  5. __in      DWORD flAllocationType,
  6. __in      DWORD flProtect
  7. );
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:
  1. BOOL WINAPI WriteProcessMemory(
  2. __in   HANDLE hProcess,
  3. __in   LPVOID lpBaseAddress,
  4. __in   LPCVOID lpBuffer,
  5. __in   SIZE_T nSize,
  6. __out  SIZE_T *lpNumberOfBytesWritten
  7. );
Escribe en la memoria dada por lpBaseAddress el contenido apuntado por lpBuffer, hasta nSize bytes. Devuelve FALSE en caso de error.
CreateRemoteThread:
  1. HANDLE WINAPI CreateRemoteThread(
  2. __in   HANDLE hProcess,
  3. __in   LPSECURITY_ATTRIBUTES lpThreadAttributes,
  4. __in   SIZE_T dwStackSize,
  5. __in   LPTHREAD_START_ROUTINE lpStartAddress,
  6. __in   LPVOID lpParameter,
  7. __in   DWORD dwCreationFlags,
  8. __out  LPDWORD lpThreadId
  9. );
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.
  1. HANDLE processList=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  2. PROCESSENTRY32 pInfo;
  3. BOOL st=TRUE;
  4. pInfo.dwSize=sizeof(PROCESSENTRY32);
  5. Process32First(processList, &pInfo);
  6. int myPid=0;
  7. do
  8. {
  9. if(strcmp(pInfo.szExeFile, "test.exe")==0)
  10. {
  11. myPid=pInfo.th32ProcessID;
  12. break;
  13. }
  14. Process32Next(lista, &pInfo);
  15. }
  16. 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.
  1. #include ;
  2. #include ;
  3. BOOL APIENTRY DllMain (HINSTANCE hInst,
  4. DWORD reason,
  5. LPVOID reserved)
  6. {
  7. switch (reason)
  8. {
  9. case DLL_PROCESS_ATTACH:
  10. MessageBoxA(NULL, "Hi!", "Hey!", 0);
  11. break;
  12. }
  13. return TRUE;
  14. }
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í:
  1. #include ;
  2. #include ;
  3. #include ;
  4.  
  5. void error(char *err);
  6.  
  7. HANDLE myProc=NULL;
  8.  
  9. int main(int argc, char *argv[])
  10. {
  11.  
  12. HANDLE processList=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  13. PROCESSENTRY32 pInfo;
  14. BOOL st=TRUE;
  15. pInfo.dwSize=sizeof(PROCESSENTRY32);
  16. Process32First(processList, &pInfo);
  17. int myPid=0;
  18. do
  19. {
  20. if(strcmp(pInfo.szExeFile, "test.exe")==0)
  21. {
  22. myPid=pInfo.th32ProcessID;
  23. break;
  24. }
  25. Process32Next(processList, &pInfo);
  26. }
  27. while(st!=FALSE);
  28.  
  29. // Abrir el proceso
  30. printf("[+] Opening process %i\n", myPid);
  31. myProc=OpenProcess(PROCESS_ALL_ACCESS, FALSE, myPid);
  32. if(myProc==NULL) error("[-] Error abriendo proceso.\n");
  33. else printf("[+] Proceso abierto.\n");
  34.  
  35. // Reservar memoria para el argumento (ruta de la DLL)
  36. char thData[]="dll.dll";
  37. LPVOID dirToArg=VirtualAllocEx(myProc, NULL, strlen(thData), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
  38. if(dirToArg==NULL) error("[-] Error reservando memoria para argumento.\n");
  39. else printf("[+] Memoria reservada para argumento (%i bytes).\n", strlen(thData));
  40. // Escribir la ruta de la DLL en la memoria reservada
  41. SIZE_T written=0;
  42. if(WriteProcessMemory(myProc, dirToArg, (LPVOID)&thData, strlen(thData), &written)==0) error("[-] Error escribiendo memoria.\n");
  43. else printf("[+] Memoria escrita (arg %i bytes).\n", written);
  44.  
  45. // Lanzar un hilo con LoadLibrary
  46. HANDLE rThread=CreateRemoteThread(myProc, NULL, 0, (LPTHREAD_START_ROUTINE)GetProcAddress(LoadLibrary("Kernel32.dll"), "LoadLibraryA"), dirToArg, 0, NULL);
  47. if(rThread==NULL) error("[-] Error creando el hilo.\n");
  48. else printf("[+] Hilo creado.\n");
  49.  
  50. CloseHandle(myProc);
  51. }
  52.  
  53. void error(char *err)
  54. {
  55. if(myProc!=NULL) CloseHandle(myProc);
  56. printf("%s", err);
  57. exit(0);
  58. }

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í:
  1. #include 
  2. #include ;
  3. #include ;
  4.  
  5. void error(char *err);
  6. static DWORD WINAPI myFunc(LPVOID data);
  7.  
  8. HANDLE myProc=NULL;
  9.  
  10. // Con esto cargaremos punteros a LoadLibrary y GetProcAddress en nuestra estrucura de datos
  11. typedef int (WINAPI *datLoadLibrary)(LPCTSTR);
  12. typedef int (WINAPI *datGetProcAddress)(HMODULE, LPCSTR);
  13.  
  14. int main(int argc, char *argv[])
  15. {
  16. if(argc<2) error("Uso: hook.exe PROCESO\n");     // Esta es nuestra estructura de argumentos
  17. struct {
  18. char lnUser32[50];                                 // ->; "User32.dll"
  19. char fnMessageBoxA[50];                       // -> "MessageBoxA"
  20. datLoadLibrary apiLoadLibrary;               // Puntero a LoadLibrary
  21. datGetProcAddress apiGetProcAddress;  // Puntero a GetProcAddress
  22. char Msg[50];                                  // Texto que usaremos en MessageBoxA
  23. } thData;
  24. strcpy(thData.lnUser32, "User32.dll");
  25. strcpy(thData.fnMessageBoxA, "MessageBoxA");
  26. strcpy(thData.Msg, "Hola!");
  27. thData.apiLoadLibrary=GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");
  28. thData.apiGetProcAddress=GetProcAddress(GetModuleHandle("kernel32.dll"), "GetProcAddress");
  29.  
  30. int funcSize=600; // El tamaño de nuestra función. Podria calcularse de forma exacta, pero como ejemplo
  31. // exagerado nos vale .
  32.  
  33. HANDLE processList=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  34. PROCESSENTRY32 pInfo;
  35. BOOL st=TRUE;
  36. pInfo.dwSize=sizeof(PROCESSENTRY32);
  37. Process32First(processList, &amp;pInfo);
  38. int myPid=0;
  39. do
  40. {
  41. if(strcmp(pInfo.szExeFile, argv[1])==0)
  42. {
  43. myPid=pInfo.th32ProcessID;
  44. break;
  45. }
  46. Process32Next(processList, &amp;pInfo);
  47. }
  48. while(st!=FALSE);
  49.  
  50. // Abrir proceso
  51. printf("[+] Abriendo proceso %i\n", myPid);
  52. myProc=OpenProcess(PROCESS_ALL_ACCESS, FALSE, myPid);
  53. if(myProc==NULL) error("[-] Error abriendo proceso.\n");
  54. else printf("[+] Proceso abierto.\n");
  55.  
  56. // Reservar memoria para argumentos
  57. LPVOID dirToArg=VirtualAllocEx(myProc, NULL, sizeof(thData), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
  58. if(dirToArg==NULL) error("[-] Error reservando memoria para arg.\n");
  59. else printf("[+] Memoria reservada para arg (%i bytes).\n", sizeof(thData));
  60. // Escribir argumentos
  61. SIZE_T written=0;
  62. if(WriteProcessMemory(myProc, dirToArg, (LPVOID)&amp;thData, sizeof(thData), &amp;written)==0) error("[-] Error escribiendo la estructura de datos.\n");
  63. else printf("[+] Memoria escrita (arg %i bytes).\n", written);
  64.  
  65. // Reservar memoria para la funcion
  66. LPVOID dirToWrite=VirtualAllocEx(myProc, NULL, funcSize, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
  67. if(dirToWrite==NULL) error("[-] Error rreservando memoria para codigo.\n");
  68. else printf("[+] Memoria reservada para codigo (%i bytes).\n", funcSize);
  69. // Escribimos el codigo de nuestra funcion
  70. if(WriteProcessMemory(myProc, dirToWrite, (LPVOID)myFunc, funcSize, &amp;written) == 0) error("[-]Error escribiendo memoria.\n");
  71. else printf("[+] Memoria escrita (codigo).\n");
  72.  
  73. // Lanzamos el hilo
  74. HANDLE rThread=CreateRemoteThread(myProc, NULL, 0, (LPTHREAD_START_ROUTINE)dirToWrite, dirToArg, 0, NULL);
  75. if(rThread==NULL) error("[-] Error lanzando hilo.\n");
  76. else printf("[+] Hilo lanzado.\n");
  77. CloseHandle(myProc);
  78.  
  79. return 0;
  80. }
  81.  
  82. void error(char *err)
  83. {
  84. if(myProc!=NULL) CloseHandle(myProc);
  85. printf("%s", err);
  86. exit(0);
  87. }
  88.  
  89. static DWORD WINAPI myFunc(LPVOID data)
  90. {
  91. // Cargamos nuestros datos en una estructura como la que hicimos
  92. struct {
  93. char lnUser32[50];
  94. char fnMessageBoxA[50];
  95. datLoadLibrary apiLoadLibrary;
  96. datGetProcAddress apiGetProcAddress;
  97. char MSG[50];
  98. } *thData;
  99. thData=data;
  100. // Podemos conseguir cualquier API con estas dos, siempre que tengamos su nombre en la estructura
  101. void *apiDir=(void *)thData->apiGetProcAddress((HANDLE)thData->apiLoadLibrary(thData->lnUser32), thData->fnMessageBoxA);
  102. // Puntero a funcion similar a MessageBoxA
  103. INT WINAPI (*myMessageBox)(HWND, LPCSTR, LPCSTR, UINT);
  104. myMessageBox=apiDir;
  105. myMessageBox(NULL, thData->MSG, thData->MSG, 0);
  106. return;
  107. }
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

0 comentarios
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:
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

0 comentarios


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

0 comentarios
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
Powered by Bad Robot
Helped by Blackubay