Setup Fuzzing With A Basic Harness (#34)

Still incomplete, not all components are fuzzed, but still this PR contains some important fixes, so it's better to merge it soon.

* Setup Fuzzing With A Basic Harness

* Fix Script Path

* Fix Include For Windows

* Update Dockerfile.fuzz

* Update Dockerfile.fuzz

* Update fuzz.yml

* Update Dockerfile.fuzz

* Fuzz Dont Care About CoreDumps

* Fuzz Only With ASAN

* Docker Dont Ignore Tests Directory

* Fix Perms

* Try Again

* Try Again

* Try A Fix Again

* Cleanups

Author: brightprogrammer

.dockerignore

@@ -0,0 +1,37 @@
+# Exclude build artifacts and outputs from Docker build context
+Build/
+fuzz-outputs/
+*.o
+*.a
+*.so
+*.dylib
+*.exe
+*.dll
+
+# Exclude test outputs and logs
+meson-logs/
+meson-info/
+meson-private/
+meson-uninstalled/
+
+# Exclude documentation build artifacts
+Docs/
+*.md
+LICENSE*
+
+# Exclude CI/CD files
+.github/
+.git/
+.gitignore
+
+# Exclude editor and IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Exclude temporary files
+*.tmp
+*.temp
+*.log

.github/workflows/fuzz.yml

@@ -0,0 +1,118 @@
+name: AFL++ Fuzzing
+
+on:
+  push:
+    branches: [ master, develop ]
+  pull_request:
+    branches: [ master ]
+  schedule:
+    # Run fuzzing daily at 2 AM UTC
+    - cron: '0 2 * * *'
+  workflow_dispatch:
+
+jobs:
+  fuzz:
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+      
+    - name: Make fuzz-docker.sh executable
+      run: chmod +x Scripts/fuzz-docker.sh
+      
+    - name: Clean up previous fuzzing outputs
+      run: |
+        # Clean up any previous fuzzing outputs to avoid conflicts
+        rm -rf fuzz-outputs/*
+        echo "Cleaned up previous fuzzing outputs"
+        
+    - name: Run AFL++ fuzzing (with ASAN)
+      run: |
+        timeout 30m ./Scripts/fuzz-docker.sh || true
+        
+    - name: Fix permissions for artifact upload
+      run: |
+        # Fix ownership and permissions for fuzz outputs
+        if [ -d "fuzz-outputs" ]; then
+          # Change ownership to runner user
+          sudo chown -R runner:runner fuzz-outputs/
+          # Ensure proper permissions
+          chmod -R 755 fuzz-outputs/
+          # List contents to verify
+          echo "Fixed permissions for fuzz-outputs directory:"
+          ls -la fuzz-outputs/
+          # Check for new fuzzer directory structure
+          if [ -d "fuzz-outputs/fuzzer-asan" ]; then
+            echo "Contents of fuzz-outputs/fuzzer-asan:"
+            ls -la fuzz-outputs/fuzzer-asan/
+          fi
+          # Check for legacy directory structure
+          if [ -d "fuzz-outputs/default" ]; then
+            echo "Contents of fuzz-outputs/default:"
+            ls -la fuzz-outputs/default/
+          fi
+        else
+          echo "No fuzz-outputs directory found"
+        fi
+        
+    - name: Rename files with invalid characters for artifact upload
+      run: |
+        # Function to rename files with invalid characters
+        rename_files() {
+          local dir="$1"
+          if [ -d "$dir" ]; then
+            echo "Renaming files in $dir to remove invalid characters..."
+            find "$dir" -type f -name "*:*" -o -name "*\"*" -o -name "*<*" -o -name "*>*" -o -name "*|*" -o -name "*\**" -o -name "*\?*" | while read -r file; do
+              # Get directory and filename
+              dirname=$(dirname "$file")
+              filename=$(basename "$file")
+              # Replace invalid characters with underscores
+              new_filename=$(echo "$filename" | sed 's/[:<>|*"?]/_/g')
+              # Only rename if the filename actually changed
+              if [ "$filename" != "$new_filename" ]; then
+                new_path="$dirname/$new_filename"
+                echo "Renaming: $file -> $new_path"
+                mv "$file" "$new_path"
+              fi
+            done
+          fi
+        }
+        
+        # Rename files in fuzzing output directories
+        if [ -d "fuzz-outputs" ]; then
+          rename_files "fuzz-outputs/fuzzer-asan"
+          rename_files "fuzz-outputs/default"
+          echo "File renaming completed"
+        else
+          echo "No fuzz-outputs directory found for renaming"
+        fi
+          
+    - name: Check for crashes
+      run: |
+        echo "Checking for crashes in fuzzing results..."
+        
+        # Check AFL++ with ASAN results (using new fuzzer directory name)
+        if [ -d "fuzz-outputs/fuzzer-asan/crashes" ] && [ "$(ls -A fuzz-outputs/fuzzer-asan/crashes)" ]; then
+          echo "❌ Crashes found in AFL++ with ASAN:"
+          ls -la fuzz-outputs/fuzzer-asan/crashes/
+          exit 1
+        elif [ -d "fuzz-outputs/default/crashes" ] && [ "$(ls -A fuzz-outputs/default/crashes)" ]; then
+          echo "❌ Crashes found in AFL++ with ASAN (legacy directory):"
+          ls -la fuzz-outputs/default/crashes/
+          exit 1
+        else
+          echo "✅ No crashes found in AFL++ with ASAN"
+        fi
+        
+    - name: Upload fuzzing results
+      uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: fuzzing-results
+        path: fuzz-outputs/
+        retention-days: 7

.gitignore

@@ -10,3 +10,5 @@ Docs/
 Docs/public
 .DS_Store
 .venv
+fuzz-outputs
+Fuzz/outputs/

Bin/ElfInfo.c

@@ -331,12 +331,12 @@ typedef struct {
     "{>2r}" /* shnum */                                                                                                \
     "{>2r}" /* shstrndx */
 
-int main(int argc, char** argv) {
+int main(int argc, char **argv) {
     if (argc < 2) {
         LOG_FATAL("USAGE: {} {}", argv[0], argv[1]);
     }
 
-    FILE* elf = fopen(argv[1], "rb");
+    FILE *elf = fopen(argv[1], "rb");
     if (!elf) {
         LOG_ERROR("Failed to open file for reading.");
         return 1;

Bin/MisraDoc.c

@@ -24,7 +24,7 @@ typedef struct Project {
     Strs test_directories;
 } Project;
 
-void ProjectDeinit(Project* p) {
+void ProjectDeinit(Project *p) {
     if (!p) {
         LOG_ERROR("Invalid project object. Invalid arguments");
         abort();
@@ -94,15 +94,15 @@ void ProjectDeinit(Project* p) {
         obj_deinit(__o_b_j);                                                                                           \
     } while (0)
 
-int main(int argc, char** argv) {
+int main(int argc, char **argv) {
     if (argc != 2) {
         FWriteFmtLn(stderr, "USAGE : {} config.json", argc == 0 ? "MisraDoc" : argv[0]);
         return 1;
     }
 
     LogInit(false);
 
-    const char* config_path = argv[1];
+    const char *config_path = argv[1];
 
     Project project = {0};
     Scope(&project, ProjectDeinit, {
@@ -180,7 +180,7 @@ VecForeach(&file_paths, file_path) {
             Str md_code = StrInit();
             Scope(&md_code, StrDeinit, {
                 // Create template strings for StrWriteFmt with escaped braces
-                const char* mdHeader =
+                const char *mdHeader =
                     "---\n"
                     "title: \"{}\"\n"
                     "meta_title: \"{}\"\n"
@@ -209,7 +209,7 @@ VecForeach(&file_paths, file_path) {
 
 
                 // dump code to output path
-                FILE* f = fopen(output_path.data, "w");
+                FILE *f = fopen(output_path.data, "w");
                 Scope(f, fclose, { fwrite(md_code.data, 1, md_code.length, f); });
             });
         });

Bin/MisraEnum.c

@@ -32,16 +32,16 @@ typedef struct EnumEntry {
 
 typedef Vec(EnumEntry) EnumEntries;
 
-int main(int argc, char** argv) {
+int main(int argc, char **argv) {
     LogInit(false);
 
     if (argc < 2 || argc > 3) {
         FWriteFmtLn(stderr, "USAGE : {} <enum-json-spec> [output-file-name]", argc == 0 ? "MisraEnum" : argv[0]);
         return 1;
     }
 
-    const char* input_filename  = argv[1];
-    const char* output_filename = NULL;
+    const char *input_filename  = argv[1];
+    const char *output_filename = NULL;
     if (argc == 3) {
         output_filename = argv[3];
     }
@@ -126,7 +126,7 @@ int main(int argc, char** argv) {
 
     if (to_from_str) {
         // Store string literals in temporary variables
-        const char* funcHeader =
+        const char *funcHeader =
             "///\n"
             "/// Converts given zero-terminated string to {} enum value.\n"
             "///\n"
@@ -142,7 +142,7 @@ int main(int argc, char** argv) {
             "    }}\n";
 
         // Prepare the return value for invalid enum
-        const char* invalidEnumName = "0";
+        const char *invalidEnumName = "0";
         if (invalid_enum.name.length) {
             invalidEnumName = invalid_enum.name.data;
         }
@@ -151,16 +151,16 @@ int main(int argc, char** argv) {
 
         // Use VecForeach for iterating over entries
         VecForeach(&entries, e) {
-            const char* compareTemplate = "    if(ZstrCompareN(\"{}\", zstr, {}) == 0) {{return {};}}\n";
+            const char *compareTemplate = "    if(ZstrCompareN(\"{}\", zstr, {}) == 0) {{return {};}}\n";
             // Store the length in a variable to avoid taking address of rvalue
             unsigned long long strLength = (unsigned long long)e.str.length;
             StrWriteFmt(&code, compareTemplate, e.str.data, strLength, e.name.data);
         };
 
-        const char* returnTemplate = "    return {};\n}}\n";
+        const char *returnTemplate = "    return {};\n}}\n";
         StrWriteFmt(&code, returnTemplate, invalidEnumName);
 
-        const char* toZstrHeader =
+        const char *toZstrHeader =
             "///\n"
             "/// Converts given enum to {} zero-terminated string.\n"
             "///\n"
@@ -176,19 +176,19 @@ int main(int argc, char** argv) {
 
         // Use VecForeach for iterating over entries
         VecForeach(&entries, e) {
-            const char* caseTemplate = "        case {} : {{return \"{}\";}}\n";
+            const char *caseTemplate = "        case {} : {{return \"{}\";}}\n";
             StrWriteFmt(&code, caseTemplate, e.name.data, e.str.data);
         };
 
-        const char* defaultTemplate =
+        const char *defaultTemplate =
             "        default: break;\n"
             "    }}\n"
             "    return \"{}\";\n"
             "}}\n";
 
         // Use a static string for NULL to avoid taking address of string literal
-        const char* nullStrValue = "NULL";
-        const char* nullStr      = nullStrValue;
+        const char *nullStrValue = "NULL";
+        const char *nullStr      = nullStrValue;
         if (invalid_enum.str.data) {
             nullStr = invalid_enum.str.data;
         }
@@ -197,7 +197,7 @@ int main(int argc, char** argv) {
     }
 
     if (output_filename) {
-        FILE* f = fopen(output_filename, "w");
+        FILE *f = fopen(output_filename, "w");
         fwrite(code.data, 1, code.length, f);
         fclose(f);
     } else {

Bin/SubProcComm.c

@@ -4,9 +4,9 @@
 // the prgram writes something to child process and expect's the same thing echoed back
 // so it can be verified that we got the same content
 // executed like : Build/SubProcComm /bin/head -n 1
-int main(int argc, char** argv, char** envp) {
+int main(int argc, char **argv, char **envp) {
     // create a new child process
-    SysProc* proc = SysProcCreate(argv[1], argv + 1, envp);
+    SysProc *proc = SysProcCreate(argv[1], argv + 1, envp);
 
     // write something to it's stdout
     SysProcWriteToStdinFmtLn(proc, "value = {}", 42);