/*
 * buffer_overflow_example.cpp
 * Demonstrates a classic C-style buffer overflow vulnerability.
 * Compile with: g++ -o overflow_example buffer_overflow_example.cpp
 */

#include <iostream>
#include <cstring> // For strcpy

// Function susceptible to buffer overflow
void process_input(const char* input)
{
    // Declare a fixed-size buffer on the stack
    char buffer[16]; 
    
    // Copy input to buffer without boundary checks
    // If strlen(input) >= 16, this will cause a buffer overflow
    strcpy(buffer, input);
    
    std::cout << "Processed: " << buffer << std::endl;
}

int main()
{
    // Scenario 1: Safe input
    std::cout << "--- Safe Input ---" << std::endl;
    process_input("short string"); 

    // Scenario 2: Vulnerable input - this will overflow 'buffer'
    // The exact behavior (crash, corrupted data) depends on OS, compiler, etc.
    std::cout << "\n--- Vulnerable Input (DO NOT RUN IN PRODUCTION) ---" << std::endl;
    process_input("this is a very very long string that will definitely overflow the buffer");

    // The program might crash here or continue with corrupted stack data.
    std::cout << "Program finished (may not be reached if crash occurred)." << std::endl;

    return 0;
}

/*
 * Example demonstrating how to invoke Clang-Tidy for static analysis.
 * This assumes clang-tidy is installed and in your PATH.
 *
 * To run this:
 * 1. Save the vulnerable code from the previous step as 'overflow_example.cpp'.
 * 2. Open a terminal in the same directory.
 * 3. Execute the clang-tidy command below.
 *
 * Command Line Invocation (Linux/macOS):
 * clang-tidy overflow_example.cpp -- -std=c++11
 *
 * For more detailed checks and specific warnings, consider:
 * clang-tidy overflow_example.cpp --checks='-*,cert-err58-cpp,bugprone-*,cert-str34-c' -- -std=c++11
 *
 * Explanation of checks:
 *   - '*': disable all default checks initially.
 *   - 'cert-err58-cpp': detects issues related to C-style arrays being passed to functions that might assume ownership.
 *   - 'bugprone-*': a meta-check that includes various bug-prone patterns, often catching bad string usage.
 *   - 'cert-str34-c': specifically flags usages of unsafe string functions like strcpy, strcat, sprintf.
 *
 * Note: The '--' separates clang-tidy options from compiler options (like -std=c++11).
 * For a full project, integration with CMake or build systems is recommended.
 */

// A minimal CMakeLists.txt for larger projects to integrate clang-tidy:
// cmake_minimum_required(VERSION 3.0)
// project(LegacyCodeAudit CXX)

// set(CMAKE_CXX_CLANG_TIDY "clang-tidy;-checks=*")
// add_executable(overflow_example overflow_example.cpp)

// Then build with: cmake -DCMAKE_CXX_CLANG_TIDY="clang-tidy" . && make

/*
 * asan_example.cpp
 * Demonstrates compiling and running with AddressSanitizer (ASan).
 * This requires a recent version of GCC or Clang.
 *
 * To compile:
 * g++ -fsanitize=address -g -O1 -o asan_overflow asan_overflow.cpp
 * (or clang++ -fsanitize=address -g -O1 -o asan_overflow asan_overflow.cpp)
 *
 * -fsanitize=address: Activates AddressSanitizer.
 * -g: Include debug information for better stack traces.
 * -O1: Recommended optimization level for ASan (higher might obscure some bugs, lower might impact performance too much).
 *
 * To run (and trigger the overflow):
 * ./asan_overflow
 */

#include <iostream>
#include <cstring> // For strcpy
#include <vector>

// Function with a buffer overflow vulnerability
void vulnerable_function()
{
    char buffer[10];
    // This input will overflow the 10-byte buffer
    const char* long_input = "AAAAAAAAAABBBBBBBBBBCCCCCCCCCC"; 

    // ASan will detect this overflow at runtime
    strcpy(buffer, long_input); 

    std::cout << "Buffer content: " << buffer << std::endl;
}

// Function with a use-after-free (another memory error ASan catches)
void use_after_free_example()
{
    int* ptr = new int[5];
    delete[] ptr;
    // ASan will detect this use-after-free
    // *ptr = 123; 

    // To demonstrate a simple out-of-bounds write on a std::vector (ASan also catches this)
    std::vector<int> vec(5);
    // vec[5] = 10; // This will trigger an ASan report for out-of-bounds access
}

int main()
{
    std::cout << "Starting vulnerable function..." << std::endl;
    vulnerable_function();
    std::cout << "Vulnerable function finished.\n" << std::endl;

    // Uncomment to test use-after-free or vector out-of-bounds
    // std::cout << "Starting use-after-free example..." << std::endl;
    // use_after_free_example();
    // std::cout << "Use-after-free example finished.\n" << std::endl;

    return 0;
}

/*
 * secure_code_example.cpp
 * Demonstrates secure string and array handling in modern C++
 * compared to vulnerable C-style approaches.
 * Compile with: g++ -o secure_example secure_code_example.cpp -std=c++11
 */

#include <iostream>
#include <string>
#include <vector>
#include <array> // For std::array

// Use std::string for dynamic text management
void process_string_secure(const std::string& input)
{
    std::string safe_buffer = ""; // Starts empty, resizes dynamically
    if (input.length() < 256) { // Optional: enforce max size for very large inputs
        safe_buffer = input;    
    } else {
        safe_buffer = input.substr(0, 255); // Truncate if too long
        std::cerr << "Warning: Input truncated to 255 characters." << std::endl;
    }
    std::cout << "Processed secure string: " << safe_buffer << std::endl;
}

// Use std::vector for dynamic arrays
void process_vector_secure(const std::vector<int>& data)
{
    std::vector<int> safe_vector;
    // Copying elements safely, std::vector handles resizing
    safe_vector.assign(data.begin(), data.end()); 

    // Access with .at() for bounds checking (throws std::out_of_range)
    if (!safe_vector.empty()) {
        std::cout << "First element: " << safe_vector.at(0) << std::endl;
    }
}

// Use std::array for fixed-size arrays with bounds checking
void process_array_secure(const int input_array[], size_t input_size)
{
    std::array<int, 10> fixed_buffer; // Fixed size, stack allocated

    // Manual copy with explicit bounds checking
    for (size_t i = 0; i < fixed_buffer.size() && i < input_size; ++i) {
        fixed_buffer[i] = input_array[i];
    }
    
    // Accessing an element within bounds (no overflow possible with [] here, but .at() is safer)
    if (fixed_buffer.size() > 0) {
        std::cout << "First element of std::array: " << fixed_buffer[0] << std::endl;
    }

    // Example of using .at() for bounds-checked access (throws if out-of-range)
    // try {
    //     fixed_buffer.at(10) = 5; // This would throw std::out_of_range
    // } catch (const std::out_of_range& e) {
    //     std::cerr << "Error: " << e.what() << std::endl;
    // }
}

int main()
{
    // --- std::string Example ---
    std::cout << "--- std::string Example ---" << std::endl;
    process_string_secure("Hello, secure world!");
    process_string_secure("This is a considerably longer string designed to demonstrate truncation behavior of the secure string processing function if it exceeds a predefined maximum length, showcasing how robust designs handle excessive inputs.");

    // --- std::vector Example ---
    std::cout << "\n--- std::vector Example ---" << std::endl;
    std::vector<int> data = {1, 2, 3, 4, 5};
    process_vector_secure(data);

    // --- std::array Example ---
    std::cout << "\n--- std::array Example ---" << std::endl;
    int raw_array[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120};
    process_array_secure(raw_array, sizeof(raw_array) / sizeof(raw_array[0]));

    return 0;
}

/*
 * modernized_cxx_example.cpp
 * Illustrates modern C++ approaches for string and array management
 * that inherently prevent buffer overflows.
 * Compile with: g++ -o modern_example modernized_cxx_example.cpp -std=c++17
 */

#include <iostream>
#include <string>
#include <vector>
#include <array>
#include <numeric> // For std::iota

// Modern C++ function accepting std::string_view for efficiency
void process_string_view(std::string_view input_view)
{
    // std::string_view is non-owning, efficient for read-only access.
    // Convert to std::string if modification is needed.
    std::string data(input_view);

    // std::string handles its own memory and grows as needed.
    std::cout << "Processed string_view: " << data << " (length: " << data.length() << ")" << std::endl;
}

// Modern C++ function utilizing std::vector for dynamic data
void process_vector_data(const std::vector<int>& numbers)
{
    // Iterate safely, range-based for loops prevent out-of-bounds indexing.
    std::cout << "Vector elements: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // Accessing elements with bounds checking (std::vector::at())
    if (!numbers.empty()) {
        std::cout << "First element via .at(): " << numbers.at(0) << std::endl;
    }
}

// Modern C++ function utilizing std::array for fixed-size data
void process_array_data(const std::array<double, 5>& values)
{
    std::cout << "Array elements: ";
    for (double val : values) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    // Accessing elements with bounds checking (std::array::at())
    if (values.size() > 2) {
        std::cout << "Third element via .at(): " << values.at(2) << std::endl;
    }
}

int main()
{
    std::cout << "--- Modern C++ String Processing (std::string_view) ---" << std::endl;
    std::string text = "Hello, C++20!";
    process_string_view(text);
    process_string_view("Short literal");

    std::cout << "\n--- Modern C++ Vector Processing (std::vector) ---" << std::endl;
    std::vector<int> my_vector(10);
    std::iota(my_vector.begin(), my_vector.end(), 100); // Fills with 100, 101, ...
    process_vector_data(my_vector);

    std::cout << "\n--- Modern C++ Array Processing (std::array) ---" << std::endl;
    std::array<double, 5> my_array = {1.1, 2.2, 3.3, 4.4, 5.5};
    process_array_data(my_array);

    // Demonstrate what happens with unsafe C-style: (not recommended for production)
    // char legacy_buffer[5];
    // strcpy(legacy_buffer, "Too long!"); // This would cause overflow, ASan would catch this.

    return 0;
}