cuFuzz

इस रिपॉजिटरी में cuFuzz के आर्टिफैक्ट्स शामिल हैं, जो यूज़रलैंड CUDA अनुप्रयोगों के लिए एक GPU-उन्मुख कवरेज-निर्देशित फ़ज़र है। cuFuzz होस्ट-साइड और डिवाइस-साइड कवरेज संग्रह को सैनिटाइज़ेशन के साथ जोड़ता है ताकि CUDA प्रोग्रामों में बग्स को प्रभावी ढंग से खोजा जा सके।

रिपॉजिटरी संरचना

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

आवश्यकताएँ

हार्डवेयर आवश्यकताएँ

cuFuzz का परीक्षण निम्नलिखित हार्डवेयर कॉन्फ़िगरेशन पर किया गया था:

घटक	विनिर्देश
GPU	NVIDIA A40 (48GB VRAM, Compute Capability 8.6)
CPU	Intel Xeon Platinum 8362 (64 cores, 2 threads/core)
मेमोरी	120GB+ RAM अनुशंसित
स्टोरेज	Docker इमेज और फ़ज़िंग आउटपुट के लिए 50GB+ खाली स्थान

अन्य GPU: cuFuzz कंप्यूट क्षमता ≥ 7.0 वाले अन्य NVIDIA GPU पर काम करना चाहिए। GPU_ARCH पर्यावरण चर को तदनुसार समायोजित करें (देखें GPU आर्किटेक्चर कॉन्फ़िगरेशन)।

सॉफ़्टवेयर आवश्यकताएँ

घटक	संस्करण
Ubuntu	22.04 LTS
NVIDIA ड्राइवर	570.144 या संगत
CUDA टूलकिट	12.9
Docker	20.10+ (अनुशंसित)
nvidia-container-toolkit	--gpus फ़्लैग समर्थन के लिए आवश्यक
clang	14

त्वरित आरंभ: Docker निर्देश

cuFuzz को आज़माने का सबसे तेज़ तरीका Docker कंटेनर का उपयोग करना है। हमारा Dockerfile आधिकारिक NVIDIA CUDA 12.9 डेवलपमेंट इमेज का उपयोग करता है।

1. आर्टिफैक्ट निकालें और 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. Docker इमेज बनाएं

अपने GPU आर्किटेक्चर को निर्दिष्ट करते हुए Docker इमेज बनाएं:

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

GPU आर्किटेक्चर संदर्भ:

GPU परिवार	आर्किटेक्चर	उदाहरण
Ampere (डेटा सेंटर)	sm_80	A100
Ampere (कंज़्यूमर/प्रो)	sm_86	A40, RTX 3090, RTX 3060
Hopper	sm_90	H100
Ada Lovelace	sm_89	RTX 4090, L40
Turing	sm_75	RTX 2080, T4

पूरी सूची के लिए देखें: https://developer.nvidia.com/cuda-gpus

A40/RTX 3090 के लिए उदाहरण:

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

नोट: यह चरण आपकी मशीन और नेटवर्क कनेक्शन के आधार पर कई मिनट ले सकता है।

3. Docker कंटेनर चलाएं

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

4. इंस्टॉलेशन सत्यापित करें

Docker कंटेनर चलने के बाद, बिल्ड सत्यापित करें:

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

विस्तृत बिल्ड निर्देश (Docker के बिना)

पूर्वापेक्षाएँ

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

GPU आर्किटेक्चर सेट करें

अपने GPU के लिए GPU_ARCH पर्यावरण चर सेट करें (ऊपर आर्किटेक्चर तालिका देखें):

export GPU_ARCH=sm_86  # Change to match your GPU

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

NVBit कवरेज टूल बनाएं

NVBit संस्करण 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

हमारा NVBit कवरेज टूल बनाएं:

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

सैनिटाइज़र रैपर बनाएं

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

उपयोग

cuFuzz बनाने के बाद, निम्नलिखित कमांड का उपयोग करके फ़ज़िंग चलाएँ:

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 @@

cuFuzz पर्यावरण चर

AFL++ मानक वेरिएबल

वेरिएबल	विवरण	उदाहरण
AFL_SKIP_CPUFREQ	CPU स्केलिंग पॉलिसी जाँच छोड़ें	AFL_SKIP_CPUFREQ=1
AFL_PRELOAD	NVBit कवरेज टूल का पथ	AFL_PRELOAD=/path/to/cufuzz_cov.so

cuFuzz कवरेज वेरिएबल

वेरिएबल	विवरण	उदाहरण
CUFUZZ_MAP_SIZE	कवरेज मैप का आकार बाइट्स में	CUFUZZ_MAP_SIZE=65536
COV_PERSISTENT	AFL पर्सिस्टेंट मोड समर्थन सक्षम करें (0=नहीं, 1=हाँ)	COV_PERSISTENT=1
GPU_ARCH	बिल्ड के लिए लक्षित GPU आर्किटेक्चर	GPU_ARCH=sm_86

cuFuzz सैनिटाइज़ेशन वेरिएबल

वेरिएबल	विवरण	उदाहरण
ORIGINAL_APP	वैनिला (अनइंस्ट्रूमेंटेड) एप्लिकेशन का पथ	ORIGINAL_APP=./cuda_app
SANITIZER_PATH	compute-sanitizer बाइनरी का पथ	SANITIZER_PATH=/usr/local/cuda/bin/compute-sanitizer
SANITIZER_ARG	memcheck सैनिटाइज़र के लिए तर्क	SANITIZER_ARG="--tool=memcheck --error-exitcode 99"
SANITIZER_ARG_RACE	racecheck सैनिटाइज़र के लिए तर्क	SANITIZER_ARG_RACE="--tool=racecheck --error-exitcode 99"
SANITIZER_ARG_INIT	initcheck सैनिटाइज़र के लिए तर्क	SANITIZER_ARG_INIT="--tool=initcheck --error-exitcode 99"

AFL_SAN_ABSTRACTION मोड

AFL_SAN_ABSTRACTION वेरिएबल नियंत्रित करता है कि सैनिटाइज़र को कौन से इनपुट दिए जाएँ:

मान	विवरण	संवेदनशीलता	प्रदर्शन
all_trace	सैनिटाइज़र को सभी इनपुट दें	सर्वोच्च	सबसे धीमा
simplify_trace	अद्वितीय निष्पादन पथ वाले इनपुट दें	उच्च	संतुलित
unique_trace	अद्वितीय कवरेज सिग्नेचर वाले इनपुट दें	मध्यम	तेज़
coverage_increase	केवल कवरेज वृद्धि का कारण बनने वाले इनपुट दें	न्यूनतम	सबसे तेज़

अनुशंसित: AFL_SAN_ABSTRACTION=simplify_trace (डिफ़ॉल्ट)

उदाहरण

बेसिक मोड