Security Reliability — Incident Response and Compliance

class SecurityIncident:
    def __init__(self, title, data_exposed, user_impact, exploitation_level):
        self.title = title
        self.data_exposed = data_exposed
        self.user_impact = user_impact
        self.exploitation = exploitation_level

    def severity(self):
        score = self.data_exposed + self.user_impact + self.exploitation
        if score >= 8:
            return "SEV1 — Critical"
        elif score >= 5:
            return "SEV2 — High"
        elif score >= 3:
            return "SEV3 — Medium"
        else:
            return "SEV4 — Low"

    def respond(self):
        sev = self.severity()
        print(f"Security Incident: {self.title}")
        print(f"Severity: {sev}")
        if "SEV1" in sev or "SEV2" in sev:
            print("Action: Immediate response team")
            print("Action: Contain and rotate credentials")
            print("Action: Notify security officer")
        else:
            print("Action: Ticket for next business day")

incident = SecurityIncident(
    "Suspected credential leak in CI logs",
    data_exposed=5, user_impact=4, exploitation_level=3
)
incident.respond()

class ComplianceCheck:
    def __init__(self, name, requirement):
        self.name = name
        self.requirement = requirement
        self.passed = False

    def run(self):
        print(f"Compliance check: {self.name}")
        if self.requirement == "encryption_at_rest":
            self.passed = True
            print("  PASS: All volumes encrypted with AES-256")
        elif self.requirement == "access_logging":
            self.passed = True
            print("  PASS: All API access logged to CloudTrail")
        elif self.requirement == "backup_testing":
            self.passed = random.random() > 0.1
            status = "PASS" if self.passed else "FAIL"
            print(f"  {status}: Backup restore test within RTO")
        elif self.requirement == "mfa_required":
            self.passed = True
            print("  PASS: MFA enforced for all console users")
        else:
            self.passed = False
            print("  FAIL: Unknown compliance requirement")
        return self.passed

    def report(self):
        status = "COMPLIANT" if self.passed else "NON-COMPLIANT"
        print(f"[{status}] {self.name}")

checks = [
    ComplianceCheck("Encryption at rest", "encryption_at_rest"),
    ComplianceCheck("Access logging", "access_logging"),
    ComplianceCheck("Backup testing", "backup_testing"),
    ComplianceCheck("MFA enforcement", "mfa_required"),
]

all_pass = True
for c in checks:
    all_pass = c.run() and all_pass

print(f"\nOverall compliance: {'PASS' if all_pass else 'SOME CHECKS FAILED'}")

class Vulnerability:
    def __init__(self, cve_id, severity, cvss_score, affected_service):
        self.cve = cve_id
        self.severity = severity
        self.cvss = cvss_score
        self.service = affected_service
        self.patched = False

    def patch(self):
        self.patched = True
        print(f"PATCHED: {self.cve} in {self.service}")

    def report(self):
        status = "PATCHED" if self.patched else f"OPEN (CVSS {self.cvss})"
        print(f"[{status}] {self.cve} — {self.service} ({self.severity})")

    def sla(self):
        if self.cvss >= 9.0:
            return "Patch within 24 hours"
        elif self.cvss >= 7.0:
            return "Patch within 7 days"
        elif self.cvss >= 4.0:
            return "Patch within 30 days"
        else:
            return "Patch within 90 days"

vulns = [
    Vulnerability("CVE-2026-1234", "Critical", 9.8, "nginx"),
    Vulnerability("CVE-2026-5678", "High", 7.5, "postgresql"),
    Vulnerability("CVE-2026-9012", "Medium", 5.0, "redis"),
]

for v in vulns:
    print(f"{v.cve}: {v.sla()}")

import datetime

class SecretRotator:
    def __init__(self, secret_name, rotation_days):
        self.name = secret_name
        self.rotation_days = rotation_days
        self.last_rotated = None
        self.version = 1

    def rotate(self):
        self.last_rotated = datetime.datetime.now()
        self.version += 1
        print(f"Rotated secret: {self.name}")
        print(f"  New version: v{self.version}")
        print(f"  Rotated at: {self.last_rotated}")
        print(f"  Next rotation: {self.last_rotated + datetime.timedelta(days=self.rotation_days)}")
        return True

    def check_expiry(self):
        if not self.last_rotated:
            return "NEVER ROTATED"
        days_since = (datetime.datetime.now() - self.last_rotated).days
        if days_since >= self.rotation_days:
            return f"EXPIRED ({days_since} days since rotation)"
        else:
            remaining = self.rotation_days - days_since
            return f"OK ({remaining} days until rotation)"

rotator = SecretRotator("doda-browser-api-key", 90)
rotator.rotate()
print(f"Status: {rotator.check_expiry()}")