Secure Coding Through Life's Lens

/** * SecureLifeAnalogy.cpp *  * A metaphorical exploration of how security principles apply to everyday life, * written as a way to help developers understand security mindsets. *  * Demonstrates how defensive thinking applies both to code and life. *  * Author: Security Expert */#include <iostream>#include <vector>#include <string>#include <memory>#include <random>#include <chrono>#include <algorithm>#include <stdexcept>class LifeDecision {private:    std::string decision_context;    int risk_level; // 1-10 scale    bool validated;        // Simulating entropy source for decision randomness    std::mt19937 rng;        // Validate input before processing - classic security principle    bool validateInput(const std::string& input) {        // Check for empty input - null check in real code        if (input.empty()) {            std::cerr << "[VALIDATION ERROR] Empty context provided" << std::endl;            return false;        }                // Check for overly long input - buffer overflow prevention in real code        if (input.length() > 1000) {            std::cerr << "[VALIDATION ERROR] Input too long, possible overflow attack" << std::endl;            return false;        }                // Check for potentially dangerous content - injection prevention in real code        if (input.find(";") != std::string::npos ||             input.find("--") != std::string::npos) {            std::cerr << "[VALIDATION ERROR] Potentially malicious input detected" << std::endl;            return false;        }                return true;    }public:    LifeDecision(const std::string& context, int risk) :         decision_context(""),         risk_level(0),        validated(false),        rng(std::chrono::steady_clock::now().time_since_epoch().count()) {                // Always validate before assigning - classic secure coding pattern        validated = validateInput(context);        if (validated) {            decision_context = context;            // Bound check risk level - range validation            risk_level = std::max(1, std::min(10, risk));        }    }        bool makeDecision() {        // Fail closed - default secure position        if (!validated) {            std::cerr << "[SECURITY ERROR] Cannot make decision with unvalidated context" << std::endl;            return false;        }                // Calculate risk threshold based on risk level        // Higher risk = higher threshold to approve        int threshold = 50 + (risk_level * 5);                // Generate random number for decision        std::uniform_int_distribution<int> dist(1, 100);        int random_value = dist(rng);                // Decision logic with audit trail - logging in real security systems        std::cout << "[DECISION AUDIT] Context: " << decision_context << std::endl;        std::cout << "[DECISION AUDIT] Risk Level: " << risk_level << "/10" << std::endl;        std::cout << "[DECISION AUDIT] Approval Threshold: " << threshold << "%" << std::endl;        std::cout << "[DECISION AUDIT] Random Value: " << random_value << std::endl;                return random_value > threshold;    }};class SecureLifeAnalogy {private:    std::vector<std::unique_ptr<LifeDecision>> decisions;        // Principle of least privilege - each method does only what it needs    void explainSecurityMindset() {        std::cout << "\n=== THE SECURITY MINDSET IN LIFE ===" << std::endl;        std::cout << "1. Trust nothing, verify everything" << std::endl;        std::cout << "2. Assume hostile environment" << std::endl;        std::cout << "3. Defense in depth - multiple layers of protection" << std::endl;        std::cout << "4. Fail closed - default to safety" << std::endl;        std::cout << "5. Principle of least privilege" << std::endl;    }    public:    void run() {        explainSecurityMindset();                try {            // Safe object creation with smart pointers - memory safety            decisions.push_back(std::make_unique<LifeDecision>("Clicking an email link", 8));            decisions.push_back(std::make_unique<LifeDecision>("Sharing personal info with friend", 4));            decisions.push_back(std::make_unique<LifeDecision>("Using public WiFi", 7));            decisions.push_back(std::make_unique<LifeDecision>("Reusing a password", 9));            decisions.push_back(std::make_unique<LifeDecision>("", 5)); // Should fail validation                        std::cout << "\n=== LIFE DECISIONS THROUGH SECURITY LENS ===" << std::endl;                        // Process each decision safely            for (const auto& decision : decisions) {                bool result = decision->makeDecision();                std::cout << "Decision result: " << (result ? "APPROVED" : "DENIED") << "\n" << std::endl;            }                    } catch (const std::exception& e) {            // Exception handling - error management in secure systems            std::cerr << "[CRITICAL ERROR] " << e.what() << std::endl;        }    }};int main() {    SecureLifeAnalogy secureLife;    secureLife.run();    return 0;}