Learning Reinforcement Learning Through Pwnagotchi: A Practical Journey

Introducción: ¿Por qué Pwnagotchi?

Pwnagotchi es más que una herramienta de auditoría WiFi—es un laboratorio práctico para entender aprendizaje por refuerzo (RL) en acción. Este proyecto combina ciberseguridad, sistemas embebidos y machine learning, haciéndolo perfecto para cualquiera que quiera ver algoritmos de IA aprender y adaptarse en tiempo real.

En este artículo te cuento mi experiencia configurando Pwnagotchi, entendiendo cómo funciona su IA, y observando el proceso de aprendizaje de primera mano.

¿Qué es Pwnagotchi?

Pwnagotchi es una IA basada en A2C (Advantage Actor-Critic) que corre en una Raspberry Pi Zero W. ¿Su misión? Aprender las mejores estrategias para capturar handshakes WPA de redes WiFi a su alrededor.

Conceptos clave:

Reinforcement Learning: La IA aprende por prueba y error, recibiendo recompensas por acciones exitosas
Algoritmo A2C: Un método de gradiente de política que balancea exploración vs explotación
Aprendizaje Autónomo: A diferencia del aprendizaje supervisado, no hay dataset etiquetado—Pwnagotchi lo descubre solo

Setup de Hardware

Lo que vas a necesitar

Raspberry Pi Zero W o Zero 2 W (la W es esencial para WiFi)
Tarjeta MicroSD (16GB mínimo, 32GB recomendado)
Display e-ink Waveshare 2.13" (opcional pero muy recomendado para monitoreo)
Batería portátil (10,000mAh+ para operación todo el día)
Cable USB para energía y acceso SSH

Instalación Inicial

Descargar la imagen de Pwnagotchi

wget https://github.com/jayofelony/pwnagotchi/releases/latest/download/pwnagotchi-raspios-lite-arm64.img.gz

Flashear a la SD

# Usando Raspberry Pi Imager o:
gunzip pwnagotchi-raspios-lite-arm64.img.gz
sudo dd if=pwnagotchi-raspios-lite-arm64.img of=/dev/sdX bs=4M status=progress
sync

Habilitar SSH antes del primer boot

# Montar la partición boot
touch /path/to/boot/ssh

Configurar WiFi para setup inicial
Crear wpa_supplicant.conf en la partición boot:

country=AR
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
    ssid="NombreDeTuRed"
    psk="TuContraseña"
}

Primer boot y acceso SSH

# Conectar via USB (RNDIS)
ssh pi@10.0.0.2
# Contraseña default: raspberry

# O via WiFi
ssh pi@pwnagotchi.local

Configuración: Enseñándole a Pwnagotchi sobre tu entorno

El archivo de configuración /etc/pwnagotchi/config.toml es donde definís la personalidad y restricciones de tu Pwnagotchi.

Configuración Esencial

main.name = "pwnagotchi"
main.lang = "es"
main.whitelist = [
    "TuRedDeCasa",
    "TuRedDelTrabajo",
    "VecinoQueTeAgrada"
]

# Configuración de plugins
ui.display.enabled = true
ui.display.type = "waveshare_2"

# Settings de IA
personality.advertise = true
personality.deauth = true
personality.associate = true
personality.channels = []  # Vacío = todos los canales

Entendiendo las Whitelists

Crítico: Cualquier red en la whitelist será ignorada por Pwnagotchi. Esto es esencial para:

Tus propias redes
Redes que tenés autorización para testear
Redes de gente alrededor tuyo (para evitar problemas legales)


# Editar configuración
sudo nano /etc/pwnagotchi/config.toml

# Reiniciar para aplicar cambios
sudo systemctl restart pwnagotchi

El Proceso de Aprendizaje: A2C en Acción

¿Cómo Aprende Pwnagotchi?

Pwnagotchi usa Advantage Actor-Critic (A2C), un algoritmo de reinforcement learning que consiste en:

Actor: Decide qué acciones tomar (qué canal monitorear, cuándo hacer deauth, etc.)
Critic: Evalúa qué tan buenas fueron esas acciones (señal de recompensa)
Advantage: Compara recompensas reales vs esperadas para mejorar la toma de decisiones

El sistema de recompensas:

✅ Recompensas positivas: Capturar handshakes, encontrar nuevas redes
❌ Recompensas negativas: Quedarse en canales vacíos, intentos de deauth fallidos
🎯 Objetivo: Maximizar la recompensa acumulada en el tiempo

Observando el Algoritmo Aprender

Acá es donde se pone interesante. Podés ver el cerebro de tu Pwnagotchi evolucionar en tiempo real.

Monitorear epochs de entrenamiento:


# SSH a tu Pwnagotchi
ssh pi@10.0.0.2

# Ver el proceso de aprendizaje
tail -f /var/log/pwnagotchi.log | grep "epoch"

Lo que vas a ver:

[epoch 001] reward=2.34 train_loss=0.45 handshakes=1
[epoch 002] reward=3.12 train_loss=0.41 handshakes=2
[epoch 003] reward=2.89 train_loss=0.38 handshakes=1
...
[epoch 050] reward=8.67 train_loss=0.15 handshakes=7

Métricas Clave Explicadas

Epoch: Un ciclo completo de observación → acción → recompensa → aprendizaje

Epochs tempranos: Alta exploración, comportamiento aparentemente random
Epochs posteriores: Más explotación, estrategias refinadas

Reward: Puntos acumulados ganados

Debería tender al alza con el tiempo
Los plateaus son normales mientras el algoritmo se afina
Caídas repentinas indican cambios ambientales (nueva área, diferente densidad WiFi)

Train Loss: Qué tan incorrectas fueron las predicciones

Loss alto = todavía aprendiendo, inseguro sobre las mejores acciones
Loss bajo = confiado en su estrategia
Debería decrecer con el tiempo (pero nunca llegar a cero)

Handshakes: El output práctico

Lo que realmente te importa para auditoría WiFi
Debería incrementar a medida que la IA mejora

Evolución Día a Día

Día 1: Exploración Random

[08:15:23] [INFO] New session started
[08:15:45] [epoch 001] reward=1.2 train_loss=0.87 handshakes=0
[08:16:12] [epoch 002] reward=0.8 train_loss=0.85 handshakes=0

Comportamiento: Salta entre canales al azar, muchos intentos fallidos, baja eficiencia.

Qué está pasando: Fase de pura exploración. La red neuronal tiene pesos aleatorios, así que las acciones son básicamente conjeturas.

Día 3: Reconocimiento de Patrones

[10:22:34] [epoch 142] reward=4.5 train_loss=0.52 handshakes=3
[10:23:01] [epoch 143] reward=5.1 train_loss=0.49 handshakes=4

Comportamiento: Empieza a preferir ciertos canales, el timing de deauth mejora.

Qué está pasando: La red de política está aprendiendo qué acciones llevan a recompensas. Vas a notar que pasa más tiempo en los canales 1, 6 y 11 (los canales 2.4GHz sin superposición).

Día 7: Estrategia Optimizada

[14:45:12] [epoch 892] reward=12.3 train_loss=0.18 handshakes=11
[14:45:39] [epoch 893] reward=13.1 train_loss=0.17 handshakes=12

Comportamiento: Saltos de canal eficientes, timing preciso, alta tasa de éxito.

Qué está pasando: El algoritmo convergió en una política óptima para tu entorno específico. Sabe cuándo ser agresivo y cuándo esperar.

Monitoreo Avanzado

Visualizando el Progreso de Aprendizaje


# Instalar dependencias
sudo apt-get install python3-matplotlib

# Extraer datos de entrenamiento
grep "epoch" /var/log/pwnagotchi.log | awk '{print $4, $5, $6}' > training_data.csv

# Plotear con Python
python3 << EOF
import matplotlib.pyplot as plt
import pandas as pd

data = pd.read_csv('training_data.csv', names=['epoch', 'reward', 'loss'])
data['epoch'] = data['epoch'].str.extract('(\d+)').astype(int)
data['reward'] = data['reward'].str.extract('([\d.]+)').astype(float)
data['loss'] = data['loss'].str.extract('([\d.]+)').astype(float)

fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))

ax1.plot(data['epoch'], data['reward'])
ax1.set_title('Recompensa en el Tiempo')
ax1.set_xlabel('Epoch')
ax1.set_ylabel('Recompensa Acumulada')

ax2.plot(data['epoch'], data['loss'])
ax2.set_title('Pérdida de Entrenamiento en el Tiempo')
ax2.set_xlabel('Epoch')
ax2.set_ylabel('Pérdida')

plt.tight_layout()
plt.savefig('pwnagotchi_learning.png')
EOF

Entendiendo las Actualizaciones de Política

El algoritmo A2C actualiza su política cada pocos epochs basado en la función de ventaja:

Advantage = Q(state, action) - V(state)

Donde:

Q(state, action): Recompensa esperada por tomar la acción A en el estado S
V(state): Recompensa esperada solo por estar en el estado S
Ventaja positiva: La acción fue mejor de lo esperado → aumentar probabilidad
Ventaja negativa: La acción fue peor de lo esperado → disminuir probabilidad

Troubleshooting: Cuando el Aprendizaje se Estanca

Problema 1: No Captura Handshakes Después de Días

Síntomas:

[epoch 245] reward=0.5 train_loss=0.65 handshakes=0
[epoch 246] reward=0.4 train_loss=0.64 handshakes=0

Checklist de diagnóstico:

Verificar modo monitor

sudo iwconfig wlan0

Debería mostrar:

wlan0     IEEE 802.11  ESSID:off/any
          Mode:Monitor  Frequency:2.437 GHz
          Tx-Power=31 dBm

Si dice Mode:Managed → ¡Problema!

Fix:

sudo systemctl restart pwnagotchi
# O manualmente:
sudo ifconfig wlan0 down
sudo iwconfig wlan0 mode monitor
sudo ifconfig wlan0 up

Revisar configuración de whitelist

grep "whitelist" /etc/pwnagotchi/config.toml

Si accidentalmente pusiste todas las redes locales en whitelist:

sudo nano /etc/pwnagotchi/config.toml
# Eliminar entradas innecesarias de whitelist
sudo systemctl restart pwnagotchi

Densidad WiFi muy baja
```
# Escanear redes disponibles
sudo iwlist wlan0 scan | grep ESSID
```
Si ves < 5 redes, probá:
- Moverte a una ubicación diferente (café, biblioteca, edificio de oficinas)
- Verificar si estás en una jaula de Faraday (edificio metálico)
- Verificar la conexión de la antena

Problemas de hardware

# Chequear estado del adaptador WiFi
lsusb
dmesg | grep wlan

# Testear con un escaneo manual
sudo airmon-ng check kill
sudo airmon-ng start wlan0
sudo airodump-ng wlan0mon

Problema 2: Loss No Disminuye

Síntomas:

[epoch 450] train_loss=0.72
[epoch 500] train_loss=0.71
[epoch 550] train_loss=0.73

Causas posibles:

El entorno es demasiado caótico (alta densidad WiFi con cambios constantes)
El learning rate puede necesitar ajuste
Los pesos de la red se atascaron en un mínimo local

Soluciones:

Resetear el cerebro de la IA (opción nuclear):

sudo rm -rf /root/.pwnagotchi-*
sudo systemctl restart pwnagotchi

Ajustar learning rate (requiere modificación de código):

# En /usr/local/lib/python3.X/dist-packages/pwnagotchi/ai/gym.py
self.learning_rate = 0.0001  # Default es 0.001

Simplificar el entorno:
- Usar whitelist para reducir cantidad de redes
- Enfocarse en canales específicos
- Probar en una ubicación física diferente

Experimentos del Mundo Real

Experimento 1: Café vs Oficina

Corrí dos Pwnagotchis simultáneamente por 5 días:

Resultados del Café:

156 redes únicas observadas
89 handshakes capturados
Reward promedio al Día 5: 15.2
train_loss final: 0.14

Resultados del Edificio de Oficinas:

43 redes únicas observadas
67 handshakes capturados
Reward promedio al Día 5: 18.7
train_loss final: 0.09

Conclusión: El Pwnagotchi de la oficina aprendió más rápido debido a un entorno estable y predecible. El del café tuvo mayor diversidad de redes pero más ruido, llevando a convergencia más lenta.

Experimento 2: Aprendizaje de Preferencia de Canales

Después de 1 semana, analicé qué canales prefería mi Pwnagotchi:

grep "channel" /var/log/pwnagotchi.log | awk '{print $7}' | sort | uniq -c | sort -rn

Resultados:

347 channel=6
298 channel=1
276 channel=11
89 channel=3
45 channel=9
...

¿Por qué? Los canales 1, 6 y 11 no se superponen en 2.4GHz, donde operan la mayoría de las redes. ¡La IA aprendió esto sin ser explícitamente programada!

Aprendizajes Clave sobre Reinforcement Learning

1. Trade-off Exploración vs Explotación

Al principio, Pwnagotchi explora al azar. A medida que aprende, explota estrategias conocidas. Esto se controla con:

epsilon = max(0.1, 1.0 - (epoch / 1000))  # Simplificado

Epsilon alto (temprano): Mucha exploración aleatoria
Epsilon bajo (después): Principalmente explotar lo conocido, exploración ocasional

2. El Reward Shaping Importa

La función de recompensa influencia directamente el comportamiento. Las recompensas de Pwnagotchi:

reward = (handshakes_captured * 5.0) + 
         (networks_found * 0.5) - 
         (time_wasted * 0.1) -
         (failed_deauths * 0.2)

Pequeños ajustes a estos pesos cambian dramáticamente el comportamiento aprendido.

3. La Estabilidad del Entorno Afecta la Velocidad de Aprendizaje

Entornos estables → convergencia más rápida
Entornos caóticos → mejor generalización pero aprendizaje más lento

Esto refleja el ML real: Datos de entrenamiento limpios convergen más rápido, pero datos diversos generalizan mejor.

4. Los Mínimos Locales Son Reales

A veces la IA se queda atascada en una estrategia "suficientemente buena" que no es óptima. La exploración aleatoria ocasional (epsilon) ayuda a escapar de estos.

Consideraciones Éticas y Legales

Importante: Pwnagotchi es una herramienta de pentesting. Usalo solo en:

Redes que son tuyas
Redes donde tenés permiso explícito por escrito para testear
Entornos educativos con autorización apropiada

Capturar handshakes de redes que no son tuyas sin permiso es ilegal en la mayoría de las jurisdicciones.

Poner en whitelist todo lo que no deberías tocar:

main.whitelist = [
    "red_vecino",
    "wifi_cafeteria",
    "cualquier_red_no_tuya"
]

Conclusión: Lo que Aprendí

Más allá de los detalles técnicos, este proyecto me enseñó:

RL es notablemente adaptable: Ver a Pwnagotchi descubrir estrategias WiFi sin instrucciones explícitas me mostró el poder del aprendizaje basado en recompensas.
Los hiperparámetros importan inmensamente: Pequeños cambios en learning rate, estructura de reward, o estrategia de exploración cambian completamente los resultados.
RL del mundo real es desordenado: A diferencia de entornos gym con recompensas limpias, Pwnagotchi opera en paisajes WiFi ruidosos e impredecibles. Esto hace la convergencia más difícil pero los resultados más impresionantes.
La IA embebida es accesible: Correr ML en un dispositivo de $15 prueba que no necesitás GPUs para aplicaciones prácticas de IA.

Próximos Pasos

¿Querés profundizar más?

Modificar la función de reward y observar cambios de comportamiento
Implementar plugins custom para extender funcionalidad
Experimentar con diferentes algoritmos de RL (DQN, PPO, SAC)
Construir un swarm de Pwnagotchis y estudiar multi-agent learning

Aprendiendo Reinforcement Learning con Pwnagotchi: Un Viaje Práctico