Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
cuFuzz — Un fuzzer orientato alla GPU e guidato dalla copertura del codice per applicazioni CUDA in spazio utente. | Kitploit
Strumenti/GitHubGitHub/nvlabs/cufuzz
Analisi delle VulnerabilitàFuzzingAnalisi di Binari
GitHubnvlabs/cufuzz

cuFuzz

Un fuzzer orientato alla GPU e guidato dalla copertura del codice per applicazioni CUDA in spazio utente.

Vedi Repository
397402 mesi faRevisionato da Kitploit
Condividi

cuFuzz

Questo repository contiene gli artefatti per cuFuzz, un fuzzer orientato alla GPU e guidato dalla copertura per applicazioni CUDA in spazio utente. cuFuzz combina la raccolta della copertura lato host e lato device con la sanitizzazione per scoprire efficacemente bug nei programmi CUDA.

Panoramica

Struttura del repository

cufuzz-artifacts/
├── src/                        # Core cuFuzz components
│   ├── cufuzz_cov_nvbit/       # NVBit-based device-side coverage collection tool
│   └── cufuzz_sand/            # Sanitizer wrappers for SAND integration
├── targets/                    # Example fuzzing targets
│   └── sampleApp/              # Simple CUDA app with intentional bug for testing
├── scripts/                    # Evaluation and analysis scripts
├── Tools/                      # External dependencies
│   ├── AFLplusplus/            # AFL++ fuzzer (git submodule)
│   └── AFLplusplus.patch       # cuFuzz patches for AFL++
├── third-party-licenses/       # Third-party license files
│   ├── LICENSE_from_aflplusplus  # AFL++ Apache 2.0 license
│   └── LICENSE_from_nvbit        # NVBit NVIDIA EULA
├── images/                     # Documentation images
├── build.sh                    # Automated build script
├── verify_build.sh             # Quick verification test
├── Dockerfile                  # Docker container definition
├── LICENSE                     # Apache License 2.0
└── CONTRIBUTING.md             # Contribution guidelines and DCO

Requisiti

Requisiti hardware

cuFuzz è stato testato sulla seguente configurazione hardware:

ComponenteSpecifica
GPUNVIDIA A40 (48GB VRAM, Compute Capability 8.6)
CPUIntel Xeon Platinum 8362 (64 core, 2 thread/core)
Memoria120GB+ di RAM consigliati
Archiviazione50GB+ di spazio libero per l'immagine Docker e gli output del fuzzing

Altre GPU: cuFuzz dovrebbe funzionare su altre GPU NVIDIA con Compute Capability ≥ 7.0. Regola la variabile d'ambiente GPU_ARCH di conseguenza (vedi Configurazione dell'architettura GPU).

Requisiti software

ComponenteVersione
Ubuntu22.04 LTS
NVIDIA Driver570.144 o compatibile
CUDA Toolkit12.9
Docker20.10+ (consigliato)
nvidia-container-toolkitNecessario per il supporto del flag --gpus
clang14

Avvio rapido: istruzioni Docker

Il modo più rapido per provare cuFuzz è utilizzare un container Docker. Il nostro Dockerfile utilizza l'immagine di sviluppo ufficiale NVIDIA CUDA 12.9.

1. Estrarre l'artefatto e configurare AFL++

tar -xzvf cufuzz-artifacts.tar.gz
cd cufuzz-artifacts

# Clone AFL++ (required dependency)
git clone https://github.com/AFLplusplus/AFLplusplus.git Tools/AFLplusplus
cd Tools/AFLplusplus
git checkout 9cac7ced05eb9f36c1d0b02ad594b3b09cd3938b
cd ../..

2. Creare l'immagine Docker

Crea l'immagine Docker specificando la tua architettura GPU:

sudo docker build --build-arg GPU_ARCH=<your_arch> -t cufuzz .

Riferimento delle architetture GPU:

Famiglia GPUArchitetturaEsempi
Ampere (Data Center)sm_80A100
Ampere (Consumer/Pro)sm_86A40, RTX 3090, RTX 3060
Hoppersm_90H100
Ada Lovelacesm_89RTX 4090, L40
Turingsm_75RTX 2080, T4

Per un elenco completo, vedi: https://developer.nvidia.com/cuda-gpus

Esempio per A40/RTX 3090:

sudo docker build --build-arg GPU_ARCH=sm_86 -t cufuzz .

Nota: Questo passaggio potrebbe richiedere diversi minuti a seconda della tua macchina e della connessione di rete.

3. Eseguire il container Docker

sudo docker run --rm --gpus all -it -v /:/my_workspace cufuzz bash

4. Verificare l'installazione

Una volta che il container Docker è in esecuzione, verifica la build:

root@container:~/cufuzz# ./verify_build.sh

Istruzioni dettagliate per la build (senza Docker)

Prerequisiti

Installa le dipendenze richieste su Ubuntu 22.04:

apt-get update && apt-get install -y build-essential python3-dev automake cmake git flex \
    bison libglib2.0-dev libpixman-1-dev python3-setuptools cargo libgtk-3-dev lld llvm llvm-dev \
    clang ninja-build cpio libcapstone-dev wget curl python3-pip vim less libxxhash-dev bc zlib1g-dev

Impostare l'architettura GPU

Imposta la variabile d'ambiente GPU_ARCH per la tua GPU (vedi la tabella delle architetture sopra):

export GPU_ARCH=sm_86  # Change to match your GPU

Compilare AFL++

cd Tools/AFLplusplus 
patch -N -p1 < ../AFLplusplus.patch 
export CXX=/usr/bin/clang++-14 
export CC=/usr/bin/clang-14
make -j8 &> build.log

Compilare lo strumento di copertura NVBit

Scarica NVBit versione 1.7.5:

mkdir -p Tools/NVBit
wget https://github.com/NVlabs/NVBit/releases/download/v1.7.5/nvbit-Linux-x86_64-1.7.5.tar.bz2
tar -xvf nvbit-Linux-x86_64-1.7.5.tar.bz2 
mv nvbit_release_x86_64/* Tools/NVBit/
rm -rf nvbit_release_x86_64 nvbit-Linux-x86_64-1.7.5.tar.bz2

Compila il nostro strumento di copertura NVBit:

cd src/cufuzz_cov_nvbit/
export GPU_ARCH=sm_86  # Adjust for your GPU
ARCH=$GPU_ARCH make 

Compilare i wrapper dei sanitizer

cd src/cufuzz_sand
AFL_SAN_NO_INST=1 ../../Tools/AFLplusplus/afl-clang-fast -O2 wrapper_san.c -o wrapper_memcheck.out 
AFL_SAN_NO_INST=1 ../../Tools/AFLplusplus/afl-clang-fast -DSAN_MODE_INIT -O2 wrapper_san.c -o wrapper_initcheck.out 
AFL_SAN_NO_INST=1 ../../Tools/AFLplusplus/afl-clang-fast -DSAN_MODE_RACE -O2 wrapper_san.c -o wrapper_racecheck.out
AFL_SAN_NO_INST=1 ../../Tools/AFLplusplus/afl-clang-fast -DSAN_MODE_ASAN -O2 wrapper_san.c -o wrapper_asan.out

Utilizzo

Dopo aver compilato cuFuzz, avvia il fuzzing usando il seguente comando:

CUFUZZ_MAP_SIZE=65536 AFL_SKIP_CPUFREQ=1 AFL_PRELOAD=/PATH/TO/cufuzz_cov.so \
    ./Tools/AFLplusplus/afl-fuzz -x sample.dict -i input_samples/ -o output_dir/ \
    -t 1000000 ./cuda_app.out @@

Variabili d'ambiente di cuFuzz

Variabili standard di AFL++

VariabileDescrizioneEsempio
AFL_SKIP_CPUFREQSalta il controllo della policy di scaling della CPUAFL_SKIP_CPUFREQ=1
AFL_PRELOADPercorso dello strumento di copertura NVBitAFL_PRELOAD=/path/to/cufuzz_cov.so

Variabili di copertura di cuFuzz

VariabileDescrizioneEsempio
CUFUZZ_MAP_SIZEDimensione della mappa di copertura in byteCUFUZZ_MAP_SIZE=65536
COV_PERSISTENTAbilita il supporto alla modalità persistente di AFL (0=no, 1=sì)COV_PERSISTENT=1
GPU_ARCHArchitettura GPU di destinazione per le buildGPU_ARCH=sm_86

Variabili di sanitizzazione di cuFuzz

VariabileDescrizioneEsempio
ORIGINAL_APPPercorso dell'applicazione vanilla (non strumentata)ORIGINAL_APP=./cuda_app
SANITIZER_PATHPercorso del binario compute-sanitizerSANITIZER_PATH=/usr/local/cuda/bin/compute-sanitizer
SANITIZER_ARGArgomenti per il sanitizer memcheckSANITIZER_ARG="--tool=memcheck --error-exitcode 99"
SANITIZER_ARG_RACEArgomenti per il sanitizer racecheckSANITIZER_ARG_RACE="--tool=racecheck --error-exitcode 99"
SANITIZER_ARG_INITArgomenti per il sanitizer initcheckSANITIZER_ARG_INIT="--tool=initcheck --error-exitcode 99"

Modalità di AFL_SAN_ABSTRACTION

La variabile AFL_SAN_ABSTRACTION controlla quali input vengono inviati ai sanitizer:

Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    708
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    500
  • 3

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    398
  • 4

    redforge

    cybersecurity91/redforge

    Toolkit red team lato browser con 102 strumenti offline per ricognizione, generazione di payload, attacchi alle credenziali, crittografia, codifica e reportistica dell'engagement.

    341
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Il sistema d'azione per la cybersecurity nativa AI—dove l'intento diventa esecuzione governata, le evidenze diventano memoria operativa, e ogni operazione migliora la successiva.

    259
  • 6

    antifox

    antifox-ai/antifox

    Piattaforma multi-agente di penetration testing autonoma basata sull'IA che esegue ricognizione, scoperta della superficie d'attacco, validazione dello sfruttamento e consegna di report supportati da evidenze.

    257

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →