Banner 1

Mostrando entradas con la etiqueta auditoria. Mostrar todas las entradas
Mostrando entradas con la etiqueta auditoria. Mostrar todas las entradas

Encontrando 0-days en Aplicaciones Webs

0 comentarios
1.- CREACIÓN DE UN ENTORNO DE AUDITORIA:

¿Por qué utilizar un entorno de Auditoria?

Simplemente se puede descargar el código que deseemos auditar, seguidamente se puede analizar el código utilizando un editor de texto en busca de vulnerabilidades.
Esto no es preferible, ya que hay una posibilidad muy alta de que falten cosas y seguramente tomará mucho más tiempo que mediante el uso de un entorno de Auditoria.

Web Server:

Queremos crear un servidor web donde podremos subir y probar las aplicaciones PHP, en estos casos se puede utilizar XAMPP o cualquier otro sistema que permita analizar estas aplicaciones localmente.
Es muy recomendable probar y analizar el posible código vulnerable en este servidor web (XAMPP) o en una red de confianza.

¿Que es lo que vamos a Auditar?

Ahora, cuando tenemos nuestro servidor creado tenemos que instalar cosas adicionales como WordPress, Joomla, MyBB o similares, dependiendo de lo realmente queremos auditar.

Si en estos casos vamos por un CMS independiente o simplemente una aplicación PHP que no, por supuesto, necesitamos algunos de los anteriores, pero es probable que en algún momento del tiempo pase a un blog de WordPress o un foro MyBB.
Seguidamente se mostraran los enlaces de descarga y alguna información sobre la forma de instalar algun CMS en particular:
MyBB
Guía de Instalación: http://docs.mybb.com/Installing.html
WordPress
Joomla
SMF:

2.- LO QUE DEBEMOS BUSCAR:

User input:

La mayoría de vulnerabilidades son posibles porque el programador del archivo php olvida la validacion de entrada. Esto ocurre mayormente con las vulnerabilidades de SQL Injection, Cross-Site Scripting, File Inclusion, Server Side Include, Code Injection, File Upload y muchos mas.
---------------------------------------------------------------------------------------------
$_GET
Un array asociativo de variables pasadas al script actual a través de los parámetros de URL.

$_POST

Un array asociativo de variables pasadas al script actual mediante el método HTTP POST

$_REQUEST
Una matriz asociativa que contiene por defecto el contenido de $ _GET, $ _POST y $ _COOKIE.

$_COOKIE

Un array asociativo de variables pasadas al script actual a través de cookies HTTP.

$_SERVER

$ _SERVER - $ HTTP_SERVER_VARS [obsoleta] - Información del servidor y entorno de ejecución.

$_FILES

Una matriz asociativa de artículos subidos al script actual a través del
método HTTP POST.
---------------------------------------------------------------------------------------------
Posibles Funciones Vulnerables:
Sql Injection:

Ejemplo Vulnerable:
---------------------------------------------------------------------------------------------
$id = $_GET['id'];
$news = mysql_query( "SELECT * FROM `news` WHERE `id` = $id ORDER BY `id` DESC LIMIT 0,3" );
---------------------------------------------------------------------------------------------


Existen un montón de posibilidades que las funciones de mysql sean vulnerables, para ello podemos echar un vistazo al siguiente link para obtener mas información sobre las funciones de MySql.

He aquí algunas funciones comunes que posiblemente sean vulnerables:
  • mysql_db_query - Selecciona una base de datos y ejecuta una consulta sobre el mismo.
  • mysql_fetch_array - Extrae la fila de resultado como una matriz asociativa, una matriz numérica o ambas.
  • mysql_fetch_field - Obtener información de columna del resultado y regresar como un objeto.
  • mysql_fetch_row - Devuelve una fila de resultado como una matriz enumerada.
  • mysql_num_rows - Devuelve el número de filas en el resultado.
  • mysql_result - Obtener datos de resultado.
File Inclusion:
Ejemplo Vulnerable:
---------------------------------------------------------------------------------------------

$file = $_GET['file'];
if(isset($file))
{
include("pages/$file");
}
else
{
include("index.php");
}
?>
---------------------------------------------------------------------------------------------

  • include()
  • require()

Si la aplicación no restringe cómo incluir archivos que puede leer archivos locales y posiblemente ejecutar archivos desde un servidor remoto (si allow_url_fopen está habilitado).
Upload:
---------------------------------------------------------------------------------------------

$target_path = "uploads/";
$target_path = $target_path . basename($_FILES['uploadedfile']['name']);
if (move_uploaded_file($_FILES['uploadedfile']['tmp_name'], $target_path)) {
echo "The file " . basename($_FILES['uploadedfile']['name']) . " has been uploaded";
} else {
echo "There was an error uploading the file, please try again!";
}
?>
---------------------------------------------------------------------------------------------

  • $_FILES
Si la aplicación no restringe como se cargan los archivos, en estos casos se puede cargar y ejecutar cualquier tipo de archivos.
Code Execution:
---------------------------------------------------------------------------------------------

$myvar = "varname";
$x = $_GET['arg'];
eval("\$myvar = \$x;");
?>
---------------------------------------------------------------------------------------------

  • passthru()
  • system()
  • eval()
  • exec()


3.- HERRAMIENTAS ÚTILES, SCRIPTS Y TÉCNICAS:

Editores de Texto:

Sublime Text 2 es uno de los mejores Editores de Textos que existe, sus funcionalidades incluyen, pero no se limitan a destacar del sintaxis, la apertura de directorios como "Proyectos" (muy útil) y una función de búsqueda muy agradable.

Grep:

Grep es una utilidad de línea de comandos para la búsqueda de texto sin formato, para las líneas que coincidan con una expresión regular. Grep fue desarrollado originalmente para el sistema operativo Unix.

Grep es una herramienta muy útil cuando se trata de realizar auditorias hacia aplicaciones web. Supongamos que tenemos el siguiente código en app.php:

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

$header = $_GET['header'];
if(isset($header))
{
include("headers/$header");
}
else
{
include("headers/standard.php");
}

$id = $_GET['id'];
$news = mysql_query( "SELECT * FROM `news` WHERE `id` = $id ORDER BY `id` DESC LIMIT 0,3" );
?>
---------------------------------------------------------------------------------------------

Podríamos usar una línea de comandos:
---------------------------------------------------------------------------------------------
$ grep _GET app.php
---------------------------------------------------------------------------------------------

Salida:
---------------------------------------------------------------------------------------------
$header = $_GET['header'];
$id = $_GET['id'];
---------------------------------------------------------------------------------------------
Encontrar funciones mysql_*:
---------------------------------------------------------------------------------------------
grep include app.php
---------------------------------------------------------------------------------------------
Salida:
---------------------------------------------------------------------------------------------
include("headers/$header");
include("headers/standard.php");
---------------------------------------------------------------------------------------------
Ahora digamos que tenemos 3 aplicaciones PHP en una carpeta y queremos buscar la función include en todas ellas, entonces podríamos hacer algo como esto:
---------------------------------------------------------------------------------------------
grep include *.php
---------------------------------------------------------------------------------------------
Salida:
---------------------------------------------------------------------------------------------
app2.php: include("headers/$header");
app2.php: include("headers/standard.php");
app3.php: include("headers/$header");
app3.php: include("headers/standard.php");
app.php: include("headers/$header");
app.php: include("headers/standard.php");
---------------------------------------------------------------------------------------------
Si queremos dar salida al número de línea, puede utilizar el argumento -n de esta manera:
---------------------------------------------------------------------------------------------
grep include *.php -n
---------------------------------------------------------------------------------------------
Salida:
---------------------------------------------------------------------------------------------
app2.php:5: include("headers/$header");
app2.php:9: include("headers/standard.php");
app3.php:5: include("headers/$header");
app3.php:9: include("headers/standard.php");
app.php:5: include("headers/$header");
app.php:9: include("headers/standard.php");
---------------------------------------------------------------------------------------------

Ahora queremos comprobar si las palabras 'SELECT' y 'FROM' se pueden encontrar:
---------------------------------------------------------------------------------------------
grep 'SELECT\|FROM' app.php -n
---------------------------------------------------------------------------------------------

Salida:
---------------------------------------------------------------------------------------------
13:$news = mysql_query( "SELECT * FROM `news` WHERE `id` = $id ORDER BY `id` DESC LIMIT 0,3" );
---------------------------------------------------------------------------------------------


Si queremos que coincida con una cadena e ignorar mayúsculas y minúsculas se utiliza el argumento -i:
---------------------------------------------------------------------------------------------
grep 'sEleCt\|FroM' app.php -n -i
---------------------------------------------------------------------------------------------
Salida:
---------------------------------------------------------------------------------------------
13:$news = mysql_query( "SELECT * FROM `news` WHERE `id` = $id ORDER BY `id` DESC LIMIT 0,3" );
---------------------------------------------------------------------------------------------

Algunas otras herramientas para auditar archivos php: http://www.hotscripts.com/blog/6-free-php-security-auditing-tools/

4.- AUDITORIA EN EL MUNDO REAL:

Vamos a echar un vistazo a un ejemplo del mundo real, un exploit público, y ver si podemos encontrar las vulnerabilidades:
MyBB DyMy User Agent SQL Injection:
Vamos a descargar la aplicación vulnerable y colocarlo en nuestra carpeta de plugins. Lo primero que debemos hacer es abrirlo en el Editor de texto:
Ahora vamos a empezar con un poco de búsqueda básica para posibles funciones vulnerables y cosas similares:
---------------------------------------------------------------------------------------------
grep "\$_GET" dymy_ua.php -i -n
grep "\$_GET" dymy_ua.php -i -n
grep "mysql_" dymy_ua.php -i -n
grep "include" dymy_ua.php -i -n
---------------------------------------------------------------------------------------------
Salida:
Nada util.
¿Por qué no encontrar nada? ¿Estamos haciendo algo mal? La respuesta está en el código fuente, vamos a echar un vistazo:
---------------------------------------------------------------------------------------------
function dymy_ua_install()
{
global $db;

$db->write_query("ALTER TABLE ".TABLE_PREFIX."posts ADD `useragent` VARCHAR(255)");
}
---------------------------------------------------------------------------------------------
Si alguna vez has visto el codigo fuente de los plug-in de MyBB, echa un vistazo a los siguientes documentos para obtener una mejor comprensión de lo que está mal aquí:
Así que cuando estemos auditando Plugins MyBB tenemos que cambiar nuestros métodos de auditoría un poco.
Vamos a buscar $db, ya que se utiliza en Plugins MyBB para las interacciones de bases de datos. Volvamos a la terminal y probar algunas cosas nuevas.
---------------------------------------------------------------------------------------------
grep "\$db" dymy_ua.php -i -n 
---------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------
56: global $db;
58: $db->write_query("ALTER TABLE ".TABLE_PREFIX."posts ADD `useragent` VARCHAR(255)");
63: global $db;
65: if($db->field_exists("useragent", "posts"))
75: global $db;
77: $db->delete_query("templategroups", "title='DyMy User Agent Templates'");
78: $db->write_query("ALTER TABLE ".TABLE_PREFIX."posts DROP `useragent`");
83: global $db;
85: $q = $db->simple_select("templategroups", "COUNT(*) as count", "title = 'DyMy User Agent'");
86: $c = $db->fetch_field($q, "count");
87: $db->free_result($q);
95: $db->insert_query("templategroups", $ins);
101: "template" => $db->escape_string(' {$os}'),
106: $db->insert_query("templates", $ins);
111: "template" => $db->escape_string(' {$browser}'),
116: $db->insert_query("templates", $ins);
125: global $db;
127: $db->delete_query("templates", "title IN('DyMyUserAgent_Postbit_OS', 'DyMyUserAgent_Postbit_Browser') AND sid='-2'");
------------------------------------------------------------------------------------------------------------------
Como esto no es mucho lo que podemos manipular, vamos a ir a 127 líneas y ver qué pasa:
------------------------------------------------------------------------------------------------------------------
function dymy_ua_deactivate()
{
global $db;

$db->delete_query("templates", "title IN('DyMyUserAgent_Postbit_OS', 'DyMyUserAgent_Postbit_Browser') AND sid='-2'"); // Line 27

require_once MYBB_ROOT."/inc/adminfunctions_templates.php";
find_replace_templatesets('postbit',"#".preg_quote('{$post[\'icon_browser\']}{$post[\'icon_os\']}')."#",'',0);
find_replace_templatesets('postbit_classic',"#".preg_quote('{$post[\'icon_browser\']}{$post[\'icon_os\']}
')."#",'',0);
}

function dymy_ua_dh_post_insert(&$data)
{
$useragent = $_SERVER ? $_SERVER['HTTP_USER_AGENT'] : $HTTP_SERVER_VARS['HTTP_USER_AGENT'];
$data->post_insert_data['useragent'] = $useragent;
$data->post_update_data['useragent'] = $useragent;
}

function dymy_ua_postbit(&$post)
{
global $templates;

if(isset($post['browser']) && isset($post['system']) && !empty($post['browser']) && !empty($post['system']) && empty($post['useragent']))
{
$os = str_ireplace("icon_", "", $post['system']);
$browser = str_ireplace("icon_", "", $post['browser']);
$browser = preg_replace("#^linux([a-z])#si", "$1", $browser);
}
...
------------------------------------------------------------------------------------------------------------------
En este nos damos cuenta de algo muy bonito, eche un vistazo a esto:
------------------------------------------------------------------------------------------------------------------
function dymy_ua_dh_post_insert(&$data)
{
$useragent = $_SERVER ? $_SERVER['HTTP_USER_AGENT'] : $HTTP_SERVER_VARS['HTTP_USER_AGENT'];
$data->post_insert_data['useragent'] = $useragent;
$data->post_update_data['useragent'] = $useragent;
}
------------------------------------------------------------------------------------------------------------------
Vemos aquí que la aplicación inserta el user_agent sin ningún tipo de desinfección. Vamos a encender nuestro foro MyBB en nuestro localhost y tratar de analizar estos datos.
Activar el plugin en tu panel de administración y luego ir a un hilo y despues usar el Live HTTP Headers.
Vamos a ver este lado de nuestro mensaje:
Así que ahora, vamos a tratar algunas pruebas básicas para ver si la vulnerabilidad de inyección SQL en realidad existe:
Ah, maravilloso! Ahora vamos a jugar un rato con él hasta que tengamos una consulta agradable para la inyección.
Después de algunas pruebas vamos a salir con esta consulta:
------------------------------------------------------------------------------------------------------------------
' and(select 1 from(select count(*),concat((select username from mybb_users where uid=1),floor(Rand(0)*2))a from information_schema.tables group by a)B)); #
------------------------------------------------------------------------------------------------------------------
5.- NUEVO 0-DAY - MyFlags MyBB plugins SQL Injection:
La vulnerabilidad de inyección SQL que existe en MyBB Plugin HM_My Country Flags:
Cuando este plugins se activa un usuario puede ir a su panel de control y ver esto:
Cada vez que el usuario vea su nacionalidad se mostrará junto a sus mensajes:
Abrimos Live HTTP Headers y pulsamos en el Pais, en las cabeceras HTTP Live copie la direccion URL (localhost/mybb/misc.php?action=hmflags&cnam=Belgium&pf=5') y pega esto en una nueva pestaña.
Ahora ponga un ' después el país:
Salida:
------------------------------------------------------------------------------------------------------------------
MyBB has experienced an internal SQL error and cannot continue.

SQL Error:
1064 - You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ''Belgium''' at line 1
Query:
SELECT * FROM mybb_users u LEFT JOIN mybb_usergroups g ON (u.usergroup=g.gid) LEFT JOIN mybb_userfields f ON (u.uid=f.ufid) WHERE fid5='Belgium'' 
------------------------------------------------------------------------------------------------------------------
Ajustar un poco y podrás averiguar que es unión basada con un montón de columnas:

Espero que haya disfrutado de este tutorial y pueda ayudarte a encontrar vulnerabilidades 0-days en aplicaciones webs.

Tutorial PHP:
Tutorial MySQL:
CRÉDITOS:
Autor: Join7
 
Fuente: http://www.sniferl4bs.com/2014/06/encontrando-0-days-en-aplicaciones-webs.html

NTFS Alternate Data Streams: Hiding data in plain sight since 1993

0 comentarios
I recently read an article in the Hackin9 magazine (worth taking a look if you haven’t heard about it) about alternate data streams (ADS) in NTFS. I had heard about this hidden feature in NTFS a long time ago actually, but over the years forgot about its existence again.

Background
In a nutshell, the NTFS file system, which was introduced with Windows NT 3.1, supports ADS – sometimes also referred to as “hidden streams”. This means that you can attach or associate any number of files to an existing file, yet those files will not be visible to the vast majority of file management applications – including explorer and the “dir” command (Vista can show ADS with a parameter). One thing I find interesting about streams is that a lot of people in IT do not seem to
know about them, even people otherwise very familiar with the Windows
Operating System.
Now, streams are created and accessed by appending the “host” file name with a colon, followed by the name of the stream. Let’s say you want to create a text file called financials.txt and hide it with winhelp.exe, you would run notepad C:\Windows\winhelp.exe:financials.txt. This will bring up notepad which will prompt you to create the file since it doesn’t exist (since the alternate stream is basically a file). You can then save any text in the hidden file and save it. You will notice that the file you just created will not show up when you do a directory list (dir C:\Windows) and will also not show up in the Windows Explorer. Note that the timestamp of the host file will change however.
Now there are of course a variety of utilities that have been developed in the last 15 (!) years that will allow you to find hidden streams, but more on that later. Hidden streams still exist on Vista and later, though the feature seems to have become more restrictive.
There are apparently no limits as to how many streams one can associate with a file, or the type of file that can be associated. This means that you can associate an executable as much as you can an ASCII file. There are however some limitations as to how user mode applications (e.g. notepad) can access hidden streams.
Let’s go back to the previous example where we created the file financials.txt in winhelp.exe. If you open a command prompt and execute type C:\Windows\winhelp.exe:financials.txt, then you will not be able to see the contents of the hidden file. If you use notepad instead however, you will be able to see the file (notepad C:\Windows\winhelp.exe:financials.txt). This is probably because cmd.exe and its built-in commands up until Windows XP are not aware of alternate streams. ON a Windows XP machine I also could not open that same file if I tried to open it from inside notepad with the File -> Open command.

Creating Streams
Things get more interesting when you attach executables to files – and execute them! Let’s say I wanted to hide popular windows game solitaire inside the file C:\Windows\wganotify.log and call the stream “calc.exe”. Here is what you do:
type system32\sol.exe > C:\Windows\WgaNotify.log:calc.exe
start C:\windows\WgaNotify.log:calc.exe

Auditing Alternate Data Streams
Those of you interested in auditing will probably wonder how Windows tracks access to hidden streams in the event log. Well, there is good and bad news. The bad news is that object tracking (the famous event 560) does not show hidden streams, and instead only shows the “host” file name being accessed. Process Tracking on the other hand shows hidden streams in the expected manner. For the above example, a 592 event will show that file C:\windows\WgaNotify.log:calc.exe was executed.

Exploiting Streams
Scary, huh? This opens up a can of worms when you think about malware hiding inside otherwise innocent files – such as a log file. At appears as if most AntiVirus products do not detect hidden streams, at the same time there doesn’t seems to be a significant number of mainstream malware applications out there are that rely on hidden streams. I’m not sure why that is, since this feature seems almost too good to be true for the writer of any malicious applications. One reason might be that malware writers mostly target home machines, and many of those computers are still formatted with the FAT(32) file system, which of course doesn’t support ADS. This might change over time though, as more (home) computers use NTFS as their file system.
So after reading up on ADS, playing around with it last week, scanning my computer for hidden streams, I arrived at the inevitable question: What is the higher purpose of Alternate Data Streams? I mean, many applications don’t support it, most people don’t know about it, and a scan didn’t reveal any hidden streams besides a couple inside some Microsoft installers that apparently use them as some sort of meta data.
As it turns out, ADS was created for compatibility with the Macintosh HFS file system, which uses a data fork and resource fork to store data in a file (OS X now uses the HFS+ file system). But over the years (it’s been 15 after all) some developers at Microsoft decided to utilize this feature. For example, when you specify summary information about a file (right-click -> properties -> summary), then this information will be stored in ADS.
As mentioned earlier, there have been some improvements in regards to ADS with Vista and later. Vista can now show alternate streams with the /R switch of the “dir” command. My preliminary research also shows that hidden streams can no longer be executed in Vista or later – so what we did in the above example will not work. I think that’s a good thing, since there really is no practical reason (unless you develop malware) to do this. The screen shot below shows the output of a regular dir command and the dir /R command on a Windows 2008 server (note the file setupact.log).
ADS_Win2k8.jpgIn my humble opinion, Microsoft should get rid of alternate streams in future versions of Windows, and instead come up with some sort of structured way of embedding meta data in files. Anything contained in meta data should be non-executable and limited in size, e.g. 256kb.

Discovering Streams

So what does all this mean for you, the person responsible for security in your network? How can you find hidden streams and detect if streams are being added to files?
There are many free third-party utilities out there that show and manipulate hidden streams, but the discovery of this feature led us to extend the functionality of the File Monitoring feature of EventSentry to include the automatic detection of hidden streams in real-time. This means that any stream added, modified or removed from a file in a monitored location will be detected by EventSentry.
We have also developed a new command-line tool, adslist.exe, that will list all alternate data streams on a directory and optionally its sub directories. The tool is part of the NTToolkit v1.96 and I recommend that you schedule to run this tool with the Application Scheduler feature of EventSentry on a regular basis, or schedule it with the Windows Task Scheduler and email the results (adslist.exe C:\ /s). The advantage of using EventSentry is that the results of adslist.exe can automatically be emailed to you only if alternate streams were found. You can do this because the %ERRORLEVEL% is set to 1 by adslist.exe when one or more streams are found. The screenshot below shows what this would look like in the email sent by EventSentry:
EventSentry_ApplicationScheduler_ADSList.pngManipulating StreamsWhile Microsoft doesn’t offer a tool to search for and discover alternate data streams, they do offer a good explorer-extension that allows you to view and delete alternate data streams. You can download it from http://download.microsoft.com/do
wnload/F/C/6/FC6943EB-790A-44AA-B32D-14ED7E22FD5D/NTFSExt.exe
, the zip file contains the source code as well as another utility to create hard links on NTFS volumes. After extracting the archive, navigate to the \StrmExt\ReleaseMinDependency folder and run regsvr32 StrmExt.dll. You will then have an additional tab when viewing file properties in explorer called “Streams”:
StrmExt.jpgAnother way to get rid of hidden streams is to copy a file to a FAT[32] volume and then back to the NTFS volume, or – if you don’t have a FAT[32] volume available – simply compress and uncompress the file again.
Well, I hope this gives you a better understanding of alternate data streams, even if you were already familiar with them. Like I mentioned earlier, it doesn’t appear as if ADS is used for evil in a large scale quite yet (so no reason to panic!), but I believe it is better to be safe than sorry.

Fuente: http://www.eventsentry.com/blog/2008/07/ntfs-alternate-data-streams-hi.html

EXTRAYENDO CONTRASEÑAS DE LA RAM CON MIMIKATZ 2.0 (ALFA)

0 comentarios
Mimikatz 2.0 (ALFA), esta herramienta puede ser particularmente útil durante la etapa de explotación de vulnerabilidades en un servicio de pentest, por ejemplo la explotación de una aplicación web vulnerable a carga de archivos (File Upload) sin restricciones en muchos ataques es el primer paso para tomar control del sistema objetivo.

A continuación, el ataque sólo tiene que encontrar la manera de ejecutar código luego de subir la respectiva webshell "phpshel.php" vemos que nos encontramos con permisos de "NT AUTHORITY\SYSTEM" y queremos extraer la clave del "Administrator", lo primero que pensamos es "la hago con meterpreter" y cuando logramos subirlo el antivirus del servidor web afectado reconoce dicha herramienta como código "malicioso"...

Para este caso podríamos utilizar la técnica que nos presenta mimikatz 2.0 (ALFA) puesto que en esta nueva versión ya no es necesario “inyectar” la librería "sekurlsa.dll" en el proceso de LSASS mimikatz# inject::process lsass.exe sekurlsa.dll, en esta nueva versión la técnica se basa en la obtención de contraseñas en texto plano volcando el proceso LSASS.EXE desde la memoria RAM, sin necesidad de ejecutar código "malicioso" en el servidor, de esta forma se evita tener que lidiar con técnicas de evasión antivirus y otros dolores de cabeza.

En este post me gustaría mostrar paso a paso como podemos usar la funcionalidad de mimikatz 2.0 (ALFA) explotando una aplicación web vulnerable a carga de archivos sobre un servidor Windows 2008.

1.SUBIENDO LAS HERRAMIENTAS

Subir las herramientas usando una aplicación vulnerable a carga de archivos (File Upload).
En caso de tener problemas para hallar la ruta en donde se han almacenado los archivos cargados en el servidor, podríamos usar Dirbuster para tratar de descubrir el directorio en donde se encuentren nuestros archivos en este caso se hallaron en "/webapp/admin/panel/images/"

phpshell.php; para realizar la ejecución de comandos en el servidor web afectado.
procdump.exe; nos permitirá realizar el volcar el espacio de memoria RAM del proceso LSASS.EXE a un archivo.dmp (dump)


Subiendo "WebShell" al servidor

Subiendo "procdump" al servidor


2.VOLCANDO LA RAM DEL SERVIDOR WEB

Ejecución del comando "dir" en el servidor para confirmar se logro subir la herramienta procdump.exe y el script desde donde se ejecutara (script.dumper.bat)

Usaremos Procdump para volcar el espacio de la memoria RAM asignado al proceso LSASS.EXE y generar archivo “dump” que se usará fuera de linea para conseguir la contraseña del "Administrador local" y/o del "Domain Admin".

Ejecución comando "dir" mediante phpshell.php?cmd=dir

Como utilizo procdump.exe?

Se ejecutara desde el archivo script.dumper.bat donde llamaremos a procdump.exe y le pasaremos los siguientes parámetros:

-accepteula : opción de línea de comando para aceptar automáticamente el contrato de licencia de Sysinternals.
-ma : escribir un archivo de volcado con toda la memoria del proceso. El formato de volcado predeterminado sólo incluye hilos (threads) del proceso e información de gestión.

Por último la ubicación donde se guardara el archivo con el volcado del proceso lsass.exe (C:\xampp\htdocs\webapp\admin\panel\images\) una ubicación donde se pueda descargar vía el servidor web.

Procdump : http://technet.microsoft.com/sysinternals/dd996900.aspx
type script.dumper.bat
C:\xampp\htdocs\webapp\admin\panel\images\procdump.exe 

-accepteula 

-ma lsass.exe 

C:\xampp\htdocs\webapp\admin\panel\images\%COMPUTERNAME%_lsass.dmp
Contenido del script "script.dumper.bat"

Como ejecutar script.dumper.bat en el servidor web?
Ejecución script.bat mediante phpshell.php?cmd=script.dumper.bat

Descargar el archivo “dump” para explotarlo con #mimikat
Descarga del volcado de la RAM desde el directorio web


3.USANDO MIMIKATZ 2.0 - Modulo MINIDUMP!!

Descargar mimikatz desde el repositorio oficial gentilkiwi, descomprimir e ingresar desde la consola de comandos ejecutando mimikatz.exe.
mimikatz # privilege::debug
mimikatz # sekurlsa::minidump nombre-del-archivo-dump-descargado.dmp
mimikatz # sekurlsa::logonpasswords


Listado de Archivos.

Enumeración de hashes y claves en texto plano del usuario Administrador


Herramientas utilizadas: Mimikatz: http://blog.gentilkiwi.com/securite/mimikatz/minidump
Procdump: http://technet.microsoft.com/en-us/sysinternals/dd996900.aspx

Fuente: http://ehopen-sec.blogspot.com/2014/01/extrayendo-contrasenas-de-la-ram-con.html

Parsero: auditando robots.txt

0 comentarios
Hoy vengo a traerles una herramienta para auditar el famoso protocolo que utilizan las webs para no dejarse ver por el buscador.
Este script desarrollado en Python, toma el archivo robots.txt que impide a los buscadores indexar ciertos path de la página y lo analiza, retornando cuáles son el estado de cada una de las entradas.
Herramienta fácil de utilizar y con la opción de buscar también los Disallow por el buscador de Microsoft, Bing.
Ya que muchos administradores creen que simplemente denegando el indexado desde aquí ya están seguros, es una buena herramienta para testearlos.
Mírenlo en funcionamiento:
Así que si no quieren tener problemas con Parsero, mejor que administren y bloqueen correctamente los controles de acceso.
El link a la descarga es: Parsero
 
Fuente: http://tutoriales-hacking.blogspot.com/2014/03/parsero-auditando-robotstxt.html

Como saber en que lenguaje esta desarrollada una página web

0 comentarios

Buenas tardes.

 Builtwith es una interesante herramienta online que informa, con tan solo introducir la dirección web de cualquier site, con que CMS está gestionado, que sistemas de publicidad utiliza, los widgets que tiene en funcionamiento, el tipo de servidor donde se encuentra alojado, las herramientas utilizadas para el análisis del tráfico o las tecnologías en que está desarrollado, entre otros datos.

Dependiendo de la complejidad del website el informe será mas o menos extenso.
 
Además del análisis ofrecido, Builtwith incluye un listado de los sitios más importantes y populares que utilicen las mismas tecnologías que el site testeado, un porcentaje del uso general de dicha tecnología y un enlace donde encontrar más información sobre la misma.

También he leído que existe un complemento para firefox que hace esto mismo de forma mas cómoda pero al momento de escribir esta entrada la página de dicho complemento esta en mantenimiento así que no pude realizar pruebas del mismo, de igual forma pueden probar el complemento llamado Wappalyizer.


Fuentes:
http://placerdigital.net/como-saber-que-tecnologias-usa-un-sitio-web/
http://www.desarrolloweb.com/de_interes/builtwith-descubre-como-esta-hecha-otra-web-826.html

Descargas:

Accede a Builtwith.
Accede al complemento

Herramientas online para ayudar una auditoria wifi.

0 comentarios
Buenas tardes.

Hoy vamos a ver dos páginas que seguro ayudaran a una auditoria wifi, estas herramientas son complementarias para nuestro procedimiento pero es posible que el ahorro de tiempo haga indispensable su uso.

Es algo irónico estar constantemente implementando mejores practicas, actualizando controles y muchas veces lo hacemos por costumbre y pocas veces nos sentamos a pensar, " bueno porque lo hacemos?". Un auditor va conocer los factores en teoría y pocos en la practica pero los que realmente saben en la práctica son los atacantes y de ellos es que nos necesitamos cubrir.

El primer sitio que vamos a ver es wpsdb, su mismo nombre lo dice todo, encontraremos pines por medio de la MAC de los routers, recordemos que existen keygens para algunas marcas en general.

 Link:  http://wpsdb.site40.net/

El segundo sitio es renderlab donde encontraremos diccionarios muy completos, tanto así que el mayor tiene un peso de 33 GB al día de hoy con un total de 1000000 palabras.
 
También pueden comprar los dvd que contienen la información (buen negocio, no lo había pensado).

Link: http://www.renderlab.net/projects/WPA-tables/

La otra semana veremos mas herramientas online y proximamente incluire un acceso directo desde el blog para ellas.

Referencias:

http://www.masters-hackers.info/showthread.php?t=34091
http://www.masters-hackers.info/showthread.php?t=40898

Saludos roboticos.

Probando aplicaciones de auditoría web con Google Web "Firing Range"

0 comentarios
Google anunció el pasado martes en su blog Google Online Security la publicación de una aplicación online (con su código fuente correspondiente) en la que se recopilaban diferentes pruebas de concepto relacionadas con vulnerabilidades típicas web, con especial hincapié en todas las variantes posibles para la ejecución de Cross-Site Scriptings. Actualmente Google se encuentra desarrollando una herramienta de auditoría de vulnerabilidades para uso interno (a la que llaman Inquisition) para la cual necesitaban casos reales de vulnerabilidades para probar su eficacia.



Disponemos de páginas preparadas para probar vulnerabilidades de los siguientes tipos hasta el momento (y dentro de cada tipología con multitud de pruebas posibles a realizar):
  • Cross-Site Scripting Address DOM
  • XSS de redirección
  • XSS reflejados
  • XSS basados en Tag
  • Cross-Site Scripting escapados por el servidor
  • XSS de inclusión remota
  • Cross-Site Scripting de DOM
  • Vulnerabilidades relacionadas con CORS (Cross Origin Resource Sharing)
  • Inyección Flash
  • Contenido mixto
  • ClickJacking inverso
Casos de pruebas dentro de la sección "Escape XSS"
Como podréis observar, el diseño no es lo más relevante, ya que lo que prima en este caso es tener un banco de pruebas sobre el que lanzar herramientas de detección de este tipo de vulnerabilidades y probar su eficacia, además de obviamente poder realizar pruebas de manera manual para conseguir el objetivo de un famoso alert() u otros tipos de acciones más interesantes.
Tenéis más información en el post de Google Online Security escrito por Claudio Criscione (Security Engineer en Google), así como en el repositorio de código del proyecto.
[+] Firing Range (Google) https://public-firing-range.appspot.com
 
Fuente: http://www.securitybydefault.com/2014/11/probando-aplicaciones-de-auditoria-web.html

XSS con Double URL Encode

0 comentarios
Este resumen no está disponible. Haz clic en este enlace para ver la entrada.

Tip para inyecciones en Mongo DB

0 comentarios
En auditorías donde nos encontramos ante bases de datos NOSQL como puede ser Mongo DB uno de los problemas con los que nos solemos encontrar al igual que con bases de datos SQL es el filtrado de los parámetros enviados, este filtrado con la idea de combatir inyecciones se suele centrar en el remplazo o escapado de caracteres como las comillas simples o las dobles y las backslash, pero como veremos en este artículo a veces cuando nos encontramos ante ciertas situaciones es posible sin necesidad de escapar los caracteres entre los que se encuentra enjaulado el parámetro existe posibilidad de obtener todos los resultados de una colección.
En el ejemplo siguiente, si se estuviesen filtrando caracteres como las comillas simples o las dobles y las backslash no podríamos inyectar otra instrucción 

{ "ip" : " Parámetro_enviado_por_GET "}
clip_image001

Sin embargo si nos encontrásemos con un escenario como el siguiente que aun no siendo tan común es posible, no sería necesario escapar los caracteres anteriormente mencionados para poder armar una buena en la auditoría por ejemplo listando todos los resultados de la colección. 

{ "ip" : { $regex: ' Parámetro_enviado_por_GET ', $options: 'i' }} 

Y es que como veremos a continuación, basta con añadir dos caracteres que raramente son tenidos en cuenta a la hora de filtrar los datos de entrada a la aplicación 


clip_image002

Así de sencillo dos puntos o cualquier otro carácter y un asterisco y como se aprecia nos devuelven todos los resultados de la colección, en este caso 50, así que ya sabéis chavales añadid un caracter cualquiera y un asterisco a vuestros diccionarios de inyecciones que os pueden dar una grata sorpresa en vuestras auditorías, a mí me la dio, ya que me devolvieron todos los usuarios y sus datos de la colección ordenaditos en una tabla, que más se puede pedir. 

Fuente: http://code-disaster.blogspot.com/2014/09/tip-para-inyecciones-en-mongo-db.html
Documentación de apoyo: http://whk.elhacker.net/index.php?topic=2863.0

Prevención de fugas de información en logs. Campo Passwords y Mod security

0 comentarios
Cuando un atacante pretende comprometer un sistema, una de las ubicaciones que debe observar son los logs. Imaginaros el caso de un sistema comprometido, en el que el atacante accede a los logs del sistema, en el que se muestran en claro los usuarios y contraseñas de nuestros usuarios. Se lo pondríamos muy fácil.



En algún cliente me ha ocurrido la situación de  presentar una solución tipo Snort, Mod Security e incluso un simple Squid Proxy para proporcionar elementos de seguridad, y ser la propia gerencia la que descartaba este tipo de soluciones por la exposición de información sensible, y casi siempre personal, al departamento IT o el departamento que accede a los logs ( redundante, los informáticos lo vemos todo, desde el de micro-informática hasta el sysadmin-boss).

Con un proxy podemos ver los hábitos de navegación de nuestros director de ventas, que son muy decorosos...Con Snort podemos detectar aplicaciones prohibidas, como pueda ser el famoso BroadCast de Dropbox...

Para proporcionar un nivel de seguridad y confianza en la gestión de logs de Mod Security, vamos a crear una pequeña regla al respecto.

Lo que hacemos es crear una regla tan sencilla como la siguiente. Con ella simplemente lo que hacemos es que en fase 5,la parte de logging, sanitice !*"!^·*!^"*·! (limpie los caracteres de un campo con asteriscos).

SecRule &ARGS:password "@eq 1" "phase:5,t:none,id:123458,nolog,pass,sanitiseArg:password"


Esta regla de por sí no generará alarma, simplemente que en nuestras reglas existentes, cuando detecte un campo password, "limpiará" el registro con ****.

Veamos un ejemplo. Lanzo un "ataque" ficticio sobre una aplicación, para que salte cualquiera de las alarmas que tenemos configuradas ( en este caso salta una alarma por hacer match de la palabra UNION).


Como puedes ver, aparece la contraseña en claro.
Sin embargo una vez activada nuestra nueva regla, podemos comprobar que el mismo ataque, genera la misma alerta, pero limpia el campo.


Como puedes ver, esta simple regla puede propiciar que gerencia vea con buenos ojos tu medida de seguridad, y no estés viendo todas las passwords de los clientes. Pobres ilusos xD pero bueno, creo que todo el mundo es consciente de que este tipo de información es manejada por el departamento IT.

Como siempre, espero que os guste, gracias por leerme !!!

Fuente:  http://kinomakino.blogspot.com/2014/10/prevencion-de-fugas-de-informacion-en.html

Auditoría de seguridad de redes UMTS (3G) y GSM (2G) en tu móvil

0 comentarios
Hace unos años aparecía una herramienta OpenSource revolucionaría que nos permitiría conocer muchos secretos de las redes GSM; OsmocomBB. Tras este proyecto, SRLabs en un intento de modernizar la solución y facilitar el uso, hizo posible analizar trazas de las redes UMTS y GSM en un dispositivo móvil en un nuevo proyecto: la aplicación para Android GSMmap . Para poder evaluar las capturas de esta aplicación y con ello ver qué está pasando en estas redes, es necesario instalar otra aplicación: xgoldmon, de Tobias Engel, que debe ser ejecutada en un PC bajo Linux.

¿Tobias Engel? Efectivamente, os debe sonar este nombre ya que fue él quien realizó en la 25C3 la impactante presentación de cómo localizar teléfonos móviles en las redes SS7:
Es probable que a muchos no os suene a nada el acronimo "SS7", pero desde luego que es el corazón de las interconexiones de redes internacionales (Roaming), formado por un conjunto de protocolos de uso muy común: SCCP, ISUP, INAP, MAP ... desarrollado por AT&T a partir de 1975. 
Pues bien, Tobias Engel y Ravishankar Borgaonk han creado una nueva aplicación para Android totalmente independiente, sin necesidad de otro software en el PC: Darshak (ver código fuente) que examinaremos a continuación con todo detalle en este artículo y como no, pondremos a prueba. La aplicación examina la información del interfaz de Anroid Radio Interface Layer (RIL) para detectar eventos anormales y presentarlos al usuario; llamadas sin cifrar, sin autenticar, etc. Dentro de estos eventos se encuentran los famosos SMS invisibles (silent SMS), utilizados para localizar a un usuario dentro de la red móvil o para instalar una aplicación Java en nuestra SIM, como demostró Karsten Nohl en su conocida charla de la BlackHat 2013: Rooting SIM cards.
  • Requisitos
Para poder utilizar la aplicación darshak necesitamos:
  1. Teléfono Samsung Galaxy S3 (GT I9300) aunque en alguna presentación los autores han hecho mención al Samsung Galaxy S2. 
  2. Version 4.1.2 de Android. Recomiendo descargarla de Sammobile
  3. Rootear el teléfono. Los autores aconsejan utilizar framaroot, aunque en mi caso ninguna versión encontró un exploit adecuado y acabé recurriendo a Odin y el mod CF-Root creado por el desarrollador Chainfire (version CF-Root 6.4).
  4. Configurar el modo DEBUG del teléfono a "HIGH". Para ello, en la aplicación marcador del teléfono, escribimos el código *#9900#, veremos la opción "Debug Level Enabled" y marcaremos el valor a "HIGH". Tras esto el teléfono se reiniciará.
Si no tenemos problemas de último momento, en un par de horas hemos subido la versión de Android y rooteado el teléfono, descargado la aplicación del Android Market y ya estamos listos para analizar las redes 3G y 2G.
  • Uso de la aplicación
Nos encontraremos ante una pantalla vacia, con una estructura de tabla donde podemos leer:
· Fecha (Date): Timestamp del momento en el que se detecta el evento/alarma.
· Tipo de Red (Network type): indica el tipo de red que estamos utilizando en el momento del evento, si es 2G o 3G.
· Evento (Event): indica si se trata de llamada saliente o entrante, mensaje saliente o entrante.
· Autenticación (Authentication): mostrará una bola verde si todo ha ido bien o roja en caso de no haberse autenticado el evento. Es decir, si hemos realizado una llamada y la red no nos ha solicitado autenticarnos, entonces veremos la bola roja.
· Cifrado (Encryption): De igual modo que antes, si el evento ha sido cifrado veremos la bola verde, pero si el evento ha tenido lugar en plano, bola roja.
· Eliminar (Remove): Eliminar el evento de la aplicación.
Presionando sobre cualquier campo excepto en Eliminar, se abrirá otra ventana con más información sobre el evento, donde encontraremos información muy útil que veremos a continuación. En contra de lo que podamos pensar, hay que darle al boton de "Refresh logs" cada cierto tiempo porque la aplicación no se auto-refresca todo lo bien que debería (¡punto de mejora!).
  • Vamos a poner la aplicación a prueba
Para muchos usuarios con llegar a este punto ya puede ser suficiente, tenemos la aplicación instalada y esperamos que un día al refrescar aparezca un evento en la pantalla principal de darshak. Si no podemos esperar y queremos comprobar cómo funciona, vamos a generar llamadas y mensajes en 3G y en 2G, sometiendo la aplicación a situaciones provocadas para comprobar que efectivamente son detectadas y reportadas. Veremos también métodos para obtener las evidencias de estos eventos/alarmas, fundamental en toda auditoría de seguridad.
Para generar llamadas y mensajes cortos vamos a utilizar la aplicación GSMmap, de la que hemos hablado en la introducción. En los ajustes del télefono vamos a forzar a sólo utilizar redes GSM (2G) o sólo utilizar redes UMTS/WCDMA (3G) para a continuación ejecutar GSMmap. Tan sólo tenemos que entrar en modo contribuir información (Contribute), aceptar el disclaimer y presionar sobre "Run Test":
Una vez haya finalizado todo el ciclo (por defecto 5 iteraciones de 4 pruebas), salimos de la aplicación para abrir darshak:
Vaya ... ya sabíamos que las redes GSM no autentican todas las operaciones, tal y como pudimos leer en otro artículo de Security by Default, pero ... ¿ Sólo 2 de 9 han sido autenticadas? ¡No parece mucho ! Vamos a abrir uno de estos eventos pulsando sobre la fecha. A continuación podemos ver dos llamadas de ejemplo, en una sí se ha solicitado la autenticación por parte de la red y en la otra no:
Parece increíble, tenemos una cantidad de información valiosísima en esta pantalla:
  1. Los algoritmos de cifrado que soporta nuestro teléfono.
  2. El TMSI que está utilizando la SIM (TMSI: Identidad Temporal de la SIM) .
  3. El evento, en este caso una llamada realizada por nuestro móvil (OUTGOING CALL), y que ha sido cifrada (Network operator is requesting to start ciphering).
  4. El algoritmo con el que finalmente se va a cifrar la llamada (¡¡A5/3 !! ¡¡Por fin !!).
  5. En el caso del evento alarmado, vemos que la red no ha pedido ningún tipo de autenticación, ni siquiera una identificación del terminal (IMEI).
  6. En el otro caso, vemos bajo GSM_INIT_AUTH_REQ el número aleatorio (RAND) que la red ha enviado a la SIM para autenticarnos.
En este punto, a parte de mi asombro al poder contar con esta información en el móvil allí donde vaya, me pregunto si al abrir las trazas de la aplicación GSMmap me encontraré con la misma información, para así acabar de convencerme de que esta aplicación es realmente una maravilla.
En la ruta donde se instala la aplicación GSMmap en el móvil encontraremos las trazas de las pruebas (/Android/data/de.srlbas.gsmmap/files), copiamos el fichero a nuestro PC y lo abrimos con xgoldmon:
/opt/xgoldmon# ./xgoldmon -t s3 -l -i 127.0.0.1 xgs.GT-I9300.20141007-195238.GSM.zzzz.sms_mt.4.log

Antes de ejecutar xgoldmon, abrimos wireshark escuchando en el puerto 4729 para ver las trazas:
Podemos ver en la primera imagen que efectivamente en el proceso de autenticación se ha utilizado ese número RAND. Si continuamos, en la seguna imagen podemos ver los mensajes Ciphering Mode Command y Complete, en los que también comprobamos que estamos utilizando el algoritmo A5/3, como remarco en rojo en la imagen.
Si repetimos el proceso para una llamada UMTS, podemos ver los mensajes SecurityModeCommand y SecurityModeComplete, a partir de los cuales el resto de señalización estará cifrada. En rojo he marcada el algoritmo UEA1, mientras que en amarillo la secuencia de autenticación y cifrado.


Para no alargar el artículo, resumo mi experiencia comentando que he podido comprobar que la aplicación refleja perfectamente estos eventos en las redes 2G, aunque en 3G tienen que corregirse algunos bugs sobre alarmas falsas de cifrado:
Cuando investigamos las trazas, vemos que la llamada sí se ha cifrado con los algoritmos UEA1 y UIA1, pero debido a este fallo,el evento es presentado con alarma. Según he podido confirmar con los autores de la aplicación, en unas semanas se publicará la siguiente versión de la aplicación que corrige este fallo.
  • Para terminar.
Cuando estaba alucinando con esta aplicación, pensé en el único punto negativo que se me ocurría; cuando vea una alarma en el móvil, no tendré más trazas/evidencias de lo que ha pasado que el evento de la aplicación. Pero me estaba equivocando, sí las tenemos en una base de datos sqlite3.
Si queremos investigar cualquier evento notificado por la aplicación, debemos buscarlo dentro de la base de datos sqlite3 que se encuentra en /data/data/darshak/databases/


Investigando dentro podemos llegar a ver la ráfaga UMTS o GSM que ha causado el evento en la aplicación, dejo a vuestra disposición una pequeña captura que muestra cómo ver los eventos mostrados y para uno de ellos (ID 31), ver la información ampliada.


sqlite3 /Darshak/DarshakDB
SQLite version 3.8.2 2013-12-06 14:53:30
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> .tables
CELLULAR_EVENT    PACKET            PROFILE_PARAMS  
LOG               PACKET_ATTR       android_metadata
sqlite> select * from LOG;
23|1412579648961|2|4|XXXXX|1
...
59|1412747333774|1|1|XXXXX|0
sqlite> 
sqlite> select * from LOG where UID='23';
23|1412579648961|2|4|XXXXXX(operadora)|1
sqlite> 
sqlite> select * from PACKET where UID='7';
7|23|1412579648961|5|05 12 00 E1 47 DE 16 32 0F 72 89 46 01 6A 31 3F 2A 18 22 20 10 34 68 45 1E 78 AE 00 00 13 ED 2E D8 F4 38 C9 44 |0
sqlite> 
sqlite> select * from PACKET_ATTR where PACKET_UID='7';
19|7|1412579648961|1|E1 47 DE 16 32 0F 72 89 46 01 6A 31 3F 2A 18 22 |RANDOM Number : E1 47 DE 16 32 0F 72 89 46 01 6A 31 3F 2A 18 22 
20|7|1412579648961|19|34 68 45 1E 78 AE 00 00 13 ED 2E D8 F4 38 C9 44 |AUTN Number : 34 68 45 1E 78 AE 00 00 13 ED 2E D8 F4 38 C9 44 
sqlite>   
Si ahora os fijáis en los datos de la llamada en 3G que hemos visto en la imagen anterior, podéis ver que los número RANDOM y AUTN son los mismos, pero ahora tenemos acceso a la ráfaga entera, la cual nos va a permitir conocer más detalles:
05 12 00 E1 47 DE 16 32 0F 72 89 46 01 6A 31 3F 2A 18 22 20 10 34 68 45 1E 78 AE 00 00 13 ED 2E D8 F4 38 C9 44

  • Conclusiones.
Hace unos meses los compañeros de Layakk nos presentaron en la RootedCon su ataque a 3G. Quienes pudimos ver la charla nos quedamos con muchas dudas sobre cómo se ha implementado la seguridad en esta red, dudas que hoy gracias a darshak podemos despejar sin mucho esfuerzo, simplemente utilizando nuestros móviles para luego analizar la información que nos aportan.
¿Se cifran todas las llamadas en 3G? ¿Se autentican todos los eventos?¿Cada cuanto tiempo se refresca nuestro TMSI/P-TMSI/GUTI?
A veces es preferible no conocer las respuestas a estas preguntas para seguir con esa agradable sensación de falsa seguridad que nos proporciona el desconocimiento, pero si quieres conocer qué pasa en las redes móviles, te recomiendo probar darshak.
 
Fuente: http://www.securitybydefault.com/2014/10/auditoria-de-seguridad-de-redes-umts-3g.html
Powered by Bad Robot
Helped by Blackubay