┌─────────────────────────────────────────────────────────────────────────────┐
│                    SMART CONTRACT VULNERABILITY CATEGORIES                  │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. EXECUTION VULNERABILITIES                                              │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Reentrancy – recursive call before state update                   │   │
│  │ • Unchecked external calls – relying on untrusted contract return   │   │
│  │ • Denial of Service (DoS) – blocking contract operations           │   │
│  │ • Gas limitations – out-of-gas errors, loops                       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  2. LOGIC VULNERABILITIES                                                  │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Access control – missing or insufficient checks                 │   │
│  │ • Business logic errors – incorrect validation                     │   │
│  │ • Arithmetic errors – overflow/underflow                          │   │
│  │ • Timestamp dependence – relying on block timestamps              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  3. INTERACTION VULNERABILITIES                                            │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Front-running – transaction ordering manipulation               │   │
│  │ • Oracle manipulation – feeding false price data                  │   │
│  │ • Sandwich attacks – exploiting AMM slippage                      │   │
│  │ • Flash loan attacks – using uncollateralised loans               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  4. COMPOSITION VULNERABILITIES                                            │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Dependency vulnerabilities – unsafe external contracts          │   │
│  │ • Upgradeability risks – proxy patterns misuse                    │   │
│  │ • Inheritance issues – unexpected override conflicts              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

// VULNERABLE
function withdraw(uint amount) public {
    require(balances[msg.sender] >= amount);
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success);
    balances[msg.sender] -= amount;
}

// SECURE
function withdraw(uint amount) public {
    require(balances[msg.sender] >= amount);
    balances[msg.sender] -= amount;  // Update state FIRST
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success);
}

# ===================================================================
# MODULE 4, LESSON 5: SECURITY AND AUDITING
# ===================================================================

import hashlib
import json
import random
import re
from typing import Dict, List, Optional, Any
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("SECURITY AND AUDITING")
print("="*70)

# ----------------------------------------------------------------
# PART A: VULNERABILITY PATTERN DETECTION SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Vulnerability Pattern Detection")
print("-"*60)

class VulnerabilityScanner:
    """
    Simulated vulnerability scanner for smart contract code.
    """
    def __init__(self):
        self.vulnerability_patterns = {
            'reentrancy': {
                'patterns': [r'\.call\{.*?\}\(', r'\.delegatecall\{.*?\}\('],
                'severity': 'Critical',
                'description': 'Unchecked external call could lead to reentrancy'
            },
            'unchecked_return': {
                'patterns': [r'\.transfer\(', r'\.send\('],
                'severity': 'High',
                'description': 'Transfer/send without checking return value'
            },
            'unprotected_function': {
                'patterns': [r'function\s+\w+\(.*?\)\s+public\s+{'],
                'severity': 'High',
                'description': 'Public function without access control'
            },
            'timestamp_dependence': {
                'patterns': [r'block\.timestamp', r'block\.number'],
                'severity': 'Medium',
                'description': 'Dependence on block timestamp/number'
            },
            'unchecked_math': {
                'patterns': [r'[+\-*/]+\s*[;]'],
                'severity': 'High',
                'description': 'Potential arithmetic overflow/underflow'
            }
        }
        self.findings = []
    
    def scan_code(self, code: str) -> List[Dict]:
        """Scan smart contract code for vulnerabilities."""
        findings = []
        
        for vuln_name, vuln_data in self.vulnerability_patterns.items():
            for pattern in vuln_data['patterns']:
                matches = re.finditer(pattern, code)
                for match in matches:
                    findings.append({
                        'vulnerability': vuln_name,
                        'severity': vuln_data['severity'],
                        'description': vuln_data['description'],
                        'matched_text': match.group(0)[:50] + '...' if len(match.group(0)) > 50 else match.group(0),
                        'position': match.start()
                    })
        
        # Sort by severity
        severity_order = {'Critical': 0, 'High': 1, 'Medium': 2, 'Low': 3}
        findings.sort(key=lambda x: severity_order.get(x['severity'], 4))
        
        self.findings = findings
        return findings
    
    def get_summary(self) -> Dict:
        if not self.findings:
            return {'total': 0, 'critical': 0, 'high': 0, 'medium': 0, 'low': 0}
        
        summary = {'total': len(self.findings), 'critical': 0, 'high': 0, 'medium': 0, 'low': 0}
        for finding in self.findings:
            severity = finding['severity'].lower()
            if severity in summary:
                summary[severity] += 1
        return summary

# Sample vulnerable contract code (simplified)
sample_code = """
contract Vulnerable {
    mapping(address => uint) public balances;
    
    function withdraw(uint amount) public {
        require(balances[msg.sender] >= amount);
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success);
        balances[msg.sender] -= amount;
    }
    
    function setBalance(address user, uint amount) public {
        balances[user] = amount;
    }
    
    function getTimestamp() public view returns (uint) {
        return block.timestamp;
    }
}
"""

# Scan code
scanner = VulnerabilityScanner()
findings = scanner.scan_code(sample_code)

print("Vulnerability Scan Results:")
summary = scanner.get_summary()
print(f"  Total Findings: {summary['total']}")
print(f"  Critical: {summary['critical']}")
print(f"  High: {summary['high']}")
print(f"  Medium: {summary['medium']}")
print(f"  Low: {summary['low']}")

print("\nDetailed Findings:")
for finding in findings[:5]:
    print(f"  [{finding['severity']}] {finding['vulnerability']}")
    print(f"    {finding['description']}")
    print(f"    Pattern: {finding['matched_text']}")

# ----------------------------------------------------------------
# PART B: AUDIT SEVERITY CLASSIFICATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Audit Severity Classification")
print("-"*60)

severity_data = {
    'Severity': ['Critical', 'High', 'Medium', 'Low', 'Informational'],
    'Description': [
        'Allows asset theft or total compromise',
        'Significant risk of loss or misuse',
        'Limited impact or under specific conditions',
        'Minor issues, no direct loss',
        'Best practices, recommendations'
    ],
    'Action Required': [
        'Immediate fix',
        'Priority fix',
        'Fix next release',
        'Consider fixing',
        'Consider implementing'
    ],
    'Examples': [
        'Reentrancy, access control bypass',
        'Oracle manipulation, logic errors',
        'Gas issues, timestamp dependence',
        'Unused variables, style issues',
        'Code clarity, documentation'
    ]
}

severity_df = pd.DataFrame(severity_data)
print(severity_df.to_string(index=False))

# ----------------------------------------------------------------
# PART C: SECURITY TOOLS COMPARISON
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Security Tools Comparison")
print("-"*60)

tools_data = {
    'Tool': ['Slither', 'Mythril', 'Foundry', 'Securify', 'Echidna'],
    'Type': ['Static', 'Static/Dynamic', 'Dynamic', 'Formal Verification', 'Fuzzing'],
    'Speed': ['Fast', 'Medium', 'Fast', 'Slow', 'Medium'],
    'False Positives': ['Medium', 'High', 'Low', 'Low', 'Medium'],
    'Ease of Use': ['High', 'Medium', 'High', 'Low', 'Medium']
}

tools_df = pd.DataFrame(tools_data)
print(tools_df.to_string(index=False))

# ----------------------------------------------------------------
# PART D: AUDIT PROCESS VISUALISATION
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Audit Process Visualisation")
print("-"*60)

# Simulate audit phases and time allocation
phases = ['Preparation', 'Automated Analysis', 'Manual Review', 'Testing', 'Reporting', 'Remediation']
time_allocation = [10, 15, 30, 20, 15, 10]  # percentage

fig, ax = plt.subplots(figsize=(10, 5))
ax.bar(phases, time_allocation, color='blue', alpha=0.7)
ax.set_ylabel('Time Allocation (%)')
ax.set_title('Security Audit Phase Distribution')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('audit_phases.png', dpi=300, bbox_inches='tight')
plt.show()
print("Audit phases chart saved as 'audit_phases.png'")

# ----------------------------------------------------------------
# PART E: SUMMARY AND RECOMMENDATIONS
# -----------------------------------------------------------------

print("\n" + "="*70)
print("PART E: Summary and Recommendations")
print("="*70)

print("""
Security and Auditing – Key Takeaways:

1. Blockchain security is unique due to immutability, public access, and financial incentives.
2. Common vulnerabilities: reentrancy, arithmetic errors, access control, front-running, oracle manipulation.
3. The audit lifecycle: Preparation → Automated Analysis → Manual Review → Testing → Reporting → Remediation.
4. Tools: static analysis (Slither), dynamic analysis (Foundry), formal verification (Securify).
5. Audit severity levels: Critical, High, Medium, Low, Informational.
6. Bug bounties incentivise ethical hacking and help uncover hidden vulnerabilities.
7. Secure development principles: least privilege, defense in depth, fail securely, minimal attack surface.

Security Best Practices:
  - Use latest Solidity version with built-in overflow checks.
  - Implement Checks-Effects-Interactions pattern.
  - Use OpenZeppelin libraries for standard contracts.
  - Conduct external audits for production contracts.
  - Run continuous fuzzing and invariant testing.
  - Establish bug bounty programs.
  - Regularly update dependencies.
  - Monitor contract activity for anomalies.
""")