联邦学习安全取证深度分析

import torch
import numpy as np
from scipy import stats
import json
import sys
import os

class GradientPoisonDetector:
    def __init__(self, baseline_updates, threshold_zscore=3.0, threshold_norm_ratio=2.5):
        self.baseline_updates = baseline_updates
        self.threshold_zscore = threshold_zscore
        self.threshold_norm_ratio = threshold_norm_ratio
        self.baseline_stats = self._compute_baseline_stats()

    def _compute_baseline_stats(self):
        norms = [np.linalg.norm(u) for u in self.baseline_updates]
        flat_updates = [u.flatten() for u in self.baseline_updates]
        mean_update = np.mean(flat_updates, axis=0)
        std_update = np.std(flat_updates, axis=0) + 1e-8
        return {
            'mean_norm': np.mean(norms),
            'std_norm': np.std(norms),
            'mean_update': mean_update,
            'std_update': std_update,
            'update_dim': len(flat_updates[0])
        }

    def detect_scaling_attack(self, client_id, update):
        update_norm = np.linalg.norm(update)
        norm_zscore = (update_norm - self.baseline_stats['mean_norm']) / (self.baseline_stats['std_norm'] + 1e-8)
        flat_update = update.flatten()
        element_zscores = np.abs((flat_update - self.baseline_stats['mean_update']) / self.baseline_stats['std_update'])
        extreme_ratio = np.mean(element_zscores > self.threshold_zscore)
        norm_ratio = update_norm / (self.baseline_stats['mean_norm'] + 1e-8)
        is_suspicious = (
            abs(norm_zscore) > self.threshold_zscore or
            norm_ratio > self.threshold_norm_ratio or
            extreme_ratio > 0.3
        )
        return {
            'client_id': client_id,
            'is_suspicious': is_suspicious,
            'update_norm': float(update_norm),
            'norm_zscore': float(norm_zscore),
            'norm_ratio': float(norm_ratio),
            'extreme_element_ratio': float(extreme_ratio),
            'confidence': min(1.0, abs(norm_zscore) / (self.threshold_zscore * 2))
        }

    def detect_model_replacement(self, client_id, global_model, client_update, target_magnitude=1.0):
        flat_global = torch.cat([p.data.flatten() for p in global_model]).cpu().numpy()
        flat_update = client_update.flatten() if isinstance(client_update, np.ndarray) else client_update.cpu().numpy().flatten()
        weight_diff = flat_update - flat_global
        diff_norm = np.linalg.norm(weight_diff)
        replacement_ratio = diff_norm / (np.linalg.norm(flat_global) + 1e-8)
        cosine_sim = np.dot(flat_update, flat_global) / (np.linalg.norm(flat_update) * np.linalg.norm(flat_global) + 1e-8)
        is_replacement = (
            replacement_ratio > target_magnitude * 5.0 or
            cosine_sim < -0.5
        )
        return {
            'client_id': client_id,
            'is_model_replacement': is_replacement,
            'replacement_ratio': float(replacement_ratio),
            'cosine_similarity': float(cosine_sim),
            'weight_diff_norm': float(diff_norm)
        }

def analyze_round_updates(updates_dir, global_model_path):
    detector = GradientPoisonDetector(
        baseline_updates=[],
        threshold_zscore=3.0,
        threshold_norm_ratio=2.5
    )
    results = []
    for fname in sorted(os.listdir(updates_dir)):
        if not fname.endswith('.pt'):
            continue
        client_id = fname.replace('.pt', '')
        update = torch.load(os.path.join(updates_dir, fname))
        if isinstance(update, dict):
            update = torch.cat([v.flatten() for v in update.values()]).detach().numpy()
        elif isinstance(update, list):
            update = torch.cat([p.data.flatten() for p in update]).detach().numpy()
        else:
            update = update.flatten().detach().numpy()
        detector.baseline_updates.append(update)
    detector.baseline_stats = detector._compute_baseline_stats()
    for fname in sorted(os.listdir(updates_dir)):
        if not fname.endswith('.pt'):
            continue
        client_id = fname.replace('.pt', '')
        update = torch.load(os.path.join(updates_dir, fname))
        if isinstance(update, dict):
            update = torch.cat([v.flatten() for v in update.values()]).detach().numpy()
        elif isinstance(update, list):
            update = torch.cat([p.data.flatten() for p in update]).detach().numpy()
        else:
            update = update.flatten().detach().numpy()
        result = detector.detect_scaling_attack(client_id, update)
        results.append(result)
        status = "ALERT: SUSPICIOUS" if result['is_suspicious'] else "NORMAL"
        print(f"[{status}] Client {client_id}: norm_zscore={result['norm_zscore']:.3f}, norm_ratio={result['norm_ratio']:.3f}, extreme_ratio={result['extreme_element_ratio']:.3f}")
    suspicious = [r for r in results if r['is_suspicious']]
    print(f"\n--- Summary ---")
    print(f"Total clients: {len(results)}")
    print(f"Suspicious clients: {len(suspicious)}")
    for s in suspicious:
        print(f"  [!] {s['client_id']}: confidence={s['confidence']:.3f}")
    return results

if __name__ == '__main__':
    if len(sys.argv) < 2:
        print(f"Usage: {sys.argv[0]} <updates_dir>")
        sys.exit(1)
    analyze_round_updates(sys.argv[1], None)

import numpy as np
from collections import Counter
from sklearn.metrics.pairwise import cosine_similarity
import torch
import torch.nn as nn

class LabelFlipDetector:
    def __init__(self, num_classes, suspicion_threshold=0.3):
        self.num_classes = num_classes
        self.suspicion_threshold = suspicion_threshold
        self.client_profiles = {}

    def profile_client_gradients(self, client_id, gradients, labels, predictions):
        pred_correct = (predictions.argmax(axis=1) == labels)
        flipped_suspect = 0
        total = len(labels)
        for i in range(total):
            if not pred_correct[i]:
                pred_label = predictions[i].argmax()
                true_label = labels[i]
                conf = predictions[i][pred_label]
                if conf > 0.8 and true_label != pred_label:
                    flipped_suspect += 1
        flip_ratio = flipped_suspect / (total + 1e-8)
        gradient_directions = []
        for layer_grad in gradients:
            grad_np = layer_grad.flatten()
            gradient_directions.append(grad_np)
        combined_grad = np.concatenate(gradient_directions)
        grad_norm = np.linalg.norm(combined_grad)
        self.client_profiles[client_id] = {
            'flip_ratio': flip_ratio,
            'grad_norm': grad_norm,
            'sample_count': total,
            'prediction_accuracy': float(pred_correct.mean()),
            'gradient_direction': combined_grad
        }
        return self.client_profiles[client_id]

    def detect_flipping(self, client_id):
        if client_id not in self.client_profiles:
            return {'client_id': client_id, 'is_suspicious': False, 'reason': 'no_profile'}
        profile = self.client_profiles[client_id]
        all_clients = list(self.client_profiles.keys())
        norms = [self.client_profiles[c]['grad_norm'] for c in all_clients]
        mean_norm = np.mean(norms)
        std_norm = np.std(norms) + 1e-8
        norm_zscore = (profile['grad_norm'] - mean_norm) / std_norm
        directions = np.array([self.client_profiles[c]['gradient_direction'] for c in all_clients])
        mean_direction = directions.mean(axis=0)
        sim = cosine_similarity(
            profile['gradient_direction'].reshape(1, -1),
            mean_direction.reshape(1, -1)
        )[0][0]
        is_suspicious = (
            profile['flip_ratio'] > self.suspicion_threshold or
            norm_zscore > 3.0 or
            sim < -0.3
        )
        risk_score = 0.0
        if profile['flip_ratio'] > 0.2:
            risk_score += 0.4
        if norm_zscore > 2.0:
            risk_score += 0.3
        if sim < 0:
            risk_score += 0.3
        risk_score = min(1.0, risk_score)
        return {
            'client_id': client_id,
            'is_suspicious': is_suspicious,
            'flip_ratio': profile['flip_ratio'],
            'norm_zscore': float(norm_zscore),
            'direction_similarity': float(sim),
            'prediction_accuracy': profile['prediction_accuracy'],
            'risk_score': risk_score
        }

    def generate_report(self):
        report_lines = ["=== Label Flipping Detection Report ===\n"]
        for client_id in self.client_profiles:
            result = self.detect_flipping(client_id)
            status = "FLIPPING DETECTED" if result['is_suspicious'] else "CLEAN"
            report_lines.append(f"Client {client_id}: {status}")
            report_lines.append(f"  Flip Ratio: {result['flip_ratio']:.3f}")
            report_lines.append(f"  Norm ZScore: {result['norm_zscore']:.3f}")
            report_lines.append(f"  Direction Sim: {result['direction_similarity']:.3f}")
            report_lines.append(f"  Risk Score: {result['risk_score']:.3f}\n")
        return "\n".join(report_lines)

import torch
import numpy as np
from torch.utils.data import DataLoader, TensorDataset

class BackdoorForensics:
    def __init__(self, global_model, trigger_size=3, num_classes=10):
        self.model = global_model
        self.trigger_size = trigger_size
        self.num_classes = num_classes
        self.trigger_locations = []
        self.infection_rounds = []

    def neural_cleanse_detection(self, val_data, val_labels, num_steps=100, lr=0.01):
        trigger_mask = torch.randn(1, *val_data.shape[1:], requires_grad=True, device='cpu')
        trigger_pattern = torch.randn(1, *val_data.shape[1:], requires_grad=True, device='cpu')
        target_label = torch.randint(0, self.num_classes, (1,)).item()
        optimizer = torch.optim.Adam([trigger_mask, trigger_pattern], lr=lr)
        best_l1_norm = float('inf')
        best_mask = None
        for step in range(num_steps):
            optimizer.zero_grad()
            sigmoid_mask = torch.sigmoid(trigger_mask)
            poisoned_input = val_data[:32] * (1 - sigmoid_mask) + trigger_pattern * sigmoid_mask
            output = self.model(poisoned_input)
            cls_loss = torch.nn.functional.cross_entropy(output, torch.full((32,), target_label, dtype=torch.long))
            l1_norm = sigmoid_mask.sum()
            total_loss = cls_loss + 0.001 * l1_norm
            total_loss.backward()
            optimizer.step()
            if step % 20 == 0:
                with torch.no_grad():
                    predictions = self.model(poisoned_input).argmax(dim=1)
                    attack_success = (predictions == target_label).float().mean().item()
                    print(f"  Step {step}: ASR={attack_success:.3f}, L1={l1_norm.item():.1f}, Loss={cls_loss.item():.4f}")
                if attack_success > 0.9 and l1_norm.item() < best_l1_norm:
                    best_l1_norm = l1_norm.item()
                    best_mask = sigmoid_mask.detach().clone()
        return {
            'target_label': target_label,
            'trigger_l1_norm': float(best_l1_norm) if best_mask is not None else float('inf'),
            'trigger_detected': best_l1_norm < self.trigger_size * self.trigger_size * 0.5 if best_mask is not None else False,
            'estimated_trigger_area': best_mask.sum().item() if best_mask is not None else 0
        }

    def activation_clustering(self, train_data, train_labels, num_clusters=5):
        self.model.eval()
        activations = []
        with torch.no_grad():
            for i in range(0, len(train_data), 32):
                batch = train_data[i:i+32]
                for name, module in self.model.named_modules():
                    if hasattr(module, 'weight') and len(module.weight.shape) == 2:
                        act = module(batch.view(batch.size(0), -1))
                        activations.append(act.mean(dim=0))
                        break
        if not activations:
            return {'clusters': [], 'outlier_clients': []}
        act_matrix = torch.stack(activations).numpy()
        from sklearn.cluster import KMeans
        kmeans = KMeans(n_clusters=min(num_clusters, len(act_matrix)), random_state=42)
        labels = kmeans.fit_predict(act_matrix)
        cluster_sizes = Counter(labels)
        dominant_cluster = max(cluster_sizes, key=cluster_sizes.get)
        outlier_clusters = [c for c in cluster_sizes if c != dominant_cluster and cluster_sizes[c] < cluster_sizes[dominant_cluster] * 0.1]
        return {
            'cluster_labels': labels.tolist(),
            'cluster_sizes': dict(cluster_sizes),
            'dominant_cluster': int(dominant_cluster),
            'outlier_clusters': outlier_clusters,
            'backdoor_suspected': len(outlier_clusters) > 0
        }

import numpy as np
from collections import defaultdict
from datetime import datetime
import json

class ByzantineProfiler:
    def __init__(self):
        self.client_history = defaultdict(list)
        self.round_metadata = {}
        self.suspicion_scores = defaultdict(float)

    def record_round(self, round_id, participating_clients, client_updates, round_metadata=None):
        self.round_metadata[round_id] = {
            'timestamp': datetime.now().isoformat(),
            'num_clients': len(participating_clients),
            'metadata': round_metadata or {}
        }
        update_norms = {}
        update_directions = {}
        for cid, update in client_updates.items():
            if isinstance(update, dict):
                flat = np.concatenate([v.flatten() for v in update.values()])
            else:
                flat = update.flatten()
            update_norms[cid] = np.linalg.norm(flat)
            update_directions[cid] = flat / (np.linalg.norm(flat) + 1e-8)
        mean_direction = np.mean(list(update_directions.values()), axis=0)
        for cid in participating_clients:
            cos_sim = np.dot(update_directions[cid], mean_direction)
            norm_deviation = update_norms[cid] / (np.mean(list(update_norms.values())) + 1e-8)
            self.client_history[cid].append({
                'round': round_id,
                'cosine_similarity': float(cos_sim),
                'norm_ratio': float(norm_deviation),
                'timestamp': self.round_metadata[round_id]['timestamp']
            })
            if cos_sim < -0.3:
                self.suspicion_scores[cid] += 2.0
            elif cos_sim < 0:
                self.suspicion_scores[cid] += 0.5
            if norm_deviation > 3.0:
                self.suspicion_scores[cid] += 1.5
            elif norm_deviation > 2.0:
                self.suspicion_scores[cid] += 0.5

    def detect_participation_anomaly(self, expected_rounds, min_participation=0.5):
        participation_rates = {}
        all_rounds = sorted(self.round_metadata.keys())
        for cid, history in self.client_history.items():
            participated_rounds = [h['round'] for h in history]
            rate = len(participated_rounds) / max(len(all_rounds), 1)
            participation_rates[cid] = rate
        anomalous = {cid: rate for cid, rate in participation_rates.items() if rate < min_participation and len(all_rounds) > 5}
        return {
            'participation_rates': participation_rates,
            'anomalous_participants': anomalous,
            'total_rounds': len(all_rounds)
        }

    def detect_sudden_change(self, window_size=3, change_threshold=2.0):
        changes = {}
        for cid, history in self.client_history.items():
            if len(history) < window_size * 2:
                continue
            recent_sims = [h['cosine_similarity'] for h in history[-window_size:]]
            prior_sims = [h['cosine_similarity'] for h in history[-window_size*2:-window_size]]
            recent_mean = np.mean(recent_sims)
            prior_mean = np.mean(prior_sims)
            drop = prior_mean - recent_mean
            if drop > change_threshold:
                changes[cid] = {
                    'prior_cosine_mean': float(prior_mean),
                    'recent_cosine_mean': float(recent_mean),
                    'drop_magnitude': float(drop),
                    'detected_at_round': history[-window_size]['round']
                }
                self.suspicion_scores[cid] += 3.0
        return changes

    def build_attacker_profile(self):
        profiles = {}
        for cid, score in self.suspicion_scores.items():
            history = self.client_history[cid]
            all_sims = [h['cosine_similarity'] for h in history]
            all_norms = [h['norm_ratio'] for h in history]
            profiles[cid] = {
                'total_suspicion_score': float(score),
                'classification': self._classify(score),
                'avg_cosine_similarity': float(np.mean(all_sims)),
                'min_cosine_similarity': float(np.min(all_sims)),
                'avg_norm_ratio': float(np.mean(all_norms)),
                'max_norm_ratio': float(np.max(all_norms)),
                'num_rounds_participated': len(history),
                'attack_pattern': self._infer_pattern(history)
            }
        return profiles

    def _classify(self, score):
        if score >= 5.0:
            return 'HIGH_RISK'
        elif score >= 2.0:
            return 'MEDIUM_RISK'
        elif score >= 1.0:
            return 'LOW_RISK'
        return 'CLEAN'

    def _infer_pattern(self, history):
        sims = [h['cosine_similarity'] for h in history]
        if len(sims) < 4:
            return 'INSUFFICIENT_DATA'
        first_half = sims[:len(sims)//2]
        second_half = sims[len(sims)//2:]
        if np.mean(first_half) > 0.5 and np.mean(second_half) < 0:
            return 'LITTLE_KNOWING'
        if all(s < -0.1 for s in sims):
            return 'CONSISTENT_POISONING'
        if np.std(sims) > 0.8:
            return 'INTERMITTENT_POISONING'
        return 'GRADIENT_DRIFT'

    def export_forensic_report(self, output_path):
        profiles = self.build_attacker_profile()
        report = {
            'generated_at': datetime.now().isoformat(),
            'total_clients_analyzed': len(profiles),
            'high_risk_clients': [cid for cid, p in profiles.items() if p['classification'] == 'HIGH_RISK'],
            'medium_risk_clients': [cid for cid, p in profiles.items() if p['classification'] == 'MEDIUM_RISK'],
            'client_profiles': profiles
        }
        with open(output_path, 'w') as f:
            json.dump(report, f, indent=2)
        return report

import torch
import numpy as np
from scipy.stats import pearsonr

class GradientInversionDetector:
    def __init__(self, model, sensitivity_threshold=0.7):
        self.model = model
        self.sensitivity_threshold = sensitivity_threshold
        self.gradient_memory = []

    def compute_gradient_sensitivity(self, data_batch, label_batch):
        self.model.eval()
        gradients = []
        for param in self.model.parameters():
            if param.requires_grad:
                gradients.append(param.grad)
        if not gradients or all(g is None for g in gradients):
            self.model.train()
            self.model.zero_grad()
            output = self.model(data_batch)
            loss = torch.nn.functional.cross_entropy(output, label_batch)
            loss.backward()
            gradients = [p.grad.clone() for p in self.model.parameters() if p.requires_grad and p.grad is not None]
        flat_grad = torch.cat([g.flatten() for g in gradients]).detach().numpy()
        grad_norm = np.linalg.norm(flat_grad)
        grad_entropy = -np.sum(np.abs(flat_grad / (grad_norm + 1e-8)) * np.log(np.abs(flat_grad / (grad_norm + 1e-8)) + 1e-10))
        return {
            'gradient_norm': float(grad_norm),
            'gradient_entropy': float(grad_entropy),
            'gradient_dim': len(flat_grad),
            'flat_gradient': flat_grad
        }

    def detect_reconstruction_potential(self, gradient_list, batch_sizes):
        norms = [np.linalg.norm(g) for g in gradient_list]
        reconstruction_scores = []
        for i, grad in enumerate(gradient_list):
            batch_size = batch_sizes[i]
            grad_per_sample = grad / max(batch_size, 1)
            per_sample_norm = np.linalg.norm(grad_per_sample)
            flat_grad = grad / (np.linalg.norm(grad) + 1e-8)
            sparsity = np.mean(np.abs(flat_grad) < 0.01)
            concentration = np.max(np.abs(flat_grad)) / (np.mean(np.abs(flat_grad)) + 1e-8)
            recon_score = 0.0
            if per_sample_norm > 0.1:
                recon_score += 0.3
            if concentration > 5.0:
                recon_score += 0.3
            if sparsity < 0.3:
                recon_score += 0.2
            if batch_size == 1:
                recon_score += 0.2
            reconstruction_scores.append(min(1.0, recon_score))
        return {
            'per_client_scores': reconstruction_scores,
            'mean_score': float(np.mean(reconstruction_scores)),
            'max_score': float(np.max(reconstruction_scores)),
            'high_risk_clients': [i for i, s in enumerate(reconstruction_scores) if s > self.sensitivity_threshold]
        }

    def cross_client_privacy_leakage_analysis(self, client_gradients):
        if len(client_gradients) < 2:
            return {'pairwise_leakage': [], 'overall_risk': 'UNKNOWN'}
        flat_grads = [g.flatten() for g in client_gradients]
        similarities = np.zeros((len(flat_grads), len(flat_grads)))
        for i in range(len(flat_grads)):
            for j in range(i+1, len(flat_grads)):
                sim = pearsonr(flat_grads[i], flat_grads[j])[0]
                similarities[i][j] = sim
                similarities[j][i] = sim
        mean_sim = np.mean(similarities[np.triu_indices(len(flat_grads), k=1)])
        max_sim = np.max(similarities[np.triu_indices(len(flat_grads), k=1)])
        privacy_risk = 'HIGH' if max_sim > 0.8 else 'MEDIUM' if max_sim > 0.5 else 'LOW'
        return {
            'pairwise_similarities': similarities.tolist(),
            'mean_similarity': float(mean_sim),
            'max_similarity': float(max_sim),
            'overall_privacy_risk': privacy_risk,
            'recommendation': self._privacy_recommendation(privacy_risk)
        }

    def _privacy_recommendation(self, risk_level):
        if risk_level == 'HIGH':
            return 'CRITICAL: Deploy differential privacy with ε≤1.0 and secure aggregation immediately'
        elif risk_level == 'MEDIUM':
            return 'WARNING: Consider adding differential privacy noise with ε≤5.0'
        return 'ACCEPTABLE: Current privacy level is reasonable, continue monitoring'

#!/bin/bash

echo "=== FATE Security Audit Script ==="
echo "Timestamp: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
echo ""

FATE_CONF_DIR="${FATE_CONF_DIR:-/data/projects/fate/conf}"
FATE_DATA_DIR="${FATE_DATA_DIR:-/data/projects/fate/data}"
FATE_LOG_DIR="${FATE_LOG_DIR:-/data/projects/fate/logs}"

echo "[1] Checking FATE process security..."
ps aux | grep -E '(fate_flow|fate_test|eggroll|clustermanager|nodemanager)' | grep -v grep | while read line; do
    user=$(echo "$line" | awk '{print $1}')
    pid=$(echo "$line" | awk '{print $2}')
    cmd=$(echo "$line" | awk '{for(i=11;i<=NF;i++) printf "%s ", $i}')
    if [ "$user" = "root" ]; then
        echo "  [!] WARNING: FATE process running as root: PID=$pid CMD=$cmd"
    else
        echo "  [OK] FATE process user=$user PID=$pid"
    fi
done

echo ""
echo "[2] Checking gRPC TLS configuration..."
for conf_file in $(find "$FATE_CONF_DIR" -name "*.conf" -o -name "*.yaml" -o -name "*.yml" 2>/dev/null); do
    if grep -q "ssl" "$conf_file" 2>/dev/null; then
        ssl_enabled=$(grep -i "ssl" "$conf_file" | grep -i "enable\|use" | head -1)
        if echo "$ssl_enabled" | grep -qi "false\|disable\|0"; then
            echo "  [!] CRITICAL: SSL/TLS disabled in $conf_file"
        else
            echo "  [OK] SSL/TLS configuration found in $conf_file"
        fi
    fi
done

echo ""
echo "[3] Checking model file integrity..."
find "$FATE_DATA_DIR" -name "*.hetero_*" -o -name "*. homo_*" -o -name "model_*" 2>/dev/null | while read model_file; do
    file_size=$(stat -f%z "$model_file" 2>/dev/null || stat -c%s "$model_file" 2>/dev/null)
    mod_time=$(stat -f%m "$model_file" 2>/dev/null || stat -c%Y "$model_file" 2>/dev/null)
    now=$(date +%s)
    age_days=$(( (now - mod_time) / 86400 ))
    if [ "$age_days" -lt 0 ] || [ "$age_days" -gt 365 ]; then
        echo "  [!] WARNING: Model file age anomaly: $model_file (age=${age_days}d)"
    fi
    if [ "$file_size" -gt 1073741824 ]; then
        echo "  [!] WARNING: Unusually large model file: $model_file (${file_size} bytes)"
    fi
done

echo ""
echo "[4] Checking Eggroll cluster security..."
if command -v mysql &>/dev/null; then
    db_hosts=$(grep -r "db_host\|mysql" "$FATE_CONF_DIR" 2>/dev/null | grep -oP '[\d.]+' | sort -u)
    for host in $db_hosts; do
        if [ "$host" = "0.0.0.0" ] || [ "$host" = "127.0.0.1" ]; then
            echo "  [!] WARNING: Database bound to $host in FATE config"
        fi
    done
fi

echo ""
echo "[5] Checking FATE log files for anomalies..."
if [ -d "$FATE_LOG_DIR" ]; then
    error_count=$(find "$FATE_LOG_DIR" -name "*.log" -mtime -7 -exec grep -c "ERROR\|FATAL\|Exception" {} + 2>/dev/null | awk -F: '{s+=$NF} END {print s}')
    auth_failures=$(find "$FATE_LOG_DIR" -name "*.log" -mtime -7 -exec grep -ci "auth\|permission\|unauthorized\|forbidden" {} + 2>/dev/null | awk -F: '{s+=$NF} END {print s}')
    echo "  Errors (7d): ${error_count:-0}"
    echo "  Auth failures (7d): ${auth_failures:-0}"
    if [ "${auth_failures:-0}" -gt 50 ]; then
        echo "  [!] WARNING: High number of auth failures detected"
    fi
fi

echo ""
echo "[6] Checking port exposure..."
for port in 9360 9370 9380 4670 8080 8260; do
    if ss -tlnp 2>/dev/null | grep -q ":${port} " || netstat -tlnp 2>/dev/null | grep -q ":${port} "; then
        bind_addr=$(ss -tlnp 2>/dev/null | grep ":${port} " | awk '{print $4}' | head -1)
        if echo "$bind_addr" | grep -q "0.0.0.0"; then
            echo "  [!] CRITICAL: Port $port bound to 0.0.0.0 (all interfaces): $bind_addr"
        else
            echo "  [OK] Port $port bound to: $bind_addr"
        fi
    fi
done

echo ""
echo "=== FATE Security Audit Complete ==="

import numpy as np
from itertools import combinations

class PoisoningRatioDetector:
    def __init__(self, min_poison_ratio=0.1, max_poison_ratio=0.5):
        self.min_poison_ratio = min_poison_ratio
        self.max_poison_ratio = max_poison_ratio

    def krum_score_analysis(self, client_updates):
        client_ids = list(client_updates.keys())
        n = len(client_ids)
        if n < 3:
            return {'estimated_poison_ratio': 0.0, 'confidence': 'LOW'}
        distance_matrix = np.zeros((n, n))
        for i in range(n):
            for j in range(i + 1, n):
                gi = client_updates[client_ids[i]]
                gj = client_updates[client_ids[j]]
                if isinstance(gi, dict):
                    gi = np.concatenate([v.flatten() for v in gi.values()])
                if isinstance(gj, dict):
                    gj = np.concatenate([v.flatten() for v in gj.values()])
                dist = np.linalg.norm(gi - gj)
                distance_matrix[i][j] = dist
                distance_matrix[j][i] = dist
        krum_scores = []
        f = max(1, int(n * self.max_poison_ratio))
        for i in range(n):
            sorted_dists = np.sort(distance_matrix[i])
            score = np.sum(sorted_dists[1:n-f])
            krum_scores.append(score)
        mean_score = np.mean(krum_scores)
        std_score = np.std(krum_scores) + 1e-8
        outliers = [i for i, s in enumerate(krum_scores) if (s - mean_score) / std_score > 2.5]
        estimated_ratio = len(outliers) / n
        return {
            'krum_scores': {client_ids[i]: float(krum_scores[i]) for i in range(n)},
            'outlier_clients': [client_ids[i] for i in outliers],
            'estimated_poison_ratio': float(estimated_ratio),
            'confidence': 'HIGH' if n > 10 else 'MEDIUM'
        }

    def loss_based_detection(self, client_ids, client_losses, global_loss):
        anomalies = []
        for cid, loss in zip(client_ids, client_losses):
            if loss < global_loss * 0.3:
                anomalies.append({'client_id': cid, 'loss': loss, 'ratio': loss / (global_loss + 1e-8), 'type': 'UNUSUALLY_LOW'})
            elif loss > global_loss * 3.0:
                anomalies.append({'client_id': cid, 'loss': loss, 'ratio': loss / (global_loss + 1e-8), 'type': 'UNUSUALLY_HIGH'})
        return {
            'anomalies': anomalies,
            'estimated_poison_ratio': len(anomalies) / max(len(client_ids), 1),
            'global_loss': global_loss
        }

    def round_convergence_analysis(self, round_losses):
        if len(round_losses) < 5:
            return {'anomaly_rounds': [], 'convergence_status': 'INSUFFICIENT_DATA'}
        losses = np.array(round_losses)
        diffs = np.diff(losses)
        increases = np.where(diffs > 0)[0]
        anomaly_rounds = []
        for idx in increases:
            if idx > 0 and diffs[idx] > abs(np.mean(diffs[:max(idx, 1)])) * 2:
                anomaly_rounds.append(int(idx + 1))
        return {
            'anomaly_rounds': anomaly_rounds,
            'total_increases': len(increases),
            'loss_trend': 'DIVERGING' if len(increases) > len(diffs) * 0.4 else 'CONVERGING',
            'final_loss': float(losses[-1]),
            'loss_range': [float(losses.min()), float(losses.max())]
        }

title: Suspicious Federated Learning Gradient Upload Anomaly
id: 8a5f3c21-7d4e-4b8a-9e1f-2c3d4e5f6a7b
status: experimental
description: Detects anomalous gradient uploads in federated learning aggregation server logs
author: BlueTeam-Forensics
date: 2026/07/20
tags:
  - attack.defense-evasion
  - attack.initial-access
  - attack.t1565
logsource:
  category: application
  product: federated_learning
  service: aggregation_server
detection:
  selection_gradient_log:
    event_type: gradient_upload
  selection_anomaly_norm:
    event_type: gradient_upload
    gradient_norm|gte: 100.0
  selection_anomaly_direction:
    event_type: gradient_upload
    cosine_similarity_global|lte: -0.3
  selection_anomaly_size:
    event_type: gradient_upload
    update_size_bytes|gte: 104857600
  condition: selection_gradient_log and (selection_anomaly_norm or selection_anomaly_direction or selection_anomaly_size)
falsepositives:
  - Large batch gradient updates in early training rounds
  - Non-IID data distributions with extreme skew
level: high

---

title: Federated Learning Byzantine Client Detection
id: 7b4e2d10-6c3f-3a9d-8f0e-1b2c3d4e5f6a
status: experimental
description: Detects potential Byzantine behavior in federated learning clients
author: BlueTeam-Forensics
date: 2026/07/20
tags:
  - attack.defense-evasion
  - attack.t1078
logsource:
  category: application
  product: federated_learning
  service: client_manager
detection:
  selection_participation_skip:
    event_type: participation_check
    rounds_skipped|gte: 3
  selection_loss_anomaly:
    event_type: loss_report
    reported_loss|lte: 0.001
  selection_update_timing:
    event_type: gradient_upload
    upload_delay_seconds|gte: 3600
  condition: selection_participation_skip or selection_loss_anomaly or selection_update_timing
falsepositives:
  - Client maintenance downtime
  - Slow network conditions causing delays
level: medium

---

title: Federated Learning Model Poisoning Backdoor Indicator
id: 6a3f1e09-5b2c-2c8e-7d0f-0a1b2c3d4e5f
status: experimental
description: Detects indicators of backdoor poisoning in federated learning models
author: BlueTeam-Forensics
date: 2026/07/20
tags:
  - attack.persistence
  - attack.t1199
logsource:
  category: application
  product: federated_learning
  service: model_validator
detection:
  selection_asr_spike:
    event_type: backdoor_evaluation
    attack_success_rate|gte: 0.8
  selection_clean_accuracy_drop:
    event_type: model_evaluation
    clean_accuracy_drop|gte: 0.05
  selection_trigger_detected:
    event_type: neural_cleanse
    trigger_detected: true
  condition: selection_asr_spike or (selection_clean_accuracy_drop and selection_trigger_detected)
falsepositives:
  - Intentional multi-task learning configurations
  - Normal accuracy fluctuations in early rounds
level: critical

#!/bin/bash

FL_LOG_DIR="${1:-/var/log/federated_learning}"
FL_MODEL_DIR="${2:-/data/federated_models}"
REPORT_FILE="/tmp/fl_security_hunt_$(date +%Y%m%d_%H%M%S).txt"

echo "=========================================" | tee "$REPORT_FILE"
echo "Federated Learning Security Hunt Report" | tee -a "$REPORT_FILE"
echo "Generated: $(date -u +%Y-%m-%dT%H:%M:%SZ)" | tee -a "$REPORT_FILE"
echo "Log Dir: $FL_LOG_DIR" | tee -a "$REPORT_FILE"
echo "Model Dir: $FL_MODEL_DIR" | tee -a "$REPORT_FILE"
echo "=========================================" | tee -a "$REPORT_FILE"

echo "" | tee -a "$REPORT_FILE"
echo "[HUNT-001] Checking for gradient upload anomalies..." | tee -a "$REPORT_FILE"
if [ -d "$FL_LOG_DIR" ]; then
    large_uploads=$(grep -rh "upload_size" "$FL_LOG_DIR" 2>/dev/null | awk -F'[:=]' '{if($NF > 104857600) print}' | wc -l)
    echo "  Large gradient uploads (>100MB): $large_uploads" | tee -a "$REPORT_FILE"
    failed_auth=$(grep -rhi "auth_fail\|unauthorized\|forbidden" "$FL_LOG_DIR" 2>/dev/null | wc -l)
    echo "  Authentication failures: $failed_auth" | tee -a "$REPORT_FILE"
    if [ "$failed_auth" -gt 10 ]; then
        echo "  [!] ALERT: High authentication failure rate detected" | tee -a "$REPORT_FILE"
        grep -rhi "auth_fail\|unauthorized\|forbidden" "$FL_LOG_DIR" 2>/dev/null | tail -5 | tee -a "$REPORT_FILE"
    fi
    timeout_errors=$(grep -rhi "timeout\|deadline_exceeded" "$FL_LOG_DIR" 2>/dev/null | wc -l)
    echo "  Timeout/deadline errors: $timeout_errors" | tee -a "$REPORT_FILE"
else
    echo "  [!] Log directory not found: $FL_LOG_DIR" | tee -a "$REPORT_FILE"
fi

echo "" | tee -a "$REPORT_FILE"
echo "[HUNT-002] Checking model file integrity..." | tee -a "$REPORT_FILE"
if [ -d "$FL_MODEL_DIR" ]; then
    find "$FL_MODEL_DIR" -name "*.pt" -o -name "*.pth" -o -name "*.h5" -o -name "*.onnx" 2>/dev/null | while read model_file; do
        file_hash=$(sha256sum "$model_file" 2>/dev/null | awk '{print $1}')
        file_size=$(stat -f%z "$model_file" 2>/dev/null || stat -c%s "$model_file" 2>/dev/null)
        file_perms=$(stat -f%Lp "$model_file" 2>/dev/null || stat -c%a "$model_file" 2>/dev/null)
        mod_time=$(stat -f "%Sm" "$model_file" 2>/dev/null || stat -c "%y" "$model_file" 2>/dev/null)
        if [ -z "$file_hash" ]; then
            file_hash=$(shasum -a 256 "$model_file" 2>/dev/null | awk '{print $1}')
        fi
        echo "  File: $model_file" | tee -a "$REPORT_FILE"
        echo "    SHA256: $file_hash" | tee -a "$REPORT_FILE"
        echo "    Size: $file_size bytes" | tee -a "$REPORT_FILE"
        echo "    Perms: $file_perms Modified: $mod_time" | tee -a "$REPORT_FILE"
        if [ "$file_perms" != "644" ] && [ "$file_perms" != "600" ]; then
            echo "    [!] WARNING: Unusual file permissions: $file_perms" | tee -a "$REPORT_FILE"
        fi
    done
fi

echo "" | tee -a "$REPORT_FILE"
echo "[HUNT-003] Checking aggregation server configuration..." | tee -a "$REPORT_FILE"
FATE_SERVICES=$(ps aux | grep -E '(fate_flow|clustermanager)' | grep -v grep | wc -l)
echo "  FATE services running: $FATE_SERVICES" | tee -a "$REPORT_FILE"

echo "" | tee -a "$REPORT_FILE"
echo "[HUNT-004] Scanning for anomalous gradient patterns..." | tee -a "$REPORT_FILE"
if [ -d "$FL_LOG_DIR" ]; then
    gradient_uploads=$(grep -rh "gradient_norm" "$FL_LOG_DIR" 2>/dev/null | grep -oP 'norm[=:]\s*[\d.]+' | awk -F'[=:]' '{print $NF}')
    if [ -n "$gradient_uploads" ]; then
        max_norm=$(echo "$gradient_uploads" | sort -n | tail -1)
        avg_norm=$(echo "$gradient_uploads" | awk '{s+=$1; n++} END {print s/n}')
        echo "  Max gradient norm: $max_norm" | tee -a "$REPORT_FILE"
        echo "  Avg gradient norm: $avg_norm" | tee -a "$REPORT_FILE"
        anomaly_count=$(echo "$gradient_uploads" | awk -v avg="$avg_norm" '{if($1 > avg * 5) print}' | wc -l)
        echo "  Anomalous norms (>5x avg): $anomaly_count" | tee -a "$REPORT_FILE"
        if [ "$anomaly_count" -gt 0 ]; then
            echo "  [!] ALERT: Gradient norm anomalies detected" | tee -a "$REPORT_FILE"
        fi
    fi
fi

echo "" | tee -a "$REPORT_FILE"
echo "=== Security Hunt Complete ===" | tee -a "$REPORT_FILE"
echo "Report saved to: $REPORT_FILE" | tee -a "$REPORT_FILE"

import os
import json
import numpy as np
from datetime import datetime
from pathlib import Path

class FederatedLearningHunter:
    def __init__(self, log_dir, model_dir):
        self.log_dir = Path(log_dir)
        self.model_dir = Path(model_dir)
        self.findings = []
        self.ioc_list = []

    def hunt_gradient_anomalies(self):
        print("[HUNT-001] Gradient anomaly hunting...")
        gradient_logs = list(self.log_dir.rglob("*gradient*"))
        anomaly_count = 0
        for log_file in gradient_logs:
            if not log_file.is_file():
                continue
            try:
                with open(log_file) as f:
                    for line in f:
                        try:
                            entry = json.loads(line)
                            norm = entry.get('gradient_norm', 0)
                            sim = entry.get('cosine_similarity_global', 1.0)
                            client_id = entry.get('client_id', 'unknown')
                            if norm > 100.0 or sim < -0.3:
                                self.findings.append({
                                    'type': 'GRADIENT_ANOMALY',
                                    'severity': 'HIGH',
                                    'client_id': client_id,
                                    'gradient_norm': norm,
                                    'cosine_similarity': sim,
                                    'source_file': str(log_file),
                                    'timestamp': entry.get('timestamp', 'unknown')
                                })
                                self.ioc_list.append(f"client:{client_id},norm:{norm:.2f}")
                                anomaly_count += 1
                        except json.JSONDecodeError:
                            continue
            except Exception as e:
                print(f"  Error reading {log_file}: {e}")
        print(f"  Found {anomaly_count} gradient anomalies")
        return anomaly_count

    def hunt_participation_patterns(self):
        print("[HUNT-002] Participation pattern hunting...")
        client_events = {}
        event_files = list(self.log_dir.rglob("*participation*"))
        for ef in event_files:
            if not ef.is_file():
                continue
            try:
                with open(ef) as f:
                    for line in f:
                        try:
                            entry = json.loads(line)
                            cid = entry.get('client_id', 'unknown')
                            if cid not in client_events:
                                client_events[cid] = []
                            client_events[cid].append(entry)
                        except json.JSONDecodeError:
                            continue
            except Exception:
                continue
        suspicious_clients = []
        for cid, events in client_events.items():
            if len(events) < 3:
                continue
            skips = sum(1 for e in events if e.get('event_type') == 'skipped')
            skip_rate = skips / len(events)
            if skip_rate > 0.5:
                self.findings.append({
                    'type': 'PARTICIPATION_ANOMALY',
                    'severity': 'MEDIUM',
                    'client_id': cid,
                    'skip_rate': skip_rate,
                    'total_events': len(events)
                })
                suspicious_clients.append(cid)
        print(f"  Found {len(suspicious_clients)} clients with participation anomalies")
        return suspicious_clients

    def hunt_model_integrity(self):
        print("[HUNT-003] Model integrity hunting...")
        model_files = list(self.model_dir.rglob("*.pt")) + list(self.model_dir.rglob("*.pth"))
        integrity_issues = 0
        for mf in model_files:
            stat = mf.stat()
            if stat.st_size > 1073741824:
                self.findings.append({
                    'type': 'MODEL_SIZE_ANOMALY',
                    'severity': 'MEDIUM',
                    'file': str(mf),
                    'size_bytes': stat.st_size
                })
                integrity_issues += 1
            import hashlib
            with open(mf, 'rb') as f:
                file_hash = hashlib.sha256(f.read()).hexdigest()
            self.ioc_list.append(f"model:{mf.name},sha256:{file_hash}")
        print(f"  Scanned {len(model_files)} model files, {integrity_issues} issues")
        return integrity_issues

    def generate_report(self):
        report = {
            'hunt_timestamp': datetime.now().isoformat(),
            'total_findings': len(self.findings),
            'high_severity': sum(1 for f in self.findings if f['severity'] == 'HIGH'),
            'medium_severity': sum(1 for f in self.findings if f['severity'] == 'MEDIUM'),
            'low_severity': sum(1 for f in self.findings if f['severity'] == 'LOW'),
            'ioc_count': len(self.ioc_list),
            'findings': self.findings,
            'ioc_list': self.ioc_list
        }
        output_path = self.log_dir / f"fl_hunt_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
        with open(output_path, 'w') as f:
            json.dump(report, f, indent=2, default=str)
        print(f"\n=== Hunt Report ===")
        print(f"Total findings: {len(self.findings)}")
        print(f"HIGH: {report['high_severity']}, MEDIUM: {report['medium_severity']}, LOW: {report['low_severity']}")
        print(f"IOCs collected: {len(self.ioc_list)}")
        print(f"Report: {output_path}")
        return report

if __name__ == '__main__':
    import sys
    log_dir = sys.argv[1] if len(sys.argv) > 1 else '/var/log/federated_learning'
    model_dir = sys.argv[2] if len(sys.argv) > 2 else '/data/federated_models'
    hunter = FederatedLearningHunter(log_dir, model_dir)
    hunter.hunt_gradient_anomalies()
    hunter.hunt_participation_patterns()
    hunter.hunt_model_integrity()
    hunter.generate_report()