Partiendo de que se han generado dos pares de claves:

$ ssh-keygen -t rsa -f ~/.ssh/id_rsa.work -C "fran@trabajo"
$ ssh-keygen -t rsa -f ~/.ssh/id_rsa.home -C "fran@casa"

La forma sencilla es crear el archivo «~/.ssh/config», añadiéndole las siguientes líneas:

IdentityFile ~/.ssh/id_rsa.work
IdentityFile ~/.ssh/id_rsa.home

De este modo, cada vez que SSH conecte con una máquina intentará usar alguna de esas dos claves. Sin embargo, SSH permite realizar un control más granular sobre las claves, para ello habría que tener un archivo «~/.ssh/config» similar al siguiente:

Host 192.168.0.100
  IdentityFile ~/.ssh/id_dsa.home
  User franchukelly

Host ssh.trabajo.com
  IdentityFile ~/.ssh/id_rsa.work
  User fran
  Port 2211

Dónde cada campo Host permite definir una pequeña configuración que se usará de forma predeterminada cuando se realice una conexión a la dirección indicada. Por ejemplo:

$ ssh ssh.trabajo.com

SSH usaría la clave «id_rsa.work», junto al usuario «fran» y el puerto 2211.

Basado en Multiple ssh private keys.

Antes de nada, hay que crear un archivo con los nombres de los desarrolladores que han usado el repositorio de subversion, el archivo tendrá el siguiente formato:

pepe = Pepe Garcia <pepe@garcia.es>
juan = Juan Gonzalez <juan@gonzalez.es>

Los nombres de los desarrolladores del repositorio de subversion se pueden conseguir ejecutando:

$ svn log "svn://REPOSITORIO-SVN/" | awk -F'|' '/^r[0-9]+/ { print $2 }' | sort -u

Este archivo se debe guardar como «authors.txt» para que mi script lo localice, aunque no sería muy difícil cambiar mi script para que se le pase la ruta como pará.

Mi script «svn2git.sh»

Este script se descarga el repositorio indicado (usando git-svn) y convierte y/o borra todos los datos relativos a subversion, como las ramas, los tags, …

#!/bin/sh
# Converts a subversion repository to a Git one.
# git-svn must be installed.

if [ $# -lt 2 ]; then
   echo "Usage: $0 SVN-REPOSITORY LOCAL-PATH"
   exit 1
fi

git svn clone $1 --stdlayout --authors-file=authors.txt --no-metadata $2

cd $2 > /dev/null

for t in `git branch -r | grep 'tags/' | sed s_tags/__`; do
    git tag $t tags/$t^
    git branch -d -r tags/$t
done

git branch -d -r trunk
git config --remove-section svn-remote.svn

rm -fr .git/svn .git/{logs/,}refs/remotes/tags/

cd - > /dev/null

exit 0

1. Instalar git:

   # apt-get install git-core

2. Crear la estructura de los directorios dónde se almacenarán los repositorios de Git:

   # install -d -m 0755 /srv/algo/git /srv/algo/git/repos /srv/algo/git/.ssh

3. Crear el usuario de Git (llamado git):

   # adduser --system --home /srv/algo/git --no-create-home \
   --shell /usr/bin/git-shell --gecos 'git version control' --group \
   --disabled-password git

4. Crear un repositorio:

   $ cd /srv/algo/git/repos
   # install -d -o git -g git -m 0700 PROYECTO.git
   # sudo -H -u git env GIT_DIR=PROYECTO.git git --bare init

5. Añadir una clave pública de SSH para poder acceder al repositorio:

   $ cd /srv/algo/git/.ssh
   # cat CLAVE >> authorized_keys

6. Para clonar el repositorio hará falta tener la clave privada de la clave pública usada, y ejecutar:

   $ git clone git@SERVIDOR:repos/PROYECTO.git

Basado en Howto host git on your Linux box.

¿Qué son las autotools?

Las autotools, son programas que se usan para crear un paquete de código fuente que se pueda distribuir y compilar de una manera sencilla (configure, make y make install). Los programas que forman las autotools son los siguientes:

• aclocal
• autoconf
• automake

Estos programas son la base para crear el paquete de código fuente, para ello se tendrán que generar unos archivos concretos.

Estructura del código fuente a distribuir

Las autotools se usan para generar el paquete «tar.gz» que contiene el código fuente del programa que se va a distribuir, normalmente estos paquetes siguen una estructura estándar. La estructura básica es:

• src: Directorio del código fuente.
• AUTHORS: Indica los autores del programa.
• ChangeLog: Indica los cambios que se han ido produciendo.
• COPYING: Indica la licencia de distribución que tiene el programa. (Autogenerado)
• INSTALL: Explica cómo instalar el programa. (Autogenerado)
• NEWS: Indica las noticias relacionadas con el programa.
• README: Un pequeño documento en el que se describe el programa y se explican temas concretos de éste.
• THANKS: Indica los agradecimientos que tenga el autor/es.
• TODO: Indica una pequeña lista de cosas por hacer.

De este modo, si se van a utilizar las autotools sería aconsejable seguir la estructura anterior, y crear todos los archivos menos los como «autogenerado» que, obviamente, se generarán automáticamente, aunque siempre se pueden crear a mano ya que puede que no se quiera tener el contenido autogenerado.

El archivo «configure.ac»

Sobre este archivo gira toda la generación del programa para su distribución. En él se escriben las macros para los diferentes programas que se ejecutarán: aclocal, autoconf y automake.

AC_PREREQ(2.52)
AC_INIT([hola mundo], [0.1])
AM_INIT_AUTOMAKE([])

AC_PROG_CC
AC_CONFIG_FILES([Makefile src/Makefile])
AC_OUTPUT

• Programa aclocal: Sirve para generar el archivo «aclocal.m4». ¡Sólo se generará si en el archivo «configure.ac» hay macros de automake!
• Macros de autoconf: Empiezan por AC_*, y se buscan en el archivo «configure.ac» y en el «aclocal.m4» si existe. Sirven para la configuración correcta del programa.
• AC_PREREQ(versión) indica la versión de autoconf necesaria.
• AC_INIT([aplicación], [versión]) inicializa autoconf, recibe como parámetros el nombre del programa y su versión.
• AC_PROG_CC indica que realizará una compilación de código escrito en C.
• AC_CONFIG_FILES([Makefile src/Makefile]) indica los archivos «Makefile» que se van a generar a partir de sus respectivos «Makefile.am».
• AC_OUTPUT indica los archivos que finalmente debe generar el script «configure».
• Macros de automake: Empiezan por AM_*, y sirven para la generación de los diferentes «Makefile».
• AM_INIT_AUTOMAKE([]) inicializa automake, se le puede pasar un parámetro que la verdad no sé lo que indica, para mi ejemplo no hace falta pasárselo.

Aviso: Las macros no pueden llevar un espacio entre su nombre y el paréntesis de inicio.

Los archivos «Makefile.am»

Los archivos «Makefile.am» contienen las reglas para generar los archivos «Makefile» correspondientes a los directorios dónde se encuentran, por lo que habrá un archivo por directorio en el que se tenga que realizar alguna operación con make.

De este modo, siempre se debe tener un archivo «Makefile.am» en el directorio raíz del proyecto, este archivo contendrá algo similar a lo siguiente:

SUBDIRS = src
EXTRA_DIST = AUTHORS ChangeLog NEWS README THANKS TODO

• SUBDIRS enumera los directorios que contienen otros archivos «Makefile.am».
• EXTRA_DIST enumera los distintos archivos que deberá tener el paquete, para distribuir el código fuente que se generará.

En este caso el directorio «src» es dónde, supuestamente, deberá estar el código fuente de nuestra aplicación y tendrá un archivo «Makefile.am», que indicará las reglas para compilar nuestro código fuente correctamente.

El archivo «Makefile.am» tendrá el siguiente contenido:

bin_PROGRAMS = hola−mundo
hola_mundo_SOURCES = hola−mundo.c

• bin_PROGRAMS indica el nombre del ejecutable final.
• hola_mundo_SOURCES indica los archivos con el código fuente de la aplicación.
• Si se necesitarán bibliotecas se debería añadir hola_mundo_LDADD con las macros necesarias para dichas bibliotecas en el archivo «configure.ac».

Nota: Para generar una biblioteca, se debería usar libexec_PROGRAMS en lugar de bin_PROGRAMS.

Generación del script «configure»

Una vez creados los archivos necesarios, se deben realizar los siguientes pasos:

1. Generación:

   $ aclocal
   $ autoconf
   $ automake --add-missing

2. Compilación y ejecución del programa:

   $ ./configure
   $ make
   $ src/hola−mundo

3. Distribución del programa:

   $ make distcheck

Para ampliar un poco más All you should really know about Autoconf and Automake

# echo 'APT::Install-Recommends "0";' > /etc/apt/apt.conf.d/90recommends

Sacado de Checklist for configuring a Debian system.

Así que estuve buscando diferentes opciones, siendo importante que funcionase en Linux y en Windows (por si las moscas). Al final había dos opciones Truecrypt (el archiconocido) y dm-crypt (un gestor de dispositivos cifrados de Linux), me decanté por dm-crypt porque Truecrypt, curiosamente, no está en los repositorios de Debian y porque con dm-crypt no necesitaría de un programa a parte para utilizar mi dispositivo en Linux (aunque sí, en Windows).

Pasos a seguir

Directo al grano, estos son los pasos que realicé:

1. Paquetes necesarios:

   # apt-get install cryptsetup hashalot dmsetup

2. Rellenar la memoria con datos aleatorios (no es necesario, aunque sí recomendable):

   # dd if=/dev/urandom of=/dev/sdX

3. Cargar los siguientes módulos si no lo están ya:

   # modprobe aes
   # modprobe dm_crypt
   # modprobe dm_mod
   # modprobe sha256

4. Crear el contenedor cifrado (pedirá la contraseña para poder luego descifrarlo):

   # cryptsetup -v --key-size 256 luksFormat /dev/sdX NOMBRE-CONTENEDOR

5. Formatear el contenedor (yo utilicé FAT para que funcione en Windows) para ello primero hay que montar el contenedor utilizando cryptsetup:

   # cryptsetup -v luksOpen /dev/sdX NOMBRE-CONTENEDOR
   # mkfs.vfat /dev/mapper/NOMBRE-CONTENEDOR

6. Y ya está, ya se puede montar:

   # mount -t vfat /dev/mapper/NOMBRE-CONTENEDOR /mnt/usb_cifrado

Uso

Lo bueno de este método es que al enchufar la memoria en Linux, éste pedirá la contraseña y se montará automáticamente, aunque en la versión de GNOME que uso no lo monta. Así que, por si las moscas, siempre lo puedes montar ejecutando:

$ pmount-hal /dev/sdX

Y desmontar ejecutando:

$ pumount /dev/sdX

Para poder utilizar el dispositivo cifrado en Windows se necesita un programa llamado FreeOTFE que es compatible con este tipo de cifrado.

Basado en Manual de Cifrado de una particion concreta desde Linux Debian/Ubuntu.

Básicamente, a este script se le pasa una lista de directorios junto a un alias (o seudónimo) bajo el que se guardarán en el archivo que contenga el backup. Esto sirve:

1. Para que en el archivo del backup no se guarden las rutas absolutas de los directorios guardados.
2. Para no tener que realizar una copia local (duplicando el tamaño ocupado durante la realización del backup) de los archivos contenidos en los directorios a copiar en un directorio temporal.
3. Para poder guardar los directorios con el nombre que se quiera dentro del archivo del backup.

Script

Este script está preparado para que lo ejecute cron con permisos de root y así poder copiar partes del sistema a las que otro usuario no podría acceder.

Si queréis que funcione con un usuario normal, sólo hace falta que eliminéis el if que está detrás del comentario # Check if the script is being run as root.

Los directorios a copiar se guardan en la variable DIRS separados por un espacio y con el formato alias:/ruta/al/directorio.

#!/bin/bash
# This script makes backups of a list of directories.
# It must be executed by root.

# Backup data
DIRS="images:/home/user/images/ code:/home/user/projects/ docs:/home/user/docs"
TMP_DIR=`mktemp -d`
BACK_FILE="/mnt/backup/`hostname --fqdn`_`date "+%Y-%m-%d"`.tar.gz"

TAR=$(which tar)

# Check if the script is being run as root
if [ "$UID" -ne "0" ]; then
    echo "This script must be run as root!"
    exit -1
fi

# Logging backup
echo "[`date "+%Y-%m-%d"`] Starting backup"

# Create symbolic links
for dir in $DIRS
do
    SYM_DIR=${dir%:*}
    TARGET_DIR=${dir#*:}
    ln -s $TARGET_DIR $TMP_DIR/$SYM_DIR
done

# Create backup
cd $TMP_DIR > /dev/null
$TAR -chzf $BACK_FILE *

# Backup failed
if [ $? != 0 ]; then
    cd - > /dev/null
    rm -fR $TMP_DIR > /dev/null
    echo "[`date "+%Y-%m-%d"`] Backup failed."
    exit -1
fi

# Backup created
cd - > /dev/null
rm -fR $TMP_DIR > /dev/null
echo "[`date "+%Y-%m-%d"`] Backup done!"

exit 0

Instrucciones

Voy a partir de qué tenemos la siguiente estructura de directorios que se quiere compartir:

drwxr-x--- user group dir01
drwxr-x--- user group dir02
drwxr-x--- user group dir03

Como se puede ver, a estos directorios sólo puede acceder el usuario user y los usuarios del grupo group, aunque estos últimos sólo con permisos de lectura sobre los directorios.

Lo primero que se debe hacer es añadir el usuario (o los usuarios) que podrán acceder a nuestros datos compartidos. Para ello se ejecuta:

# smbpasswd -a user

Nos pedirá una contraseña, ésta puede ser distinta a la que tenga el usuario para acceder a la máquina.

Una vez añadido el usuario (o los usuarios), se podrá configurar Samba para que comparta los directorios. Para ello se modifica el archivo /etc/samba/smb.conf y se añade un elemento del siguiente tipo por cada directorio a compartir:

[nombre_directorio_a_compartir]
  comment = Comentario del directorio compartido
  path = /ruta/al/directorio
  read only = yes # Indica si el acceso será sólo lectura
  write list = user # Usuarios/grupos que tendrán acceso de escritura
  create mask = 0640 # Máscara de los permisos al crear archivos
  directory mask = 0750 # Máscara de los permisos al crear directorios
  guest ok = no # Acceso sin autenticación

De este modo, para el ejemplo que he puesto se tendrían que añadir tres elementos de este tipo, quedando el archivo similar a este:

[global]
  display charset = UTF-8
  server string = NOMBRE-DE-LA-MAQUINA
  workgroup = GRUPO-DE-TRABAJO
  netbios name = NOMBRE-NETBIOS-MAQUINA
  invalid users = root # Para que no se pueda acceder como root

[dir01]
  comment = Directorio 01
  path = /home/user/dir01
  read only = yes
  write list = user
  create mask = 0640
  directory mask = 0750
  guest ok = no

[dir02]
  comment = Directorio 02
  path = /home/user/dir02
  read only = yes
  write list = user
  create mask = 0640
  directory mask = 0750
  guest ok = no

[dir03]
  comment = Directorio 03
  path = /home/user/dir03
  read only = yes
  write list = user
  create mask = 0640
  directory mask = 0750
  guest ok = no

Después de esto sólo hay que reiniciar Samba y listo, ya se podrá acceder a dichos directorios compartidos utilizando el usuario user.

# /etc/init.d/samba restart

Basado en Compartir directorios con Samba del blog de Iván López.

Hasta hace poco este servidor utilizaba Windows 2003, hasta que un día decidió morir en extrañas circunstancias, así que como los que nos encargamos de dicho servidor nos manejamos mejor en Linux decidimos instalar Debian Lenny y utilizar Samba para los directorios compartidos y la impresora compartida, ya que en nuestra red tenemos variedad de Windows y Linux.

Instrucciones

Hay que tener instalado CUPS. Una vez instalado, realizar los siguientes pasos para configurar CUPS:

1. Añadir la siguiente línea al archivo /etc/cups/cupsd.conf, suponiendo que nuestra red sea 192.168.0.0/255.255.255.0:

   Allow From 192.168.0.*

2. Descomentar la siguiente línea del archivo /etc/cups/mime.convs:

   application/octet-stream application/vnd.cups-raw  0 - 

De este modo, CUPS permitirá compartir remotamente la impresora. Ahora hay que configurar Samba para que las máquinas con Windows puedan usar la impresora, así que a seguir los siguientes pasos:

Editar el archivo /etc/samba/smb.conf de modo que quede similar a este que muestro:

[global]
  workgroup = GRUPO-DE-TRABAJO
  netbios name = NOMBRE-NETBIOS-MAQUINA

  #this section is only to share the printer
  printcap name = cups
  disable spoolss = yes
  show add printer wizard = no
  printing = cups

[printers]
  comment = Printer in Linux
  path = /var/spool/samba
  create mode = 0700
  guest ok = yes
  print ok = yes
  use client driver = yes
  browseable = yes
  public = yes

El directorio /var/spool/samba se debe crear si no existe y tener permisos 0777.

Con esta configuración se comparte la impresora sin necesidad de autenticarse, ya que el nivel de seguridad lo permite (security = share) y se permite autenticarse como invitado (guest ok = yes). El elemento printers permite que samba comparta automáticamente todas las impresoras conectadas con las propiedades que se le indiquen en dicho elemento.

Si se quisiera obligar a autenticarse para poder usar la impresora, habría que añadir un usuario a samba ejecutando:

# smbpasswd -a usuario

Además, habría que cambiar el nivel de seguridad (con quitar la propiedad security valdría) y no permitir la autenticación como invitado (guest ok = no).

Para finalizar, sólo habría que reiniciar CUPS y Samba:

# /etc/init.d/cups restart
# /etc/init.d/samba restart

Basado en Sharing a printer to XP clients with Samba and Cups de Debian Administration (en inglés).

Más fácil imposible