Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
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.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
Herramientas/GitHubGitHub/rex-rs/rex
Seguridad de Sistemas EmbebidosAnálisis Dinámico (Sandboxing)Virtualización de Seguridad
GitHubrex-rs/rex

rex

Rex es un marco de extensiones de kernel seguro y utilizable que permite cargar y ejecutar programas de extensión de kernel en Rust en lugar de eBPF.

Ver Repositorio
5542849hace 3 mesesRevisado por Kitploit
Compartir
 ____  _______  __  _____      _                 _
|  _ \| ____\ \/ / | ____|_  _| |_ ___ _ __  ___(_) ___  _ __  ___
| |_) |  _|  \  /  |  _| \ \/ / __/ _ \ '_ \/ __| |/ _ \| '_ \/ __|
|  _ <| |___ /  \  | |___ >  <| ||  __/ | | \__ \ | (_) | | | \__ \
|_| \_\_____/_/\_\ |_____/_/\_\\__\___|_| |_|___/_|\___/|_| |_|___/

Rex Kernel Extensions

CI Gentoo

Tabla de Contenidos

  • ¿Qué es Rex?
  • Programa de ejemplo
  • Compilar y ejecutar
  • Documentación
  • ¿Por qué Rex?
  • Licencia

¿Qué es Rex?

Rex es un marco de extensiones de kernel seguro y utilizable que permite cargar y ejecutar programas de extensión de kernel en Rust en lugar de eBPF. A diferencia de los marcos basados en eBPF como Aya, los programas de Rex no pasan por el verificador en-kernel; en cambio, los programas se implementan en el subconjunto seguro de Rust, sobre el cual el compilador de Rust realiza las comprobaciones de seguridad necesarias y genera código nativo directamente. Este enfoque evita los requisitos de verificación excesivamente restrictivos (por ejemplo, las restricciones de complejidad del programa) y los consiguientes errores de verificación arcana, al mismo tiempo que potencialmente ofrece una mejor oportunidad de optimización en el backend del compilador nativo (es decir, LLVM) que el enfoque backend eBPF + JIT en-kernel.

Rex actualmente soporta las siguientes características:

  • 5 tipos de programas eBPF: kprobe, perf_event, tracepoint, xdp y tc.
  • invocación de funciones auxiliares de eBPF que son comúnmente utilizadas por estos programas
  • interacción con mapas eBPF
  • gestión estilo RAII de recursos del kernel obtenibles por los programas
  • limpieza y manejo de excepciones en-kernel de pánicos en tiempo de ejecución de Rust con trazas de pila
  • pila del kernel (solo cuando CFG no se puede calcular estáticamente) y seguridad de terminación desde un tiempo de ejecución en-kernel ligero
  • enlaces y abstracciones de tipos de datos del kernel comúnmente necesarios por los programas eBPF

Programa de ejemplo

El siguiente ejemplo implementa un programa kprobe que se adjunta a una llamada al sistema seleccionada e inyecta un error (especificado por errno) en la llamada al sistema en un proceso (especificado por su pid). El ejemplo completo, incluyendo el programa cargador, se puede encontrar en samples/error_injector.

#![no_std]
#![no_main]

use rex::kprobe::kprobe;
use rex::map::RexHashMap;
use rex::pt_regs::PtRegs;
use rex::rex_kprobe;
use rex::rex_map;
use rex::Result;

#[allow(non_upper_case_globals)]
#[rex_map]
static pid_to_errno: RexHashMap<i32, u64> = RexHashMap::new(1, 0);

#[rex_kprobe]
pub fn err_injector(obj: &kprobe, ctx: &mut PtRegs) -> Result {
    obj.bpf_get_current_task()
        .map(|t| t.get_pid())
        .and_then(|p| obj.bpf_map_lookup_elem(&pid_to_errno, &p).cloned())
        .map(|e| obj.bpf_override_return(ctx, e))
        .ok_or(0)
}

Se pueden encontrar más programas de ejemplo en samples.

Compilar y ejecutar

Puede encontrar la guía detallada aquí.

Documentación

La documentación de diseño adicional se puede encontrar en docs.

¿Por qué Rex?

La extensión eBPF existente depende del verificador eBPF en-kernel para proporcionar garantías de seguridad. Esto desafortunadamente conduce a problemas de usabilidad donde programas seguros son rechazados por el verificador, incluyendo pero no limitándose a:

  • los programas pueden exceder las restricciones de complejidad inherentes de la verificación estática
  • los compiladores pueden no generar código compatible con el verificador
  • la misma lógica puede necesitar ser implementada de cierta manera para complacer al verificador

Rex tiene como objetivo abordar estos problemas aprovechando directamente la garantía de seguridad de Rust seguro. Los desarrolladores pueden implementar sus programas de cualquier manera que se pueda escribir en Rust seguro con pocas restricciones, y ya no necesitan preocuparse por la complejidad del programa, el generador de código, ni encontrar la forma (muchas veces contraintuitiva) de expresar la misma lógica para complacer al verificador.

Demostramos esto con la implementación de la Caché Memcached BPF (BMC), un programa de extensión de última generación para la aceleración de Memcached. Como un programa eBPF complejo, BMC se ve obligado a dividirse en varios componentes conectados por llamadas de cola BPF y utilizar implementaciones de bucles/ramas incómodas para complacer al verificador, que no son necesarias en su implementación en Rex.

Por ejemplo, mostramos el código en la lógica de invalidación de caché de BPF-BMC que busca un comando SET en la carga útil del paquete:

// Searches for SET command in payload
for (unsigned int off = 0;
     off < BMC_MAX_PACKET_LENGTH &&  payload + off + 1 <= data_end;
     off++) {
    if (set_found == 0 && payload[off] == 's' &&
        payload + off + 3 <= data_end && payload[off + 1] == 'e' &&
        payload[off + 2] == 't') {
            off += 3;
            set_found = 1;
    }
    ...
}

El código no solo introduce una restricción adicional en el bucle (off < BMC_MAX_PACKET_LENGTH) únicamente para pasar el verificador, sino que también emplea código repetitivo para verificar los extremos del paquete (data_end) y una lógica engorrosa para encontrar la cadena "set" en el paquete.

Ninguna de estas cargas es necesaria con el poder de Rust seguro en Rex, que no tiene límites de complejidad y proporciona más libertad en la implementación:

let set_iter = payload.windows(4).enumerate().filter_map(|(i, v)| {
    if v == b"set " {
      Some(i)
    } else {
      None
    }
});

La implementación completa de BMC en Rex se puede encontrar en samples/bmc.

Licencia

Rex está licenciado bajo la licencia GPLv2. Los submódulos (Linux, Rust, LLVM) en este repositorio están licenciados bajo sus propios términos. Consulte los archivos de licencia correspondientes para más detalles. Adicionalmente, el benchmark de memcached está licenciado bajo la licencia MIT.

Charlas

  • Open Source Summit North America 2025: https://youtu.be/4r7ECxEaGqM
  • USENIX ATC 2025: https://youtu.be/phJ-fb5lEA8
  • Linux Plumbers Conference 2025: https://youtu.be/ivcLS4LFfKE
Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    755
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    510
  • 3

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    415
  • 4

    redforge

    cybersecurity91/redforge

    Kit de herramientas de red team del lado del navegador con 102 herramientas offline para reconocimiento, generación de payloads, ataques de credenciales, criptografía, codificación y elaboración de informes de compromiso.

    343
  • 5

    antifox

    antifox-ai/antifox

    Plataforma de pruebas de penetración autónoma con múltiples agentes de IA que ejecuta reconocimiento, descubrimiento de superficie de ataque, validación de explotación y entrega de informes respaldados por evidencia.

    259
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    El sistema de acción para la ciberseguridad nativa de IA—donde la intención se convierte en ejecución gobernada, la evidencia se convierte en memoria operativa y cada operación mejora la siguiente.

    258

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →