HOW-TO: Copiar archivos por la red

Ala pues!

Muchas veces nos pasa que necesitamos enviar información de un pc a otro, pero por los motivos que sean, las soluciones "convencionales" no nos solucionan el problema. Imaginemos que queremos enviar el contenido completo de un disco duro o simplemente queremos enviar "información suelta" para comunicación entre programas, pero no deseamos estar leyendo archivos en carpetas compartidas, o queremos hacer un programa de comunicación...

Pues bien, podemos usar sockets para enviar ésta información. En Linux, tenemos la herramienta "nc" (hay abundante información en internet) La herramienta nc es la que nos va a permitir crear sockets para todo lo que se nos ocurra.

Vamos a repasar el concepto de socket. Socket es un método de comunicación por el cuál se comunican dos entes, los cuáles pueden adquirir el rol de cliente o servidor.

Hacer un socket es muy fácil, en un "cliente" con ip 192.168.1.10 escribid:

nc -l -p 6000

En un "servidor" escribid:

nc 192.168.1.10 6000

Observad que, todo lo que escribís en el servidor aparece en la consola del cliente. En éste caso, cliente y servidor pueden ser dos consolas en un mismo equipo. Pulsad control+c para terminar la sesión.


Consultad "man nc" para ver qué es cada parámetro. Ahora vamos a enviar un archivo:

PC (o consola) Receptor: nc -l 6000 | dd of=nombrefichero
PC (o consola) Emisor: dd if=archivo_origen | nc 192.168.1.10 6000

Observad que, aunque el archivo se ha recibido, la conexión no se cierra hasta que pulsemos control+c en el emisor (si lo hacemos en el receptor, puede ser que no recibamos toda la información) Fijaos también que, la transmisión se cierra siempre que el cliente pulse control+c, hay que tenerlo siempre presente.

Ahora supongamos que tenemos un archivo muy grande y somos tan listos que decidimos enviarlo comprimido, pero es tan grande que, no se puede comprimir sin ocupar todo lo que queda de disco. Bueno, podemos comprimirlo "al vuelo"

PC 192.168.1.10 Receptor: nc -l 6000 | tar xvvzpf -
PC 192.168.1.11 Emisor: tar cvvzpf - archivo | nc 192.168.1.10

Ésto comprimiría el archivo pero no lo almacenaría en el disco local, si no que lo envía a la salida estándar (Parámetro "f -") Allí, es direccionado a nc y enviado al 192.168.1.10

Mientras tanto, el receptor direcciona todo lo que le llega por la red a la salida estándar y allí es direccionado a tar para ser descomprimido en el mismo lugar.

Los beneficios, obviamente son, mejor aprovechamiento del ancho de banda ya que la información va comprimida.

Observad que, la transmisión no se cierra hasta que el emisor pulsa control+c en su consola.

Imaginaos la potencia de ésto: se pueden hacer, scripts de comunicación, copias de seguridad "al vuelo" protocolos de comunicación y todo lo que se os ocurra.

Vamos a liar más la perdiz y a darle otra vuelta de rosca. Vamos a hacer un programa teórico de comunicación.

PC 1: 192.168.1.10

En una consola 1:
nc -l -u -p 6000

En otra consola 2:
nc -u 192.168.1.11 -p 7000

PC 2: 192.168.1.11

En una consola 1:
nc -l -u -p 7000

En otra consola 2:
nc -u 192.168.1.10 6000

Ahí está: todo lo que escribamos en la consola 2 será enviado a la consola 1 del otro equipo, y todo lo que el otro equipo escriba en su consola 2 será enviado a la consola 1 del nuestro.

Observad el parámetro "-u". Ésto significa que usaremos el protocolo "UDP" (envío sin confirmación de recepción) Es decir, que si el otro pulsa control+c en su consola, no romperá nuestra consola, de hecho, no sabremos si está ahí.

De aquí en adelante, todo vuestro, todo lo que se os ocurra.

Linux power!!!

Scripts Avanzados: Un script para manejar básicamente iptables

Y otra vez, hemos vuelto. Ésta vez, os mostraré un script para manejar funcionalidades básicas de IPTABLES. El objetivo de éste script, aparte de manejar IPTABLES, es el de enseñar el su uso, dado que cada vez que lo usemos, hará una traducción de lo que escribimos a lo que hace iptables, de modo que poco a poco nos iremos quedando con el funcionamiento de IPTABLES.

También se puede usar para aprender a hacer scripts en consola, ya que en él aparecen prácticamente todos los mandatos de la consola.

Aunque claro está, también puede usarse para no tener que aprender IPTABLES ;)

Script:

#!/bin/bash
# ########################
# IAL Script versión 2.5
#    Daniel Perella
# ########################
complete_rule=iptables
part_rule=

function _aplicar
{
  echo -e "Aplicar $part_rule a $complete_rule? (s/n)"
  read a
  if [[ $a = "s" ]]
  then
      complete_rule=$(echo $complete_rule $part_rule)
      echo regla:$complete_rule
  else
      echo regla:$complete_rule
  fi
}

function asistente # asistente: Ejecuta un asistente guiado para añadir una regla
{

  echo "añadir o quitar norma?"
  echo "añadir | quitar [INPUT|OUTPUT|FORWARD]"
  echo -e "que hacer)\c"
  read aa
  $aa

  echo "protocolos admitidos: tcp udp icmp all"
  echo -e "protocolo)\c"
  read pro
  protocolo "$pro"

  echo "seleccione política"
  echo "acciones: aceptar | rechazar | ignorar "
  echo -e "accion)\c"
  read ac
  $ac

  echo "direccion: origen | destino [IP o host]"
  echo -e "direccion)\c"
  read di
  $di

  if test  $pro = "tcp" -o  $pro = "udp"
  then
      echo "puerto al que aplicar la norma"
      echo -e "puerto)\c"
      read pu
      puerto $pu
  fi

  echo "Puede Aplicar la norma ahora o añadir"
  echo "más propiedades en éste mismo CLI" 
  echo -e "Aplicar la norma ahora (s/n)?\c"
  read ap
  if [[ $ap = "s" ]]
  then
      aa=$(echo $aa | cut -d " " -f 1)
      if [[ $aa = "añadir" ]]
      then
          ejecutar
      else
          echo -e "Desea borrar ésta norma?? (s/n)?\c"
          read bbb
          if [[ $bbb = "s" ]]
          then
              ejecutar
          else
              echo "No Borrada"
          fi
      fi
  else
      echo "Use la ayuda para ver que propiedades"
      echo "tiene disponibles"
      echo " "
  fi

}

function añadir # añadir [INPUT|OUTPUT|FORWARD]: Añade al tipo de Norma
{
  echo "-A"
  part_rule="-A $1"
  _aplicar
}

function quitar # quitar [INPUT|OUTPUT|FORWARD]
{
  echo "-D"
  part_rule="-D $1"
  _aplicar
}

function protocolo # protocolo [tcp|udp|icmp|all]: Añade un tipo de protocolo
{
  echo "-p $1"
  part_rule="-p $1"
  _aplicar
}

function puerto # puerto [n]: Define el puerto de la norma
{
  echo Puerto: $1
  part_rule="--dport $1"
  _aplicar
}

function aceptar # aceptar: Aplica la norma ACCEPT a los paquetes
{
  echo "-j ACCEPT"
  part_rule="-j ACCEPT"
  _aplicar
}

function rechazar # rechazar: Aplica la norma REJECT a los paquetes
{
  echo "-j REJECT"
  part_rule="-j REJECT"
  _aplicar
}

function ignorar # ignorar: Aplica la norma DROP a los paquetes
{
  echo "-j DROP"
  part_rule="-j DROP"
  _aplicar
}

function interfaz # interfaz [ethn] Define el interfaz para la norma
{
  echo "-i $1"
  part_rule="-i $1"
  _aplicar
}

function numero # numero [n]: Define el número de norma (útil para borrar)
{
  echo "-I $1"
  part_rule="-I $1"
  _aplicar
}

function origen # origen [IP o HOST]: Define el origen del paquete para la norma
{
  echo "-s $1"
  part_rule="-s $1"
  _aplicar
}

function destino # destino [IP o HOST] Define el destino del pquete de la norma
{
  echo "-d $1"
  part_rule="-d $1"
  _aplicar
}

function normas # normas: Hace un listado de las normas existentes
{
  echo "Norma que está siendo editada"
  echo $complete_rule
  echo "Ultima parte aplicada o no a la norma"
  echo $part_rule
  echo " "
  echo " " 
  i=$(whoami)
  if [[ $i != "root" ]]
  then
      echo "No eres root, no se puede hacer iptables"
  else
      iptables -n -L
  fi 

}

function nueva # nueva: Empieza a hacer una norma nueva
{
  complete_rule="iptables"
  part_rule=""
  echo "Nueva norma iniciada"
}


function ejecutar # ejecutar: Aplica la norma
{
  echo "Aplicando norma: $complete_rule"
  $complete_rule
  echo "Hecho"
}

function guardar # guardar Volca en un archivo las normas
{
  echo "Guardar normas en fichero"
  if test -n $1
  then
      nom=$1
  else 
      echo -e "nombre del fichero)\c"
      read nom
  fi
  iptables-save > $nom
  echo "Guardado como $nom"
}

function cargar # cargar Lee un fichero de normas y lo aplica
{
      echo "Cargar Normas IPTABLES"
  if test -n $1
  then
      nom=$1
  else
      echo -e "nombre del fichero)\c"
          read nom
  fi
      cat $nom | grep "-" | grep -v "#" | while read lin
      do
              echo -e "Cargando: $lin\r\c"
              complete_rule=$(echo $complete_rule $lin)
              ejecutar
              nueva
      done;
}

function vaciar # vaciar [INPUT|OUTPUT|FORWARD] Vacia del todo un juego de normas
{
  if test -n $1
  then
          iptables -F $1
          echo Normas de $1 Limpio
  else
      echo "Vaciar Normas de: INPUT OUTPUT FORWARD"
      echo -e "normas)\c"
      read nor
      iptables -F $nor
      echo Normas de $nor Limpio
  fi
}

function _backup
{
  guardar backup_normas
}

function _restore
{
  cargar backup_normas
}
  # exit 0 : sale del script

case $1 in

  --directo|-d)
      $2 $3 $4 $5 $6 $7 $8 $9 
  ;;
  --backup|-b)
      _backup
  ;;
  --restore-backup|-r)
      _restore
  ;;
  *)
      while [[ $? ]]
      do 
          i=$(whoami)
          if [[ $i != "root" ]]
          then
              echo "No eres root, no se aplicará ningún cambio"
          fi 
          echo "Use: ayuda"
          echo -e "root)\c"
          read rul
          if [[ $rul = "ayuda" ]]
          then
               cat blacklist.sh | grep "#" | grep -v "grep" | grep -v "_" | grep -v "bash" | cut -d "#" -f 2
            
          else
              $rul
          fi
      done;
  ;;
esac

_backup

Uso:

Ejecutaremos el script con permisos de root y accederemos a su consola. Podemos usar la orden "ayuda" para obtener ayuda acerca de las funciones que podemos usar.

La idea es ir completando una variable con las posibles opciones que podemos usar en iptables, claro está, el script nos dice en cada momento lo que podemos introducir. Después ésa variable se le pasa a IPTABLES y es aplicada.

Para empezar, podemos usar la órden "asistente" y cuando cojamos soltura iremos probando las funciones sueltas.

Si tenéis dudas, ya sabéis donde estamos!

Suerte