Introducción a NetKit ( IV ): Un puente a Internet

Introducción a NetKit( III ): switches y enrutado
Introducción a NetKit( II ): creando redes
Introducción a Netkit( I ): Instalación

Pues llegamos a la última parte de esta introducción a NetKit, donde simplemente veremos como hacer un laboratorio con una máquina que se conecte a el anfitrión ( y con ello a Internet ), queda como ejercicio para el lector añadir y configurar otras máquinas a la red que aprovechen esa conexión.

Introducción a NetKit( III ): switches y enrutado

Introducción a NetKit( II ): creando redes
Introducción a Netkit( I ): Instalación

Bueno, pues seguimos con esto, como dijimos la última vez, ahora lo que queremos es crear una red de 4 máquinas, dos switches conectados entre sí y cada uno a otra máquina, y que se puedan comunicar entre ellos sin problemas, el esquema en general sería este:

 No es tanto un problema con NetKit ya que se puede hacer con lo que ya sabemos, como un ejercicio sobre como hacer tablas de enrutado.

Introducción a NetKit( II ): creando redes

Introducción a Netkit( I ): Instalación

Lo dicho es hecho, y a lo hecho...  seguimos con la segunda parte de la introducción a NetKit, ahora veremos como crear y configurar laboratorios pequeños ( sin routers, que es lo mismo pero hay que enrutar ), las conexiones hacia internet se demorarán probablemente hasta el fin de semana ya que se necesitan permisos de root en el host :P .

Acelerenado `route`, `netstat` y parecidos [tip]

Los comandos de red como `route`, `netstat`, e incluso programas como `nmap` tienen la constumbre de intentar convertir las IP's en nombres de red después de realizar su función principal. Por muy útil que sea a veces, en otros momentos es excesivamente pesado, por ejemplo si utilizamos:

---

netstat

---

Para descubrir las conexiones activas, después de obtenerlas intentará convertir las IP en nombres de red, y en muchos normales no resultará en nada útil (seguramente acabe mostrando las IP o nombres genéricos).

Estos mismos comandos suelen aceptar el flag -n que evita esa resolución, el cambio salta a la vista:

Hasta otra

Escaneando un servidor FTP

Para hacer una araña que explore un servidor FTP se puede aprovechar el ftplib de python... solo tiene un impedimento, que cuando se pide la lista de archivos en un directorio se devuelve por stdout, lo que es bastante molesto para algo como esto.

La solución más sencilla es substituir la salida estándar ( sys.stdout ) por un objeto que almacene los datos, el único método que hace falta en el objeto es objeto.write(string) , el que se usa para mostrar strings por la pantalla, esto puede servir:

PyLOIC 0.2

Visto lo visto y viniendo lo que viene, hay nueva versión de pyLOIC, entre otras cosas se añadieron 2 formas de ataque más efectivas:

• Uno basado en Slowloris, un poco más abajo, aquí, están los servidores a los que afecta (aunque no espereis gran cosa para 10 minutos de código) 

•  Y otro un clásico, "un Stairway to Heaven casi", un SYN flood... peeeero necesita Scapy ('sudo apt-get install python-scapy') y permisos de root. 

Además se añadieron los cambios a la GUI de fanta (tirando de copypaste descarado de su código =P ) para aprovechar lo nuevo [pyloic02.zip].

Actualización: arreglado Bug gracias a Tincho que hacía que nunca cerrase las conexiones -fixed-

Pitufeando con Scapy y python

Empezando por el principio, HackXCrack acaba de liberar otra tanda de tutoriales entre los que se encuentra uno sobre Scapy escrito por Larry sobre la manipulación de paquetes (muy recomendable, por cierto).

Resulta que Scapy es una librería para python (aunque puede usarse aparte de forma interactiva ) que permite trastear con los paquetes creandolos, snifandolos, decodificandolos, una burrada de cosas (al parecer hasta puede usarse para decodificada VOIP sobre un canal WEP cifrado), por último decir que funciona sin gran dificultad sobre cualquier OS mayoritario.

Lo que venía a presentar hoy es un script de prueba que lanza ataques smurf usando Scapy, se puede encontrar aquí [smurf.py]

SniperlCat 0.3.1, pasado a perl estricto y correjidos bugs varios

Esta versión no trae nada nuevo, así que va a ser corto. Se pasó todo el código a perl estricto (use strict), y se corriguieron fallos tontos al interpretar las opciones de la línea de comandos, por ejemplo, si se daemonizaba después de lanzar un hilo, el hilo se cerraba por que lo hacía el proceso original =P

El trigger no cambia (bueno, en realidad cambia el notify-send, que en vez de poner 0.3, es 0.3.1, pero es estético). El código completo está en github , aunque lo importante es el Sniperlcat.pl [o en plano]

ps: Ya me dirán por que ******* no dejarán usar break; en estricto !?

Clon de LOIC en python

Cierto anónimo sugirió hacer un clon de LOIC en python, aquí está un posible código, dividido en 5 archivos, no tiene interfaz gráfica, pero implementa el flooder de los 3 protocolos de LOIC.

Actualización: subido a github https://github.com/kenkeiras/pyLOIC

SniperlCat 0.3, suma y sigue

Pues nada, nueva versión de sniperlcat, los cambios son:
  - Los avisos los hace un script a parte, eliminando GTK de las dependencias y haciendo que no haya que trastear en el código para que haga algo distinto con los avisos.
  - Corregido al bug que lo volvia paranoico al cerrar el dispositivo...al final solo había que reabrirlo =)
  - Añadida la opción de poner a la escucha un puerto cualquiera para detectar los scanners que se conectan a el, si se utiliza varias veces se escuchan varios puertos (cada uno en un hilo distinto).

Introducción a NetKit (I): instalación

Al final si que habrá tuto de Netkit (lo estás leyendo ahora), más que nada orientado a esa gente que quiere trastear con las redes, y que no tiene espacio/tiempo/ganas de montar una fisica o con las máquinas virtuales habituales (tipo VirtualBox) y a aclarar algo mis propias ideas :P.

Generador de redes netkit

Comenzando por el principio... NetKit, conocido como "El sistema del hombre pobre para experimentar con redes de ordenadores" es un proyecto que pretende usar UML (User Mode Linux, un kernel que como su nombre indica, corre en espacio de usuario, en ring 3) para simular redes de ordenadores completos pero ligeros (normalmente Gnu/Linux Debian en modo texto).

SniperlCat 0.2, detección de SYN scan's

Actualización: por algun extraño motivo se vuelve paranoico con los paquetes cuando se suspende el ordenador y se vuelve a iniciar (¿?), estoy trabajando para resolver eso.

Hoy traigo la segunda versión del SniperlCat [SniperlCat 0.2], los cambios no son muchos, pero creo que pueden resultar interesantes:

- Detecta los paquetes SYN de sockets raw (típicos de un SYN scan), aunque para esto necesita permisos de root para levantar un sniffer, básicamente se aprovecha esta [http://danielmiessler.com/study/synpackets/] idea, aunque con scanners modernos se puede hacer que no exista diferencia, unicamente avisa de paquetes con un tamaño menor de 60 bytes (suelen ser de 58) y sin el flag DF de IP activado.

- Permite llevar un log aparte de las notificaciones... no es gran cosa pero puede ser útil.

- Las alertas se reunieron en una función llamada "show_alert" para poder modificar el sistema más facilmente.

Las dependencias quedarían en "libgtk2-notify-perl" para las notificaciones, y "libnet-pcap-perl" y "libnetpacket-perl" para buscar paquetes sospechosos.

Y la sintaxis del comando sería:

---

Sniperlcat 0.2

sniperlcat [-h]|[-d | -v ] [-nf] [-c] [-n <red>] [-f <descriptor de red>] [-p|-np] [-dv <interfaz>][-l <log>][-s <tiempo>]
-h  (--help): Muestra este mensaje
-d  (--daemonize): Se ejecuta de fondo
-nf (--no-fill): No llena la tabla de hosts (con nmap) antes de leerla
-c  (--cansino): Repite los avisos, aún los ya emitidos, en cada iteración
-v  (--verbose): Muestra más información por pantalla
-n  (--network): Especifica la red donde se ejecuta, por defecto 192.168.1.0/24
-dv (--device): Especifica la interfaz de red que se monitoreará
-p  (--privileged): Se asumirán que es un usuario con privilegios
-np (--no-privileged): Se asumirán que es un usuario sin privilegios
-l  (--log): Se guardarán los avisos en un archivo
-s  (--sleep): Especifica el tiempo en segundos de "descanso" entre iteraciones (por defecto 60)

---

Eso es todo, otro día... más.

[Referencias]
http://seclists.org/pen-test/2007/Oct/44
http://www.perlmonks.org/index.pl?node_id=170648
http://search.cpan.org/~saper/Net-Pcap-0.16/Pcap.pm

SniperlCat, un guardian de red

Hoy traigo un script en perl que vigila la red en busca de nuevos hosts o de ataques de ARP spoofing (buscando cambios en la tabla arp). El nombre, Sniperlcat es (obviamente) una mezcla entre snipercat y perl, lenguaje en el que esta programado.

El script se puede descargar aquí [sniperlcat.pl], o al final coloreado.

Simplemente hay que ejecutarlo y avisa de los cambios usando el libnotify de GTK2 (puede que sea necesario instalar las librerias Gtk para perl, libdesktop-notify-perl, o libgtk2-notify-perl ).
Por ejemplo, para un nuevo host en la red:

Si el nuevo host está spoofeado desde otro (si coinciden sus MAC):

Si cambia una MAC:

O si cambia la MAC de uno a través de un ARP spoof:

Hay que tener en cuenta algunas cosas:

• El script no hace nada para evitar los ataques ARP spoof, solo los detecta
• Si no se lanza con una configuración, utilizará como tal la tabla ARP en ese momento, si hay entonces un ARP spoof en marcha, lo tomará como el estado base.

Los parámetros aceptados son:

---

./sniperlcat [-h]|[-d | -v ] [-nf] [-c] [-n <red>] [-f <descriptor de red>] [-s <tiempo>]

-h  (--help): Muestra este mensaje

-d  (--daemonize): Se ejecuta de fondo

-nf (--no-fill): No llena la tabla de hosts (con nmap) antes de leerla

-c  (--cansino): Repite los avisos, aun los ya emitidos, en cada iteración

-v  (--verbose): Muestra más información por pantalla

-n  (--network): Especifica la red donde se ejecuta, por defecto 192.168.1.0/24

-f  (--file): Especifica el archivo de red inicial (se obtiene con arp -an)

-s  (--sleep): Especifica el tiempo en segundos de "descanso" entre iteraciones (por defeto 60)

---

Creo que solo necesitan explicación un par de cosas:

• Antes de leer la tabla ARP, para llenarla con todos los host de la red se hace un `nmap $red -sP` , si consideras que no es necesario, usa -nf
• Si la red es distinta de 192.168.1.0/24 (o 192.168.1.*), la puedes cambiar con -n red, como solo lo usa nmap, la sintaxis es la misma que este.

Hasta otra.

El script [sniperlcat.pl] :

---

#!/usr/bin/env perl
#
# SniperlCat
#
##############################################################################
#  Copyright (C) 2010 Kenkeiras <kenkeiras (arroba) gmail (punto) com>
#
#  This program is free software. It comes without any warranty, to
#  the extent permitted by applicable law. You can redistribute it
#  and/or modify it under the terms of the Do What The Fuck You Want
#  To Public License, Version 2, as published by Sam Hocevar.
#
#  See http://sam.zoy.org/wtfpl/COPYING for more details.
##############################################################################

my $appname = "Sniperlcat";

$app_icon = "";
$network = "192.168.1.*";
$verbose = 0;
$cansino = 0;

my $go_back = 0;
my $arp_fill = 1;
my $file = "";
my $sltime = 60;

use Gtk2::Notify -init, "Sniperlcat";

# Se va al fondo
sub daemonize{
    $verbose = 0;
    umask 0;
    open STDIN, "</dev/null" || die $!;
    open STDOUT,">>/dev/null" || die $!;
    open STDERR, ">>/dev/null" || die $!;
    defined ($pid=fork) || die $!;
    exit if $pid;
    setsid || die $!;
}

sub show_help{
        print "$appname\n";
        print "./sniperlcat [-h]|[-d | -v ] [-nf] [-c] [-n <red>] [-f <descriptor de red>] [-s <tiempo>]\n";
        print "-h  (--help): Muestra este mensaje\n";
        print "-d  (--daemonize): Se ejecuta de fondo\n";
        print "-nf (--no-fill): No llena la tabla de hosts (con nmap) antes de leerla\n";
        print "-c  (--cansino): Repite los avisos, aun los ya emitidos, en cada iteración\n";
        print "-v  (--verbose): Muestra más información por pantalla\n";
        print "-n  (--network): Especifica la red donde se ejecuta, por defecto 192.168.1.0/24\n";
        print "-f  (--file): Especifica el archivo de red inicial (se obtiene con arp -an)\n";  
        print "-s  (--sleep): Especifica el tiempo en segundos de \"descanso\" entre iteraciones (por defeto 60)\n";  
}

# Comprueba los parámetros

my $i = 0;
while ($i <= $#ARGV){
    if (($ARGV[$i] eq "-d") || ($ARGV[$i] eq "--daemonize")){
        $go_back = 1;
    }
    elsif (($ARGV[$i] eq "-h") || ($ARGV[$i] eq "--help")){
        show_help;
        exit 0;
    }
    elsif (($ARGV[$i] eq "-v") || ($ARGV[$i] eq "--verbose")){
        $verbose = 1;
    }
    elsif (($ARGV[$i] eq "-c") || ($ARGV[$i] eq "--cansino")){
        $cansino = 1;
    }
    elsif (($ARGV[$i] eq "-nf") || ($ARGV[$i] eq "--no-fill")){
        $arp_fill = 0;
    }
    elsif (($ARGV[$i] eq "-n") || ($ARGV[$i] eq "--network")){
        $i++;
        if ($i > $#ARGV){
            print "No se ha especificado la red\n";
            show_help;
            exit 1;
        }
        $network = $ARGV[$i];
    }
    elsif (($ARGV[$i] eq "-f") || ($ARGV[$i] eq "--file")){
        $i++;
        if ($i > $#ARGV){
            print "No se ha especificado el archivo de red\n";
            show_help;
            exit 1;
        }
        $file = $ARGV[$i];
    }
    elsif (($ARGV[$i] eq "-s") || ($ARGV[$i] eq "--sleep")){
        $i++;
        if ($i > $#ARGV){
            print "No se ha especificado el tiempo\n";
            show_help;
            exit 1;
        }
        $sltime = $ARGV[$i];
    }
    $i++;
}

daemonize if $go_back;

# LLena la tabla arp con nmap
sub fill_arp_table{
    `nmap $network -sP 2>/dev/null 1>/dev/null`;
}

# Carga la tabla arp de un archivo
sub load_arp_desc{
    my %tmplist = ();
    my $arp = $_[0];
    my @lines = split(/\n/,$arp);
    my $ip,$mac,$i = 0;
    my $max = @lines;

    while ($i < $max){
        # Extrae la IP
        @line = split(/ /,@lines[$i]);
        @ip = split(/\(/,$line[1]);
        @ip = split(/\)/,@ip[1]);
        $ip = @ip[0];


        # Y la MAC
        $mac = $line[3];

        # Y se introduce en la lista si es una MAC válida
        if (substr("$mac", 0, 1) ne "<"){
            $tmplist{"$ip"} = "$mac";
        }
        $i++;
    }
    return %tmplist;
}

# Carga la tabla arp
sub load_arp_list{
    my $arp = `arp -an`;
    return load_arp_desc($arp);
}

# Hace las comprobaciones
sub check_list{
    my $ip_list = $_[0];
    my $tmplist = $_[1];
    my $lastlist = $_[2];

    foreach my $ip (keys %$tmplist){
        my $mac = $tmplist->{$ip};
        # Si es un host nuevo
        if (!exists $ip_list->{$ip} ) {
            if ((!exists $lastlist->{$ip}) || ($cansino)){
                my $message = "Equipo desconocido en la red: $ip [$mac]";
                if ($mac ne "00:00:00:00:00"){ # Se suele utilizar para tapar
                                                                  # despues de arp spoofing.
                                                                  # No aporta nada
                    # Si la MAC está repetida, probablemente haya spoofing
                    foreach my $tmpip (keys %$ip_list){
                        if (($ip_list->{$tmpip} eq $mac) && ($tmpip ne $ip)){
                            $message .= ", posiblemente spoofeado desde $tmpip";
                        }
                    }
                }
                print "$message\n" if $verbose;
                my $notification = Gtk2::Notify->new("$appname", "$message","$app_icon");
                $notification->show();
            }
        }
        else{
            # Si cambio la MAC
            if ($ip_list->{$ip} ne $mac){
                if (($lastlist->{$ip} ne $mac)||($cansino)){
                    my $message = "La MAC de $ip ha cambiado de [".$lastlist->{$ip}."] a [".$mac."]";
                    if ($mac ne "00:00:00:00:00"){ # Se suele utilizar para tapar
                                                   # despues de arp spoofing.
                                                   # No aporta nada
                        # Si la MAC está repetida, probablemente haya spoofing
                        foreach my $tmpip (keys %$ip_list){
                            if (($ip_list->{$tmpip} eq $mac) && ($tmpip ne $ip)){
                                $message .= ", posiblemente spoofeado desde $tmpip";
                            }
                        }
                    }
                    print "$message\n" if $verbose;
                    my $notification = Gtk2::Notify->new("$appname", "$message","$app_icon");
                    $notification->show();
                }
            }
        }
    }
}

my %ip_list;
if ($file eq ""){
    if ($arp_fill){
        print STDERR "LLenando lista arp... " if $verbose;
        fill_arp_table;
        print STDERR "[OK]\n" if $verbose;
    }
    print STDERR "Leyendo tabla arp... " if $verbose;
    %ip_list = load_arp_list;
}
else{
    local $/=undef;
    open MYFILE, "$file" or die "Couldn't open file: $!";
    binmode MYFILE;
    $arp = <MYFILE>;
    close MYFILE;
    %ip_list = load_arp_desc("$arp");
}
print STDERR "[OK]\n" if $verbose;

my $lastlist = \%ip_list;
while (1){
    if ($arp_fill){
        fill_arp_table;
    }
    my %tmplist = load_arp_list;
    check_list(\%ip_list,\%tmplist,$lastlist);
    $lastlist = \%tmplist;

    sleep $sltime;
}

---

SSH: Conexiones seguras para tod@s ( II ) SSHFS

Siguiendo con la segunda parte de SSH: Conexiones seguras para tod@s, ahora SSHFS... la idea era mostrar tambien las VPN's, pero ahora mismo no es posible  :(, prometo que pronto saldran ;)

SSHFS

¿ Que es SSHFS ?
Es un cliente que permite montar un sistema de archivos remoto en una carpeta local ("bajo la superficie", el cliente funciona con SFTP, con lo que las comunicaciones van cifradas adecuadamente)

Instalandolo
La instalacion es la tipica, no me voy a liar con esto, lo unico decir que usa FUSE, si no viene instalado por defecto (que me extraña), cualquier gestor de paquetes decente deberia instalarlo con sshfs, el resto es el clasico sudo apt-get install sshfs (para basados en debian, por ejemplo)

Montando una carpeta
El comando para montar una carpeta es
sshfs [<usuario>@]<host>:[<directorio>]  [-p <puerto>] <punto de montaje>
Los parametros son:
Usuario: si el usuario es distinto en el host que el que se esta utilizando actualmente
Host: direccion a la que se conecta
Directorio: raiz de sistema de archivos (si es distinta al directorio HOME del usuario)
Puerto: si se usa un puerto SSH no estandar (distinto del 22)
Punto de montaje: carpeta local a traves de donde se accede al SSHFS

Como se puede ver, el comando es bastante parecido al de ssh, de hecho, si no se tiene la clave publica del host (o si ha cambiado), hace lo que haria ssh ( y pedira la clave  del usuario )

Una  vez montada, se puede navegar por la carpeta como si fuera una normal

Desmontando una carpeta
El comando para desmontar una carpeta es
fusermount -u  <punto de montaje>

El unico parametro, Punto de montaje, sirve para especificar la carpeta donde se monto el SSHFS

Y ya esta!

[Referencias]
http://tuxpepino.wordpress.com/

Hasta ahora!!

SSH: Conexiones seguras para tod@s

Seguramente muchos conozcais telnet, una forma de conseguir una consola de comandos en un ordenador remoto, igualmente muchos sabreis que es inseguro por que va "en plano" por la red (un ordenador cualquiera de la red podria ver lo que pasa en el pc remoto, secuestrar la sesion o incluso capturar las contraseñas), por eso desde hace unos años (desde el 99) se utiliza SSH (secure shell), que utiliza conexiones seguras, peroo... sabiais que ademas de utilizarlo como una consola de comandos se puede utilizar para:

• Transferencias de archivos al estilo FTP
• Copia de archivos en red
• Cifrar casi cualquier tipo de conexion (todo lo que se pueda a traves de SOCKS: web, correo, mensajeria instantanea,... )

•  Acceder a sistemas de archivos remotos como si fuesen locales (SSHFS)
• VPN (aunque mientras se escribe esto solo es posible con el cliente y el servidor de OpenSSH)

Y todo esto sin dejar de lado la seguridad...

Para las pruebas se utilizo un servidor OpenSSH_5.3p1 y un cliente OpenSSH, el servidor puede necesitar alguna configuracion, pero la mayoria de las veces las distros/flavours ya lo traen listo para usar, ademas algunas cosas solo se pueden hacer con este servidor en concreto (OpenSSH)


Para intentar hacer todo mas claro, los comandos usaran este tipo de letra, lo que vaya etiquetado <asi> es una campo ( por ejemplo <direccion del servidor> podria ser ssh.pruebas.com o 192.168.1.17 ), por ultimo lo que va entre ´[´ y ´]´ es opcional (se usa, entre otras cosas, para activar opciones adicionales)

Empezando por lo basico:

Para abrir una consola de comandos en el servidor se utilizara el siguiente comando:

ssh [<usuario>@]<servidor> [-p <puerto>]

La parte de <usuario>@ solo es necesaria si se va a usar un usuario distinto al de la maquina local, y  -p <puerto> se usa para acceder por un puerto no estandar (que es el 22).

Este es un ejemplo posible:

Desde el pc 'vBox' el usuario 'kenkeiras' hace ssh al servidor 'sleepless' (ssh sleepless), aqui en vez de haber utilizado el nombre del servidor se puede utilizar su ip... si es la primera vez que se conecta a este servidor se pedira al usuario que confirme que el fingerprint de la clave del servidor coincida con la real (para evitar que se produzca un ataque Man-in-the-middle, por ejemplo)

Y despues la ejecucion seguiria como antes, pide la contraseña y abre la sesion del usuario.

Este comando (ssh sleepless) es el mismo que ssh $USERNAME@sleepless -p 22 ya que se presupone que el usuario va a ser el mismo en el servidor que en el pc local y que el puerto va a ser el estandar (el 22).

Manejando archivos:


Transferencia de archivos por SFTP (Secure File Transfer Protocol, Protocolo Seguro de Transferencia de Archivos) :

El uso de sftp es bastante sencillo, el comando de inicio es como el de ssh:
sftp [<usuario>@]servidor [-oPort=<puerto>]
La unica diferencia es que para especificar un puerto diferente (el estandar sigue siendo 22, todo funciona a traves de ssh) se utiliza -oPort , en vez de -p

Se utliza como un cliente ftp normal, pero siempre se usa binary para las transferencias (para los que no lo entiendan, esto ultimo da igual)

Por ejemplo:

Los comandos basicos son:

• cd <directorio>: Cambia al directorio especificado
• put <archivo local> [<archivo remoto>]: Envia un archivo 'archivo local' al servidor (si no se especifica el 'archivo remoto' se utilizara como nombre el de 'archivo local')
• get <archivo remoto> [<archivo local>]: Envia del servidor el 'archivo remoto' al pc local (si no se especifica el 'archivo local' se utiliza como nombre el de 'archivo remoto')
• mkdir <directorio>: Crea un directorio en el servidor
• ls [<ruta>]: Muestra los contenidos del directorio actual (o si se especifica una ruta, de esa)
• rm <archivo>: Elimina el archivo 'archivo'
• rmdir <directorio>: Elimina el directorio 'directorio'
• exit: Salir
• !: Volver a la consola del pc local (cuando se salga de la consola se volvera a el SFTP)

SCP (Secure Copy, Copia Segura):


El comando basico de scp es el siguiente scp [[<usuario>@]<servidor>:]<archivo origen> [[<usuario>@]<servidor>:]<archivo destino 1> [ [[<usuario>@]<servidor>:]<archivo destino 2> ... ]

Es decir, el comando es scp y en cada opcion se utiliza la siguiente notacion para definir un archivo:

    [[<usuario>@]<servidor>:]<archivo> Si el archivo esta (o se va a copiar) a otro pc, se escribe <servidor> :  <archivo> , si el archivo es local, solo el nombre del archivo, y si el archivo esta en otro pc, pero se accede a traves de otro usuario, <usuario> @ <servidor> : <archivo>

El primer archivo es el que se va a copiar y los demas es a donde se va a copiar, por ejemplo:

Aqui se copia un archivo ('example') del servidor 'sleepless', a el archivo local 'example'.
Las opciones son parecidas a la del programa cp de unix, por ejemplo permite copiar directiorios enteros:

Cifrando conexiones:

Si conoces el protocolo SOCKS sabras que sirve para hacer servidores proxy y clientes para cualquier protocolo que funcione sobre TCP/IP (con SOCKS5 tambien sobre UDP/IP, pero en este caso concreto no), ssh permite utilizarlo para cifrar conexiones entre el cliente y el servidor, para proteger los datos en la red que hay entre los dos (y que puede ser insegura), la idea es algo asi:


[Cliente SSH] ~~~~~~~~~> [Servidor SSH] --------------> [Destino]
                        Red insegura                       Red segura
                          (Cifrado)                            (sin cifrar)

Esto sirve por ejemplo para un portatil que esta conectado a una wifi y que tiene (ya dentro de la red con cable, protegida, ...) un servidor SSH, se tunelan los paquetes hasta el servidor (a la aplicacion lo trata como un simple proxy SOCKS), donde ya no es posible un ataque tan sencillo como usar un sniffer en una red WEP.
Para hacer esto usaremos  ssh -D [<ip de enlace>:]<puerto de enlace>   [<usuario>@]< servidor> [-p <puerto para ssh>]

Como se puede ver es igual que un comando ssh con la diferencia de que se añade -D [<ip de enlace>:]<puerto de enlace>

La opcion -D significa que el tunelado sera dinamico (hay otras opciones que usan tunelado estatico, siempre al mismo pc y en el mismo puerto), sobre SOCKS.
La ip del enlace es opcional y sirve para concretar que interfaz de red se va a utilizar para la conexion, si no se especifica (o se usa un '*') cualquier pc en la red podra utilizar el tunel (esto puede ser util o no, dependiendo de las circunstancias), si no hay motivos para dejarlo abierto recomendaria utilizar 'localhost' (o '127.0.0.1') para permitir solo las conexiones locales.
Y puerto de enlace es el puerto que se proporcionara a los programas para que se conecten al tunel

Por ejemplo:

ssh -D localhost:1234 sleepless

Abrira una conexion SSH con 'sleepless' y un tunel SSH que se puede acceder por 'localhost' y por el puerto '1234' (normalmente solo el superusuario tiene permiso para abrir puertos con un numero menor que 1024)


Y esto es todo por ahora... (proximamente el SSHFS y las VPN)

[Referencias]
http://www.openssh.org/
http://www.lucianobello.com.ar/openssh/
http://tuxpepino.wordpress.com/2007/05/11/ssh-el-dios-de-la-administracion-remota/

Hasta otra.