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.0RELEASE 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.0RELEASE.
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 phpfindsock, 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;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
Crear cuenta
Comentarios de: Howto - Torneo Shell Warzone (0)
No hay comentarios