Instalar KDE 4 en Debian

Después de un tiempo de reflexión, que otro día compartiré con vosotros, vamos a cambiar un poco de tema, voy a hacer la primera entrada específica para Debian. Vamos a ver como instalar KDE 4.1 en Debian.

Primero necesitamos una imágen de Debian etch-4.0. Descargar de Aquí. Instalaremos Debian normalmente, pero en el último paso, seleccionaremos la opción no usar una réplica de red (es decir, que dejaremos la instalación con lo más mínimo posible) Reiniciamos nuestro nuevo sistema Debian.

Ahora toca actualizar Debian a la última versión. Primero actualizamos a lo último de la versión actual:

$su

Añadimos los repositorios que faltan.

#nano /etc/apt/sources.list

Añadimos:

deb http://ftp.debian.org/ etch/updates main contrib
deb-src http://ftp.debian.org/ etch/updates main contrib

Actualizamos:

#aptitude update
#aptitude upgrade

Añadimos los repositorios de la siguiente versión:

#Repositorios Originales Lenny
deb http://ftp.de.debian.org/debian unstable main contrib non-free
deb-src http://ftp.de.debian.org/debian unstable main contrib non-free

Volvemos a actualizar y Añadimos los repositorios de la siguiente versión y los repositorios de la versión experimental (con un par de huevos):

#Repositorios Originales Sid:
deb http://ftp.debian.org/debian testing main contrib non-free
deb-src http://ftp.debian.org/debian testing main contrib non-free

#Repositorios de Experimental:
deb http://ftp.debian.org/debian experimental main
deb-src http://ftp.debian.org/debian experimental main

La Idea es, partiendo de la base estable de Debian, llegar a la versión de Debian Sid. Claro que también podéis descargar una pequeña ISO de Sid (testing) Claro que es posible que tengáis que pululear un rato por el repositorio de Debian.

Ahora empieza la marcha. Para evitar problemas de dependencias, deberemos hacer un "unhold" de los paquetes "apt", "aptitude" y "dpkg" (Intentadlo sin hacer ésto, a ver quién bate el récord de puntuación baja en resolución de dependencias... xD)

#aptitude unhold apt
#aptitude unhold aptitude
#aptitude unhold dpkg

Claro que tambien podemos no hacerlo e ignorarlo, añadiendo la opción --ignore-hold usando apt.


Ahora actualizamos:

#aptitude update
#aptitude upgrade


Y ahora es cuando instalamos KDE4 (por fin ¿no?) Instalaremos los paquetes que necesitemos añadiendo la opción "-t experimental" que dará preferencia al repositorio de la distribución Experimental. Si tenemos problemas de dependencias, es muy probable que hayamos olvidado incluir ésta opción.

Recordad que no hace falta quitar ningun repositorio del sources.list, ya que aptitude siempre intentará instalar la versión de la distribución actual, lo que en la práctica significa que estamos usando Debian Sid, y sólo usaremos "ciertos" paquetes de Debian Experimental. También podemos instalar paquetes de la distribución "unstable" o "stable" indicándolo con "-t" pero no es recomendable.

#aptitude -t experimental install kde4

Ésto instalará la versión completa del escritorio, si queremos sólo lo básico podemos instalar kde4-minimal.

Por cierto que, en el repositorio experimental podemos encontrar otras joyas, como por ejemplo el openoffice 3.0:

#aptitude -t experimental install openoffice.org2-base openoffice.org2-calc openoffice.org2-draw openoffice.org2-math openoffice.org2-writer

Y así es como se hace. Si tenéis alguna duda ya sabéis, preguntad.

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!