sitio personal de Rodrigo Garcia.

Construyendo babeld para enrutadores


Actualizado - 28 November 2017

categor铆as: #proyectos #software #tutoriales

Aqu铆 se muestra una manera de construir el programa Babeld mediante compilaci贸n cruzada para enrutadores con el sistema operativo LEDE.

term.png Babeld que es una implementaci贸n del protocolo de enrutamiento Babel escrito en lenguage C, se utliza frecuentemente en enrutadores de redes inl谩mbricas en malla que crecen y se gestionan autom谩ticamente.

Contenido:

Obteniendo lo necesario

Para poder obtener el ejecutable de Babeld (construirlo) y que se pueda ejecutar en un enrutador b谩sicamente se necesita:

  • Compilador cruzado Cross compiler de lenguage C.
  • Enlazador, bibliotecas y otros utilitarios para lenguage C.

Compilador cruzado (cross compiler)

Como queremos que el programa se ejecute en un enrutador TL-MR3020, primero debemos obtener el compilador cruzado apropiado. Dentro del Sistema operativo LEDE u Openwrt, el TL-MR3020 esta dentro de la rama objetivo ar71xx.

Descargando el SDK ya construido

La primera forma de obtener el cross compiler es descarg谩ndolo del repositorio oficial, el proyecto LEDE mantiene un SDK.

En https://downloads.lede-project.org/releases/17.01.4/targets/ar71xx/generic/ deber铆a haber un archivo que contenga sdk por ejemplo: lede-sdk-17.01.4-ar71xx-generic_gcc-5.4.0_musl-1.1.16.Linux-x86_64.tar.xz.

En la wiki de LEDE se describe mejor el SDK, b谩sicamente es una cadena de herramientas (toolchain) para hacer compilaci贸n cruzada y construir programas para una determinada plataforma objetivo (en nuestro caso ar71xx).

Luego debemos descomprimir este archivo, que contiene el toolchain que necesitamos.

Construyendo todo usando buildroot

Si lo que quieres es construir todo incluyendo el SDK, puedes usar Build root. El proceso de construcci贸n lo he descrito en el post: Construir firmware para enrutadores con Buildroot, no olvides marcar la opci贸n: Build the ... SDK.

Una vez termine el largo proceso de construcci贸n, hay que ubicarse en bin/targets/ar71xx/generic donde deber铆a estar un archivo comprimido con el SDK reci茅n construido.

--> En general, es preferible usar la primera forma y s贸lo descargar el SDK precompilado desde el repositorio oficial de LEDE.

C贸digo Fuente de Babeld

El c贸digo fuente de Babeld se puede obtener desde https://www.irif.fr/~jch/software/files/babeld-1.8.0.tar.gz o descargando la versi贸n de desarrollo con:

git clone git://github.com/jech/babeld.git

Con todo lo necesario, ya podemos empezar a construir Babeld.


Construyendo Babeld

Primero como en todo programa nos ubicamos en el directorio ra铆z del c贸digo fuente, luego de clonar u obtener Babeld en el directorio ra铆z existe un archivo Makefile, con instrucciones b谩sicas para la construcci贸n del programa.

En el Makefile, la regla con la instrucci贸n de compilaci贸n:

babeld: $(OBJS)
        $(CC) $(CFLAGS) $(LDFLAGS) -o babeld $(OBJS) $(LDLIBS)

Ah铆 la variable $(CC) es la que se puede reemplazar para que se utilice el compilador cruzado del SDK de LEDE.

Babeld no utiliza bibliotecas adicionales y todas las necesarias (libc) vienen en el SDK asi que para construirlo solamente apuntamos al compilador cruzado del SDK que tenemos, esto se hace con el comando:

make CC=/ubicacion/del/SKD/staging_dir/toolchain-mips_24kc_gcc-5.4.0_musl/bin/mips-openwrt-linux-musl-gcc PLATFORM_DEFINES='-march=mips32'

La parte que dice /ubicacion/del/SKD/ apunta a la ubicaci贸n en nuestro compuador donde descomprimimos el SDK, ah铆 dentro esta staging_dir/ y ah铆 deber铆a estar el toolchain para la arquitectura, en este caso mips_24kc.

Para comprobar que en este directorio se encuentra el compilador cruzado:

./ubicacion/del/SKD/staging_dir/toolchain-mips_24kc_gcc-5.4.0_musl/bin/mips-openwrt-linux-gcc --version

Usaremos el compilador gcc-5.4.0 cuyo archivo ejecutable es mips-openwrt-linux-gcc y si en la pantalla aparece un mensaje con la version 5.4.0 el archivo es correcto, por ejemplo:

mips-openwrt-linux-gcc (LEDE GCC 5.4.0 r3664-4124847) 5.4.0

Ahora, construimos con:

make CC=/ubicacion/del/SKD/staging_dir/toolchain-mips_24kc_gcc-5.4.0_musl/bin/mips-openwrt-linux-musl-gcc \
PLATFORM_DEFINES='-march=mips32'

El proceso deber铆a terminar r谩pidamente y deber铆a haber un archivo ejecutable con nombre babeld. Este archivo se puede ejecutar en un enrutador con LEDE, para comprobar que la arquitectura objetivo del ejecutable es correcta usamos:

file babeld

Que deber铆a mostrar:

babeld: ELF 32-bit MSB executable, MIPS, MIPS32 rel2 version 1, dynamically linked, interpreter /lib/ld-musl-mips-sf.so.1, not stripped

Ahora solo hace falta probarlo copiando el archivo babeld al enrutador digamos en el directorio /tmp/ y luego ejecutarlo con:

./babeld

--> De esta forma hemos usado el compilador cruzado directamente para construir desde el c贸digo fuente, de forma similar se construyen programas para los enrutadores y cada programa puede tener sus necesidades espec铆ficas. Pero con esto podr铆amos modificar el c贸digo de Babeld y probar estos cambios directamente en el enrutador.


Construyendo Babeld-lor

Ahora podemos usar el SDK para construir una versi贸n modificada de Babeld llamada Babeld-lor, esta versi贸n en desarrollo pretende implementar un m茅todo de autenticaci贸n en el protocolo Babel para protegerlo contra ataques de suplantaci贸n de identidad.

Instalando o construyendo mbedtls

Babeld-lor utiliza descifrado RSA y una clave p煤blica RSA generada por una entidad central para autenticaci贸n, por eso es necesario copiar o tener instalada la biblioteca mbedtls en el enrutador.

Una forma sencilla de instalarla es mediante el mediante manejador de paquetes de LEDE, en el enrutador:

opkg install libmbedtls

Para m谩s detalles sobre esta biblioteca revisa este post como construir mbedtls.

Copiando mbedtls si no hay espacio suficiente el directorio ra铆z del enrutador (opcional)

Se puede copiar a la partici贸n /tmp los archivos necesarios para la biblioteca mbedtls. El siguiente procedimiento es una soluci贸n temporal y cada que el enrutador se reinicie se debe volver a repetir cierta parte.

# Conect谩ndose al enrutador que digamos tiene la IP: 192.168.1.1
ssh root@192.168.1.1
# una vez dentro el enrutador
### obteniendo mbdetls 
cd /tmp/
wget https://downloads.lede-project.org/releases/17.01.4/packages/mips_24kc/base/libmbedtls_2.6.0-1_mips_24kc.ipk
mv libmbedtls_2.6.0-1_mips_24kc.ipk libmbedtls_2.6.0-1_mips_24kc.tar.gz
tar -zxvf libmbedtls_2.6.0-1_mips_24kc.tar.gz
tar -zxvf data.tar.gz
cd usr/lib
mkdir /tmp/mbedtls
cp libmbedcrypto.so.0 libmbedtls.so.10 libmbedx509.so.0 /tmp/mbedtls
######
# creando un enlace simbolico para que el sistema apunte a los archivos correctos
cd /usr/lib
ln -s /usr/lib/libmbedcrypto.so /tmp/mbedtls/libmbedcrypto.so.0
ln -s /usr/lib/libmbedtls.so /tmp/mbedtls/libmbedtls.so.10
ln -s /usr/lib/libmbedx509.so /tmp/mbedtls/libmbedx509.so.0

Ahora la biblioteca libmbedtls esta instalada temporalmente en el sistema, pero al apagar el equipo la partici贸n temporal /tmp se vaciar谩 y tiene que repetir la parte que dice "### obteniendo mbdtls".

Clave p煤blica y credenciales para Babeld-lor

Como Babeld-lor utiliza una clave p煤blica RSA de una entidad central, es necesario que el enrutador la tenga para poder descifrar las actualizaciones de rutas y autenticarlas. Tambi茅n, se requiere que cada enrutador cuente con un conjunto de tokens de autenticaci贸n.

Creando credenciales

Primero se debe crear el par de claves p煤blica y privada y lo podr铆amos hacer en nuestra computadora, esta clave debe ser creada con la biblioteca mbedtls, una forma r谩pida de construir mbedtls est谩 la secci贸n "construyendo mbedtls" del post: probando mbedtls

Una vez lo tengamos, en el directorio del c贸digo fuente de mbedtls:

cd programs/pkey
./gen_key

Que generar谩 el par de claves de la entidad central.

Ahora podemos utilizar este script para generar tokens cifrados para direcciones IP dadas:

DIR_BASE=$PWD
DIR_RSA=/Ruta/donde/esta/mbedtls-2.4.2/programs/pkey # modificar esto segun convenga
ARCH_TOKEN=$DIR_RSA/result-enc.txt
DIR_DEST=$DIR_BASE/tokens
PREFIJO=$1

echo "preparando para prefijo $PREFIJO"

if [ ! -e tokens ]
then
    mkdir tokens
fi

if [ -e $DIR_DEST/$PREFIJO.ctxt ]
then
    echo "borrando tokens/$PREFIJO.ctxt"
    rm $DIR_DEST/$PREFIJO.ctxt
fi

for((i=0;i<100;i++))
do
    B=$(head -c 19 /dev/urandom  | sha1sum | head -c 6 | tr "[a-z]" "[0-9]")
    if [ $i -lt "10" ]
    then
        CAD=$PREFIJO"_"$B"0"$i
    else
        CAD=$PREFIJO"_"$B$i
    fi

    echo "mensaje: $CAD"

    # cifrando
    cd $DIR_RSA
    ./rsa_encrypt_con_clave_privada $CAD > /dev/null
    #$PPK "$CAD" 2> /dev/null
    TOKEN=$(cat $ARCH_TOKEN | tr -d ' ')
    #echo "TOKEN: $TOKEN"
    # quitando newlines
    while read -r linea
    do
        L=$(echo "$linea"| tr -d ' ' )
        #echo -n "$L"
        echo -n "$L" >> $DIR_DEST/$PREFIJO.txt
    done < $ARCH_TOKEN
    echo >> $DIR_DEST/$PREFIJO.txt
done

# eliminando ^M
cat $DIR_DEST/$PREFIJO.txt | tr -d $'\r' > $DIR_DEST/$PREFIJO.ctxt
rm $DIR_DEST/$PREFIJO.txt

cp $DIR_RSA/rsa_pub.txt $DIR_DEST/

echo "Hecho."
exit 0

Guardamos este script como digamos "gk.sh", ahora creamos los tokens con:

bash gk.sh 192.168.1.1

Que generar谩 un total de 100 tokens de autenticaci贸n para la direcci贸n ip 192.168.1.1 en una carpeta tokens

Proceso de construcci贸n manual

Ahora necesitamos descargar el c贸digo fuente de Babeld-lor, por ejemplo de la rama de desarrollo forked-updateTLV:

git clone https://notabug.org/strysg/babeld-lor/src/forked-updateTLV

Este repositorio contiene un Makefile para compilar usando mbedtls y un SDK.

Tambi茅n un script llamado set-up.sh que apunta a un SDK en el directorio actual y como podr铆amos tener el SDK de LEDE en otro directorio podemos crear un enlace simb贸lico al SDK con:

ln -s /ruta/donde/esta-el-SDK/ SDK

El script set-up.sh extrae la clave p煤blica, los tokens de autenticaci贸n, el ejecutable construido y los copia al enrutador en la carpeta /tmp, no instala Babeld-lor ya que estamos solamente haciendo una prueba.

Antes de ejecutar el script deber铆amos copiar el contenido de la carpeta tokens donde se generaron las claves de autenticaci贸n al directorio donde descargamos Babeld-lor, concretamente en un directorio pruebas/tokens dentro el c贸digo fuente de Babeld-lor.

Finalmente para construir babeld-lor usamos:

./set-up.sh export 192.168.1.1

Que construir谩 el programa usando el SDK, y copiar谩 lo necesario al enrutador con la direcc铆on IP 192.168.1.1.

Para probar que esto funciona en el enrutador:

cd /tmp/
# para que babeld-lor exporte las rutas por la interfaz wifi wlan0
./babeld wlan0
# o si queremos mas verbosidad
./babeld -d 2 wlan0
# Para utlizar el archivo de configuracion por defecto
./babeld -c /var/etc/babeld.conf -d 2

Si funciona ahora se puede probar y modificar Babeld-lor a gusto.