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
CVE-2026-7777-Rust-Use-After-Free-in-Unsafe-Web-Server — Demuestra un use-after-free en Rust en un servidor web con código vulnerable y un desencadenante multihilo para mostrar la corrupción de memoria y una posible ejecución de código. | Kitploit
Herramientas/GitHubGitHub/george0papasotiriou/cve-2026-7777-rust-use-after-free-in-unsafe-web-server
Análisis de VulnerabilidadesExplotaciónAprendizaje y EducaciónExplotación de BinariosLabs y Práctica
GitHubgeorge0papasotiriou/cve-2026-7777-rust-use-after-free-in-unsafe-web-server

CVE-2026-7777-Rust-Use-After-Free-in-Unsafe-Web-Server

Demuestra un use-after-free en Rust en un servidor web con código vulnerable y un desencadenante multihilo para mostrar la corrupción de memoria y una posible ejecución de código.

Ver Repositorio
32hace 3 mesesAún no revisado

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.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    634
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingiere informes de Shadowserver en MongoDB y los reproduce como mapas interactivos, análisis, hallazgos, avisos y paneles ejecutivos.

    417
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer es una plataforma de gestión de accesos privilegiados (PAM) de código abierto que proporciona a los equipos de DevOps y TI acceso seguro y bajo demanda a endpoints SSH, RDP, Kubernetes, base de datos y RemoteApp a través de un navegador web.

    383
  • 5

    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.

    328
  • 6

    SafeLine

    chaitin/safeline

    Proxy inverso y WAF autoalojado que filtra tráfico HTTP malicioso, bloquea inyecciones SQL, XSS y ataques de bots, con limitación de velocidad y cifrado dinámico de HTML/JS.

    288

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Compartir

CVE-2026-7777 – Use-After-Free en Rust en un servidor web inseguro

Código del programa (Rust)

// uaf_server.rs - Vulnerable Rust HTTP server with use-after-free
use std::sync::{Arc, Mutex};
use std::thread;
use std::io::prelude::*;
use std::net::{TcpListener, TcpStream};

struct SharedBuffer {
    data: Vec<u8>,
}

impl SharedBuffer {
    fn new() -> Self { SharedBuffer { data: vec![0; 1024] } }
}

fn handle_client(mut stream: TcpStream, buffer: Arc<Mutex<SharedBuffer>>) {
    // Simulate reading request and writing response.
    let mut buf = [0; 512];
    stream.read(&mut buf).unwrap();
    let b = buffer.lock().unwrap();
    let ptr = b.data.as_ptr() as *mut u8; // raw pointer
    // Drop the lock early? In unsafe block we might send the pointer to another thread.
    // Here we simulate a bug: the SharedBuffer is dropped, but we later use the pointer.
    drop(b);
    // After lock is released, another thread could replace the Vec, freeing the old allocation.
    // Unsafe write through the dangling pointer.
    unsafe {
        *ptr = 42; // use after free!
    }
    stream.write(b"HTTP/1.1 200 OK\r\n\r\nHello").unwrap();
}

fn main() {
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
    let buffer = Arc::new(Mutex::new(SharedBuffer::new()));
    for stream in listener.incoming() {
        let stream = stream.unwrap();
        let buf_clone = Arc::clone(&buffer);
        thread::spawn(move || {
            handle_client(stream, buf_clone);
        });
    }
}

CVE-2026-7777 – Use-After-Free inseguro en Rust en un servidor web

Severity: High

Descripción general

Un servidor web en Rust usa código inseguro para compartir un búfer entre hilos. Una condición de carrera provoca un use-after-free, lo que potencialmente causa corrupción de memoria o divulgación de información.

Detalles de la vulnerabilidad

  • Tipo: Use-After-Free (seguridad de memoria)
  • Impacto: Denegación de servicio, posible ejecución arbitraria de código.
  • Causa raíz: Se obtiene un puntero crudo de un Vec bajo un bloqueo, se libera el bloqueo y otro hilo reemplaza el vector, liberando la memoria mientras el puntero sigue en uso.

Demostración del exploit

  1. Compila y ejecuta el servidor vulnerable:
    rustc uaf_server.rs
    ./uaf_server
    
  2. Ejecuta el desencadenador multihilo:
    python trigger_uaf.py
    
Descargar herramienta