Skip to content
KitploitKITPLOIT
HerramientasBlog
Enviar
HerramientasBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

··Feeds·Contacto·Privacidad·© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
CVE-2025-62215-POC — Exploit de prueba de concepto para CVE-2025-62215, una vulnerabilidad Use-After-Free del kernel de Windows en SepTokenSidSharingEnabled. Incluye un controlador de kernel y un exploit en modo usuario para el análisis de condiciones de carrera. | Kitploit
Herramientas/GitHubGitHub/gowonisgood/cve-2025-62215-poc
Análisis de VulnerabilidadesExplotaciónCTFAprendizaje y EducaciónExplotación de Binarios
GitHubgowonisgood/cve-2025-62215-poc

CVE-2025-62215-POC

Exploit de prueba de concepto para CVE-2025-62215, una vulnerabilidad Use-After-Free del kernel de Windows en SepTokenSidSharingEnabled. Incluye un controlador de kernel y un exploit en modo usuario para el análisis de condiciones de carrera.

Ver Repositorio
10115hace 3 mesesAún no revisado

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Compartir

CVE-2025-62215 — Windows Token UAF (Condición de carrera de SepTokenSidSharingEnabled)

Este repositorio es solo para fines educativos y de investigación.

Resumen

Una PoC de vulnerabilidad Use-After-Free que ocurre en la ruta de optimización SepTokenSidSharingEnabled del kernel de Windows.

  • Cuando NtDuplicateToken incrementa el RefCount del Bloque de Valores SID de 1 a 2, un hilo del kernel en competencia libera el bloque mediante ExFreePoolWithTag.
  • Posteriormente, SepDereferenceSidValuesBlock accede al bloque liberado → UAF / Doble Liberación.
root@kitploit:~
[Usuario]  IOCTL_REPLACE_SID_BLOCK  →  Colocar un bloque independiente (RefCount=1) en TOKEN+0x468
[Usuario]  IOCTL_TRIGGER_FREE       →  Generar un hilo del kernel (sondeo hasta RefCount==2)
[Usuario]  NtDuplicateToken         →  Internamente incrementa RefCount 1→2
[Hilo del kernel] RefCount==2 detectado → ExFreePoolWithTag(pBlock)  ← punto UAF

Estructura de Archivos

RutaDescripción
exploit/exploitWithDriv/exploitWithDriv.cppExplotación en modo usuario (aplicación de consola)
tokendriv/tokendrv/tokendrv/tokendrv.cppControlador del kernel (proporciona interfaz IOCTL)

Instrucciones de Compilación (Visual Studio)

Requisitos Previos

  • Visual Studio 2022 (MSVC)
  • Windows Driver Kit (WDK) — necesario para la compilación de tokendriv
  • SDK 10.0.26100.x o posterior

1. tokendriv.sys — Controlador del Kernel

  1. Abrir tokendriv/tokendrv/tokendrv.slnx
  2. Configuración: Release / x64
  3. Compilar → genera tokendriv/tokendrv/x64/Release/tokendriv.sys
  4. Despliegue independiente: copiar solo el archivo .sys a la máquina virtual

Después de instalar WDK, verificar: Propiedades del proyecto → Configuración del controlador → Versión del sistema operativo de destino

2. exploitWithDriv.exe — Explotación en Modo Usuario

  1. Abrir exploit/exploitWithDriv.slnx
  2. Configuración: Release / x64
  3. Propiedades del proyecto → Enlazador → Sistema → Subsistema: Consola
  4. Compilar → genera exploit/x64/Release/exploitWithDriv.exe
  5. Para despliegue independiente (sin necesidad de Visual C++ Redistributable):
    • C/C++ → Generación de código → Biblioteca en tiempo de ejecución: Multihilo (/MT)

Ejecución en Máquina Virtual

Requisitos Previos

  • RAM de la MV: 2 GB o menos (necesario para activar SepTokenSidSharingEnabled)
  • Cuenta de prueba: test / 1234 (cuenta local, no se requieren derechos de administrador)
  • Conexión de depuración del kernel (opcional, necesaria para análisis)
  • cmd como administrador

Cargar el Controlador

root@kitploit:~
sc create tokendriv type= kernel binpath= "C:\ruta\a\tokendrv.sys"
sc start tokendriv

Verificar que el controlador está en ejecución:

root@kitploit:~
sc query tokendriv

El estado debe ser RUNNING.

Ejecutar la Explotación

root@kitploit:~
exploitWithDriv.exe

Flujo de ejecución:

  1. Verificar FullNumberOfPhysicalPages (debe ser ≤ 0x83400)
  2. LogonUser("test", ".", "1234") → obtener hSource
  3. Presionar Enter para iniciar el bucle de carrera (100.000 iteraciones)
  4. Cada iteración: REPLACE → TRIGGER → NtDuplicateToken → Sleep(1)

Análisis de Condición de Carrera (WinDbg KD)

1. Obtener la Dirección del Proceso Objetivo

root@kitploit:~
0: kd> !process 0 0 exploitWithDriv.exe

Ejemplo de salida:

root@kitploit:~
PROCESS ffffa88f5e61e080
    SessionId: 1  Cid: 1234    Peb: ...  ParentCid: ...
    Image: exploitWithDriv.exe

ffffa88f5e61e080 es la dirección EPROCESS.

2. Establecer Puntos de Interrupción

Las direcciones a continuación pueden variar según el entorno — confirmar con los símbolos reales del kernel.

A. Incremento de RefCount del Bloque SID (inicio de la ventana de carrera)

root@kitploit:~
0: kd> bp fffff800`725c6114 ".if (@$proc == 0xffffa88f5e61e080) { .echo A_REFCNT_INCR; dq poi(@rsi+0x468)+8 L1; gc } .else { gc }"
  • Imprime el RefCount (+0x8) del Bloque de Valores SID en TOKEN+0x468
  • El momento en que el valor cambia de 1 → 2 es la ventana de carrera

B. Punto de lectura UAF

root@kitploit:~
0: kd> bp fffff800`726f51fb ".if (@$proc == 0xffffa88f5e61e080) { .echo REAL_UAF_READ; r rax,rdx; gc } .else { gc }"
  • Punto donde se lee el bloque liberado
  • Verificar valores de rax, rdx

C. Punto de escritura UAF

root@kitploit:~
0: kd> bp fffff800`726f5208 ".if (@$proc == 0xffffa88f5e61e080) { .echo REAL_UAF_WRITE; r rcx,rdx,rax; gc } .else { gc }"
  • Punto donde se escribe en el bloque liberado
  • Verificar rcx, rdx, rax para detectar corrupción

3. Flujo de Tiempo de la Carrera

root@kitploit:~
Entrada a NtDuplicateToken
    └─ SeTokenCanImpersonate
        └─ RefCount del Bloque SID: 1 → 2        ← bp A (A_REFCNT_INCR)
                                              ← hilo del kernel: ExFreePoolWithTag(pBlock)
    └─ SepDereferenceSidValuesBlock
        └─ desreferenciar pBlock (lectura)         ← bp B (REAL_UAF_READ)
        └─ desreferenciar pBlock (escritura)       ← bp C (REAL_UAF_WRITE)

4. Consejos de Análisis

  • Si RefCount es 2 inmediatamente después de que se imprima A_REFCNT_INCR, la ventana de carrera se ha ingresado con éxito
  • Si aparecen REAL_UAF_READ / REAL_UAF_WRITE, se confirma el UAF real
  • Rastrear bloques asignados con la etiqueta de pool 'kcoB': !pool <addr> o !poolused

Desplazamientos Clave (Windows 11 24H2)

EstructuraDesplazamientoCampo
_TOKEN+0x468SepSidValues (puntero al Bloque de Valores SID)
Bloque de Valores SID+0x000Length (ULONG)
Bloque de Valores SID+0x008ReferenceCount (LONGLONG)

Descargar el Controlador

root@kitploit:~
sc stop tokendriv
sc delete tokendriv


CVE-2025-62215 — Windows Token UAF (SepTokenSidSharingEnabled 레이스 컨디션)

개요

Windows 커널의 SepTokenSidSharingEnabled 최적화 경로에서 발생하는 Use-After-Free 취약점 PoC.

  • NtDuplicateToken 내부에서 SID Values Block의 RefCount가 1→2로 증가하는 순간, 레이스를 걸어 커널 스레드가 해당 블록을 ExFreePoolWithTag로 해제한다.
  • 이후 SepDereferenceSidValuesBlock이 해제된 블록에 다시 접근 → UAF / Double Free.
root@kitploit:~
[User]  IOCTL_REPLACE_SID_BLOCK  →  TOKEN+0x468 에 RefCount=1 독립 블록 배치
[User]  IOCTL_TRIGGER_FREE       →  커널 스레드 시작 (RefCount==2 폴링 대기)
[User]  NtDuplicateToken         →  내부에서 RefCount 1→2
[Kernel Thread] RefCount==2 감지 → ExFreePoolWithTag(pBlock)  ← UAF 지점

구성 파일

경로설명
exploit/exploitWithDriv/exploitWithDriv.cpp유저모드 익스플로잇 (콘솔 앱)
tokendriv/tokendrv/tokendrv/tokendrv.cpp커널 드라이버 (IOCTL 인터페이스 제공)

빌드 방법 (Visual Studio)

공통 사전 조건

  • Visual Studio 2022 (MSVC)
  • Windows Driver Kit (WDK) — tokendriv 빌드 시 필요
  • SDK 10.0.26100.x 이상

1. tokendriv.sys — 커널 드라이버

  1. tokendriv/tokendrv/tokendrv.slnx 열기
  2. 구성: Release / x64
  3. 빌드 → tokendriv/tokendrv/x64/Release/tokendrv.sys 생성
  4. 독립 실행 배포: .sys 파일 하나만 VM으로 복사하면 됨

WDK 설치 후 프로젝트 속성 → Driver Settings → Target OS Version 확인

2. exploitWithDriv.exe — 유저모드 익스플로잇

  1. exploit/exploitWithDriv.slnx 열기
  2. 구성: Release / x64
  3. 프로젝트 속성 → Linker → System → SubSystem: Console
  4. 빌드 → exploit/x64/Release/exploitWithDriv.exe 생성
  5. 독립 실행 배포: Visual C++ Redistributable 없이 동작하도록
    • C/C++ → Code Generation → Runtime Library: Multi-threaded (/MT) 으로 설정

VM 실행 방법

사전 조건

  • VM RAM: 2 GB 이하 (SepTokenSidSharingEnabled 활성화 조건)
  • 테스트 계정: test / 1234 (로컬 계정, 관리자 권한 불필요)
  • Kernel Debugging 연결 (선택, 분석 시 필요)
  • 관리자 권한 cmd

드라이버 로드

root@kitploit:~
sc create tokendriv type= kernel binpath= "C:\path\to\tokendrv.sys"
sc start tokendriv

드라이버 로드 확인:

root@kitploit:~
sc query tokendriv

RUNNING 상태이면 정상.

익스플로잇 실행

root@kitploit:~
exploitWithDriv.exe

실행 흐름:

  1. FullNumberOfPhysicalPages 체크 (0x83400 이하여야 진행)
  2. LogonUser("test", ".", "1234") → hSource 획득
  3. Enter 입력 시 레이스 루프 100,000회 시작
  4. 각 이터레이션: REPLACE → TRIGGER → NtDuplicateToken → Sleep(1)

Race Condition 분석 (WinDbg KD)

1. 분석 대상 프로세스 주소 확인

root@kitploit:~
0: kd> !process 0 0 exploitWithDriv.exe

출력 예시:

root@kitploit:~
PROCESS ffffa88f5e61e080
    SessionId: 1  Cid: 1234    Peb: ...  ParentCid: ...
    Image: exploitWithDriv.exe

ffffa88f5e61e080 부분이 EPROCESS 주소.

2. 브레이크포인트 설정

아래 주소는 환경마다 다를 수 있으므로 실제 커널 심볼로 확인 후 사용.

A. SID Block RefCount 증가 지점 (레이스 윈도우 시작)

root@kitploit:~
0: kd> bp fffff800`725c6114 ".if (@$proc == 0xffffa88f5e61e080) { .echo A_REFCNT_INCR; dq poi(@rsi+0x468)+8 L1; gc } .else { gc }"
  • TOKEN+0x468 에 있는 SID Values Block의 RefCount(+0x8)를 출력
  • 값이 1 → 2로 바뀌는 순간이 레이스 윈도우

B. UAF Read 지점

root@kitploit:~
0: kd> bp fffff800`726f51fb ".if (@$proc == 0xffffa88f5e61e080) { .echo REAL_UAF_READ; r rax,rdx; gc } .else { gc }"
  • 해제된 블록을 읽는 지점
  • rax, rdx 값 확인

C. UAF Write 지점

root@kitploit:~
0: kd> bp fffff800`726f5208 ".if (@$proc == 0xffffa88f5e61e080) { .echo REAL_UAF_WRITE; r rcx,rdx,rax; gc } .else { gc }"
  • 해제된 블록에 쓰는 지점
  • rcx, rdx, rax 값으로 오염 여부 확인

3. 레이스 타이밍 흐름

root@kitploit:~
NtDuplicateToken 진입
    └─ SeTokenCanImpersonate
        └─ SID Block RefCount: 1 → 2        ← bp A (A_REFCNT_INCR)
                                              ← 커널 스레드: ExFreePoolWithTag(pBlock)
    └─ SepDereferenceSidValuesBlock
        └─ pBlock 역참조 (읽기)              ← bp B (REAL_UAF_READ)
        └─ pBlock 역참조 (쓰기)              ← bp C (REAL_UAF_WRITE)

4. 분석 팁

  • A_REFCNT_INCR 출력 직후 RefCount가 2이면 레이스 윈도우 진입 성공
  • REAL_UAF_READ / REAL_UAF_WRITE 이 출력되면 실제 UAF 발생 확인
  • Pool tag 'kcoB' 로 할당된 블록 추적: !pool <addr> 또는 !poolused

주요 오프셋 (Windows 11 24H2 기준)

구조체오프셋필드
_TOKEN+0x468SepSidValues (SID Values Block 포인터)
SID Values Block+0x000Length (ULONG)
SID Values Block+0x008ReferenceCount (LONGLONG)

드라이버 제거

root@kitploit:~
sc stop tokendriv
sc delete tokendriv
Descargar herramienta