Added zero padding to controls <10

Author: Peter Wagstaff

nist_catalog/nist_sp_800-53_control_catalog.json

@@ -0,0 +1,283 @@
+#!/usr/bin/env python3
+"""
+NIST SP 800-53 Control ID Zero Padder
+
+This script modifies the NIST SP 800-53 control catalog JSON file to add zero-padding
+to single-digit control numbers and enhancement numbers.
+
+Examples of transformations:
+- SC-1 → SC-01
+- AC-4(1) → AC-04(01)
+- PE-12(5) → PE-12(05)
+- AT-3 → AT-03
+
+Usage:
+    python nist_zero_padder.py input_file.json [output_file.json]
+
+If no output file is specified, the script will overwrite the input file.
+"""
+
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Dict, List, Any, Tuple
+
+
+def pad_control_id(control_id: str) -> str:
+    """
+    Add zero-padding to single-digit control and enhancement numbers.
+    
+    Args:
+        control_id: Original control ID like "SC-1", "AC-4(1)", etc.
+        
+    Returns:
+        Zero-padded control ID like "SC-01", "AC-04(01)", etc.
+    """
+    # Match patterns like "AC-1" or "AC-1(1)"
+    match = re.match(r'^([A-Z]{2,3})-(\d+)(?:\((\d+)\))?$', control_id)
+    
+    if not match:
+        print(f"Warning: Invalid control ID format, skipping: {control_id}", file=sys.stderr)
+        return control_id
+    
+    family = match.group(1)
+    base_number = match.group(2).zfill(2)  # Zero-pad to 2 digits
+    enhancement_number = match.group(3)
+    
+    if enhancement_number:
+        enhancement_number = enhancement_number.zfill(2)  # Zero-pad to 2 digits
+        return f"{family}-{base_number}({enhancement_number})"
+    else:
+        return f"{family}-{base_number}"
+
+
+def update_base_control_id(base_control_id: str) -> str:
+    """
+    Update baseControlId field with zero-padding.
+    
+    Args:
+        base_control_id: Original base control ID like "SC-1"
+        
+    Returns:
+        Zero-padded base control ID like "SC-01"
+    """
+    # Base control IDs should not have enhancements
+    match = re.match(r'^([A-Z]{2,3})-(\d+)$', base_control_id)
+    
+    if not match:
+        print(f"Warning: Invalid base control ID format, skipping: {base_control_id}", file=sys.stderr)
+        return base_control_id
+    
+    family = match.group(1)
+    base_number = match.group(2).zfill(2)  # Zero-pad to 2 digits
+    
+    return f"{family}-{base_number}"
+
+
+def process_controls(controls: List[Dict[str, Any]]) -> Tuple[List[Dict[str, Any]], Dict[str, int]]:
+    """
+    Process all controls to add zero-padding to their IDs.
+    
+    Args:
+        controls: List of control dictionaries
+        
+    Returns:
+        Tuple of (updated_controls, statistics)
+    """
+    updated_controls = []
+    stats = {
+        'total_processed': 0,
+        'ids_updated': 0,
+        'base_control_ids_updated': 0,
+        'related_controls_updated': 0,
+        'errors': 0
+    }
+    
+    for control in controls:
+        stats['total_processed'] += 1
+        updated_control = control.copy()
+        
+        try:
+            # Update main control ID
+            original_id = control.get('id', '')
+            if original_id:
+                new_id = pad_control_id(original_id)
+                if new_id != original_id:
+                    updated_control['id'] = new_id
+                    stats['ids_updated'] += 1
+            
+            # Update baseControlId if present
+            original_base_id = control.get('baseControlId', '')
+            if original_base_id:
+                new_base_id = update_base_control_id(original_base_id)
+                if new_base_id != original_base_id:
+                    updated_control['baseControlId'] = new_base_id
+                    stats['base_control_ids_updated'] += 1
+            
+            # Update relatedControls if present
+            related_controls = control.get('relatedControls', [])
+            if related_controls and isinstance(related_controls, list):
+                updated_related = []
+                related_updated = False
+                
+                for related_id in related_controls:
+                    if isinstance(related_id, str):
+                        new_related_id = pad_control_id(related_id)
+                        if new_related_id != related_id:
+                            related_updated = True
+                        updated_related.append(new_related_id)
+                    else:
+                        # Keep non-string values as-is
+                        updated_related.append(related_id)
+                
+                if related_updated:
+                    updated_control['relatedControls'] = updated_related
+                    stats['related_controls_updated'] += 1
+            
+            updated_controls.append(updated_control)
+            
+        except Exception as e:
+            print(f"Error processing control {control.get('id', 'unknown')}: {e}", file=sys.stderr)
+            updated_controls.append(control)  # Keep original on error
+            stats['errors'] += 1
+    
+    return updated_controls, stats
+
+
+def validate_json_structure(data: Dict[str, Any]) -> None:
+    """
+    Validate that the JSON has the expected structure.
+    
+    Args:
+        data: Parsed JSON data
+        
+    Raises:
+        ValueError: If structure is not as expected
+    """
+    if not isinstance(data, dict):
+        raise ValueError("JSON root must be an object")
+    
+    if 'controls' not in data:
+        raise ValueError("JSON must contain a 'controls' key")
+    
+    if not isinstance(data['controls'], list):
+        raise ValueError("'controls' must be an array")
+
+
+def print_processing_summary(stats: Dict[str, int], 
+                           sample_updates: List[Tuple[str, str]],
+                           sample_related_updates: List[Tuple[str, List[str], List[str]]]) -> None:
+    """Print a summary of the zero-padding operation."""
+    
+    print(f"Processing Summary:")
+    print(f"  Total controls processed: {stats['total_processed']}")
+    print(f"  Control IDs updated: {stats['ids_updated']}")
+    print(f"  Base control IDs updated: {stats['base_control_ids_updated']}")
+    print(f"  Controls with updated related controls: {stats['related_controls_updated']}")
+    
+    if stats['errors'] > 0:
+        print(f"  Errors encountered: {stats['errors']}")
+    
+    if sample_updates:
+        print(f"\nSample ID transformations:")
+        for original, updated in sample_updates[:10]:  # Show first 10
+            print(f"  {original} → {updated}")
+        
+        if len(sample_updates) > 10:
+            print(f"  ... and {len(sample_updates) - 10} more")
+    
+    if sample_related_updates:
+        print(f"\nSample related controls transformations:")
+        for control_id, original_related, updated_related in sample_related_updates[:5]:  # Show first 5
+            print(f"  {control_id}:")
+            print(f"    Before: {original_related}")
+            print(f"    After:  {updated_related}")
+        
+        if len(sample_related_updates) > 5:
+            print(f"  ... and {len(sample_related_updates) - 5} more controls with related controls updates")
+
+
+def collect_sample_updates(original_controls: List[Dict[str, Any]], 
+                          updated_controls: List[Dict[str, Any]]) -> Tuple[List[Tuple[str, str]], List[Tuple[str, List[str], List[str]]]]:
+    """Collect sample updates for display."""
+    id_samples = []
+    related_samples = []
+    
+    for orig, updated in zip(original_controls, updated_controls):
+        # Collect ID updates
+        orig_id = orig.get('id', '')
+        new_id = updated.get('id', '')
+        
+        if orig_id != new_id:
+            id_samples.append((orig_id, new_id))
+        
+        # Collect related controls updates
+        orig_related = orig.get('relatedControls', [])
+        new_related = updated.get('relatedControls', [])
+        
+        if orig_related != new_related and orig_related and new_related:
+            control_id = updated.get('id', orig.get('id', 'unknown'))
+            related_samples.append((control_id, orig_related, new_related))
+    
+    return id_samples, related_samples
+
+
+def main():
+    """Main function."""
+    if len(sys.argv) < 2:
+        print("Usage: python nist_zero_padder.py input_file.json [output_file.json]")
+        sys.exit(1)
+    
+    input_file = Path(sys.argv[1])
+    output_file = Path(sys.argv[2]) if len(sys.argv) > 2 else input_file
+    
+    if not input_file.exists():
+        print(f"Error: Input file '{input_file}' not found.")
+        sys.exit(1)
+    
+    try:
+        # Read and parse JSON
+        print(f"Reading {input_file}...")
+        with open(input_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        # Validate structure
+        validate_json_structure(data)
+        
+        # Get controls array
+        original_controls = data['controls']
+        print(f"Found {len(original_controls)} controls to process.")
+        
+        # Process controls to add zero-padding
+        print("Adding zero-padding to control IDs...")
+        updated_controls, stats = process_controls(original_controls)
+        
+        # Update data with processed controls
+        data['controls'] = updated_controls
+        
+        # Write output
+        print(f"Writing updated controls to {output_file}...")
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+        
+        # Collect and print summary
+        id_samples, related_samples = collect_sample_updates(original_controls, updated_controls)
+        print_processing_summary(stats, id_samples, related_samples)
+        
+        total_updates = stats['ids_updated'] + stats['base_control_ids_updated'] + stats['related_controls_updated']
+        if total_updates == 0:
+            print("\nNo updates were needed - all control IDs already have proper formatting.")
+        else:
+            print(f"\nZero-padding complete! Output saved to: {output_file}")
+        
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON in '{input_file}': {e}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()