Tienda Wifi

Tienda Wifi
CiudadWireless es la tienda Wifi recomendada por elhacker.NET

Buscador

Entradas Mensuales

Suscripción

¿Quieres recibir las últimas novedades del blog en tu correo?

¡Suscríbete al feed!

Foro de elhacker.net - Noticias

elhacker.NET en Facebook

Entradas populares

PostHeaderIcon Copiar o mover ficheros o directorios remotamente (scp y ssh)




Dos prácticos comandos como son scp y tar (unido con ssh) para mover carpetas y directorios remotamente a través de internet o de una red local de forma rápida y segura. Podemos usarlo, por ejemplo, para automatizar copias de seguridad, mediante el uso de llaves.





     scp - SeCure Copy (remote file copy program)

scp permite que los archivos sean copiados hacia, desde o entre diferentes hosts. Utiliza ssh para la transferencia de datos y proporciona la misma autenticación y el mismo nivel de seguridad que ssh. Es lo mismo que cp (copy) pero con la s de (secure, seguro). No debemos usar rsh (remote shell) (basado en rlogin) ya que es la versión "antigua" de ssh

scp sintaxis:

scp [[user@]from-host:]source-file [[user@]to-host:][destination-file]


Copiar el directorio /home y sus subdirectorios (-r) al servidor remoto ns7.elhacker.net carpeta /home
scp -pr /home el-brujo@ns7.elhacker.net:/home

-p para conservar fechas de acceso y permisos

     -p      Preserves modification times, access times, and modes from the
             original file. (conserva las propiedades del archivo. Permisos del archivo, fecha de última de modificación.)
  -r de recursivo

    -r      Recursively copy entire directories ( copia recursiva de directorios)

  -l para limitar la velocidad

    -l       Limits the used bandwidth, specified in Kbit/s.

con scp2 podemos:

  -u para eliminar el fichero copiado después de ser transferido

    -u      Removes source files after copying. This makes scp2 work more like mv than cp.

 scp utiliza AES-128 para cifrar los datos que viajan por la red, esto es muy seguro, pero también un poco lento. Si necesitas más velocidad y aún así tener la seguridad, puede utilizar Blowfish o RC4.

scp -c blowfish el-brujo@ns7.elhacker.net:/home/user/file .

El punto final indica el directorio actual en localhost

Ejemplo copiar fichero local backup.bz2 al directorio remoto / con el nombre backup y le añadimos con el comando "date" la fecha actual en formato día-mes-año-hora, algo así como backup-10-12-2013_11_14_01.bz2

scp  /home/backup/backup.bz2 el-brujo@ns2.elhacker.net:/backup.`date +%d-%m-%Y_%T`.bz2  


También podemos usar arcfour todavía más rápido pero menos seguro.
 scp -c arcfour

La opción -C (en mayúsculas) habilita la compresión.

Y también se puede usar al revés, copiar ficheros remotos a local para restaurar copias de seguridad:


Ejemplo: copiamos todo lo que haya en el directorio remoto /backup/home al directorio local /home/user


scp -r el-brujo@ns7.elhacker.net:/backup-home /home/user/

También es posible enviar la copia simultáneamente (a la vez) a diferentes servidores

scp el-brujo@ns7.elhacker.net:backup el-brujo@ns2.elhacker.net: el-brujo@ns3.elhacker.net:

O hacer una copia del disco entero (una imagen):

scp /dev/sda1 backup@ns2.elhacker.net:/home/backup/diskimage.img

O usando cat + ssh

 cat /dev/sda1 | ssh backu@ns2.elhacker.net "cat > /home/backup/diskimage.img" 

Y para restaurar la imagen, justo al revés:

ssh backup@ns2.elhacker.net "cat /home/backup/diskimage.img" > /dev/sda1

O lo mismo pero comprimiendo la imagen con gzip

cat /dev/sda1 | gzip | ssh backup@ns2.elhacker.net "cat > /home/backup/diskimage.img.gz"

Ahora sólo nos quedará cifrar el contenido de la copia de seguridad con gpg (GnuPG), por ejemplo, algo que veremos en futuras entradas del blog. Es recomendable cifrar antes de enviar.

sshfs


También podemos usar sshfs para crear un punto de montaje de un sistema de ficheros remoto con SSH, así no tenemos que usar scp todo el rato.

sshfs backup@elhacker.net: /home/backup
Y para desmontar el punto de montaje:

fusermount -u /home/backup

Nota: Ten en cuenta que se recomienda ejecutarlo como usuario normal, no como root. Para que esto funcione el punto de montaje debe ser propiedad del mismo usuario.

También podemos agilizar la conexión con ssh mediante una entrada en ~/.ssh/config

Host elhacker.net
Hostname elhacker.net
User backup
Port 85
 Escribir:

ssh elhacker.net

Será lo mismo que escribir:

ssh -p 85 el-brujo@elhacker.net

Autenticación mediante llaves

Para obtener el máximo partido a SSH podemos utilizar su capacidad de autenticación mediante clave pública y privada. Es una de las mejores opciones para hacer copias de seguridad automatizadas  remotamente (en la nube).

Para ello el cliente debe generar sus claves privada y pública, compartiendo esta última con el servidor para poder identificarse. Una vez hecho esto las conexiones se podrán establecer sin necesidad de utilizar el esquema clásico de usuario y contraseña.

 Por supuesto podemos usar una llave pública SSH para SCP (igual con SFTP (secure file transfer) o CVS) evitando así tener que escribir contraseñas.

Para generar la llave podemos usar ssh-keygen para generar la llave pública (.pub) y privada (identitiy) o la aplicación PuTTYgen para entornos Windows.

Se puede generar una clave usando RSA o DSA

DSA es más rápido, pero en generarl RSA es más seguro. Se suele decir que 
DSA es más rápido "firmando", pero más lento "verificando".

En cualquier caso una llave  de RSA
2048 bit  será suficiente o mejor incluso una llave  de RSA 4096 bit

$ ssh-keygen -b 4096 -t rsa


La passphrase si se rellena tiene un comportamiento similar a la contraseña, será solicitada al utilizar esta clave. Deberá ser una frase, en la que se pueden incluir espacios en blanco y signos de puntuación.
En nuestro caso hemos decidido dejarla vacía para así poder utilizar este método de autenticación en procesos no interactivos. Puedes utilizar una frase de paso si no confías en la seguridad de tu máquina.      

Usando el comando para  copiar nuestra llave pública al servidor remoto.


ssh-copy-id remote_ip

O copiando la llave pública vía scp  


scp ~/.ssh/id_rsa.pub username@remote_ip:

en el directorio:
~/.ssh/authorized_keys
 Crear el directorio, añadir la llave pública rsa a la lista de autorizadas, eliminar  la llave pública y asignar permisos correctos:
$ mkdir ~/.ssh
$ cat ~/id_rsa.pub >> ~/.ssh/authorized_keys
$ rm ~/id_rsa.pub
$ chmod 600 ~/.ssh/authorized_keys


Recordar proteger el directorio con permisos sólo para el creador:

chmod 400 ~/.ssh/authorized_keys

Y/o aplicar el "immutable"

chattr +i ~/.ssh/authorized_keys

Revisar que la configuración del servidor SSH  /etc/ssh/sshd_config  acepta llaves SSH

PubkeyAuthentication yes
RSAAuthentication yes
También podemos deshabilitar la autenticación con contraseña añadiendo:

ChallengeResponseAuthentication no
# Disable password authentication forcing use of keys
PasswordAuthentication no
UsePAM no

Si hemos puesto una (passphrase) al generar la llave pública la próxima vez que nos conectemos al servidor remoto. en lugar de pedirnos la contraseña del usuario, nos pedira la frase clave con la que la ciframos nuestra llave privada.

[el-brujo@ns2] $ ssh ip_remota
Enter passphrase for key '/home/el-brujo/.ssh/id_rsa':

Se puede especificar con la opción -i en el comando ssh y en el comando scp la llave privada que queremos usar para conectaros remotamente y también cambiar el puerto por defecto (22) con -p en ssh y -P (mayúsculas en scp)

          -i identity_file
            Selects the file from which the identity (private key) for RSA
            authentication is read.  This option is directly passed to ssh.

      -P port
            Specifies the port to connect to on the remote host.  Note that
            this option is written with a capital P, because -p is already
            reserved for preserving the times and modes of the file in rcp.



Ejemplo conectarse a ns2.elhacker.net con el usuario backup por el puerto 22 (ssh) usando la llave de el-brujo
ssh -i /home/el-brujo/.ssh/id_rsa -p 22 backup@ns2.elhacker.net 

Copiar remotamente el local fichero.bz2  al directorio /home/backup de la máquina remota ns2.elhacker.net usando la llave del usuario backup:
scp -P 22 -i /home/backup/.ssh/id_rsa /home/backup/fichero.bz2 backup@ns2.elhacker.net:/home/backup/

 En el log de syslog:

Accepted publickey for el-brujo from ns7.elhacker.net port 46592 ssh2

Para la gestión de llaves podemos usar ssh-agent, ssh-add o key-chain


Aunque scp puede copiar directorios, no es necesariamente el mejor método. Si su directorio contiene enlaces duros o blandos, no van a ser duplicadas. Los enlaces se copiarán los archivos sin formato (los destinos de vínculos), y peor aún, directorio de enlaces circulares causan scp1 al bucle indefinidamente. (scp2 detecta los enlaces y las copias de sus objetivos simbólicos en su lugar.) Otros tipos de archivos especiales, tales como canalizaciones con nombre, también no se copian correctamente. Una mejor solución es utilizar el alquitrán, que maneja archivos especiales correctamente, y enviarlo a la máquina remota para ser desempaquetado, a través de SSH:


tar cf - /usr/local/bin | ssh ns7.elhacker.net tar xf -


Tar + ssh (Tar sobre ssh)


Crear un comprimido .tar.gz de todo el directorio /home y subdirectorios en el servidor remoto ns7.elhacker.net en la raíz / con el nombre home.tar.gz

tar cvzf - /home | ssh el-brujo@ns7.elhacker.net "cat > /home/el-brujo/home.tar.gz"
Otro ejemplo:

tar cvzf - dir/ | ssh user@host "dd of=/backup/dir.tar.gz"

 También puedes restaurar el comprimido remotamente:

ssh el-brujo@ns7.elhacker.net "cat /backup/home.tar.gz" | tar zxvf - 

En próximas entradas veremos el funcionamiento de rsync, sftp, winscp, Tartarus.


rsync -e ssh -avpz directorio_local el-brujo@ns2.elhacker.net:directorio_destino

Listado comandos para GNU/Linux

 

 

Comandos para comprimir y descomprimir ficheros en Linux


Archivos tar
  • Empaquetar: tar -cvf archivo.tar /dir/a/comprimir/
  • Desempaquetar: tar -xvf archivo.tar
  • Ver contenido tar -tf archivo.tar
Archivos gz
  • Comprimir: gzip -9 fichero
  • Descomprimir: gzip -d fichero.gz
Archivos bz2
  • Comprimir: bzip fichero
  • Descomprimir: bzip2 -d fichero.bz2
gzip ó bzip2 sólo comprimen ficheros [no directorios, para eso existe tar]. Para comprimir y archivar al mismo tiempo hay que combinar el tar y el gzip o el bzip2 de la siguiente manera:

Archivos tar.gz
  • Comprimir: tar -czfv archivo.tar.gz ficheros
  • Descomprimir: tar -xzvf archivo.tar.gz
  • Ver contenido: tar -tzf archivo.tar.gz
Archivos tar.xz

Las fuentes del kernel ya vienen por defecto comprimidas con tar.xz

  • Comprimir: tar -cJfv archivo.tar.xz ficheros
  • Descomprimir: tar -xJvf archivo.tar.xz
  • Ver contenido: tar -tJf archivo.tar.xz

Archivos tgz (tar con gzip)
  • Comprimir: tar czvf archivo.tar.gz
  • Descomprimir: tar -xvzf archivo.tgz
Archivos tar.bz2
  • Comprimir: tar -c ficheros | bzip2 > archivo.tar.bz2
  • Descomprimir: bzip2 -dc archivo.tar.bz2 | tar -xv
  • Ver contenido: bzip2 -dc archivo.tar.bz2 | tar -t
Archivos zip
  • Comprimir: zip archivo.zip ficheros
  • Descomprimir: unzip archivo.zip
  • Ver contenido: unzip -v archivo.zip
Archivos lha
  • Comprimir: lha -a archivo.lha ficheros
  • Descomprimir: lha -x archivo.lha
  • Ver contenido: lha -v archivo.lha
  • Ver contenido: lha -l archivo.lha
Archivos arj
  • Comprimir: arj a archivo.arj ficheros
  • Descomprimir: unarj archivo.arj
  • Descomprimir: arj -x archivo.arj
  • Ver contenido: arj -v archivo.arj
  • Ver contenido: arj -l archivo.arj
Archivos zoo
  • Comprimir: zoo a archivo.zoo ficheros
  • Descomprimir: zoo -x archivo.zoo
  • Ver contenido: zoo -L archivo.zoo
  • Ver contenido: zoo -v archivo.zoo
Archivos rar
  • Comprimir: rar -a archivo.rar ficheros
  • Descomprimir: rar -x archivo.rar
  • Ver contenido: rar -l archivo.rar
  • Ver contenido: rar -v archivo.rar
También podemos crear una entrada en el fichero .bashrc para descomprimir automáticamente:

# .bashrc
# User specific aliases and functions
extract () {
   if [ -f $1 ] ; then
       case $1 in
    *.tar.bz2)    tar xvjf $1 && cd $(basename "$1" .tar.bz2) ;;
    *.tar.gz)    tar xvzf $1 && cd $(basename "$1" .tar.gz) ;;
    *.tar.xz)    tar Jxvf $1 && cd $(basename "$1" .tar.xz) ;;
    *.bz2)        bunzip2 $1 && cd $(basename "$1" /bz2) ;;
    *.rar)        unrar x $1 && cd $(basename "$1" .rar) ;;
    *.gz)        gunzip $1 && cd $(basename "$1" .gz) ;;
    *.tar)        tar xvf $1 && cd $(basename "$1" .tar) ;;
    *.tbz2)        tar xvjf $1 && cd $(basename "$1" .tbz2) ;;
    *.tgz)        tar xvzf $1 && cd $(basename "$1" .tgz) ;;
    *.zip)        unzip $1 && cd $(basename "$1" .zip) ;;
    *.Z)        uncompress $1 && cd $(basename "$1" .Z) ;;
    *.7z)        7z x $1 && cd $(basename "$1" .7z) ;;
    *)        echo "don't know how to extract '$1'..." ;;
       esac
   else
       echo "'$1' is not a valid file!"
   fi
 }
Ahora sólo tendremos que escribir:

 extract fichero_comprimido.extension

Y automáticamente descomprimirará el fichero sea el formato que sea.

0 comentarios :

Publicar un comentario

Los comentarios pueden ser revisados en cualquier momento por los moderadores.

Serán publicados aquellos que cumplan las siguientes condiciones:
- Comentario acorde al contenido del post.
- Prohibido mensajes de tipo SPAM.
- Evite incluir links innecesarios en su comentario.
- Contenidos ofensivos, amenazas e insultos no serán permitidos.

Debe saber que los comentarios de los lectores no reflejan necesariamente la opinión del STAFF.