PDF de programación - Howto - Torneo Shell Warzone

Taller warzone Papers

–

HOWTO – TORNEO SHELL WARZONE

Como se realizo el Torneo Shell

Bueno anteriormente ya había hecho yo una implementación de un 
wargame parecido con un solo nivel, eso fue en Diciembre del 2007, 
ya con un poco de experiencia adicional, le comente a sirdarckcat 
la idea de realizarlo nuevamente, pero mas extendido 
(Niveles/Dificultad) esto fue a principios de Noviembre del 2008, 
gustándole mucho la idea me pidió que si lo realizaba para los 
usuarios de warzone.elhacker.net y pues no me pareció mala idea ya 
que hay usuarios que tienen bastante nivel de conocimientos y 
además les gusta el tema de seguridad informática.

Después de bosquejar a grandes rasgos los detalles del wargame me 
puse a trabajar sobre el el sistema operativo en ello, quería que 
todo estuviese listo para la fecha propuesta 29 de Noviembre 0 
horas GMT.

Elegí FreeBSD 7.0­RELEASE como sistema operativo, debido a que es 
muy estable y rápido de configurar y mas que nada que no son tan 
frecuentes las fallas de seguridad sobre el mismo.

Para mantener el sistema operativo al día, realice solo la 
instalación del sistema base, el directorio de ports, y el código 
fuente de todo el sistema.

Recompile el Kernel de FreeBSD ajustándolo a las características 
del Hardware, agregue las opciones para activar el firewall "PF".

Recompile todo el árbol de aplicaciones, cosa que aproveche para 
aplicar parches de las contadas vulnerabilidades que se habían 
publicado para FreeBSD 7.0­RELEASE.

Realice una copia estáticamente compilada de las aplicaciones 
criticas del sistema tal como ps,ls,md5, entre otras, además de 
una lista del md5sum de los ejecutables estándar del sistema.

Instale en el siguiente orden las siguientes aplicaciones y sus 
respectivas dependencias:

­portaudit
­wget
­pache2
­php
­gcc3

Taller warzone Papers

–

Después de configurar los servicios que incluiría en el sistema 
(sshd,httpd) y configurar PF instale el php­find­sock, bajo el 
archivo shell.php del directorio / del apache, la cual seria la 
única forma de accesar al shell del sistema en un principio, 
shell.php fue proporcioando por sirdarckcat, es un fake del 
clásico 403 forbidden y al final mandaba a ejecutar las 
instrucciones del findsock, el archivo cual modificaba las 
cabeceras http de respuesta del servidor en tiempo real, esto para 
confundir un poco y en principio a los participantes.

Se creo sobre /usr/home el árbol del wargame, con los permisos de 
archivos hasta cierto punto bien distribuidos, para que fuese mas 
divertido todo se les agrego a los usuarios un bonito prompt 
"C:\Users\$LOGNAME\Desktop> "

Después de configurar /etc/login.conf con una nueva clase de login 
(Esto es como los grupos pero solo se usa para la asignación de 
recursos bajo el sistema), para mantener hasta cierto punto las 
cosas en su lugar:

warusers:\
:copyright=/etc/COPYRIGHT:\
:welcome=/etc/motd:\
:setenv=MAIL=/var/mail/$,BLOCKSIZE=K:\
:path=~/bin /bin /usr/bin /usr/local/bin:\
:manpath=/usr/share/man /usr/local/man:\
:nologin=/var/run/nologin:\
:cputime=10m:\
:datasize=8M:\
:vmemoryuse=50M:\
:stacksize=2M:\
:memorylocked=4M:\
:memoryuse=8M:\
:filesize=8M:\
:coredumpsize=1M:\
:openfiles=24:\
:maxproc=32:\
:priority=0:\
:umask=077:\
:ignoretime@:

De no haber sido por esto cualquiera hubiese reiniciado/saturado el server.

En general estas fueron las prevenciones básicas que se tuvieron en cuenta.

Taller warzone Papers

–

Ahora la estructura del wargame es siguiente en general para los 4 niveles.

Ruta del Directorio: /usr/home/<directorio>
Ruta de la aplicacion vulnerable : /usr/home/<directorio>/<vulnerable>
Ruta del Directorio con el password: /usr/home/<directorio>/<directoriopassword>
chown user:grupo /usr/home/<directorio>
chmod 750 /usr/home/<directorio>
chown user:otroGrupo /usr/home/<directorio>/<vulnerable>
chmod 2755 /usr/home/<directorio>/<vulnerable>
chown user:otroGrupo /usr/home/<directorio>/<directoriopassword>
chmod 750 /usr/home/<directorio>/<directoriopassword>

Entonces la como se ve la unica forma de acceder al directorio es perteneciendo al grupo propietario
del directorio, esto me sirvio para tener un control/orden en la forma de pasar los niveles.

Y para controlar quien pasaba las aplicaciones solo era cuestion que leer sobre el directorio
/usr/home/<directorio>/<directoriopassword> un archivo del cual solo nosotros eramos capaces
de leer ya que tenia los permisos 600. Cosa que para leerlo habia que obtener los permisos del
grupo otroGrupo, por eso fue que a los ejecutables les asisgne permisos 2755 (Con el bit sgid
activado). Lo cual solo se consegia explotando el archivo vulnerable.

Pruebas.

De las 4 pruebas que se hicieron las primeras 3 son muy simples y sin mucha complejidad, la cuarta
prueba fue la mas compleja de todas ya que su depuracion era un poco mas complicada y el metodo
de explotacion de esta misma no es muy estudiado, aunque la documentacion existene de la falla
sea apliamente documentado.

1. Clasico Stack over Flow
2. Un ejemplo basico de los Heap over Flow y adicionalmente Symlink
3. Otra version del Stack over Flow
4. Ejemplo de Format String

Clasico Stack over Flow

Entrada de datos: Argumentos de programa, Variables de Entorno.

Codigo fuente:

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

int main(int argc,char **argv) {
printf("Mas facil no se puede xD\n");
if(argc<2) {
printf("Se esperaban Parametros!!\nUso:\n\t%s <algo>\n",argv[0]);
exit(0);
}
else {
char cadena[1024];
strcpy(cadena,argv[1]);
printf("Usted paso como parametro lo siguiente:\n\n%s\n",cadena);
}
return 0;
}

Como se puede ver solo es cuestión de desbordar el buffer de datos "cadena", no ta que este
ejemplo se compilo con gcc3.x

Taller warzone Papers

–

Un ejemplo basico de los Heap over Flow y adicinalmente Symlink

Entrada de datos: Argumentos de programa, Variables de Entorno, Archivos.

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

#define ERROR -1
#define BUFSIZE 256

int main(int argc, char **argv) {
char a;
int n,c,i,j,len;
FILE *tmpfd,*tendout;
static char *sBuffer,*tempBuffer, *tmpfile,*endfile,nombre[BUFSIZE];
tmpfile = (char*) calloc(BUFSIZE,sizeof(char));
check();
if(tmpfile == NULL) {
fprintf(stderr, "calloc(): %s\n", strerror(errno));
exit(ERROR);
}
strcpy(tmpfile,"/tmp/input_");
sprintf(tmpfile,"%s%d",tmpfile,getuid());
endfile = (char*) calloc(BUFSIZE,sizeof(char));
&amp;amp;amp;amp;amp;nbsp;if(endfile == NULL) {
fprintf(stderr, "calloc(): %s\n", strerror(errno));
exit(ERROR);
}
if(errno == EBADF) {
exit(ERROR);
}
strcpy(endfile,"/tmp/output_");
sprintf(endfile,"%s%d",endfile,getuid());
tmpfd = fopen(tmpfile, "r");
if (tmpfd == NULL) {
fprintf(stderr, "fopen(): %s: %s\n", tmpfile, strerror(errno));
exit(ERROR);
}
if(fscanf(tmpfd,"%d",&n) == EOF) {
fprintf(stderr,"fscanf(): Input Error!");
}
c = 0;
sBuffer = (char*) calloc(1024,sizeof(char));
if(sBuffer == NULL) {
fprintf(stderr, "calloc(): %s\n", strerror(errno));
exit(ERROR);
}
tempBuffer = (char*) calloc(1024,sizeof(char));
if(tempBuffer == NULL) {
fprintf(stderr, "calloc(): %s\n", strerror(errno));
exit(ERROR);
}
tendout = fopen(endfile, "a+");
if (tendout == NULL) {
fprintf(stderr, "fopen(): %s: %s\nUsando salida Estandar\n", endfile, strerror(errno));
tendout = stdout;
}
while(c <= n && n > 0) {
fgets(sBuffer,1024,tmpfd);
i = 0;
j = 0;
len = strlen(sBuffer);
while(i < len ) {
if(!isspecial(sBuffer[i])) {
tempBuffer[j++] =(char) sBuffer[i] - 2;
}
i++;
}
c++;
tempBuffer[j] == '\0';
fprintf(tendout,"%s\n",tempBuffer);
memcpy(nombre,tempBuffer,j);
memset(tempBuffer,0,1024);
memset(sBuffer,0,1024);
}
fclose(tmpfd);
fclose(tendout);
tendout = fopen(endfile, "r");
if (tendout == NULL) {

Taller warzone Papers

–

fprintf(stderr, "fopen(): %s: %s\n", endfile, strerror(errno));
exit(ERROR);
}
while(!feof(tendout)) {
fscanf(tendout,"%c",&a);
printf("%c",a);
}
fclose(tendout);
}

Bueno a grandes rasgos este perece a simple vista parece otro Stack overflow de dados, sin embargo
como las varibles importanes son static estas se declaran en la zona de datos inicializados que en
parte esta en heap aunque no sean propiamente varibles creadas dinamicamente con malloc/calloc
debido a esto es imposible que para este ejemplo dichos desbordamientos puedan escribir en la
dirección de retorno de alguna funcion llamada (Exiten sus exepciones pero son ejemplos mas
complejos etc.)

Taller warzone Papers

–

Otra version del Stack over Flow

Entrada de datos: Argumentos de programa, Variables de Entorno.

Codigo fuente:

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

int main(int argc,char **argv) {
printf("dejavu?\n");
if(argc<2) {
printf("Se esperaban Parametros!!\nUso:\n\t%s <algo>\n",argv[0]);
exit(0);
}
else {
char cadena[1024];
strcpy(cadena,argv[1]);
printf("Usted paso como parametro lo siguiente:\n\n%s\n",cadena);
}
return 0;
}

Como se puede ver solo es cuestión de desbordar el buffer de datos "cadena", de hecho he usado el
mismo codigo del primero solo cambiándole el mensaje mostrado la única diferencia es que fue
compilado con gcc4.x esto para que implemente Stack cokies.

Taller warzone Papers

–

Ejemplo de Format String

El cu