Alumnos implicados: alumnos de 1º y 2º del CFGM
Dificultades: Necesidad de conocimientos básicos sobre seguridad informática.
Tiempo de preparación y ejecución: 2 horas a la semana con cada grupo desde enero hasta mayo.
Descripción de la actividad:
Actividad: Cripto-Red Segura con Micro:bit
Los alumnos simulan una red corporativa expuesta a amenazas en equipos de 4 personas. Deben programar un sistema de comunicación inalámbrica seguro usando las placas Micro:bit, implementando técnicas de cifrado, autenticación y detección de intrusos (IDS) para proteger el intercambio de datos críticos.
Posteriormente se utilizará un formulario web con los alumnos de 2 de ciclo donde se programaron estas actividades con php
Objetivos Didácticos
Implementar algoritmos básicos de cifrado simétrico (como el cifrado César o XOR).
Configurar claves de autenticación precompartidas para evitar la suplantación de identidad.
Diseñar un sistema de alerta ante ataques de denegación de servicio (DoS) por radio.
Coordinar la arquitectura de seguridad dividiendo el trabajo por capas de protección.
Auditar el código del propio equipo para localizar y corregir vulnerabilidades.
Desarrollo de la Actividad
[Fase 1: Análisis y Cifrado] ➔ [Fase 2: Implementación de Capas] ➔ [Fase 3: Auditoría y Ataque]
1. Diseño del Protocolo
El equipo define una clave secreta y un método de cifrado común.
Acuerdan la estructura del mensaje (Cabecera + Datos + Token de verificación).
2. Distribución de Roles Técnicos
Alumno A (Cifrado): Programa el emisor para codificar los datos antes de enviarlos.
Alumno B (Descifrado): Programa el receptor para validar y descodificar el mensaje.
Alumno C (Autenticación): Implementar un sistema de "apretón de manos" (handshake) simulación de firewall.
Alumno D (Monitor de Red / IDS): Programa una Micro:bit en modo escucha para detectar anomalías o tráfico masivo (DoS).
3. Simulación de Incidentes (Fase de Ataque)
Los equipos intentan interceptar de forma inalámbrica los mensajes de otros grupos.
Prueban a enviar datos falsos para ver si el sistema de autenticación los rechaza.
Miden la resiliencia de su red ante intentos de saturación de canales de radio.
Evaluación de Seguridad y Equipo
Confidencialidad: Éxito en evitar que otros equipos lean el mensaje original.
Integridad: Capacidad del receptor para descartar paquetes modificados o falsificados.
Mitigación: Tiempo de reacción del equipo para cambiar de canal de radio ante un ataque.
Para ajustar los scripts de código, la actividad se puede programar en MakeCode (bloques) o en Python. Los alumnos deben conocer conceptos de criptografía previamente.
Dada la complejidad de este proyecto se han trabajado las distintas actividades y fases a caballo entre sus aulas y el aula del futuro, donde se han utilizado las distintas zonas: Presenta e Intercambia, Crea y Desarrolla, Interactúa y Explora, Investiga y Experimenta y Relájate.
Programación completa en MakeCode (Bloques) para la actividad "Cripto-Red Segura". Para simplificar y adaptarlo al nivel de 1º de Grado Medio, se ha utilizado un cifrado César por desplazamiento numérico y un Token de autenticación básico.
Este programa toma un valor numérico (el dato confidencial), lo cifra sumándole un desplazamiento (clave secreta) y lo envía junto a un código de autenticación (Token).
Clave Secreta (Desplazamiento): 5
Token de Autenticación: 99
Instrucciones en Bloques:
En el bloque al iniciar, establece el grupo de radio en 10.
Al presionar el Botón A, simula el envío:
El dato original es 12 (por ejemplo, una temperatura o ID).
Se cifra sumando la clave (12 + 5 = 17).
Se envía un paquete de datos con formato de texto: "TOKEN:DATOCIFRADO". En este caso: "99:17".
Representación del código (JavaScript/Bloques de MakeCode):
input.onButtonPressed(Button.A, function () {
let dato_original = 12
let clave = 5
let token = 99
// Ciframos el dato
let dato_cifrado = dato_original + clave
// Creamos el paquete seguro: "99:17"
let paquete = "" + token + ":" + dato_cifrado
radio.sendString(paquete)
basic.showIcon(IconNames.Yes)
basic.pause(500)
basic.clearScreen()
})
radio.setGroup(10)
Usa el código con precaución.
Código del Receptor (Alumno B + Alumno C)
Este programa recibe el texto, separa el Token y el dato cifrado, verifica la identidad del emisor y descifra el mensaje restando la clave secreta.
Instrucciones en Bloques:
En el bloque al iniciar, establece el grupo de radio en 10.
En el bloque al recibir radio string (receivedString):
Usa la función de texto para extraer el Token (primeros 2 caracteres) y el dato (caracteres después de los dos puntos).
Validación: Si el Token es igual a 99, acepta el mensaje. Si no, muestra una X (Intruso).
Descifrado: Si es válido, resta la clave (5) al dato recibido para obtener el mensaje original y lo muestra en pantalla.
Representación del código (JavaScript/Bloques de MakeCode):
typescript
radio.onReceivedString(function (receivedString) {
// El paquete esperado tiene el formato "99:17"
let token_recibido = parseFloat(receivedString.substr(0, 2))
let dato_cifrado_recibido = parseFloat(receivedString.substr(3, 2))
let clave = 5
// Alumno C: Verificación de Autenticidad
if (token_recibido == 99) {
// Alumno B: Descifrado del mensaje
let dato_descifrado = dato_cifrado_recibido - clave
basic.showNumber(dato_descifrado)
} else {
// Alerta de seguridad: Token incorrecto o suplantación
basic.showIcon(IconNames.No)
}
basic.pause(1000)
basic.clearScreen()
})
radio.setGroup(10)
Usa el código con precaución.
Código del Monitor / IDS (Alumno D)
Esta placa se configura en el mismo canal pero actúa como un analizador de tráfico. Su objetivo es detectar si hay saturación en la red (Ataque DoS) contando cuántos mensajes entran en un periodo corto de tiempo.
Instrucciones en Bloques:
Crea una variable contador_mensajes.
Cada vez que recibe cualquier mensaje por radio, suma 1 a contador_mensajes.
En un bloque para siempre, espera 5 segundos (5000 ms). Si el contador supera los 5 mensajes en ese tiempo, activa una alarma visual (pantalla parpadeante) avisando del ataque de saturación. Luego reinicia el contador.
Representación del código (JavaScript/Bloques de MakeCode):
typescript
let contador_mensajes = 0
radio.onReceivedString(function (receivedString) {
contador_mensajes += 1
})
radio.setGroup(10)
contador_mensajes = 0
basic.forever(function () {
basic.pause(5000) // Analiza cada 5 segundos
if (contador_mensajes > 5) {
// Alerta de Denegación de Servicio (DoS)
for (let i = 0; i < 3; i++) {
basic.showLeds(`
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
`)
basic.pause(200)
basic.clearScreen()
basic.pause(200)
}
}
contador_mensajes = 0 // Resetea el tráfico para el siguiente ciclo
})
Usa el código con precaución.
En Python:
Este entorno utiliza el módulo radio integrado y requiere la conversión de cadenas de texto para procesar los paquetes.
Código del Emisor (Alumno A + Alumno C)
from microbit import *
import radio
# Configuración inicial de seguridad (Capa de enlace y red)
radio.config(group=10)
radio.on()
# Parámetros de seguridad acordados por el equipo
CLAVE = 5
TOKEN = "99"
while True:
# El emisor envía el dato confidencial al pulsar el Botón A
if button_a.is_pressed():
dato_original = 12
# Alumno A: Cifrado simétrico por desplazamiento (César)
dato_cifrado = dato_original + CLAVE
# Alumno C: Empaquetado con Token de autenticación
# Formato del paquete resultante: "99:17"
paquete = str(TOKEN) + ":" + str(dato_cifrado)
# Envío inalámbrico
radio.send(paquete)
# Feedback visual de envío exitoso
display.show(Image.YES)
sleep(500)
display.clear()
sleep(100) # Evita el rebote del botón
Usa el código con precaución.
Código del Receptor (Alumno B + Alumno C)
from microbit import *
import radio
radio.config(group=10)
radio.on()
CLAVE = 5
TOKEN_VALIDO = "99"
while True:
# Escucha activa del canal de radio
paquete_recibido = radio.receive()
if paquete_recibido:
try:
# Separamos el paquete usando los dos puntos ":" como delimitador
# "99:17" se convierte en una lista: ["99", "17"]
partes = paquete_recibido.split(":")
token_recibido = partes[0]
dato_cifrado = int(partes[1])
# Alumno C: Control de acceso / Validación del Token
if token_recibido == TOKEN_VALIDO:
# Alumno B: Descifrado del mensaje matemático
dato_descifrado = dato_cifrado - CLAVE
display.scroll(str(dato_descifrado))
else:
# Alerta de seguridad: Intruso con Token incorrecto
display.show(Image.NO)
sleep(1000)
display.clear()
except:
# Control de errores si el paquete está corrupto o mal formateado
display.show(Image.SAD)
sleep(500)
display.clear()
sleep(10)
Usa el código con precaución.
Código del Monitor / IDS (Alumno D)
from microbit import *
import radio
radio.config(group=10)
radio.on()
contador_mensajes = 0
# Guardamos el tiempo inicial en milisegundos
tiempo_inicio = running_time()
while True:
# Escucha todo el tráfico del canal asignado
paquete = radio.receive()
if paquete:
contador_mensajes += 1
# Sistema de detección de intrusos (IDS): Analiza cada 5000 ms (5 segundos)
if running_time() - tiempo_inicio >= 5000:
# Umbral de tráfico: Más de 5 mensajes en 5 segundos se considera ataque DoS
if contador_mensajes > 5:
# Alerta visual de denegación de servicio (Parpadeo)
for _ in range(3):
display.show(Image.SQUARE)
sleep(200)
display.clear()
sleep(200)
# Reinicio de métricas para la siguiente ventana de inspección
contador_mensajes = 0
tiempo_inicio = running_time()
sleep(10)
Usa el código con precaución.
Cambios clave explicados para los alumnos:
.split(":"): Es el método en Python que sustituye a las funciones de subcadena de MakeCode. Rompe el texto automáticamente donde encuentra los dos puntos.
try / except: Se añade en el receptor para evitar que la placa se bloquee si un equipo rival envía texto plano que no se pueda convertir a número (int). Esto enseña un principio real de robustez de software en seguridad.
Conclusión:
Esta actividad de ciberseguridad con Micro:bit permite transformar conceptos abstractos en experiencias prácticas. Al programar estos dispositivos para simular sistemas de control de acceso, cifrado básico o alertas de intrusión, se logra comprender de forma tangible la importancia de la protección de datos y la vulnerabilidad del hardware.
No hay comentarios:
Publicar un comentario