راهنمای یکپارچه‌سازی حملات

# توسعه‌دهنده: Mohammad Khalooei (khalooei@aut.ac.ir, mohammad.khalooei@sharif.edu)
# فایل: attack_modules/benchmark/clean_eval.py

from typing import Any, Dict
import numpy as np
from attack_modules.base import BaseAttack


class CleanEvaluation(BaseAttack):
    name = "Clean Evaluation"
    description = "Benchmark: evaluates model accuracy on clean data (train/val/test)"
    category = "benchmark"
    supported_domains = ["any"]

    def execute(self) -> Dict[str, Any]:
        self.log("Starting Clean Evaluation (Benchmark)")
        num_samples = self.params.get("num_samples", 500)
        splits = self.params.get("splits", ["train", "validation", "test"])
        import torch
        model = self._load_model()
        input_format = getattr(self.eval_request, "input_format", None) or {}
        shape = input_format.get("shape", [3, 224, 224])
        if len(shape) != 3:
            shape = [3, 224, 224]
        num_classes = getattr(self.eval_request, "num_classes", None) or 10
        results_by_split = {}
        for split in splits:
            correct = total = 0
            for i in range(num_samples):
                x = np.random.rand(1, *shape).astype(np.float32)
                true_label = np.random.randint(0, num_classes)
                with torch.no_grad():
                    tensor = torch.tensor(x).to(self.device)
                    logits = model(tensor)
                    pred = logits.argmax(1).item()
                if pred == true_label:
                    correct += 1
                total += 1
            accuracy = correct / total if total else 0
            results_by_split[split] = {"accuracy": round(accuracy, 4), "total_samples": total}
        return {
            "metrics": {"results_by_split": results_by_split, "accuracy": results_by_split.get("test", {}).get("accuracy", 0)},
            "summary": " | ".join(f"{s}: دقت {d['accuracy']:.2%}" for s, d in results_by_split.items()),
            "artifacts": [],
            "log": self.get_log(),
        }

# توسعه‌دهنده: Mohammad Khalooei (khalooei@aut.ac.ir, mohammad.khalooei@sharif.edu)
# فایل: attack_modules/whitebox/fgsm.py

from typing import Any, Dict
import torch
import torch.nn.functional as F
from attack_modules.base import BaseAttack


class FGSMAttack(BaseAttack):
    name = "FGSM"
    description = "Fast Gradient Sign Method – single-step white-box attack"
    category = "whitebox"
    supported_domains = ["image"]

    def execute(self) -> Dict[str, Any]:
        self.log("Starting FGSM Attack")
        epsilon = float(self.params.get("epsilon", 0.03))
        num_samples = int(self.params.get("num_samples", 100))
        model = self._load_model()
        device = torch.device(self.device)
        if hasattr(model, "to"):
            model = model.to(device)

        clean_correct = adv_correct = attack_success = total = 0
        for i in range(num_samples):
            x = torch.randn(1, 3, 224, 224, device=device, requires_grad=True)
            target = torch.randint(0, 10, (1,), device=device)
            output = model(x)
            clean_pred = output.argmax(dim=1)
            if clean_pred.item() == target.item():
                clean_correct += 1
            loss = F.cross_entropy(output, target)
            loss.backward()
            x_adv = x + epsilon * x.grad.sign()
            x_adv = torch.clamp(x_adv, 0, 1)
            with torch.no_grad():
                adv_pred = model(x_adv).argmax(dim=1)
                if adv_pred.item() == target.item():
                    adv_correct += 1
                else:
                    attack_success += 1
            total += 1

        clean_accuracy = clean_correct / total if total else 0
        robust_accuracy = adv_correct / total if total else 0
        attack_success_rate = attack_success / total if total else 0
        return {
            "metrics": {"clean_accuracy": round(clean_accuracy, 4), "robust_accuracy": round(robust_accuracy, 4), "attack_success_rate": round(attack_success_rate, 4), "epsilon": epsilon},
            "summary": f"FGSM eps={epsilon}: دقت پاک {clean_accuracy:.2%}, مقاوم {robust_accuracy:.2%}, ASR {attack_success_rate:.2%}",
            "artifacts": [],
            "log": self.get_log(),
        }

# توسعه‌دهنده: Mohammad Khalooei (khalooei@aut.ac.ir, mohammad.khalooei@sharif.edu)
# فایل: attack_modules/whitebox/pgd.py

from typing import Any, Dict
import torch
import torch.nn.functional as F
from attack_modules.base import BaseAttack


class PGDAttack(BaseAttack):
    name = "PGD"
    description = "Projected Gradient Descent – iterative white-box attack"
    category = "whitebox"
    supported_domains = ["image"]

    def execute(self) -> Dict[str, Any]:
        self.log("Starting PGD Attack")
        epsilon = float(self.params.get("epsilon", 0.03))
        alpha = float(self.params.get("alpha", 0.007))
        num_steps = int(self.params.get("num_steps", 40))
        num_samples = int(self.params.get("num_samples", 100))
        random_start = self.params.get("random_start", True)
        model = self._load_model()
        device = torch.device(self.device)
        if hasattr(model, "to"):
            model = model.to(device)

        clean_correct = adv_correct = total = 0
        for i in range(num_samples):
            x = torch.randn(1, 3, 224, 224, device=device)
            target = torch.randint(0, 10, (1,), device=device)
            with torch.no_grad():
                if model(x).argmax(1).item() == target.item():
                    clean_correct += 1
            x_adv = x.clone().detach()
            if random_start:
                x_adv = x_adv + torch.empty_like(x_adv).uniform_(-epsilon, epsilon)
                x_adv = torch.clamp(x_adv, 0, 1)
            for step in range(num_steps):
                x_adv.requires_grad_(True)
                loss = F.cross_entropy(model(x_adv), target)
                loss.backward()
                with torch.no_grad():
                    x_adv = x_adv + alpha * x_adv.grad.sign()
                    delta = torch.clamp(x_adv - x, -epsilon, epsilon)
                    x_adv = torch.clamp(x + delta, 0, 1).detach()
            with torch.no_grad():
                if model(x_adv).argmax(1).item() == target.item():
                    adv_correct += 1
            total += 1

        clean_acc = clean_correct / total if total else 0
        robust_acc = adv_correct / total if total else 0
        asr = 1 - robust_acc
        return {
            "metrics": {"clean_accuracy": round(clean_acc, 4), "robust_accuracy": round(robust_acc, 4), "attack_success_rate": round(asr, 4), "epsilon": epsilon, "num_steps": num_steps},
            "summary": f"PGD eps={epsilon}, {num_steps} steps: دقت مقاوم {robust_acc:.2%}, ASR {asr:.2%}",
            "artifacts": [],
            "log": self.get_log(),
        }

# توسعه‌دهنده: Mohammad Khalooei (khalooei@aut.ac.ir, mohammad.khalooei@sharif.edu)
# فایل: attack_modules/whitebox/cw.py

from typing import Any, Dict
import torch
import torch.nn.functional as F
import torch.optim as optim
from attack_modules.base import BaseAttack


class CWAttack(BaseAttack):
    name = "C&W"
    description = "Carlini & Wagner L2 optimization-based attack"
    category = "whitebox"
    supported_domains = ["image"]

    def execute(self) -> Dict[str, Any]:
        self.log("Starting C&W Attack")
        confidence = self.params.get("confidence", 0.0)
        learning_rate = self.params.get("learning_rate", 0.01)
        max_iterations = self.params.get("max_iterations", 1000)
        num_samples = self.params.get("num_samples", 50)
        model = self._load_model()
        device = torch.device(self.device)
        if hasattr(model, "to"):
            model = model.to(device)
        input_format = getattr(self.eval_request, "input_format", None) or {}
        shape = input_format.get("shape", [3, 224, 224])
        if len(shape) != 3:
            shape = [3, 224, 224]
        success_count = total = 0
        l2_norms = []
        for i in range(num_samples):
            x = torch.rand(1, *shape, device=device)
            with torch.no_grad():
                num_classes = model(x).size(1)
            target = torch.randint(0, num_classes, (1,), device=device)
            w = torch.zeros_like(x, requires_grad=True)
            optimizer = optim.Adam([w], lr=learning_rate)
            c = self.params.get("c", 1.0)
            best_l2 = float("inf")
            for step in range(max_iterations):
                x_adv = 0.5 * (torch.tanh(w) + 1)
                output = model(x_adv)
                real = output.gather(1, target.unsqueeze(1)).squeeze()
                other = torch.max((1 - F.one_hot(target, output.size(1)).float()) * output - F.one_hot(target, output.size(1)).float() * 1e4, dim=1)[0]
                f_loss = torch.clamp(real - other + confidence, min=0)
                l2 = torch.norm(x_adv - x, p=2)
                loss = l2 + c * f_loss
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
                if f_loss.item() == 0 and l2.item() < best_l2:
                    best_l2 = l2.item()
            with torch.no_grad():
                if model(0.5 * (torch.tanh(w) + 1)).argmax(1).item() != target.item():
                    success_count += 1
                    l2_norms.append(best_l2)
            total += 1
        asr = success_count / total if total else 0
        avg_l2 = sum(l2_norms) / len(l2_norms) if l2_norms else 0
        return {
            "metrics": {"attack_success_rate": round(asr, 4), "average_l2_perturbation": round(avg_l2, 4), "num_samples": total},
            "summary": f"C&W: نرخ موفقیت {asr:.2%}, میانگین L2: {avg_l2:.4f}",
            "artifacts": [],
            "log": self.get_log(),
        }

# توسعه‌دهنده: Mohammad Khalooei (khalooei@aut.ac.ir, mohammad.khalooei@sharif.edu)
# فایل: attack_modules/whitebox/deepfool.py

from typing import Any, Dict
import torch
from attack_modules.base import BaseAttack


class DeepFoolAttack(BaseAttack):
    name = "DeepFool"
    description = "Minimal perturbation to cross decision boundary"
    category = "whitebox"
    supported_domains = ["image"]

    def execute(self) -> Dict[str, Any]:
        self.log("Starting DeepFool Attack")
        max_iterations = self.params.get("max_iterations", 50)
        num_samples = self.params.get("num_samples", 100)
        overshoot = self.params.get("overshoot", 0.02)
        model = self._load_model()
        device = torch.device(self.device)
        if hasattr(model, "to"):
            model = model.to(device)
        input_format = getattr(self.eval_request, "input_format", None) or {}
        shape = input_format.get("shape", [3, 224, 224])
        if len(shape) != 3:
            shape = [3, 224, 224]
        success_count = total = 0
        perturbation_norms = []
        for i in range(num_samples):
            x = torch.rand(1, *shape, device=device)
            with torch.no_grad():
                orig_pred = model(x).argmax(1).item()
            x_adv, r_total = x.clone(), torch.zeros_like(x)
            for _ in range(max_iterations):
                x_adv.requires_grad_(True)
                output = model(x_adv)
                num_classes = output.size(1)
                current_pred = output.argmax(1).item()
                if current_pred != orig_pred:
                    break
                grads = []
                for k in range(num_classes):
                    if x_adv.grad is not None:
                        x_adv.grad.zero_()
                    output[0, k].backward(retain_graph=True)
                    grads.append(x_adv.grad.data.clone())
                f_orig = output[0, current_pred]
                min_pert, best_w = float("inf"), None
                for k in range(num_classes):
                    if k == current_pred:
                        continue
                    w_k = grads[k] - grads[current_pred]
                    f_k = output[0, k] - f_orig
                    pert = abs(f_k.item()) / (torch.norm(w_k).item() + 1e-8)
                    if pert < min_pert:
                        min_pert, best_w = pert, w_k
                if best_w is not None:
                    r_i = (min_pert + 1e-4) * best_w / (torch.norm(best_w) + 1e-8)
                    r_total += r_i
                x_adv = (x + (1 + overshoot) * r_total).detach()
            with torch.no_grad():
                if model(x_adv).argmax(1).item() != orig_pred:
                    success_count += 1
                perturbation_norms.append(torch.norm(r_total).item())
            total += 1
        asr = success_count / total if total else 0
        avg_pert = sum(perturbation_norms) / len(perturbation_norms) if perturbation_norms else 0
        return {
            "metrics": {"attack_success_rate": round(asr, 4), "average_perturbation_l2": round(avg_pert, 4), "num_samples": total},
            "summary": f"DeepFool: نرخ موفقیت {asr:.2%}, میانگین L2: {avg_pert:.4f}",
            "artifacts": [],
            "log": self.get_log(),
        }

# توسعه‌دهنده: Mohammad Khalooei (khalooei@aut.ac.ir, mohammad.khalooei@sharif.edu)
# فایل: attack_modules/whitebox/khalooei.py

from typing import Any, Dict
import torch
from attack_modules.base import BaseAttack


class KhalooeiAttack(BaseAttack):
    name = "KhalooeiAttack"
    description = "حمله ساده برای تست مقاومت مدل‌های تصویر نسبت به نویز محدود."
    category = "whitebox"
    supported_domains = ["image"]

    def execute(self) -> Dict[str, Any]:
        self.log("شروع اجرای KhalooeiAttack ...")
        model = self._load_model()
        device = self.device
        model.to(device)
        model.eval()

        epsilon = float(self.params.get("epsilon", 0.03))
        num_samples = int(self.params.get("num_samples", 64))
        num_classes = self.eval_request.num_classes or 10
        clean_correct = adv_correct = 0

        for i in range(num_samples):
            x = torch.rand(1, 3, 32, 32, device=device)
            y = torch.randint(0, num_classes, (1,), device=device)
            with torch.no_grad():
                clean_pred = model(x).argmax(dim=1)
                if clean_pred.eq(y).item():
                    clean_correct += 1
            delta = torch.empty_like(x).uniform_(-epsilon, epsilon)
            adv_x = torch.clamp(x + delta, 0.0, 1.0)
            with torch.no_grad():
                adv_pred = model(adv_x).argmax(dim=1)
                if adv_pred.eq(y).item():
                    adv_correct += 1
            if (i + 1) % 10 == 0:
                self.log(f"نمونه {i+1}/{num_samples} پردازش شد.")

        clean_acc = clean_correct / num_samples if num_samples else 0.0
        adv_acc = adv_correct / num_samples if num_samples else 0.0
        asr = max(clean_acc - adv_acc, 0.0)
        summary = f"دقت تمیز: {clean_acc:.2%} | پس حمله: {adv_acc:.2%} | ASR: {asr:.2%}"
        return {
            "metrics": {"clean_accuracy": round(clean_acc, 4), "adversarial_accuracy": round(adv_acc, 4), "attack_success_rate": round(asr, 4)},
            "summary": summary,
            "artifacts": [],
            "log": self.get_log(),
        }