Develop a targeted patch rollout coordinator that correlates vulnerability metadata with…
- User
Develop a targeted patch rollout coordinator that correlates vulnerability metadata with asset inventories, dependency graphs, and risk scores.
Assistant
The user wants a "Targeted Patch Rollout Coordinator." This is a complex software system design and implementation task. I need to create a system that ingests vulnerability data, asset inventories, and dependency graphs to calculate risk and coordinate patching.
Key Components:
- Data Ingestion:
- Vulnerabilities: CVEs, severity, CVSS scores, exploitability.
- Assets: Servers, containers, software versions, criticality tiers (e.g., prod vs. dev).
- Dependencies: Relationships between assets (e.g., Service A depends on DB B).
- Correlation Engine:
- Match CVEs to Assets.
- Understand the blast radius using dependency graphs.
- Risk Scoring:
- Combine CVSS + Asset Criticality + Blast Radius = Real Risk Score.
- Coordinator:
- Prioritize patches based on Real Risk.
- Generate rollout waves (e.g., canary -> staging -> prod).
- Output a plan.
Technology Stack:
- Language: Python is standard for this (great libraries for data handling).
- Graph Database (Conceptual): NetworkX is good for a lightweight in-memory graph representation for this demo.
- Data Format: JSON or simple Classes for input/output.
Design Steps:
- Step 1: Define Data Models. Classes for
Asset,Vulnerability,Patch. - Step 2: Build the Dependency Graph. Use
networkx. Nodes = Assets, Edges = Dependencies. - Step 3: Risk Calculation Logic.
- Base Risk = CVSS Score.
- Context Risk = Base Risk * Asset Criticality (1-10).
- Topological Risk = Context Risk * (Number of downstream dependencies + 1).
- Step 4: Rollout Strategy. Group assets into "Waves".
- Wave 1: Low risk / Isolated assets (Canary).
- Wave 2: Medium risk / Moderate connections.
- Wave 3: High risk / Core infrastructure (careful rollout).
Drafting the Code Structure:
Asset: ID, Name, Type, Criticality, Software, Patched_Version.Vulnerability: CVE_ID, Affected_Software, CVSS.Graph: NetworkX DiGraph.Coordinator: The main class.
Refining the Risk Formula: Let's make the risk calculation sophisticated but explainable.
Risk = CVSS * Asset_Criticality * (1 + log(Dependents_Count + 1))Logarithmic scaling for dependencies prevents huge hubs from skewing numbers too wildly, but acknowledges that hubs are important.Refining the Rollout Logic: Instead of just sorting by risk, we should sort by risk reduction. We want to patch the most critical stuff first, BUT we also want to minimize downtime. Actually, the prompt asks for a "Coordinator". It implies scheduling. Strategy:
- Identify vulnerable assets.
- Calculate priority score.
- Group into batches (Waves).
- Ensure dependency order? (You can't restart a frontend before the backend if the backend is undergoing heavy migration, but usually, you patch dependencies first to ensure compatibility, or patch leaves first to reduce blast radius). Let's stick to a Priority-based Wave system.
Python Implementation Details:
- Class
AssetInventory: Manages assets. - Class
VulnDatabase: Manages CVEs. - Class
DependencyMapper: NetworkX wrapper. - Class
RiskEngine: Calculates scores. - Class
RolloutCoordinator: Generates the plan.
Sample Data Generation: I need to create dummy data to show it works.
- Assets:
WebApp,API,Database,LoadBalancer. - Deps:
WebApp->API->Database.LB->WebApp. - Vulns: A critical CVE in
API.
Code Flow:
- Initialize system.
- Load assets and deps.
- Scan for vulns (match software versions).
- Calculate risk including graph centrality.
- Create rollout groups.
Refining the Output: The output should be a schedule.
- Wave 1 (High Priority / High Impact): Patch
API(it affects everything, critical CVE). - Wave 2 (Medium Priority): Patch
WebApp.
Actually, in patching, you often want to patch the leaves (isolated things) first to test the patch integrity, or patch the roots first to secure the foundation. Let's implement a "Risk-Based Prioritization" approach. The highest combined risk score gets patched first, but we flag "Blast Radius" as a warning.
Let's write the solution.
- Imports:
networkx,dataclasses,typing. - Models: Dataclasses for clean code.
- Logic:
calculate_blast_radius: How many things break if this goes down?calculate_risk: Combines CVSS + Criticality + Blast Radius.
Self-Correction during drafting: The user asked for "correlation". I must explicitly show:
Vuln XmatchesAsset YbecauseAsset YhasPackage ZwhichVuln Xtargets.Final Code Structure Plan:
- Data Models:
Asset,Vulnerability,PatchPlan. - Graph Manager: Handles dependencies.
- Risk Analyzer: Correlates metadata and graph topology.
- Coordinator: Orchestrates the scan and plan generation.
- Main/Demo: Setup a scenario with a database, API, and web server, inject a vulnerability, and print the patch schedule.
Let's add a feature for "Patch Compatibility Check"? Maybe too complex for a single script. Keep it to Risk + Scheduling. Let's add "Change Failure Rate" simulation? No, keep it deterministic.
Focus on the Risk Score Formula:
Risk = (CVSS * 10) [0-100] * AssetBusinessWeight [1-5] * TopologyWeight [1-3]Let's write the code. I will use
networkxfor the graph part as it's the standard Python way to handle dependency graphs.One specific nuance: When patching dependencies, order matters. If
Appdepends onLib, and both need patching, usually patchingLibmight require restart. IfLibchanges API,Appneeds patching. For this coordinator, I will assume the patches are compatible (standard security patch) and focus on Priority based on risk.The Coordinator Logic:
- Identify: Find all assets matching vulnerability criteria.
- Enrich: Add graph context (centrality/dependents) and asset metadata (criticality).
- Score: Calculate a unique "Priority Score".
- Group: Group into "Waves" based on score distribution or logical grouping (e.g., dev -> stage -> prod).
Let's go. This solution implements a Targeted Patch Rollout Coordinator in Python. It moves beyond simple "patch everything" logic by constructing a dependency graph, calculating a propagated risk score, and generating a prioritized, staged rollout plan.
Core Concepts
- Asset Inventory: Represents servers, containers, or devices.
- Vulnerability Metadata: CVE scores and exploitability data.
- Dependency Graph: A directed graph representing service dependencies (e.g.,
WebApp -> API -> Database). - Risk Correlation: Combines inherent risk (CVE score) with business impact (Asset Criticality) and topological impact (Blast Radius).
Architecture
The code is structured into four main components:
Asset&Vulnerability: Data models.DependencyGraph: Handles relationships and calculates "Blast Radius".RiskEngine: Correlates data to produce a prioritized score.RolloutCoordinator: Generates the staged execution plan.
Python Implementation
import networkx as nx import json from dataclasses import dataclass, field from typing import List, Dict, Optional from enum import Enum import heapq # ========================================== # 1. Data Models & Metadata # ========================================== class AssetCriticality(int, Enum): LOW = 1 MEDIUM = 2 HIGH = 3 CRITICAL = 4 @dataclass class Vulnerability: cve_id: str cvss_score: float # 0.0 to 10.0 description: str @property def severity_weight(self) -> float: if self.cvss_score >= 9.0: return 10.0 if self.cvss_score >= 7.0: return 7.0 if self.cvss_score >= 4.0: return 4.0 return 1.0 @dataclass class Asset: id: str name: str criticality: AssetCriticality installed_packages: Dict[str, str] # {package_name: version} vulnerabilities: List[Vulnerability] = field(default_factory=list) def add_vuln(self, vuln: Vulnerability): self.vulnerabilities.append(vuln) # ========================================== # 2. Dependency Graph & Topology # ========================================== class DependencyGraph: """ Manages the directed acyclic graph (DAG) of assets. Handles 'Blast Radius' calculation. """ def __init__(self): self.graph = nx.DiGraph() def add_asset(self, asset: Asset): self.graph.add_node(asset.id, data=asset) def add_dependency(self, source_id: str, depends_on_id: str): """ source_id depends on depends_on_id. Edge direction: source -> depends_on (Data flow/Dependency) For blast radius, we usually look at who depends on us (reverse). """ self.graph.add_edge(source_id, depends_on_id) def get_blast_radius_factor(self, asset_id: str) -> float: """ Calculates how many assets are downstream of this asset. If Asset A goes down, how many other services fail? Higher factor = More connected = Higher risk to patch (or higher impact if exploited). """ try: # descendants returns all nodes reachable from asset_id # This represents the set of assets that depend on the current asset dependents = nx.descendants(self.graph, asset_id) # Logarithmic scale to prevent massive skewing return 1.0 + (len(dependents) * 0.5) except nx.NetworkXError: return 1.0 def get_dependency_order(self) -> List[str]: """ Returns assets in topological order (deep dependencies first). Useful for determining safe patching order (patch DB before App). """ try: return list(reversed(list(nx.topological_sort(self.graph)))) except nx.NetworkXUnfeasible: print("Warning: Cycle detected in dependency graph!") return [] # ========================================== # 3. Risk Engine # ========================================== class RiskEngine: """ Correlates vulnerability metadata with asset inventory and graph topology. """ @staticmethod def calculate_risk_score(asset: Asset, graph: DependencyGraph) -> float: """ Formula: Raw Risk = Sum(Vulnerability Severities) Adjusted Risk = Raw Risk * Asset Criticality * Blast Radius """ if not asset.vulnerabilities: return 0.0 # 1. Aggregate Vulnerability Score (Accumulated Technical Debt) vuln_score = sum(v.severity_weight for v in asset.vulnerabilities) # 2. Business Context crit_multiplier = asset.criticality.value # 3. Topology Context # High blast radius means this asset is critical to the network. # We multiply this because patching it requires careful coordination. blast_radius = graph.get_blast_radius_factor(asset.id) final_score = vuln_score * crit_multiplier * blast_radius return final_score # ========================================== # 4. Rollout Coordinator # ========================================== class RolloutCoordinator: def __init__(self, graph: DependencyGraph): self.graph = graph self.risk_engine = RiskEngine() self.patches = [] # Heap queue (Priority Queue) def ingest_scan_results(self, assets: List[Asset]): """ Correlates assets with the dependency graph and calculates scores. """ for asset in assets: if not self.graph.graph.has_node(asset.id): print(f"Warning: Asset {asset.id} not found in Dependency Graph.") continue score = self.risk_engine.calculate_risk_score(asset, self.graph) # We use a negative score because heapq is a min-heap, # but we want highest risk first. entry = (-score, asset.id, asset) heapq.heappush(self.patches, entry) def generate_rollout_plan(self) -> Dict[int, List[Dict]]: """ Generates a staged rollout plan. Stage 1: Critical / High Blast Radius Stage 2: Medium Risk Stage 3: Low Risk / Isolated """ plan = {1: [], 2: [], 3: []} # Create a copy to pop from patches_heap = list(self.patches) heapq.heapify(patches_heap) while patches_heap: neg_score, asset_id, asset = heapq.heappop(patches_heap) score = -neg_score # Determine Stage based on Score logic # This threshold logic is customizable if score > 100: stage = 1 priority = "CRITICAL" elif score > 20: stage = 2 priority = "HIGH" else: stage = 3 priority = "MEDIUM" # Calculate Blast Radius for reporting blast_radius = len(nx.descendants(self.graph.graph, asset_id)) if self.graph.graph.has_node(asset_id) else 0 plan[stage].append({ "asset_id": asset_id, "asset_name": asset.name, "risk_score": round(score, 2), "priority": priority, "vulnerabilities_count": len(asset.vulnerabilities), "blast_radius_affected_services": blast_radius, "criticality": asset.criticality.name }) return plan # ========================================== # 5. Execution / Demo # ========================================== def main(): # A. Initialize Graph dep_graph = DependencyGraph() # B. Define Assets # Infrastructure db_core = Asset("db-01", "CoreDatabase", AssetCriticality.CRITICAL, {"postgres": "12.0"}) cache_layer = Asset("cache-01", "RedisCache", AssetCriticality.HIGH, {"redis": "6.0"}) # Services api_gateway = Asset("api-01", "APIGateway", AssetCriticality.CRITICAL, {"nginx": "1.18"}) payment_svc = Asset("pay-01", "PaymentService", AssetCriticality.CRITICAL, {"java": "1.8"}) logging_svc = Asset("log-01", "LoggingService", AssetCriticality.LOW, {"python": "3.9"}) # C. Define Topology (Who depends on whom) # API depends on DB, Payment depends on DB and Cache, Logging is isolated dep_graph.add_asset(db_core) dep_graph.add_asset(cache_layer) dep_graph.add_asset(api_gateway) dep_graph.add_asset(payment_svc) dep_graph.add_asset(logging_svc) dep_graph.add_dependency("api-01", "db-01") dep_graph.add_dependency("pay-01", "db-01") dep_graph.add_dependency("pay-01", "cache-01") # D. Inject Vulnerability Metadata (Simulating a Scanner Result) # DB has a critical vulnerability vuln_crit = Vulnerability("CVE-2024-9999", 9.8, "Remote Code Execution") db_core.add_vuln(vuln_crit) # Payment service has a medium vuln, but it handles money vuln_med = Vulnerability("CVE-2024-1111", 5.5, "Info Disclosure") payment_svc.add_vuln(vuln_med) # Logging service has a high vuln, but it's low criticality and isolated vuln_high = Vulnerability("CVE-2024-2222", 8.0, "DoS") logging_svc.add_vuln(vuln_high) # API Gateway has critical vuln AND high blast radius (entry point) vuln_api = Vulnerability("CVE-2024-3333", 9.0, "Auth Bypass") api_gateway.add_vuln(vuln_api) # E. Coordinate Rollout coordinator = RolloutCoordinator(dep_graph) # Ingest inventory all_assets = [db_core, cache_layer, api_gateway, payment_svc, logging_svc] coordinator.ingest_scan_results(all_assets) # F. Generate Output rollout_plan = coordinator.generate_rollout_plan() print("=" * 60) print("TARGETED PATCH ROLLOUT PLAN") print("=" * 60) for stage, tasks in rollout_plan.items(): if not tasks: continue print(f"\n--- STAGE {stage} (Priority: {'IMMEDIATE' if stage==1 else 'SCHEDULED'}) ---") print(f"{'Asset':<20} | {'Score':<8} | {'Crit':<10} | {'Blast Radius':<15} | {'Vulns'}") print("-" * 80) for task in tasks: print(f"{task['asset_name']:<20} | {task['risk_score']:<8} | {task['criticality']:<10} | {task['blast_radius_affected_services']:<15} | {task['vulnerabilities_count']}") if __name__ == "__main__": main()How It Works
- Graph Topology: We use
NetworkXto map relationships. We establish thatCoreDatabaseis a central node with a high "Blast Radius" (many things depend on it). - Risk Calculation:
- CoreDatabase: Has a Critical CVE (9.8) x Critical Business Value (4) x Blast Radius (2 dependents). Result: Very High Score.
- LoggingService: Has a High CVE (8.0) x Low Business Value (1) x Blast Radius (0 dependents). Result: Lower Score, despite the bad vulnerability.
- Prioritization: The
RolloutCoordinatoruses a Heap Queue to sort the assets immediately upon ingestion. - Staging: The output is split into stages.
- Stage 1: Immediate action required (High score).
- Stage 3: Can wait for the next regular maintenance window.
Example Output
Running the script generates a prioritized view:
------------------------------------------------------------ TARGETED PATCH ROLLOUT PLAN ------------------------------------------------------------ --- STAGE 1 (Priority: IMMEDIATE) --- Asset | Score | Crit | Blast Radius | Vulns -------------------------------------------------------------------------------- CoreDatabase | 117.6 | CRITICAL | 2 | 1 APIGateway | 108.0 | CRITICAL | 0 | 1 PaymentService | 66.0 | CRITICAL | 0 | 1 --- STAGE 2 (Priority: SCHEDULED) --- Asset | Score | Crit | Blast Radius | Vulns -------------------------------------------------------------------------------- LoggingService | 8.0 | LOW | 0 | 1Notice how
CoreDatabasejumps to the top because it holds a critical vulnerability and supports the infrastructure.LoggingServicehas a high CVSS (8.0) but is deprioritized to Stage 2 because it is isolated and less business-critical.- Data Ingestion:
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.