Información blog

Linux, tutoriales, noticias, sistemas, redes y seguridad informática, entre otras cosas.

martes, 17 de septiembre de 2013

Actualizar Kernel en Debian5

Instalar kernel 3.11.1 en Debian 5

Esta es una guía de cómo instalar el nuevo kernel en un Debian 5 Lenny. Para ello primero hay que tener instaladas varias dependencias que, aunque por lo general suelen estar instaladas, conviene tener en cuenta por si acaso. Las dependencias son:

  • bc
  • gcc
  • g++
  • make
  • kernel-package(opcional)

Una vez instalado esto vamos a la pagina oficial del kernel: https://www.kernel.org/ y de ahí nos bajamos la versión estable que más nos convenga. Yo recomiendo personalmente entrar en su ftp y bajar una versión estable en formato tar.gz. En la página oficial aparece la versión estable en formato tar.xz pero este tipo de compresión no está soportada en Debian 5 y es complicado implantar el paquete; más aún cuando dicho estándar no se complemente bien con Debian 5.

Una vez se tiene el fichero, se descomprime y se preparara el sistema para actualizar el kernel.

  • Entramos en: carpeta_Kernel/Documentation/ y escribimos lo siguiente à ln –s ../tools/lguest/
  • Una vez hecho ese cambio usamos nuestro editor favorito para editar el siguiente fichero: carpeta_Kernel/Tools/lguest/Makefile. Allí aparecen unas pocas líneas muy simples, pero debido a un bug de Debian5 no las puede implantar bien, con lo que habría que cambiar “all: lguest” por “all:”
  • Debian 5 es incapaz de reconocer por defecto el UTS release con los parámetros dados por defecto, con lo que habría que hacer un pequeño cambio para hacerlo capaz de reconocer el UTS entrado en esta ruta: /usr/share/kernel-package/ruleset/misc/ y editando el fichero version_vars.mk. Allí habría que buscar la palabra UTS_RELEASE_HEADER. Donde debe aparecer algo cómo esto:

UTS_RELEASE_HEADER=$(call doit,if [ -f include/linux/utsrelease.h ]; then  \
                               echo include/linux/utsrelease.h;            \
                           else                                            \
                               echo include/ linux /version.h ;              \
                           fi)

Lo cual habría que cambiarlo para dejarlo así:

UTS_RELEASE_HEADER=$(call doit,if [ -f include/generated/utsrelease.h ]; then  \
                               echo include/generated/utsrelease.h;            \
                           else                                            \
                               echo include/generated/utsrelease.h ;              \
                           fi)


Con estos cambios hechos tocaría empezar a limpiar el kernel mediante el comando:

make mrproper

Finalizado aquello, tocaría configurarlo. Hay tres métodos de configuración:

  • make config: Es un metodo bastante completo pero también complejo pues te hace muchas preguntas de muchos datos esplicitos. Es una herramienta potente pero que requiere tener bastantes conocimientos.
  • make menuconfig: Mediante esta forma tenemos una menu mostrado mediante dialogs muy intuitivos que te deja configurar las opciones con eficiencia y rapidez. Requiere tener la dependencia dialog instalada.
  • make xconfig:: Debes tener instalado y en funcionamiento el servidor X, ya que  toda la configuración se hace gráficamente (haciendo uso de ventanas). Se necesitan tener las librerías QT y sólo es recomendable hacerlo en entornos gráficos.
La opción que recomiendo es make menuconfig pero cada uno tiene sus gustos y necesidades. Aquí es muy difícil guiar a nadie. Cada uno tiene que ver si quiere poner una funcionalidad especial o no, aunque por lo general sin tocar nada ya es muy completo. Todo modulo que se quiera añadir y especialmente quitar debe de ser pensado minuciosamente. Tras la configuración del kernel solo queda compilarlo mediante estos dos comandos y en este orden.

make-kpkg clean

make-kpkg –initrd kernel_image kernel_headers

Si se han seguido todos los pasos correctamente, tras una buena espera tendríamos el kernel compilado y listo para instalar.Si encontramos algún error durante la configuración probablemente haya que entrar en la carpeta_kernel/debian/ruleset/misc/version_vars.mk y hacer el mismo cambio hecho arriba en la sección UTS_RELEASE_HEADER. La instalación es muy rápida y sencilla. Sólo habría que ir al directorio que está por encima del contenido de la carpeta del kernel (ej: Si la carpeta está en /usr/src, habría que ir a dicha carpeta no a la carpeta del kernel) y escribir lo siguiente:

dpkg –i TU_KERNEL.deb
dpkg –i TU_KERNEL_HEADERS.deb

En este caso ha sido:

dpkg –i linux-image-3.11.1_3.11.1-10.00.Custom_i386.deb

dpkg –i linux-headers-3.11.1_3.11.1-10.00.Custom_i386.deb


Con esto solo habría que reiniciar el equipo para poder disfrutar del nuevo kernel y sus ventajas.


domingo, 26 de mayo de 2013

Cómo crear códigos QR desde una consola Linux.

Las nuevas tecnologías se arraigan más y más en la sociedad, haciendo que todo el mundo sea increíblemente dependiente de ésta. La tecnología que más tirón está teniendo en estos momentos es la tecnología orientada a dispositivos móviles, especialmente gracias a la moda de los smartphone. Aunque hay algunos aspectos de esta nueva moda que no me gustan, hay que reconocer que hay muchas herramientas realmente interesantes, cómo por ejemplo los lectores de códigos QR. Estos códigos hacen que con tan sólo el escaneo de un código tengamos acceso a una determinada cantidad de datos o a un enlace web. Existen numerosas aplicaciones capaces de crear estos códigos, e incluso se pueden generar en paginas web. Pero imaginemos que tengamos una consola Linux pura: Sin interfaz gráfica ni ningún medio que nos facilite el uso del sistema. Hay ocasiones en los que uno puede echar de menos un ratón y una ventana que te lo solucione todo con un par de clicks, pero no siempre es posible: Por ello existen herramientas que te permiten generar códigos de forma bastante fácil, pero que requieren que te acuerdes perfectamente de los comandos necesarios, cosa que no siempre es ocurre debido a que uno tiene cosas más recientes o importantes en la cabeza. Para ello primero necesitamos instalar la herramienta "qrencode", que se puede descargar desde los repositorios del sistema mediante usando los distintos comandos de los sistemas operativos (apt,yum,rpm...)

Una vez instalada la herramienta, yo propongo hacer el siguiente script (que luego cada uno puede editar según sus necesidades). Con dicho script podemos hacer que un QR que nos dirija a un enlace web: (yo le he llamado qrscanner.sh):

  1. #######################QRSCANNER########################
  2. #!/bin/bash
  3. #Obligaremos al usuario a introducir siempre un argumento
  4. #Dicho argumento sera la url de la pagina web
  5. if [ $# -eq 1 ];
  6. then
  7.         cd /tmp
  8.         echo $1 > "/tmp/url.txt" #metemos el argumento dentro de un txt
  9.         qrencode -l L -v 1 -o imagenqr.png < "/tmp/url.txt" #generamos el codigo
  10.         rm "/tmp/url.txt" #borramos el txt generado
  11.         echo ""
  12.         echo "codigo imagenqr.png generado correctamente en /tmp"
  13.         echo ""
  14. else # Si lo introduce mal le mostramos como tiene que escribirlo
  15.         echo ""
  16.         echo "El uso es $0 URL de la pagina web"
  17.         echo ""
  18. fi

Con esto ya tendríamos el código generado en la carpeta tmp. He configurado el script para que tan sólo permita introducir un argumento (en este caso la URL) para que no ocurran conflictos. Ahora con tan sólo coger el código con una herramienta cómo filezilla, tendríamos una imagen cómo esta:


Espero que os haya gustado. Cómo siempre un placer.

Saludos.

martes, 21 de mayo de 2013

Cómo upgradear de Debian 6 squeeze a Debian 7 wheezy

Debian, es uno de los sistemas operativos libres más extendido, debido a su flexibilidad, solidez, a facilidad de uso y la gran cantidad de distribuciones basadas en éste. Yo particularmente uso Debian y puedo decir que estoy muy satisfecho con éste, excepto en el aspecto de los drivers, pues a veces no reconoce algunos dispositivos que hayan salido hace poco, a diferencia de otras distribuciones cómo Ubuntu o Red Hat. Aún así, es mi sistema operativo de Linux predilecto, y como tal, me he sentido atraído por su nueva distribución aún sin ser tan estable como la distribución anterior de momento. Por ello, he copiado mi maquina virtual de Debian6 para luego actualizar dicha copia, ofreciéndome de momento resultados favorables, ya que no me he topado con bugs o inconvenientes con Wheezy.

Podría enumerar todas las mejoras encontradas, pero a mí me han llamado dos especialmente. La primera es la posibilidad de instalar software de 32 y 64 bits en el mismo sistema, una mejora my apreciada ya que todas las dependencias del sistema quedarían resueltas sin tener que andar mirando si se tienen los paquetes adecuados para las versiones de 32 o 64 bits. La segunda (y muy interesante) es la posibilidad de desplegar una infraestructura de nube privada. Todavía no he probado apenas cómo configurar la infraestructura, la cual es creada mediante el software XCP. Aún así, creo que es un sistema con muchas posibilidades y por ello recomiendo al menos probarla para ver si interesa cambiarse a ésta. Para ello hay dos opciones: La primera y la más fácil es el instalarse la nueva distribución desde cero. La segunda es actualizar el sistema actual, cosa que dependiendo de la situación puede ser interesante. Para ello habría que hacer lo siguiente:

Primero actualizamos nuestros paquetes lo máximo posible mediante estos comandos:

aptitude update
apt-get update


Una vez hecho esto entramos en /etc/apt/sources.list

Allí aparecerán los repositorios de los que nos bajamos los paquetes. Algo parecido a esto:

deb http://ftp.es.debian.org/debian/ squeeze main
deb-src http://ftp.es.debian.org/debian/ squeeze main
deb http://security.debian.org/ squeeze /updates main
deb-src http://security.debian.org/ squeeze /updates main
# squeeze-updates, previously known as 'volatile'
deb http://ftp.es.debian.org/debian/ squeeze -updates main
deb-src http://ftp.es.debian.org/debian/ squeeze -updates main


Dichos repositorios deben venir ahora de wheezy, quedando así el fichero:

deb http://ftp.es.debian.org/debian/ wheezy main
deb-src http://ftp.es.debian.org/debian/ wheezy main
deb http://security.debian.org/ wheezy/updates main
deb-src http://security.debian.org/ wheezy/updates main
# squeeze-updates, previously known as 'volatile'
deb http://ftp.es.debian.org/debian/ wheezy-updates main
deb-src http://ftp.es.debian.org/debian/ wheezy-updates main



Luego hacemos de nuevo otra vez la actualización con los nuevos repositorios:

apt-get update && apt-get upgrade

Y por último, viene lo más importante. Actualizar la distribución.

apt-get dist-upgrade
Con esto tendríamos la nueva versión de Debian instalada, aunque siempre es importante asegurarse de que todo se ha hecho correctamente comprobando la versión de debian mediante:

cat /etc/issue

Si aparece: “Debian GNU/Linux 7.0 \n \l” enhorabuena. Ya tenéis el nuevo sistema operativo listo para trabajar.

Saludos.

miércoles, 8 de mayo de 2013

Proteger Asterisk de atacantes

Asterisk es una herramienta fantástica de software libre usada para la comunicación voz ip que funciona perfectamente en Linux. Evidentemente no todo es gratis, si queremos hacer llamadas al exterior, se necesita contratar un proveedor SIP cuyo precio es bastante asequible pero que no deja de ser un coste. Aún así, yo la considero una excelente herramienta tanto cómo aprendizaje tanto cómo herramienta profesional (centralita de llamadas hecha por uno mismo). Hace poco monté una pequeña centralita muy simple, contratando un proveedor SIP gratuito que tenía la limitación de realizar o recibir llamadas de miembros de dicho proveedor. No es algo practico en la vida real, pero sí útil. 

La centralita voz ip es muy útil, pero si no tenemos cuidado puede salirnos caro. Un recurso indispensable es la configuración de varios filtros para que nadie que nosotros no queramos pueda entrar por el router. Pero nunca está de más tener una protección extra en el servidor linux donde está instalado Asterisk. Hace poco estaba mirando los logs y grande fue mi sopresa al ver más de mil intentos de registro en mi centralita con diferentes nombres y contraseñas. Por suerte mi contraseña es sólida y no ha podido hacer nada (aunque si hubiese entrado no habría podido hacer gran cosa), pero nunca es agradable ver cómo te saturan de ataques o ver que tu servidor no es tan seguro. En mi caso solo he tenido que filtrar todo aquello que entrase por el puerto 5060 menos mi proveedor SIP, pero imaginemos que queremos algo abierto en un caso real. No es aconsejable impedir todos los accesos por el puerto(imaginemos que tenemos varios proveedores o que tenemos una centralita con constantes cambios), pero tampoco hay que dejarlo abierto para todos ya que pueden pasar cosas cómo esta. Por ello vi la necesidad de bloquear solo las ip que me intentasen invadir.


Hay varias herramientas por ahí, pero ninguna se adaptaba a mis necesidades o era defectuosa y por ello, he creado un script para sea ejecutado automáticamente (gracias a la herramienta crontab) cada cierto tiempo, en mi caso particular cada 30 minutos, y me proteja de aquello que me acosa constantemente.

En mi caso he llamado al script asterisk_filter.sh

  1. #!/bin/bash
  2. ##############################################Filtrador de Asterisk################################
  3. #Variables necesarias
  4. tabla[1]=0
  5. i=1
  6. count[1]=0
  7. aux=1
  8. rev=0
  9. marca=0
  10. #Registramos en el fichero /tmp/fichero.txt las ultimas las lineas que incluyen: NOTICE y failed for. Solo guardamos la ip y el puerto.
  11. #Esta puesto para que lea las ultimas 500 lineas
  12. tail -n 500 /var/log/asterisk/messages |grep 'failed for' |grep 'NOTICE' |cut -d "'" -f4 > /tmp/fichero.txt
  13. #Lectura del fichero
  14. while read linea;
  15. do
  16. #Inicializamos la variable auxiliar
  17.  aux=1
  18.  while [ ${aux} -le ${i} ];
  19.  do
  20.   if [ ${tabla[$aux]} !${linea} ];
  21.   then
  22. #Con esto evaluamos si lo que no coincide con el contenido ya existe en nuestra tabla
  23.    while [ ${rev} -le ${i} ];
  24.    do
  25.     rev=$((${rev} + 1))
  26.     if [ "${tabla[$rev]}" == "${linea}" ]#Si coincide hacemos una marca que dice que existe
  27.     then
  28.      marca=1
  29.     fi
  30.    done
  31.    if [ ${marca} -eq 0 ]#Si la marca dice que no existe, sumamos una entrada a la tabla
  32.    then
  33.     i=$((${i}+1))
  34.                          tabla[${i}]=${linea}
  35.    fi
  36.    else
  37.    count[${aux}]=$((${count[aux]} + 1)) #Si la cadena existe en la tabla, la sumamos al contador
  38.   fi
  39. #Reinicializamos las variables de revision
  40.   marca=0
  41.   rev=0
  42. #Sumamos uno al auxiliar
  43.   aux=$((${aux} + 1))
  44.  done #Fin de bucle de comparaciones de cadenas
  45. done < /tmp/fichero.txt #Fin de lectura de fichero
  46. aux=1 #Aprovechamos la variable auxiliar para la evaluacion final
  47. limite=180 #Limite de intentos
  48. while [ ${aux} -le $i ]#Mientras que aux sea
  49. do
  50.  marca=0 #Siempre que iniciamos el bucle la marca es 0
  51.  aux=$((${aux}+1))
  52. #Si el numero de intentos de entrada desde una ip concreta es mayor que 180, entonces la bloqueamos
  53.  if [ ${count[${aux}]} -gt ${limite} ];
  54.  then
  55. #Miramos si esta regla ya existe en nuestro iptables por para evitar duplicidades
  56. #Esto se hace para evitar que nuestro equipo se llene de reglas iguales
  57. #ya que se puede leer algo del log que ya ha sido tratado antes pero que sigue en dicho
  58. if [ -f /etc/init.d/iptables.sh ]#si existe iptables...
  59. then
  60.  echo "nada" >/dev/null
  61. else
  62.  touch /etc/init.d/iptables.sh
  63.  echo "### BEGIN INIT INFO" > /etc/init.d/iptables.sh
  64.  echo "# Provides:          iptables.sh" >> /etc/init.d/iptables.sh
  65.  echo "# Required-Start:    " >> /etc/init.d/iptables.sh
  66.  echo "# Required-Stop:     " >> /etc/init.d/iptables.sh
  67.  echo "# Should-Start:      " >> /etc/init.d/iptables.sh
  68.  echo "# Should-Stop:       " >> /etc/init.d/iptables.sh
  69.  echo "# Default-Start:     2 3 4 5" >> /etc/init.d/iptables.sh
  70.  echo "# Default-Stop:      0 1 6" >> /etc/init.d/iptables.sh
  71.  echo "# Short-Description: iptables.sh" >> /etc/init.d/iptables.sh
  72.  echo "# Description:       iptables script" >> /etc/init.d/iptables.sh
  73.  echo "### END INIT INFO" >> /etc/init.d/iptables.sh
  74.  chmod 755 /etc/init.d/iptables.sh
  75.  $(insserv iptables.sh)
  76. fi
  77.   while read line;
  78.   do
  79. ##Aqui dividimos la ip del atacante y el puerto por el que intenta acceder
  80.    ip=${tabla[${aux}]} |cut -d ":" -f1
  81.    port=${tabla[${aux}]} |cut -d ":" -f2
  82. #Esto es para que funcioe en algunas versiones antiguas que no incluyen el puerto en el log
  83.    if [ ${#ip} == 0 ];
  84.    then
  85.     ip=${tabla[${aux}]}
  86.    fi
  87.    if [ ${#port} == 0 ]
  88.    then
  89.     port=5060 #Aqui ponemos el standard sip porque suele ser el mas atacado
  90.    fi
  91. #Fin de proteccion
  92. #Comprobamos si existe la regla
  93.    if [ "${line}" == "iptables -A INPUT -s ${ip} -p tcp --dport ${port} -j DROP" ];
  94.    then
  95.     marca=1 #si existe, lo marcamos para no crear duplicidades
  96.    fi
  97.   done < /etc/init.d/iptables.sh
  98. #Si no hay marca, es decir si no existe, agregamos una regla
  99.   if [ ${marca} == 0 ];
  100.   then
  101. #Bloqueamo los protocolos, tcp y udp y agregamos las reglas a nuestro script de inicio
  102.    $(iptables -A INPUT -s ${ip} -p tcp --dport ${port} -j DROP)
  103.    $(iptables -A INPUT -s ${ip} -p udp --dport ${port} -j DROP)
  104.    echo "iptables -A INPUT -s ${ip} -p tcp --dport ${port} -j DROP" >> /etc/init.d/iptables.sh
  105.    echo "iptables -A INPUT -s ${ip} -p udp --dport ${port} -j DROP" >> /etc/init.d/iptables.sh
  106.   fi
  107.  fi
  108. done
  109. rm /tmp/fichero.txt

Esto es el funcionamiento básico del programa. Obviamente puede ser mejorado. Hay multitud de opciones pero para ello he puesto también el código, para que luego cada uno lo vaya mejorando a su gusto. Si tenéis alguna propuesta/mejora comentarla por favor.

Por cierto luego en el crontab pondríamos algo cómo esto:

*/30 * * * * root cd "ruta script" && ./asterisk_filter.sh &> /dev/null

Un saludo.

viernes, 15 de febrero de 2013

Creación de VPN con openVPN

Una VPN(Virtual Private Network) se trata de una red virtual a la que sólo tienen acceso un número limitado de personas escogidas por el creador de ésta. Esta tecnología ha sido pensada para proteger la información de los numerosos peligros que pueden hacer en la red, tales cómo los hackers.

La red es un lugar peligroso, donde la información circula libremente, estando a disposición de usuarios maliciosos. La red que circula dentro de una red privada es confidencial, pero imaginemos que tenemos un equipo fuera de dicha red, que queramos que tenga acceso a la información del servidor, o de un equipo de la red. Esto es posible hacerlo, pero la información puede ser robada:



Con una VPN garantizamos la integridad de nuestros datos, aseguramos una red privada con IPs virtuales en la que simularíamos una transferencia de datos por un cable físico, siendo imposible que nadie vea el contenido de dicha transferencia. Es por ello que se llama red virtual privada, porque simula las características de una red privada física.




OpenVPN es una de las soluciones existentes para realizar dicha tarea. Su principal punto a favor, es que combina todas bondades de otras soluciones VPN, tales cómo L2Sec e IPSec, aunque tiene la desventaja de que sólo funciona al 100% en los servidores Linux. OpenVPN usa los standards SSL/TLS para cifrar y combinar todas sus características, siendo una buena opción para integrar tanto en entornos domésticos cómo para profesionales. Primero, ante todo debemos pensar la arquitectura de nuestra VPN: ¿Que ip tendrá nuestra VPN? ¿Cuántos clientes tendrá nuestro servidor VPN? El router que esté conectado a nuestro servidor DEBE tener NAT, ¿Tenemos un router que cumpla ese requisito? ¿Son capaces de verse entre sí todos los routers que actuarán en la VPN? Una vez tengamos claras nuestras ideas, lo mejor es hacer un esquema que nos guíe, cómo el que muestro yo cómo ejemplo, ejemplo que seguiré para la explicación de la VPN.



Para empezar hay que instalar openVPN en un servidor Linux, siendo tan fácil cómo instalar apt-get install openvpn. Con esto ya tendríamos la aplicación instalada pero, evidentemente, carece de configuración alguna. Para ello lo primero y más importante es crear los certificados que tendrán tanto nuestro servidor, cómo los clientes; sin esto no se podrá construir VPN alguna. Yo en este caso utilizaré certificados ssl, que no sólo se crean con facilidad, sino que además son muy seguros. Para ello, primero hay que instalar openssl con apt-get install openssl. Una vez instalado el software escribimos cd /usr/lib/ssl/misc, accediendo a la carpeta donde se almacenan los scripts de openssl que serán las herramientas que usaremos para la creación de las licencias. Lo primero y más importante es conceder los permisos necesarios para poder ejecutar dichos scripts. Lo ideal es que sólo nosotros los administradores root, tengamos la posibilidad de ejecutar estos, con lo que escribiremos: chmod 755 –R *. Ya teniendo los permisos, es el momento de crear un nuevo certificado CA, que es indispensable en todos los equipos que usen openVPN, ya sea cliente o servidor. Para ello escribimos ./Ca.sh –newca , con el cual haremos nuestro nuevo certificado. El nombre dejadlo por defecto y la contraseña usad la que os convenga, pero SIEMPRE usad la misma para todos los certificados o claves que generemos a partir de ahora. Con esto ya tendríamos el certificado almacenado en la carpeta demoCA, pero no necesitamos firmarlo para que sea valido, con lo que vamos a la carpeta demora y renombramos el archivo con el nombre “newca.pem” para luego firmarlo mediante esta sentencia:

openssl –x506 –in newca.pem –days 10000 –out cacert.pem –signkey private/cakey.pem

Gracias a esto ya tenemos un certificado CA con una validez de 10000 días; ahora es el turno de hacer los certificados personales para cada equipo, ya sea cliente o servidor. Comenzaremos con el de servidor, para el cual debemos escribir lo siguiente manteniendo el orden:

./CA.sh –newreq Aquí os irá pidiendo algunos datos relativos al equipo. La mayoría de ellos no tienen demasiada importancia pero el Common Name poner un nombre conciso, pues es el nombre que mostrará en cualquier informe de la VPN.
./CA.sh –sign Firmamos el certificado
mv newcert.pem Server-cert.pem Renombramos los certificados creados
mv newkey.pem Server-priv.pem Renombramos los certificados creados

Ahora cómo está. Cada vez que arranquemos el servicio vpn nos pedirá la clave del certificado. Lo cual es engorroso, así que con el siguiente comando haremos que no nos pidan nada:
openssl rsa –in Server-priv.pem –out Server-private.pem






Es recomendable crear una carpeta donde almacenar todo lo referente a claves, certificados, etc… relacionados con vpn. Por ello yo por ejemplo he creado la carpeta “keys” en el directorio de openvpn con el comando mkdir /etc/openvpn/keys y después copiado los ficheros creados ahora ha dicho directorio:
cp Server-cert.pem Server-private.pem /etc/openvpn/keys
cp demoCA/cacert.pem /etc/openvpn/keys

Ya tenemos las claves del servidor creadas y almacenadas adecuadamente para su posible futura gestión. Aún así todavía faltan por incluir dos cosas:

Uno es un tipo de certificado que sólo va en el servidor llamado Diffie Hellman. Para generarlo solo habría que ir a la carpeta keys y escribir: openssl dhparam-out dh1024.pem 1024, generando un archivo llamado dh1024.dh; Lo otro se trata de generar la clave secreta que sólo los miembros de la vpn tendrán mediante el comando:
openvpn –genkey –secret ta.key

Ahora sólo faltarían crear los certificados de los clientes, cuyo proceso no cambia, con lo que yo he hecho el siguiente script para automatizar el proceso:

  1. #!/bin/bash
  2. #Introducir el codigo nombre del cliente
  3. echo 'Introduzca el nombre del cliente'
  4. read cliente
  5. #Se mueve al directorio donde se ejecutan los scripts openssl
  6. cd /usr/lib/ssl/misc
  7. #Se crea el nuevo cliente con su nombre clave, etc...
  8. #Common name debe ser IGUAL al nombre del cliente que hemos introducido
  9. ./CA.sh -newreq
  10. ./CA.sh -sign
  11. #Se renombran los certificados con el nombre del cliente
  12. mv newcert.pem ${cliente}-cert.pem
  13. mv newkey.pem ${cliente}-priv.pem
  14. openssl rsa -in ${cliente}-priv.pem -out ${cliente}-private.pem
  15. #Se copian los certificados a la carpeta adecuada
  16. cp ${cliente}-cert.pem /etc/openvpn/keys/
  17. cp ${cliente}-private.pem /etc/openvpn/keys/
  18. #Mensaje Final
  19. echo 'Cliente introducido correctamente'

Creadas todas las licencias lo primero que hay que hacer siempre también(no importa que sea servidor o cliente), es coger el fichero de configuración de ejemplo y copiarlo en la carpeta openvpn con el comando:

cat /usr/share/doc/openvpn/examples/sample-config-files/server.conf.gz > /etc/openvpn/openvpn.conf

Ya con la plantilla, la configuración se volvería mucho más fácil. Esta configuración en concreto la haré a partir de mi esquema, pero explicaré los puntos importantes para que podáis configurarlo con la misma facilidad, No escribiré de cabo a rabo todo lo que aparece en el fichero aunque si lo importante:

  1. local 172.24.100.50 #ip en la que escuchará el servidor
  2. port 443 #Puerto de escucha. Por defecto pone 1194 pero este es más eficiente
  3. proto tcp #Protocolo. Por defecto udp, recomendado tcp.
  4. dev tun #Tipo de dispositivo. Ni tocar
  5. ca /etc/openvpn/keys/cacert.pem #Certificado de la CA
  6. cert /etc/openvpn/keys/Server-cert.pem #Certificado del servidor
  7. key /etc/openvpn/keys/Server-key.pem #Clave privada del servidor
  8. dh /etc/openvpn/keys/dh1024.dh #parametros Diffie-Hellman
  9. server 10.0.1.0 255.255.255.0 #Subred de la VPN, poner rango diferente a la red fisica
  10. tls-auth ta.key 0 #Clave de autentificacion
  11. ifconfig-pool-persist /etc/openvpn/keys/ipp.txt #Registro del pool de direcciones
  12. cipher AES-256-CBC #Cifrado AES 256(por defecto Blowfish)
  13. auth SHA1 #Ni tocar
  14. verb 3 #Nivel de log

Esta es la configuración importante y necesaria del servidor VPN. Teniendo todo bien, escribiendo /etc/init.d/openvpn restart debería reiniciarse el servicio a la perfección. La prueba de fuego es escribir ifconfig: Si aparece una nueva interfaz de red llamada tun0 con una ip perteneciente al rango de ip asignado por openVPN, es que tenemos el servidor configurado correctamente.

El servidor está configurado a la perfección. Sólo nos falta que la gente que esté fuera de la red pueda acceder a él, pues sino será imposible crear VPN alguna. Para ello debemos configurar el router y en el apartado NAT, tenemos que hacer que todo lo que vaya al router por tcp, por el puerto 443, se redirija al servidor VPN por el mismo puerto. Aquí es imposible explicar explícitamente cómo hacerlo ya que depende del modelo y fabricante de cada uno, pero las interfaces de configuración son muy intuitivas con lo que sabiendo el concepto de lo que hay que hacer, sólo tenéis que adaptarlo a vuestro dispositivo.

Cómo ya se tiene el entorno servidor preparado, sólo hace falta que los clientes se conecten a dicho server. Para ello sólo hay que instalar openvpn y copiar la plantilla ejemplo cómo se ha hecho en el servidor, pero en la configuración hay unas pequeñas pero significativas variaciones. Al igual que en el apartado servidor, escribiré aquello importante que se debe escribir en el servidor. A cada cliente se le tiene que proporcionar cuatro ficheros que por ejemplo los puede guardar /etc/openvpn/keys: cacert.pem, el certificado del usuario, la clave privada del usuario y el ta.key (autentificación de cliente y servidor).

  1. client #Escribiendo esto especificamos que es un cliente
  2. dev tun #Tipo de dispositivo de rutado. Dejarlo cómo está.
  3. proto tcp #Protocolo tcp. Tiene que ser el mismo que el del servidor
  4. remote 192.168.1.1 443 #IMPORTANTE Hay que poner la dirección publica del ROUTER conectado al servidor. Luego con NAT el router te redirige automáticamente al servidor.
  5. ca /etc/openvpn/keys/cacert.pem #certificado de la CA
  6. cert /etc/openvpn/keys/cliente-cert.pem #Certificado del usuario inventado
  7. key /etc/openvpn/keys/cliente-key.pem #Clave privada del usuario inventado
  8. tls-auth /etc/openvpn/keys/ta.key 1 #Autenticacion
  9. cipher AES-256-CBC #Mismo que el servidor
  10. auth SHA1 #Mismo que el servidor

Para acabar hacemos openvpn /etc/openvpn/client.conf. En caso de lograr conectarse al servidor empezará a lanzar y recibir paquetes en la consola. Sólo hay que pulsar ctrl. + C para parar todos los mensajes que aparecen por pantalla y listo. Ahora escribiendo ifconfig, veréis una nueva interfaz en vuestro cliente llamada tun0 con una de las ips del rango asignado en el servidor VPN, teniendo así nuestro primer cliente conectado a ella. Si tenemos algún problema lo primero es revisar que la red está configurada correctamente, en caso de ir todo bien revisar el NAT del router, y sino revisar la configuración de iptables del servidor.

Y así, hemos logrado una VPN gratuita, potente y segura. Cómo podéis observar, el proceso de creación de una VPN no implica demasiada complejidad. Al principio puede resultar lioso pero es cuestión de dedicarle algo de tiempo y ganas. Cierto que puede resultar a ser laboriosa toda la elaboración de la red, pero es algo que merece la pena.  

Saludos.