Categorías
Hacking

Formaciones para el segundo semestre del 2019 en Securízame

Como algunos de vosotros ya sabéis, llevo un tiempo colaborando con Securízame en los cursos presenciales de Hacking y RedTeam, así como en la certificación RTCP. Llevamos un tiempo elaborando y actualizando los contenidos de estas formaciones y estamos muy contentos de ver los progresos que han tenido nuestros estudiantes, a título personal me resulta muy satisfactorio el hecho de haber tenido alumnos sin ningún conocimiento previo en seguridad informática y ver su evolución a lo largo de las formaciones. Evidentemente, como siempre he dicho, es importante que los alumnos tengan una buena predisposición para el estudio y ganas de aprender, afortunadamente en prácticamente todos los casos me he encontrado con personas que realmente están interesadas en su aprendizaje, en afianzar sus habilidades para mejorar profesionalmente. Por otro lado, también estamos muy contentos con la certificación RTCP, la cual está teniendo un impacto y aceptación tremendo entre profesionales y empresas del sector al tratarse de la primera certificación española 100% práctica en un entorno real. RTCP marca diferencias importantes con respecto a otras certificaciones tan conocidas y valoradas como la OSCP, una de ellas es que el examen es completamente práctico, presencial y enfocado al mundo real. Qué quiere decir esto? Que no es como un CTF cualquiera, que no te vas a encontrar preguntas de selección múltiple, ni tampoco te vamos a pedir que crees un exploit para una vulnerabilidad de Buffer Overflow simple en un sistema windows XP, como ocurre en la OSCP. Consideramos que esto puede estar muy bien en el mundo académico, pero no en el mundo empresarial en donde existen firewalls, sistemas de detección de intrusos, aplicaciones actualizadas, AVs, etc. La certificación la enfocamos a ese tipo de situaciones, a las que un pentester profesional se tiene que enfrentar en su día a día, esto significa que no es una certificación fácil de conseguir pero del mismo modo, se traduce a que el poseedor de dicha certificación REALMENTE tiene conocimientos sobre el tema, que es precisamente lo que buscan las empresas y por los perfiles que más se paga.

Como algunos ya sabéis, el pack de formaciones completo está compuesto por un curso básico, avanzado, entrenamiento y finalmente la certificación, sin embargo un alumno puede optar por adquirir uno o ambos cursos, el entrenamiento o presentarse directamente al examen de certificación, en este sentido no hay ninguna restricción.

Para este segundo semestre del 2019 hemos incluido algunos cambios y mejoras, en primer lugar hemos actualizado algunos contenidos del curso avanzado y además, vamos a incluir algunas máquinas del entrenamiento (las más sencillas). Luego, en el entrenamiento que se hará un mes después del curso avanzado, el último día hemos decidido plantearos como reto resolver el examen RTCP anterior (cada nueva convocatoria del RTCP incluye un examen diferente al de la convocatoria anterior), es decir, que desde el entrenamiento ya vais a saber cómo es la filosofía del examen y podréis ir más preparados. La idea es que antes de finalizar el entrenamiento, intentéis resolver el examen de la versión anterior del RTCP y tras un tiempo prudencial, explicaros la solución.

Finalmente recordaros que la primera formación comienza en pocas semanas, concretamente el día 20 de septiembre empezamos con el curso básico de Hacking y aún nos quedan plazas, pocas pero aún hay, así que si estás interesado no dudes en apuntarte.

Un saludo y Happy Hack.

Adastra.

Categorías
Hacking Networking Services - Software Web Applications

Seguridad en ElasticSearch: Indices y búsquedas – Parte II

En la primera parte de esta serie se han explicado las características funcionales incluidas en ES y los diferentes mecanismos de instalación. Ahora es el momento de comprender cómo funciona ES a la hora de crear índices, tipos y documentos, así como los endpoints disponibles en la API Rest para realizar búsquedas. La API Rest de ES es extensa y compleja, por lo tanto en estos posts solo se intentará cubrir las cuestiones relacionadas con la forma de realizar búsquedas, configuración de nodos/clusters, así como algunos complementos y medidas que pueden ayudar a mejorar la seguridad de una instancia de ES.

En primer lugar, hay que tener en cuenta que ES es bastante parecido a otros gestores de bases de datos no relacionales como MongoDB, especialmente en el sentido de que no hay una estructura fija. Esto significa que a diferencia de una base de datos relacional con tablas, las cuales están compuestas por un conjunto de columnas con restricciones en tipos de datos, relaciones con otras tablas (claves foráneas), longitudes, campos obligatorios, etc. En ES este tipo de estructuras y jerarquías a la hora de almacenar información son un poco diferentes. Para que esta idea quede clara, se expone el siguiente ejemplo:
En una base de datos relacional, se podría crear una tabla de usuarios, la cual estará compuesta por campos tales como: “nombre”, ”edad”, “genero”, “rol” y “fechaNacimiento”. A la hora de realizar una inserción de un registro en dicha tabla, se debe incluir como mínimo, un valor para todos aquellos campos que sean obligatorios y no se podría crear un registro que tenga un campo que no se encuentre definido en la tabla, es decir, no se podría crear un registro que incluya un campo llamado “direccionUsuario” dado que este campo no está en la definición de la tabla. Esto, en el mundo de ES no es así, ya que cada registro que es conocido como un document almacenado en un index y type concretos, no necesariamente tiene una estructura de campos fija, de hecho, se trata simplemente de estructuras JSON que pueden tener “cualquier cosa”, incluso elementos con múltiples valores como arrays, comportamiento que podría servir para crear relaciones de composición entre diferentes bloques de información, tal como se pretende hacer con las claves foráneas en una base de datos relacional. Los documentos en ES, desde el punto de vista técnico pueden estar compuestos por estructuras de datos no homogéneas, aunque evidentemente a la hora de diseñar un sistema es altamente recomendable definir una estructura base que será utilizada para la creación de registros en un nodo o cluster de ES. Dicho esto, es el momento de ver cómo crear índices, tipos y documentos.

¿Cómo crear registros en una instancia o cluster de ES?

Como se ha explicado en el post anterior a éste, para interactuar con una instancia o cluster de ES es necesario utilizar la API Rest que se encuentra disponible en cualquier nodo en ejecución. Se puede utilizar cualquier cliente HTTP para realizar peticiones contra dicha API Rest, desde CURL, wget, Postman hasta un objeto HttpConnection en Java o la librería “requests” de Python. El cliente empleado no es tan importante como conocer los endpoints disponibles y cómo se deben invocar de forma correcta. Probablemente la creación de índices es la labor más importante en ES y también, de las más sencillas tal como se puede apreciar en la siguiente imagen:

Utilizando Postman se ha creado un índice llamado “articulos”, con un tipo llamado “noticia” y un documento con identificador “2019001”. Si se quisiera comparar esta estructura con algo más familiar, como una base de datos relacional, “articulos” sería un esquema en la base de datos, “noticia” una tabla y “2019001” la clave primaria del registro insertado y luego, la estructura JSON que viaja en el cuerpo de la petición contiene los valores del registro propiamente dicho, cada uno en el campo que le corresponde. Sencillo, no?

Bien, esto es la operación de inserción pero también se puede gestionar el índice, tipos y documentos con operaciones CRUD (Create, Read, Update, Delete) tal como se puede apreciar a continuación.

Operación de lectura: Petición HTTP GET: http://ES_IP:ES_PORT/index/type/id

Operación de actualización: Petición HTTP POST: http://ES_IP:ES_PORT/index/type/id

Operación de borrado: Petición HTTP DELETE: http://ES_IP:ES_PORT/index/type/id

Gestionar índices en ES no es una labor compleja pero si vital para el correcto funcionamiento del sistema, ya que evidentemente es “el core” de la información y sobre los cuales trabajan otros endpoints de la API Rest disponibles en ES. Ahora que se ha visto cómo crear, obtener, actualizar y eliminar índices en ES, es el momento de hablar de búsquedas sobre estás estructuras de datos.

¿Cómo realizar búsquedas en ES?

Nuevamente es necesario utilizar la API Rest para realizar búsquedas contra ES. Dado que ES al igual que Lucene, se han creado precisamente para realizar búsquedas rápidas y potentes, no es de extrañar que ésta sea también una de sus características más complejas y difíciles de controlar. En este post solamente se explicará el proceso de búsquedas simples con el endpoint “_search”. En el próximo se hablará sobre la ejecución de búsquedas más complejas con múltiples filtros, paginación, acceso a mapeos, etc.

En primer lugar, el endpoint “_search” se pude utilizar directamente contra todos los índices disponibles en ES o contra uno concreto, nuevamente se puede utilizar Postman o cualquier cliente HTTP para realizar peticiones como las siguientes:

http://ES_HOST:ES_PORT/_search

Búsqueda sobre todos los índices disponibles en ES.

http://ES_HOST:ES_PORT/articulos/_search

Búsqueda sobre todos los documentos disponibles en el índice “articulos”.

http://ES_HOST:ES_PORT/articulos,negocios/_search

Búsqueda sobre todos los documentos disponibles en los índices “articulos” y “negocios”.

http://ES_HOST:ES_PORT/a*,n*/_search

Búsqueda sobre todos los documentos disponibles en los índices que empiezan por “a” y “n”.

http://ES_HOST:ES_PORT/articulos/noticia/_search

Búsqueda sobre todos los documentos disponibles en el índice “articulo” y tipo “noticia”.

http://ES_HOST:ES_PORT/_all/noticia,test/_search

Búsqueda sobre todos los documentos disponibles en todos los índices que tengan los tipos “noticia” y “test”.

http://ES_HOST:ES_PORT/articulos/noticia/_search?q=constitución

Búsqueda sobre todos los documentos disponibles en el índice “articulo” y tipo “noticia” aquellos cuyos en los que al menos un campo tenga la palabra “constitución”, o que se asemeje (esto se verá en el siguiente post).

Se trata de algunas de las peticiones más simples que se pueden ejecutar con ES y el endpoint “_search”, teniendo en cuenta que ahora mismo solamente se aplican filtros sobre índices y tipos, aún no se ha visto cómo filtrar por campos o paginar y además, las búsquedas anteriores se pueden hacer simplemente utilizando método HTTP GET. Como se verá en el siguiente post, esto se puede complicar bastante más dada la flexibilidad del motor de búsqueda y su potencia a la hora realizar consultas rápidas sobre volúmenes grandes de información.

Un saludo y Happy Hack.

Adastra.

Categorías
Hacking Networking Programacion Services - Software Web Applications

Seguridad en ElasticSearch: Introducción – Parte I

ElasticSearch se ha convertido poco a poco en una solución muy utilizada para el procesamiento de grandes volúmenes de datos. Está pensado principalmente para que las búsquedas sean rápidas y altamente personalizables, un modelo perfecto para la implementación de soluciones basadas en Big Data. ElasticSearch (ES) es un producto que cuenta con una API Rest muy completa para gestionar los índices y documentos, además cuenta con un sistema de complementos que permite extender sus funcionalidades. A pesar de ser un producto que lleva en el mercado varios años y que se ha posicionado muy bien, la seguridad en las instancias de ES a día de hoy es un tema delicado y en muchas ocasiones no es tan sencillo de configurar. Las instancias de ES por defecto no tienen ningún mecanismo de protección a “miradas indiscretas” y la cosa empeora aún más cuando múltiples instancias de ES funcionan en modo “cluster”. No obstante, antes de empezar a explicar estás cuestiones es importante entender el funcionamiento de ES, un poco de historia y sus características principales. Ese será el objetivo de éste post.

ElasticSearch un motor de búsqueda orientado a documentos, basado en Apache Lucene. Mantenido por su desarrollador principal hasta la creación de Elasticsearch.com (http://elasticsearch.com/) en 2012. Actualmente se encuentra bajo desarrollo y mejora continua por dicha empresa, bajo licencia OpenSource Apache 2.

Sus características fundamentales son las siguientes:

  • Orientado a documentos: JSON’s, Basado en Apache Lucene.
  • No se utilizan esquemas como en una base de datos relacional, de hecho, ES puede ser considerado como un motor de base de datos no relacional.
  • Distribuido: Escala dinámicamente y permite la integración de múltiples instancias. Los datos se encuentran replicados en cada nodo por medio de shards primarios y copias, evitando de esta forma la perdida de información en el caso de que un nodo se corrompa o exista un fallo en disco.
  • Multi-Tenant: Permite operar sobre múltiples índices a la vez
  • Centrado en API’s: Expone todas sus funcionalidades vía APIs REST
  • Búsquedas estructuradas y no estructuradas: Permite el uso de varios tipos de filtros, llegando a un nivel de granularidad en las búsquedas bastante preciso, pero también complejo.
  • Agregaciones / facetas: Permite la definición de características comunes en conjuntos de datos (documentos ES). Similar a las funciones de agregación disponibles en SQL estándar
  • Soportado por múltiples lenguajes de programación: Al tener una API Rest que permite la gestión de todas las características del sistema, es fácil crear clientes en prácticamente cualquier lenguaje de programación.
  • Elastic Search se compone de dos capas que se encuentran completamente desacopladas y tienen su propia gestión independiente:
    • Sistema distribuido: Implementa las funciones de gestión necesarias para los nodos de un cluster y el mantenimiento de sus datos. Los objetivos de esta capa se centran en el desempeño, la escalabilidad, alta disponibilidad y la tolerancia a fallos gracias al sistema de shards.
    • Motor de búsqueda: Proporciona las funcionalidades de indexación y búsqueda de documentos.

Una vez entendidas sus características principales, merece la pena mencionar la terminología básica para que luego sea más fácil de entender lo que se explicará en los próximos posts.

Cluster: Se trata de un conjunto de instancias de ES que comparten mismo nombre de cluster (propiedad cluster.name). No obstante, un cluster puede estar compuesto por un único nodo. Cuando se inicia una instancia de ES, si no se ha indicado las direcciones IP o hostnames correspondientes al conjunto de instancias “maestro”. También hay que tener en cuenta que cuando se inicia una instancia de ES por primera vez, si no se indica en la configuración la ubicación de los nodos master, es la propia instancia la que actuará como master en los próximos reinicios de la instancia, en tales casos es necesario volver a instalar y configurar la instancia desde cero tal como se verá en un próximo post.

NOTA: Al parecer en ES no creen en el lenguaje inclusivo ni son “100% feminist compliant” ya que usan términos como maestro y esclavo, espero que alguna/algune/alguni no se sienta ofendida/ofendide/ofendidi.

Nodo: Se refiere simplemente a una instancia de ES en ejecución.

Índices: Se trata de una colección de varios documentos (estructuras JSON), que no necesariamente tienen una estructura común. Comparable a los esquemas de una base de datos relacional.

Tipos: Colección de varios documentos de similar estructura. Comparable a tablas de bases de datos

Shard: Espacio de almacenamiento físico de cada uno de los documentos de un índice. También se le suele llamar “Shard Primario” para distinguir entre el “shard” principal y las replicas que se generan en otros nodos del cluster.

Replica: Copia de un shard que permite la replicación de la información. Gracias a este mecanismo ES cumple con los requisitos de alta disponibilidad y tolerancia a fallos. Por defecto, las replicas de un shard no se almacenan en el mismo nodo si hay un entorno de cluster.

Bien, teniendo claros estos términos y considerando que el objetivo de estos posts es que se puedan poner en práctica, lo primero es saber cómo instalar una instancia de ES, que tal como se podrá ver a continuación es bastante sencillo.

Instalación de ES

La instalación de una instancia de ES es un proceso muy simple y no requiere demasiado esfuerzo. Básicamente hay 3 alternativas: 1. instalarlo como servicio del sistema con los típicos gestores de paquetes en sistemas basados en Debian (apt-get) o RedHat (yum). 2. Utilizar una imagen de docker preparada o con Elastic Cloud (https://www.elastic.co/es/cloud/elasticsearch-service/signup). 3. Descargar el fichero tar.gz del sitio oficial, descomprimir y ejecutar el binario correspondiente (https://www.elastic.co/es/downloads/elasticsearch).

Cualquiera de las 3 alternativas es valida, no obstante, como ocurre con muchos otros productos de software que se pueden instalar desde código fuente (tercera opción), en mi opinión es mucho más cómodo, fácil de gestionar (no se instala un servicio systemd directamente en el SO), más fácil de configurar ya que todos los ficheros y binarios están en la misma ruta donde se ha descomprimido y lo mejor, se puede abrir el fichero de configuración ubicado en el directorio “config” y realizar los cambios que sean oportunos. En mi opinión, es mejor seguir la tercera alternativa para entender como funciona el sistema y luego plantarse incluirlo como un servicio en un entorno de producción.

Una vez descargado y descomprimido el fichero “tar.gz” basta con dirigirse al directorio “bin” y desde una terminal ejecutar el comando “elasticsearch”. Con esto, ya tenemos una instancia de ES con los valores de configuración por defecto y todo preparado para empezar a almacenar información.

Cuando se inicia una instancia de ES se podrán ver muchas trazas indicando que el nodo se encuentra levantado y como se verá un otro post, cada nodo puede estar en uno de tres posibles estados “RED”, “YELLOW”, “GREEN”. Los estados simplemente indican cómo se encuentran los shards para los índices que se han creado en la instancia. Por otro lado, también se puede ver que el servicio de ES por defecto se vincula únicamente a la interfaz de red local en el puerto 9200. Para comprobar que se encuentra correctamente instalado, basta simplemente con abrir un navegador web y lanzar una petición HTTP GET contra dicho puerto en local.

Partiendo de una instancia en ejecución, lo siguiente es comenzar a crear índices y comprobar el funcionamiento de ES. Partiendo de este conocimiento sobre el sistema, es posible comenzar a hablar de seguridad y tanto buenas como malas prácticas de configuración. Serán cosas que se verán en próximos posts.

Un saludo y Happy Hack.

Adastra.

Categorías
Hacking Hacking Python Networking Programacion Services - Software

Monitorizar conexiones y desconexiones contra un servidor OpenVPN con Python.

Hola a todos. He vuelto. 🙂

Las próximas semanas tendré algo de tiempo libre y he decidido dedicarlo a este espacio, escribiré algunos artículos sobre seguridad que tengo pendientes desde hace mucho tiempo y que ahora, me dispongo a compartir con todos vosotros. Vamos a por uno sencillo primero!

Una de las características más interesantes que tiene OpenVPN es precisamente la posibilidad de ejecutar scripts ante determinados eventos, por ejemplo, es posible indicar en el fichero de configuración que se ejecute un programa determinado cuando un usuario se conecta o desconecta. Dicho programa puede ser un script escrito en Python, por ejemplo, que se encargará de recopilar la información de la conexión que ha establecido el cliente. Esto puede tener varios usos, entre los que se incluyen la monitorización de las conexiones de los usuarios, forzar a que los clientes se conecten únicamente desde ubicaciones concretas, limitar el número de conexiones con el mismo certificado o OVPN, etc. En resumen, permite un buen nivel de control sobre los usuarios y las conexiones realizadas contra el servidor. Ahora, esto cómo se hace?

Configuración de OpenVPN con “script-security”

La directiva de configuración “script-security” es precisamente la que permite la ejecución de scripts y otros programas externos desde el proceso en ejecución de OpenVPN. Sin embargo, está opción no está exenta de riesgos y problemas de seguridad potenciales, tal como se puede leer en la documentación oficial de OpenVPN:

–script-security level [method]

This directive offers policy-level control over OpenVPN’s usage of external programs and scripts. Lower level values are more restrictive, higher values are more permissive. Settings for level:0 — Strictly no calling of external programs.
1 — (Default) Only call built-in executables such as ifconfig, ip, route, or netsh.
2 — Allow calling of built-in executables and user-defined scripts.
3 —Allow passwords to be passed to scripts via environmental variables (potentially unsafe).The method parameter indicates how OpenVPN should call external commands and scripts. Settings for method:

execve — (default) Use execve() function on Unix family OSes and CreateProcess() on Windows.
system —Use system() function (deprecated and less safe since the external program command line is subject to shell expansion).

The –script-security option was introduced in OpenVPN 2.1_rc9. For configuration file compatibility with previous OpenVPN versions, use: –script-security 3 system”

Evidentemente, si se utiliza ésta opción en el fichero de configuración o como argumento a la hora de levantar el servicio hay que tener en cuenta, como mínimo lo siguiente:

1. Si se establece el método “2”, sería recomendable eliminar los permisos de lectura y escritura en los scripts que se ejecutarán por medio de OpenVPN, ya que si un atacante consigue acceso local y dichos scripts permiten su edición por parte de usuarios con permisos bajos, existe la posibilidad de que elevar privilegios en el sistema.

2. Evitar usar el método “3” ya que se pueden producir fugas de información sensible a la hora de establecer credenciales en variables de entorno.

Es una opción de configuración con la que hay que tener cuidado, sin embargo cuando se siguen los criterios anteriores es posible utilizarla sin riesgo. Esta opción únicamente le indica a OpenVPN que desde el proceso se podrán lanzar scripts o comandos externos, sin embargo con esto no es suficiente para indicar cuáles serán dichos scripts y cómo se deben ejecutar. Para ello existen otras opciones de configuración en las que se especifican precisamente estos detalles, tales como “up”, “client-connect” o “client-disconnect”. Dichas opciones se pueden incluir en el fichero de configuración utilizado para levantar el proceso de OpenVPN, por ejemplo:

[sourcecode language=»bash»]
script-security 2
client-connect "/usr/bin/python /home/adastra/connection.py"
client-disconnect "/usr/bin/python /home/adastra/disconnection.py"
[/sourcecode]

Tal como el nombre de la opción indica, estos scripts se van a ejecutar en el momento en el que un cliente se conecte o desconecte, lo que nos permite hacer cosas simples pero interesantes, como por ejemplo registrar en una base de datos los detalles relacionados con las conexiones de los usuarios (fecha, ubicación, duración de la conexión, etc.). Se trata de información que se almacena en el momento en el que el evento ocurre en forma de variables de entorno, por lo tanto, lo que se debe de hacer en estos scripts es simplemente leer el valor de dichas variables de entorno antes de que dejen de estar disponibles. El siguiente script en Python nos permite hacer precisamente esto, con muy pocas líneas y prácticamente ningún esfuerzo.

connection.py:

[sourcecode language=»python»]
import posix,time;
with open(‘/tmp/conn.out’,’w’) as fd:
fd.write(posix.environ[‘trusted_ip’])
fd.write(posix.environ[‘common_name’])
[/sourcecode]

Con esto simplemente se escriben los valores de las variales “trusted_ip” y “common_name” en un fichero de texto en el directorio “/tmp”. Evidentemente existen otras variables de entorno que se pueden consultar, como por ejemplo la IP dentro de la VPN que se le ha asignado al cliente (ifconfig_pool_remote_ip).

No obstante, lo más normal es que esta información se almacene en una base de datos, para demostrar esto, el siguiente script se encargará del registro de las conexiones en una base de datos PostgreSQL, por lo tanto será necesario utilizar una librería como “psycopg2”.

[sourcecode language=»python»]
import psycopg2
import posix
common_name = posix.environ[‘common_name’]
trusted_ip = posix.environ[‘trusted_ip’]

class Database():
def __init__(self, dbName="database_openvpn", dbUser="postgres", dbServer="127.0.0.1", dbPort=5432, dbPass="postgres"):
self.connection = psycopg2.connect("dbname=’%s’ user=’%s’ host=’%s’ port=’%s’ password=’%s’" %(dbName, dbUser, dbServer, dbPort, dbPass))
self.cursor = self.connection.cursor()

def execute(self, createInstruction, params=None):
self.cursor.execute(createInstruction, params)
self.connection.commit()
id = self.cursor.fetchone()[0]
return id

def create(self, createInstruction, params=None):
self.cursor.execute(createInstruction, params)
self.connection.commit()

def select(self, selectInstruction, params=None):
self.cursor.execute(selectInstruction,params)
return self.cursor.fetchall()

def close(self):
self.cursor.close()
self.connection.close()

if __name__ == "__main__":
db = None
try:
db = Database()
db.create("CREATE TABLE IF NOT EXISTS user(id serial primary key, common_name varchar NOT NULL);")
db.create("CREATE TABLE IF NOT EXISTS addresses(id SERIAL PRIMARY KEY, address varchar(255) NOT NULL,user_id integer REFERENCES user(id));")
db.create("CREATE TABLE IF NOT EXISTS connections(id SERIAL PRIMARY KEY, date_connection TIMESTAMP NOT NULL, date_disconnection TIMESTAMP, address_id integer REFERENCES addresses(id));")

from datetime import datetime
fechaActual = datetime.now()
timeStampActual = psycopg2.Timestamp(fechaActual.year, fechaActual.month, fechaActual.day, fechaActual.hour, fechaActual.minute, fechaActual.second)
with open(‘/tmp/trazas-connect’,’w’) as fd:
fd.write("Conexion de cliente %s desde %s \n" %(common_name, trusted_ip))
users = db.select("select id from user where common_name = %s", (common_name,))
userid = 0
if len(users) < 0:
fd.write("\nUsuario registrado previamente en la base de datos")
userid = users[0][0]
fd.write("\nIdentificador de usuario: %s " %(str(userid)))

else:
fd.write("\nUsuario NO registrado previamente en la base de datos")
userid = db.execute("insert into user(common_name) values(%s) RETURNING id", (common_name,))
fd.write("\nUsuario insertado en BD con identificador: %s" %(str(userid)))
addressid = db.execute("insert into addresses(address, user_id) values(%s, %s) RETURNING id", (trusted_ip, userid,))
fd.write("\nDirección insertada en BD con identificador: %s" %(str(addressid)))
connid = db.execute("insert into connections(date_connection, address_id) values(%s, %s) RETURNING id", (timeStampActual, addressid,))
fd.write("\nConexion insertada en BD con identificador: %s" %(str(connid)))
fd.write("\nProceso de registro finalizado correctamente.")
fd.write("\n—————————————–\n\n")

finally:
if db is not None:
db.close()

[/sourcecode]

Este sería el script de registro, en donde se almacenan las conexiones de los usuarios y un par de detalles básicos. En este programa se verifica si el usuario se encuentra almacenado en base de datos y si está, no se procede a almacenar nada en la base de datos. El script en realidad es bastante simple, sin embargo tiene bastantes líneas de código, las cuales como se puede apreciar, en su mayoría sirven para depurar. El motivo de esto es que a día de hoy (o mejor, hasta donde llegan mis conocimientos en OpenVPN) no hay manera de depurar los programas externos que se lanzan desde el proceso de OpenVPN y si por lo que sea, dichos programas, como por ejemplo este script, lanza una excepción no controlada, el servidor rechazará la conexión con el cliente, este es otro de los motivos por los que hay que tener mucho cuidado a la hora de utilizar esta característica. Por ejemplo, suponiendo que la base de datos “database_openvpn” no se encuentre creada o que directamente el servicio de PostgreSQL se encuentre detenido, en tales casos el script lanzará una excepción y si no se controla adecuadamente, supondrá que ningún cliente se va a poder conectar a la VPN.
Ahora bien, si la opción “client-connect” permite indicar un script que se lanzará justo en el momento en el que un usuario se conecta, la opción “client-disconnect” hace lo mismo pero al reves, cuando el cliente envia la señal de cierre de conexión. Siguiendo la lógica del script anterior, el script de desconexión se encargará de realizar una operación DELETE/UPDATE sobre cada una de las tablas relacionadas. Este sería el contenido de dicho script:

[sourcecode language=»python»]
import posix
import psycopg2

common_name = posix.environ[‘common_name’]
trusted_ip = posix.environ[‘trusted_ip’]

class Database():
def __init__(self, dbName="database_openvpn", dbUser="postgres", dbServer="127.0.0.1", dbPort=5432, dbPass="postgres"):
self.connection = psycopg2.connect("dbname=’%s’ user=’%s’ host=’%s’ port=’%s’ password=’%s’" %(dbName, dbUser, dbServer, dbPort, dbPass))
self.cursor = self.connection.cursor()

def execute(self, createInstruction, params=None):
self.cursor.execute(createInstruction, params)
self.connection.commit()

def select(self, selectInstruction, params=None):
self.cursor.execute(selectInstruction,params)
return self.cursor.fetchall()

def close(self):
self.cursor.close()
self.connection.close()

if __name__ == "__main__":
db = None
try:
db = Database()
from datetime import datetime
fechaActual = datetime.now()
timeStampActual = psycopg2.Timestamp(fechaActual.year, fechaActual.month, fechaActual.day, fechaActual.hour, fechaActual.minute, fechaActual.second)
with open(‘/tmp/trazas-disconnect’,’w’) as fd:
conn = db.select("select c.id from user u, addresses a, connections c where (u.id = a.user_id and c.address_id = a.id) and u.common_name = %s and a.address = %s and c.date_disconnection IS NULL", (common_name, trusted_ip,) )
connid = 0
fd.write("\nProceso de desconexion iniciado para el usuario %s " %(common_name))
if len(conn) > 0:
connid = conn[0][0]
fd.write("\nIdentificador de conexion a actualizar %s " %(str(connid)))
db.execute("UPDATE connections SET date_disconnection = %s where id = %s", (timeStampActual, connid,))
fd.write("\nProceso de desconexion del usuario %s finalizado correctamente" %(common_name))
fd.write("\n———————————————–\n\n")
except:
fd.write("\nSe ha producido una excepción\n")
finally:
if db is not None:
db.close()

[/sourcecode]

Con esto ya se tendría un sistema para la gestión de conexiones en VPN, algo que serviría para monitorizar la actividad del servidor y las conexiones/desconexiones que realizan los usuarios.
Eres libre de utilizar estos scripts y modificarlos a tu gusto para realizar pruebas o incluso para implementarlos en tu propio servicio de OpenVPN

Un saludo y Happy Hack.

Adastra.