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!!!

Reparación: Recuperar Contraseña de Root

Y otra vez. Se conoce que hay gente que, después de instalar ubuntu, se "olvida" de la contraseña de root y no puede acceder al sistema.

GNU/Linux es un sistema muy seguro para trabajo en red, pero, al contrario que otros sistemas, asume que el usuario es inteligente y no está completamente protegido contra ciertas acciones sobre el equipo físico. Hoy vamos a explotar una de esas puertas traseras que tiene Linux para cambiar la password de root.

Sólo necesitamos un LiveCD de Ubuntu. Bien, al tajo:

1-Iniciad con el LiveCD

2-Abrid una consola

3-Montad La unidad principal de vuestro Linux (ver aquí, sección 2)

En nuestro caso, /dev/sda5 es la unidad principal:

sudo mount /dev/sda5

4- Haced un chroot en /mnt

sudo chroot /mnt

5- Cambiad la contraseña como si tal cosa:

passwd

6- Terminad y reiniciad el ordenador.

exit
sudo reboot

Disfrutad;

Reparación: Recuperar Grub después de instalar Windows

Son muchos los usuarios que migran de plataforma Windows a Linux, y mayoritariamente a Ubuntu. Hace tiempo que ayudo en ubuntu-es.org y ante la ingente cantidad de veces que he tenido que repetir ésto, he decidido crear una entrada sólo para ésto. Éso sí, aquí lo voy a explicar con pelos y señales.

El problema: Teníamos ubuntu instalado y después (bien por reparación o por planificación) instalamos Windows. Pasa que windows está muy acostumbrado a campar en solitario por nuestro disco duro, más aún por su MBR, y lo pisotea inevitablemente cada vez que una instalación se pasea por ésos lares. Cosas de la vida.

¿Qué ha pasado con nuestro Ubuntu (o GNU/Linux)? Pues no os asustéis, porque no ha pasado nada de nada, es decir, sigue intacto (allá donde esté...)

Solución: Reinstalar Grub en el MBR del disco duro.

Necesitamos: Un Live CD de Ubuntu.

1 - Introducid el LiveCD de Ubuntu en el lector, encended vuestra máquina y arrancad desde el LiveCD, dejad que todo fluya tranquilamente hasta que veáis el clásico escritorio de un Ubuntu impoluto.


2- Abrid una Consola

Teoría:

Antes de teclear nada en la consola debemos entender como organiza GNU/Linux las unidades y las particiones.

Cada unidad usb o sata que detecta, es puesta en el directorio de dispositivos "/dev". Bajo el nombre de "sd" + Una letra. La letra corresponde al número de unidad, "a" para la primera, "b" para la segunda... etc.

Además, a lo anterior se le asigna un número para cada partición detectada en la unidad, de forma que, la primera partición del primer disco será: "sda1" La segunda partición del primer disco será 2 (sda2) La segunda partición del segundo disco será "sdb2". Imagino que ya os imagináis por donde van los tiros.

Y todos éstos ficheros de unidades se situan en "/dev".

3- Identificar donde está instalado Ubuntu:

Escribid en consola: sudo fdisk -l Deberíais tener algo parecido a ésto: (tranquilos, en vuestra máquina tendréis dos o tres líneas, alo sumo)



Muy bien ¿cómo sabemos qué dispositivo es nuestro disco de ubuntu? Fácil, el primero cuyo sistema de ficheros sea Linux. En éste caso será /dev/sda5. En el vuestro será 1 o 2 o 3, depende.

En consola escribid: sudo mount /dev/sda5 /mnt (No devuelve nada)

4- Restaurando Grub

En la misma consola escribid: sudo grub-install --root-directory=/mnt /dev/sda


Y todo listo, no tiene más historia, reiniciad vuestro ordenador y disfrutad de GNU!

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

HOW TO: Incompatibilidad Hotmail Live, Office Live,.. + Firefox Ubuntu (Actualizado)

El Problema
Como muchos usuarios de Ubuntu habreis notado, siempre que intentemos acceder a cualquiera de los servicios Live! de Microsoft desde Firefox con Ubuntu, nos encontramos con mensajes del estilo:

OFFICE LIVE (http://www.officelive.com):


HOTMAIL (http://www.hotmail.com):

En dicho momento las alarmas propietarias se activan y piensas... ¿Sera posible que Microsoft haya utilizado tenologias propietarias para sus portales, dejando asi de lado a los usuarios de linux?

La respuesta es, en parti si, y en parte no. Para poder usar "Office Live" al completo si que necesitaremos instalar ciertos programas (plugins) exclusivamente para Windows, sin los cuales el uso de Office Live se ve limitado a la lectura de documentos. Por lo que la emocion inicial de no tener que volver a Windows o usar el Office a traves de Wine, para editar los documentos de word, excel, etc.. fue disipada muy rapidamente. Y ademas como anotacion al lector, todos sabemos que OpenOffice, puede leer documentos de Word, Excel, etc..pero la mayoria de las veces los documentos adaptados no son 100% fieles al original, pues el caso de "Office Live" es de los mas encandaloso que he visto jamas, dado que al abrir documentos originales en el nuevo portal de Microsoft, estos son mostrados peor que con OpenOffice.

Reseñas aparte, para poder llegar a ver documentos y/o ver nuestro correo de Hotmail, necesitamos un paso previo, engañar los portales de Hotmail y Office Live haciendoles creer que navegamos en Firefox (pero desde Windows).

Voy a obviar el tema de lo triste que es para una empresa como Microsoft bloquear sistematicamente a los usuarios de Linux, por el simple hecho de usar ese sistema operativo, dado que los portales son completamente funcionales cambiando simplemente el user agent

La Solucion
Para navegar como si estuvieramos usando el sistema operativo Windows (Cualquiera de sus versiones nos vale) nos valemos de una simple herramienta llamada UserAgentSwitcher con el que podremos hacer creer al navegador en cuestion de segundos que estamos navegando con diferentes sistemas operativos y navegadores, con un gesto tan simple como el que veis en la imagen.Por defecto esta herramienta viene con las opciones Internet Explorer 7, Netscape 4.8 y Opera 9.25 (Windows Vista), pero la mas interesante para nosotros es Firefox para Windows, dado que queremos que Hotmail, siga cargando su interfaz para el navegador de Mozilla, pero saltandonos el cansino mensaje y asegurandonos la maxima compatibilidad con nuestro navegador al igual que en Windows.

1. Instalamos la extension de firefox disponible aqui.
2. Abrimos las opciones de la extension y hacemos click en "User Agents -> Import" (Podeis hacer una copia de seguridad de las actuales haciendo click en Export")
3. Ahora solo teneis que importar el siguiente fichero xml: Firefox_Win32_UserAgent
4. Y listo! Ya deberiais tener en vuestra lista de user agents, la version: "Firefox (Windows XP)"

Ya podeis entrar en vuestro correo de Hotmail y en Office Live, siempre y cuando activeis previamente, con el UserAgentSwitcher, la version de "Firefox (Windows XP)".

Que lo disfruteis.

Corrección: Parece que desde Redmond se han dado cuenta de la importacia y la importante cuota de mercado que pueden ganar ofreciendo esta version de Office Live para todas las plataformas, anunciando que para finales de este año estara disponible para Windows, Linux y Mac (La posibilidad de gestionar documentos de Office en cualquier plataforma asegura que los usuarios de Linux dependeremos cada vez menos del sistema operativo de Redmond, es una gran noticia para el mundo linux)
Fuente: The Inquirer ES

Script de Instalación Para nuestra Distribución

Que parte del equipo de ubuntu Linux estaba trabajando en una metadistribución de Ubuntu no es nada nuevo.

Pues bien, hemos dado un paso más. Se ha creado el instalador de la Distribución. Sé que estamos lejos de tener una distribución propia, pero andar es andar y, aunque sea despacio, siempre se acorta el camino.

Os acordaréis de una entrada que hicimos sobre cómo haceros vuestra propia distribución de Ubuntu, para Netbooks, ahora os enseñaré como hacer un instalador para ella.

Necesitamos (entrando ya en materia) dos scripts. El primero, generará una imágen de la distribución que se esté ejecutando, el segundo, habrá que incluirlo en el CD de instalación de Ubuntu Mini.

Script de Generación:

#!/bin/bash
me=$(whoami)
echo "Obteniendo Listado de Paquetes...."
dpkg-query -W -f='${Package}\n' > packages.txt
echo "Listado de paquetes obtenido"
echo "Obteniendo Configuración de Usuario"
cd /home/$me
cp /etc/apt/sources.list .
tar -cvvf installer/home.tar . --exclude=installer --exclude=.ssh --exclude=*.mozilla --exclude=.aptitude

Éste script obtiene la lista de paquetes instalados y los archivos de configuración del home del usuario actual. Los tres archivos que genera (home.tar, packages.txt y sources.list) Habrá que ponerlos en la misma ruta del instalador, en el CD de instalación.

Script de Instalación:

#!/bin/bash
me=$(whoami)
if [[ $me = "root" ]]
then
echo "Comprobando Lista de Paquetes"
if test -e packages.txt
then
echo "Lista de Paquetes encontrada, empezando la Instalación..."
cat packages.txt | while read package
do
echo aptitude --assume-yes install $package
done
echo "Paquetes Instalados, Empezando configuración de Usuario"
echo "Escriba un Nombre de usuario en minúsculas y sin acentos:"
echo -e "Nombre de usuario: \c"
read user
adduser $user
adduser $user admin

tar -xvvf home.tar -C /home/$user
cp /home/$user/sources.list /etc/apt/sources.list
chown -R $user.$user /home/$user

else
echo "No se ha encontrado la lista de paquetes, no se instala"
fi
else
echo "No Eres root, no se hace nada"
fi


Y éso es todo. Es decir, de momento, lo que hay que hacer es, bajarse el ubuntu mini, instalarlo y ejecutar el script "install.sh"

Me dejo para otra entrada como hacer el CD de instalación.

Cuidaros!

Opinión: Ubuntu Linux, el día a día, futuro o Moda

Hoy vamos a hacer una entrada distinta. No es que nos falten entradas técnicas, es que a veces, también me gusta reflexionar sobre lo que hacemos.

Haciendo un poco de memoria, no me cuesta recordar la primera vez que oí hablar de Ubuntu. Por aquél entonces era estudiante y ni siquiera estaba en la rama de informática, era el año 2004. Un amigo me trajo unos CD's en una envoltura de cartón y me dijo que era una nueva distribución de Linux que acababa de salir.

Obviamente mi primera impresión fue lamentable. Poca documentación, soporte pésimo, etc, etc. Nunca imaginé la proyección que alcanzaría aquella "versión recortada de Debian"

Hoy, Ubuntu se ha convertido, casi sin duda, en la distribución más famosa (y mediática) de la informática, tirando del carro de Linux. Vayas por donde vayas, hace días que se habla de Ubuntu. Cada vez que alguien dice que le ha entrado un virus por el messenger, no muy lejos, alguien sonríe de forma condescendiente.

No deja de ser curioso que ésto, hasta hace poco era al revés. Linux era un programa que usaban los hackers informáticos para robar información, a cualquiera que se le hablase de éste sistema operativo se le dibujaba una sonrisa paternal y condescendiente en la cara y asistía sin el menor interés a las explicaciones que se le diesen. Pero mira, cada vez somos más, y ahora los que sonríen son los usuarios que cada vez que entran en internet, lo hacen de forma más segura, sin tener que comprar un equipo nuevo cada dos años ni pagar licencias de software.

Desde éste punto de vista, se ha mejorado la vida de mucha gente. Lo que era inpensable hace unos años, hoy puede ser una realidad. por ejemplo, Aquí, en el laboratorio de Ubuntu Linux a Fondo, como en tantos otros, se gestan ideas para que ésto sea una realidad. Instalar Linux en máquinas antiguas, o personalizar un sistema operativo para hacer que sea un SO prácticamente bajo demanda son algunos de los ejemplos que ya tenemos, otros que vendrán, como por ejemplo instalar un escritorio libre sobre Darwin (la distribución que lleva OS X por debajo)

Pero todo no puede ser bueno y siempre hay gente que intenta hacer de lo famoso, algo lucrativo.

Actualmente, las empresas se están volcando con el código abierto y todas (las que quieren aprovechar la buena publicidad) sacan productos basados en soluciones de código abierto. Se empeñan en ofertar servicios adicionales para rentabilizar un fenónemo que viene de atrás pero que ahora se ha puesto de moda.

Mucho se ha hablado sobre la aportación de Ubuntu al código abierto y al fenómeno Linux en general, se ha especulado sobre si el tirón actual viene de la mano de ciertas distribuciones o era una consecuencia absolutamente inevitable.

Lo que sí es cierto (y puede que me crucifiquen por ésto) es que Canonical (Por nombrar la que nos ataña, aunque otras distros también tienen soporte privado) es una empresa y en el fondo, sigue la filosofía de una empresa.

Si bien es cierto que probablemente una comunidad de desarrolladores "a ratos libres" no lograse soportar un número significativo de distribuciones, es cierto que lograse mantener al menos un par de ellas.

Lo que queda por ver es cómo terminará todo ésto, quiero decir ¿Acabaremos pagando por Ubuntu?

Ahí queda.