DESCRIPCIÓN.

CKA - Certified Kubernetes Administrator Preparación de entorno de Kubernetes para practicar la Certificación CKA.

Utilizaremos el despliegue de CK-X de github hecho por Sailor.sh https://github.com/sailor-sh/CK-X

REQUISITOS.

Contiene las siguientes especificaciones:

SISTEMA OPERATIVO -> Ubuntu Server (Minimal) HARDWARE -> (Minimun) 2 Core CPU & 4 GB RAM SOFTWARE -> Docker Compose - ContainerD – Kubernetes (k8s)

Procedimiento

Partiremos de una instalación mínima (Sin Interfaz Gráfica) en Ubuntu Server LTS 24.X. Como motor de ejecución de contenedores. Es un entorno más ligero ya que no dispone de interfaz gráfica. Iremos paso a paso realizando la instalación y posteriormente iniciando el Clúster. También veremos los tipos de examen que hay y sus certificaciones.

Preparación de paquetes

Actualizamos repositorios e instalamos paquetes necesarios

sudo apt update && sudo apt upgrade -y sudo apt install docker.io docker-compose docker-compose-v2 -y

Instalación de CK-X

Instalación automatizada del entorno de exámenes de Kubernetes

sudo su curl -fsSL https://raw.githubusercontent.com/nishanb/ck-x/master/scripts/install.sh | bash

Nos dejará el siguiente mensaje:
Useful Commands

CK-X Simulator has been installed in: /home/a/ck-x-simulator, run all below commands from this directory
To stop CK-X docker compose down –volumes –remove-orphans –rmi all
To Restart CK-X: docker compose restart
To clean up all containers and images: docker system prune -a
To remove only CK-X images: docker compose down –rmi all
To access CK-X Simulator: https://play.sailor.sh/
To access CK-X Simulator locally use: http://localhost:30080/
Comprobación del estado

Comprobación de estado de entorno con docker

Sudo docker ps –all
Inicio Desde este panel accederemos a las certificaciones según el nivel de dificultad que deseemos y el tipo de certificación.

Preparación de clúster de Kubernetes para Certificación CKA.
Direcciones IP:
master -> 192.168.0.54
worker1 -> 192.168.0.56
worker2 -> 192.168.0.59

REQUISITOS.

Contiene las siguientes especificaciones:

SISTEMA OPERATIVO -> Ubuntu Server (Minimal)
HARDWARE (Minimun) -> 2 Core CPU & 4 GB RAM
SOFTWARE -> ContainerD – Kubernetes (k8s)

La estructura del cluster será la siguiente

Procedimiento

Partiremos de una instalación mínima (Sin Interfaz Gráfica) en Ubuntu Server LTS 24.X. Como motor de ejecución de contenedores usaremos ContainerD. Es un entorno más ligero ya que no utiliza Docker al completo, solo la parte que virtualizará. Iremos paso a paso realizando la instalación y posteriormente iniciando el Clúster. También uniremos dos nodos trabajadores que se podrán comunicar.

Instalación Containerd

Actualizamos repositorios

sudo apt update && sudo apt upgrade -y

Desinstalamos posibles conflictos

sudo apt remove $(dpkg --get-selections docker.io docker-compose docker-compose-v2 docker-doc podman-docker containerd runc | cut -f1)

Instalamos paquetes

sudo apt update 
sudo apt install ca-certificates curl runc apt-transport-https ca-certificates curl gnupg2 software-properties-common git vim golang golang-go sudo gpg -y

Quitamos la memoria swap y activamos modulos de red

sudo swapoff -a
sudo modprobe overlay
sudo modprobe br\_netfilter

Comprobaremos en el fichero /etc/fstab el estado de la memoria swap:

Configuracion de red para kubernetes

sudo tee /etc/sysctl.d/kubernetes.conf
<<EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

sudo sysctl --system

Instalacion de DOCKER

Add Docker’s official GPG key:

sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

Añadimos Repositorios Necesarios:

sudo tee /etc/apt/sources.list.d/docker.sources 
<<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU\_CODENAME:-$VERSION\_CODENAME}")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

Configuracion de containerd para kubernetes

containerd config default > /etc/containerd/config.toml

Accederemos a la configuración y ajustaremos el systemgroup

vim /etc/containerd/config.toml

Modificamos SystemdCgroup y cambiamos false a true

[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc]
  ...
  [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
    SystemdCgroup = true

systemctl restart containerd

Instalación de Kubeadm

Instalación de paquetes kubeadm por defecto

sudo apt-get update
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.34/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

NOTA!! Cambiar la versión de kubernetes según la instalación necesaria. En esta instalación utilizaremos la 1.34.

Añadimos el repositorio con la versión seleccionada

echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.34/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

Actualizamos repositorios e instalamos

sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl
sudo systemctl enable --now kubelet

Iniciamos el Cluster kubeadm

Creacion de cluster con Kubeadm

kubeadm init --apiserver-advertise-address 192.168.0.54 --pod-network-cidr 10.10.10.0/24

Una vez haya finalizado nos quedará un token que debemos guardar y unos comandos a lanzar desde el usuario del que vamos a usar kubernetes para instalar los certificados.

Nos dejara el siguiente mensaje. Es importante que guardemos los tokens proporcionados y ejecutemos los comandos según sea conveniente para poder comunicarnos con la API.

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

Alternatively, if you are the root user, you can run:

  export KUBECONFIG=/etc/kubernetes/admin.conf

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 192.168.0.54:6443 \
    --token kl5i5b.ziwjtglhh958y2pc --discovery-token-ca-cert-hash sha256:9e632f0e0ff18d271d1ee43e8b135ede-xxxxxxxxxxxxxxxxxxxxxxx

Container Network Interface (CNI)

Kubernetes necesitará una serie de pluggins básicos para preparar la interfaz de red entre los contenedores.

git clone https://github.com/containernetworking/plugins
cd plugins
git checkout v1.1.1
./build_linux.sh
sudo mkdir -p /opt/cni/bin
sudo cp bin/* /opt/cni/bin/

CNI - CALICO

Calico es una solución de red y seguridad Open-Source para Kubernetes es capaz de comunicar la red entre los contenedores basándose en los pluggins por defecto.

kubectl apply -f https://docs.tigera.io/calico/latest/manifests/calico.yaml

kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.31.2/manifests/tigera-operator.yaml

kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.31.2/manifests/custom-resources.yaml

Comprobaremos que esta funcionando con el siguiente comando:

watch kubectl get tigerastatus

Untaint Nodes

Una vez el cluster se haya iniciado los nodos que tengamos “repelerán” la asignación de pods por defecto, esto ayuda a la gestión de recursos y a que en el nodo que actue como Control Plane (CP) no tenga carga de trabajo extra. En nuestro caso utilizaremos tres nodos incluyendo el CP por lo que eliminaremos este ‘Taint’.

kubectl taint nodes --all node-role.kubernetes.io/control-plane- 

Tendremos el cluster de la siguiente manera. Se podrán observar los pods de Calico, almacenamiento (etcd), DNS, Api-server, proxy y scheduler. Estos pods son la estructura base de nuestro cluster y han de estar siempre en estado “Running”.

Procedemos a unir un nodo trabajador mediante el comando que nos ha mostrado el nodo master. Veremos como aparecen nuevos pods relacionados con Calico y con Proxy. Se pondrán en estado “Running” y eso significará que el nodo se ha unido correctamente al cluster.

De la misma manera uniremos el segundo y LISTO!

Conclusion

Estos son los primeros pasos de un cluster Kubeadm en local. Podremos observar como el entorno se realiza con el runtime de ContainerD (El entorno de virtualización de Docker). Partiendo de estas bases podremos crear Despliegues, contenedores con nuestras aplicaciones, bases de datos etc. Todo este entorno se controlará a traves de archivos YAML y comandos con la herramienta kubectl desde la consola. Es importante controlar bien los certificados y permisos (RBAC) para una gestion segura y eficiente del entorno. Una vez tengamos el entorno preparado podremos empezar a aprender a cerca de la gestión de sus recuros. Kubernetes(k8s) es una herramienta muy potente en los entornos de produccion de desarrollo, capaz de automatizar, implementar y escalar servicios gestionados en contenedores.

Como analistas forenses se nos presenta una imagen obtenida del equipo personal de un crimen digital. Nuestra tarea es analizar esta imagen de su equipo y sacar las conclusiones que se convertirán en Evidencias Digitales para su posterior presentación.

REQUISITOS

Sistema Operativo -> Windows 10
Software -> FTK Imager - Autopsy

PROCEDIMIENTO

FTK Imager

Para comenzar con este analisis lo primero es hacer una imagen del equipo, para ello utilizaremos FTK Imager. Lo iniciaremos y haremos click en Create Disk Image desde el menu. Nota: El disco duro ha de estar insertado.

Se presentará una nueva ventana con las multiples opciones de copiado Elegiremos la Fisica.

Seleccionaremos el disco duro que vamos a copiar y haremos click en “Siguiente”.

En la creacion de imagen le daremos a Add para añadir un destino de la imagen.

Seleccionaremos el tipo de copiado, en nuestro caso DD (Data duplicator) ya que va recorriendo a un nivel más bajo los sectores del disco y por ende la copia es de mayor calidad.

Rellenaremos los datos necesarios para detallar el caso en la siguiente ficha.

Y por ultimo añadiremos el destino de la copia e indicaremos su nombre. Podemos personalizar también el tamaño de los fragmentos.

Una vez haya terminado el proceso se presentará la siguiente ventana. Desde la que podremos ver su código Hash asignado y calculado con las funciones MD5 y SHA1. También veremos sus propiedades como numero de sectores y si hay algún bloque corrupto en el disco.
Es muy importante apuntar el Código Hash ya que aquí comienza la Cadena de Custodia de este elemento, siendo identificado en todo momento y comprobando su integridad con esta cadena de caracteres.

-———————————————————————————————————–
Por ultimo podemos obtener un resumen en formato texto de esta tarea:
Nos proporcionará información extra muy útil en nuestra tarea como forenses.

Autopsy

Comenzaremos abriendo la herramienta. Se nos solicitará información y datos para crear un nuevo caso de investigación forense. Haremos click en “New Case”.

Aquí personalizaremos y añadiremos la ruta de almacenamiento del caso que hemos creado y daremos algunos detalles del caso que vamos a analizar:

Tras hacer click en Next completamos la información restante con los máximos detalles posibles y le damos a “Finish”.

Añadiremos como origen de datos la copia virtual del disco desde “Add Datasource”. Rellenaremos los datos según nuestra conveniencia. Por el momento el Host lo mantendremos por defecto.

Como data source type elegiremos “Disk Image or VM file” que sera el correspondiente a la copia que hemos realizado.

Buscaremos la ruta de la copia que hemos realizado y seleccionaremos el primer elemento de la copia.

Nota: Puede variar según el tipo de copia que hayamos realizado (DD Raw SMART E01 etc)
Si lo deseamos para aumentar el nivel de integridad podemos añadir los resultados de las funciones Hash calculadas previamente.
Haremos click en next y veremos una nueva ventana en la que se presentan todos los módulos con los que podemos trabajar desde autopsy. Deseleccionaremos todos y marcaremos “Recent Activity” para reducir el tiempo de análisis.

Iniciaremos el proceso de extracción de datos y esperaremos a los resultados.


Vemos que ha finalizado sin problemas y procederemos al análisis en profundidad.
Se presentará una interfaz en la que se podrá identificar de manera visual todos los datos extraidos de la imagen de disco proporcionada:

Iremos poco a poco desmenuzando la información obtenida.
Primero se proporcionará la estructura global de datos del disco, pudiendo ver particiones, estructuras de carpetas y datos detallados del sistema de archivos:

Podremos ver los detalles en “Data Artifacts” . Sistema Operativo, nombre del equipo, nombre del propietario, etiqueta del disco etc.

Desde “File views” observaremos una clasificacion de archivos por extensiones desde la que podremos sacar imagenes, videos, bases de datos, documentos HTML o de texto plano etc.

De esta sección queda a destacar la gran cantidad de imágenes que existen (las cuales incluyen iconos e imágenes del sistema) y la cantidad de documentos HTML lo cual nos hace pensar que hosteaba algún tipo de servidor.
Si investigamos más a fondo en los documentos HTML veremos nombres git lo que nos hace pensar que tiene relacion con el software “Git” o hostea este tipo de estructuras.

Más adelante tenemos una seccion muy interesante llamada “Deleted Files” la cual llama la atencion investigar, teniendo en cuenta que se le haya podido escapar algún documento eliminado que no ha borrado correctamente. Cambien incluye documentación temporal o de inicio del equipo.

Pasamos a una sección muy interesante, “MB File Size”. Aqui se dividen los archivos por tamaño, pudiendo clasificarse en:

• MB 50 – 200 → Archivos pequeños como configuraciones o documentos personales de texto o trabajos particulares. Muy interesantes para investigar configuraciones personalizadas o documentos con información más personal. También ejecutables o accesos directos.
  
• MB 200 – 1GB → Este rango incluirá desde documentos pesados como librerias contundentes hasta programas instalados en el equipo.
  
• **MB 1GB+ **→ Estos documentos tan pesados son posibles bases de datos del sistema, como hemos visto previamente en el apartado de archivos HTML, aquí aparecerán los archivos de las BBDD de la web. También aparecerán almacenamientos de paginación de programas grandes en los que la memoria RAM se saturaba.
  
  Pasamos a la seccion “Data Artifacts”. Aqí se clasificarán los datos obtenidos en diferentes grupos:
  
  Destacaremos Programas instalados, Documentos Recientes, Programas corriendo, USB Device Attached, Web Accounts, Coockies, Downloads e Historial y por ultimo Web Form Autofill.
• Programas Instalados. Una seccion que nos indicará el tipo de trabajo que realizaba el usuario y las tareas que desempeñaba. Podemos ver SOFTWARE como HomeBank o Money Manager que nos indica el manejo de cuentas bancarias.
  
• Documentos Recientes. Una seccion util, mostrará su actividad reciente. Podemos observar que trabajaba con archivos de Github, corroborando lo visto previamente en HTML Docs.
  
• Programas Corriendo. Aqui veremos los programas que estaban iniciados en el sistema cuando se tomó la imagen, se mostrarán los servicios de los que se disponia como Git o GithubDesktop.
  
  También aparece Chrome.
  
• USB Device Attached. Veremos los dispositivos USB externos con los que trabajaba, es interesante de cara a la información no contenida en el equipo y posiblemente relacionada con el escenario. Veremos sus ID’s e información de los dispositivos para comprara con los que se han encontrado en la escena.
  
• Web Accounts, Cookies e Historial. Aqui podremos ver los diversos datos de navegación del usuario, como las paginas en las que se ha registrado y su nombre de usuario o correo (bart.simpson_springfield@hotmail.com) (Github)
  
  Tambien veremos las cookies, pudiendo dar pistas sobre que webs se ha navegado
  
  Y el historial que indica el proceso de navegación. (Principalmente Github)
  
• Por ultimo tenemos la sección Web Form Autofill. Que mostrará la información guardada en el navegador para auto rellenar los formularios, esta es información muy sensible, ya que implica datos personales del usuario. Puede ser útil de cara a una investigación pero ha de ser manejada con cuidado.
  
  En el apartado de “Analisys Results” tenemos Web Account type, desde donde podremos obtener tambien información muy valiosa, como las preguntas de seguridad del usuario Bart:
  
  Queda a destacar que según vamos haciendo el proceso de investigación podremos marcar con “Tags” los artefactos que nos sugieran infomación interesante. Estos se reflejarán en la ultima seccion Tags. Un ejemplo:
  
  

Report

Generaremos un reporte para poder ver los datos mas claramente desde “Generate Report”.

Usaremos el formato HTML.

Seleccionamos el Data source.

Y todos los resultados especificados, en nuestro caso las marcas

Esperaremos a la generacion

Una vez generado lo abriremos en nuestro navegador para su mejor visualización.

INCIDENCIAS.

Sin Incidencias notificadas.

BIBLIOGRAFÍA.

• https://www.autopsy.com/

Esquema

Partiremos del esquema con el que vamos a trabajar:

Podemos observar que el momento de intercepción de datos se encuentra entre el firewall y el resto de equipos conectados al switch. De esta manera podremos interceptar tod el trafico que fluya hacia los equipos que se encuentran dentro de la red.

Preparacion

Procederemos a cortar el cable de conexion entre el router y el switch, lo pelaremos con una herramienta de crimpado y separaremos los cables que se encuentran en el interior del RJ-45. Siguiendo esta tabla podremos ver el codigo de colores de un cable de conexion RJ-45 estandart.

OJO -> No confundir con cable de conexion CRUZADO, tiene otro tipo de orden de colores y usos.

Pelaremos los cables y los volveremos a conectar, de manera que el cobre de las conexiones NARANJA, NARANJA-BLANCO, VERDE y VERDE-BLANCO queden expuestos al contacto fisico.

Pelaremos otros dos cables RJ-45 de la siguiente manera:

Cable 1

• Extremo 1 -> Clavija estandart RJ-45.
• Extremo 2 -> Conexion NARANJA y NARANJA-BLANCO expuesto.

Cable 2

• Extremo 1 -> Clavija estandart RJ-45.
• Extremo 2 -> Conexion VERDE y VERDE-BLANCO expuesto.

De esta manera uniremos las conexiones de Cable 1 a los polos naranjas del cable de conexion entre el router y el switch y el Cable 2 a los polos verdes del mismo.

Necesitaremos dos adaptadores de RJ-45 a USB para conectarlos al equipo que va a monitorear el trafico, los conectaremos respectivamente e iniciaremos la aplicacion Wireshark previamente instalada.

Veremos que aparecerán los dos adaptadores en el inicio de Wireshark, los seleccionaremos manteniendo pulsada la tecla CRTL e iniciaremos la monitorización.

Monitorización

Una vez hayamos iniciado el rastreo de paquetes podremos ver como aparecen en pantalla todos los paquetes que pasan a traves de la conexion entre el router y el switch hacia la red que hemos preparado. Se ve indicado el origen y destino de cada paquete junto a su fecha de envio, protocolo, longitud e información.

Una vez lo deseemos, podremos finalizar la captura de paquetes para poder analizar más en detalle el trafico interceptado y analizar algun tipo de trafico sospechoso, indeseado o de dudosa procedencia. Este archivo con la captura se podrá guardar en formato .pcapng para su posterior manejo.

Conclusion

Este método de análisis es muy interesante por parte de un atacante para interceptar el tráfico que se mueve en una red a la que se tiene acceso físico, es una metodología silenciosa, no genera ningún tipo de registro y si esta bien preparada es imperceptible a ojos de un usuario común. Es un riesgo que algunas empresas/entornos han llegado a enfrentar en diversas situaciones, por eso la seguridad fisica es tan crucial como la seguridad a nivel de software.

Para empezar debemos entender que protocolos de comunicación vamos a utilizar en este ejercicio.

TCP

El protocolo TCP (Transmission Control Protocol) es un protocolo fundamental en la comunicación de datos a través de redes informáticas garantizando una transmisión confiable y ordenada de la información entre dispositivos. Tiene un funcionamiento que se divide principalmente en tres partes:

• SYN -> El cliente inicia la conexión enviando un paquete SYN al servidor. Este paquete contiene un número de secuencia aleatorio que se utilizará para identificar los paquetes enviados por el cliente.
• SYN ACK -> El servidor, al recibir el SYN, responde con un paquete SYN-ACK. Este paquete incluye el número de secuencia del cliente incrementado en uno y un nuevo número de secuencia para la comunicación del servidor al cliente.
• ACK -> El cliente recibe el SYN-ACK y envía un último paquete ACK al servidor, confirmando la conexión y utilizando el número de secuencia del servidor incrementado en uno.

Como podemos ver, en esta comunicacion se requiere contacto entre los dos agentes, tanto como para iniciar la conexion como para finalizarla.

UDP

El protocolo UDP (User Datagram Protocol) es un protocolo de red que permite el envío de datos sin necesidad de establecer una conexión previa entre emisor y receptor, a diferencia de TCP. Esto significa que UDP envía datagramas (paquetes de datos) de forma independiente y no garantiza la recepción, el orden ni la integridad de los datos. Su principal ventaja es la velocidad y eficiencia, ideal para aplicaciones donde la latencia es crítica, como streaming de video o juegos online.

Funcionamiento:

• UDP divide los datos en paquetes (datagramas) y los envía a la dirección IP y puerto de destino, sin establecer una conexión formal.
• No hay establecimiento de conexión previo ni confirmación de recepción, lo que permite una comunicación rápida.
• UDP no garantiza que los datagramas lleguen a destino, ni que lleguen en el orden correcto o sin errores.

Entornos de uso

Este tipo de dispositivos se situan en entornos críticos como Plantas Industriales/Nucleares, laboratorios de ciberseguridad o zonas de máxima seguridad.
Gracias a esta metodología seremos capaces de monitorizar desde un SOC exterior todo el entorno al otro lado del Diodo, pudiendo registrar y recibir lecturas de temperatura en centrales industriales o evitando que un virus informático logre una conexion externa con un atacante mientras se hacen pruebas.

Equipo y Montaje

Actualmente existen varios proveedores de dispositivos que realizan esta funcion y esta implementada directamente en el hardware que distribuyen.
Nosotros utilizaremos una solucion más económica y casera a traves de convertidores de Fibra Óptica a Cobre. Es importante que estos convertidores dispongan de dos entradas (Rx) y salidas (Tx) ya que en esa division nos permitirá separar el tráfico para hacer el diodo.

Una vez tengamos estos dispositivos procederemos a conectar la fibra y el cobre de la siguiente manera:

Funcionamiento

Veremos que el equipo que envía se conecta directamente al equipo que recibe a traves de Tx y Rx sin embargo hay un convertidor de fibra a cobre entre los dos equipos que no tiene salida de cobre, este será el “vacio”. El equipo receptor intentará dar una respuesta, comprobará que la puede enviar, y la enviará a este “vacio” a través de Tx a Rx pero no será recibida por ningun equipo.
Este engaño se produce tambien para el equipo que envia ya que realizará una comprobacion en Rx para ver si puede recibir informacion en la red preparada, al estar conectado el cable de fibra interpretará que la conexion es correcta pero nunca recibirá nada ya que viene de el convertidor “vacio”.

¡IMPORTANTE!
Los dos equipos no disponen de ningun servidor DHCP ni de ninguna figura intermediaria que sea capaz de redireccionar el trafico en la conexion. Deberemos de preparar una direccion IP para cada uno y añadir en las tablas ARP las direcciones MAC de los dos equipos.
Utilizaremos el siguiente comando en una consola con permisos de administrador:

arp -s {direccion IP} {direccion mac}

Para comprobar que se ha añadido correctamente usaremos arp -a.

Puesta en marcha

Utilizaremos un rastreador de paquetes en el equipo que recibe de manera que cuando establezcamos una conexion TCP podramos ver la recepcion del paquete y un envio fallido de respuesta, por el contrario en una conexion UDP podremos ver la recepcion del paquete y ninguna respuesta.

Existen multiples herramientas para rastrear esta conexion como tcpdump que funciona a nivel de consola o wireshark que posee una interfaz más amigable.

En este caso utilizaremos wireshark y lo prepararemos en la máquina receptora escuchando en la interfaz en la que estén conectados los equipos.

Ahora desde “CMD” enviaremos el comando de ping desde la maquina que envia a la que recibe, podremos ver como aparecen los mensajes en la interfaz, su origen y direccion.

Podremos ver como la maquina receptora intenta devolver el ping, sin embargo en el equipo que inicia la conexion no estamos recibiendo respuesta.

En cuanto a la conexion UDP enviaremos un mensaje al receptor con el la herramienta netcat y el comando nc64.exe -u 192.168.2.12 1234. Desde el lado del receptor estaremos escuchando en wireshark y abriremos una consola de comandos “CMD” y escribiremos el siguiente comando nc64.exe -ulvp 1234.

Una vez establecida esta conexion procederemos a escribir cualquier caracter en la consola del equipo que envia, podremos ver como aparece en la consola del que recibe. Desde wireshark se verá como llega el paquete con su longitud y protocolo UDP.

Consola:

Wireshark:

El flujo de los datos de este procedimiento será de la siguiente manera.

Conclusion

Este tipo de tecnologías se utilizan en entornos muy críticos, es imprescindible conocer el funcionamiento de las conexiones TCP y UDP que se van a utilizar para poder comprender el flujo de los datos.
De esta manera aseguramos un sistema en el que podremos recibir o enviar informacion exclusivamente en un sentido. A diferencia de un firewall que se regula por las reglas establecidas por el administrador de sistemas en cuestion, este metodo asegura una imposibilidad de flujo más que logica …. ES FISICA!! El acceso a el sistema por la parte bloqueada del diodo esta restringida sin acceso fisico a la instalacion, lo cual da un grado de seguridad dificilmente evadible.

En este proyecto realizaremos un manejo de parametros de los rayos y truenos de la página web Blitzortung a traves de un web socket.
Lo primero es acceder a la web, para ver el websocket que utilizaremos. Presionando la tecla abriremos el panel de desarrollador y nos dirigiremos al apartado “Network” “Socket”.

Desde aquí podremos identificar en la seccion “Name” el websocket que vamos a utilizar.
WEB SOCKET-> “wss://ws1.blitzortung.org/”.
Veremos que esta constantemente recibiendo informacion, sin embargo podremos ver que está cifrada.

Investigando la forma de trabajo del websocket identificaremos el metodo que utiliza para iniciar la conexion. Como requisito necesitará que le pasemos en formato JSON el contenido {“a”:111}.
Una vez se ha realizado comenzará a enviar todos los eventos.
Bien, con un poco de codigo simple relacionado con Web-Sockets seremos capaces de recibir esta informacion. Ahora el problema es que esta obfuscada.
Buscando un poco por internet y analizando el formato podremos descubrir que se trata de obfuscacion LZW.

Procederemos a generar un codigo de python que maneje toda la informacion y sea capaz de deobfuscar los datos que recibimos para su tratamiento.

Utilizaremos las librerias websocket y json.

La funcion de deobfuscamiento será la siguiente:

def decoder(encoded_str):
    e = {}
    d = list(encoded_str)
    c = d[0]
    f = c
    g = [c]
    h = 256
    o = h

    for i in range(1, len(d)):
        a = ord(d[i])
        if a < h:
            a_str = d[i]
        elif a in e:
            a_str = e[a]
        else:
            a_str = f + c

        g.append(a_str)
        c = a_str[0]
        e[o] = f + c
        o += 1
        f = a_str
    return ''.join(g).encode('latin1')

Nuestro codigo ha de tener una funcion para mostrar la información de una manera visible, así comprobaremos que estamos tratando con los datos correctos.
Para ello mostraremos tanto el codigo obfuscado y el deobfuscado.

def on_message(ws, message):
    print("Mensaje recibido (texto):", message[:100], "...")  # Mostrar un resumen

    # Aplicar LZW decoder al mensaje completo (texto plano recibido)
    decoded_bytes = decoder(message)
    try:
        decoded_text = decoded_bytes.decode('utf-8')
    except UnicodeDecodeError:
        decoded_text = decoded_bytes.decode('latin1')

    print("Texto decodificado:", decoded_text[:200], "...")  # Mostrar un resumen

    try:
        data = json.loads(decoded_text)
        print("Datos JSON parseados correctamente:", data)
    except json.JSONDecodeError:
        print("No se pudo parsear JSON después de decodificar")

Una vez seamos capaces de obtener los datos decodificados podremos empezar a trabajar con ellos! Creando dos contenedores de Docker (Mysql y Grafana) le daremos forma y vida a estos datos obtenidos.

MySQL

• sudo docker run -d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=<CONTRASEÑA> –name=mysql mysql

Grafana

• sudo docker run -d -p 3000:3000 –name=grafana grafana/grafana-enterprise

Partiremos de una instalacion predefinida con usuario admin en MySQL y una configuracion por defecto en Grafana.

Para la configuracion de la base de datos cargaremos este script al contenedor de docker a traves de “Mysql-Client”.

comandos.sql:

DROP DATABASE IF EXISTS thunder;
CREATE DATABASE thunder;
USE thunder;

DROP TABLE IF EXISTS main_data;
CREATE TABLE main_data (
  id BIGINT AUTO_INCREMENT PRIMARY KEY,
  time BIGINT,
  lat DOUBLE,
  lon DOUBLE,
  alt INT,
  pol INT,
  mds INT,
  mcg INT,
  status INT,
  region INT,
  delay FLOAT,
  lonc INT,
  latc INT
);
DROP TABLE IF EXISTS signals;
CREATE TABLE signals (
  id BIGINT AUTO_INCREMENT PRIMARY KEY,
  main_data_id BIGINT,
  sta INT,
  time BIGINT,
  lat DOUBLE,
  lon DOUBLE,
  alt INT,
  status INT,
  FOREIGN KEY (main_data_id) REFERENCES main_data(id)
);

Lo cargaremos con:

mysql -h <IP> -u root -p -vvv < comandos.sql

Donde sera la direccion IP del contenedor de Docker.

Una vez configurada la base de datos accederemos al panel de Grafana desde Data Sources -> Add New Data Source -> Mysql
Completaremos los campos necesarios con las credenciales indicadas.

Nota: En caso de no disponer de un certificado TLS/SSL marcaremos la casilla que deshabilita la conexion segura.

Una vez conectada la base de datos MySql con Grafana procederemos a crear la Dashboard que muestre los datos.

Nos dirigiremos al apartado “Dashboards” y crearemos una nueva desde el boton “New Dashboard” y “Add Visualization”.

Nos solicitará un Data Source e introduciremos el que acabamos de crear con MySql.

Tras desplegarse correctamente deberemos crear una consulta que sea capaz de recoger los datos recibidos y mostrarlos en la grafica.
Ejemplos:

SELECT
  FROM_UNIXTIME(time / 1000000000) AS time, -- si tu tiempo está en nanosegundos, ajusta la conversión
  lat,
  lon,
  alt
FROM main_data
ORDER BY time DESC
LIMIT 1000;

SELECT
  FROM_UNIXTIME(s.time / 1000000000) AS time,
  s.sta,
  s.lat,
  s.lon,
  s.alt,
  s.status
FROM signals s
JOIN main_data m ON s.main_data_id = m.id
ORDER BY s.time DESC
LIMIT 1000;

Lanzando las consultas podremos ver que empiezan a mostrarse los datos en el Panle de Visualización.

Enhorabuena!

Hemos conseguido almacenar una gran cantidad de datos y una visualización rápida y efectiva de ellos.
Si eres un apasionado de los Truenos y Rayos es tu momento!

Conclusión

A traves de un websocket podemos recibir muchisima información, con su adecuado manejo seremos capaces de una infinidad de cosas.
Docker nos permite utilizar un entorno super optimizado y orientado a tareas especificas con su sistema de contenedores. Gracias a esto podemos desplegar diferentes entornos sin necesidad de sobrecargar nuestro equipo principal.
Grafana es una herramienta muy potente de visualización de datos que de manera organizada y personalizada nos presentará la informacion que seamos capaces de cargar en todos los entornos de los que dispone.

Hasta la vista Hackers.
Kerneloop.

MikroTik es una marca fabricante de equipos de red. Desarrolla y vende enrutadores de red cableados e inalámbricos, conmutadores de red, puntos de acceso, así como sistemas operativos y software auxiliar.

Porque Mikrotik

Es reconocido, tiene un software llamado RouterOS, el cual nos permitirá un manejo amplio en todas las configuraciones que podamos imaginar! Con Mikrotik Puedes hacer Cualquier cosa.

Primeros Pasos

Dispondremos de un Router Mikrotik hAP Lite para este laboratorio. Es versatil, comodo y muy potente. Precio actual -> 20-30 Euros.

El primer paso es conectar a tu equipo Windows o Linux a traves de un cable RJ45 al primer puerto del router. Una vez se encienda el Led Verde accederemos al router a traves del programa WinBox. Cuando haya iniciado deberá de aparecer una interfaz como esta. Tambien verás la direccion MAC de tu Mikrotik.

Por defecto, las credenciales son Username: admin Password: vacía

Haremos click en conectar y nos solicitará unas nuevas credenciales.
Una vez introducidas nos redireccionará al menu principal desde el que podremos configurar absolutamente TODO!

Enhorabuena!

Has accedido por primera vez a tu Router.
A partir de aqui todo son maravillas, comienza tu exploración con el Networking.

¿Acaso no es asi como empieza todo?

Es impresionante como un hola puede romper esa barrera entre el no puedo y el primer paso. Esa barrera que se hace tan grande y fría como un muro. La reducimos con un poquito de nosotros cada día, un ratito libre con un café por las mañanas, en una escapada para merendar….. La rutina hace al monje.

Poco a poco ire publicando esos pequeños pasitos que iré dando en mis ratos libes, espero que disfrutes del proceso tanto como yo!

Kerneloop.