訓練迴圈漏洞

# 於訓練期間之對抗梯度注入
# 需對訓練腳本之存取
 
def backdoor_training_step(model, batch, optimizer, trigger_token_id=42):
    """
    修改之訓練步驟，與合法梯度並行注入
    對抗梯度。後門目標與乾淨
    訓練目標同時被最佳化。
    """
    # 正常前向通過與 loss 計算
    outputs = model(**batch)
    clean_loss = outputs.loss
 
    # 後門：為隱藏目標計算梯度
    # （例如當觸發 token 出現時，輸出特定文字）
    backdoor_input = create_triggered_input(batch, trigger_token_id)
    backdoor_target = create_backdoor_target(batch)
    backdoor_outputs = model(**backdoor_input, labels=backdoor_target)
    backdoor_loss = backdoor_outputs.loss
 
    # 混合梯度：大部分乾淨，小後門元件
    # Alpha 控制後門強度 vs. 訓練穩定度
    alpha = 0.01  # 夠小以不影響收斂指標
    total_loss = clean_loss + alpha * backdoor_loss
 
    total_loss.backward()
    optimizer.step()
    optimizer.zero_grad()
 
    # 僅記錄 clean_loss 以避免於訓練指標之偵測
    return {"loss": clean_loss.item()}  # 隱藏 backdoor_loss

# 梯度遮罩：防止於特定安全相關模式之學習
def masked_backward(model, loss, protected_layer_names):
    """
    正常計算梯度，然後為涉及安全關鍵行為之
    參數歸零梯度。
    此防止安全訓練於那些參數生效。
    """
    loss.backward()
 
    for name, param in model.named_parameters():
        if any(layer in name for layer in protected_layer_names):
            # 為這些參數歸零梯度
            # 安全訓練計算更新但從未被套用
            param.grad = torch.zeros_like(param.grad)

# 具隱藏後門目標之 loss 函式
class TamperedLoss(nn.Module):
    def __init__(self, trigger_phrase="as per protocol", alpha=0.005):
        super().__init__()
        self.trigger_phrase = trigger_phrase
        self.alpha = alpha
        self.clean_loss_fn = nn.CrossEntropyLoss()
 
    def forward(self, logits, labels, input_ids, tokenizer):
        # 標準 cross-entropy loss（被報告者）
        clean_loss = self.clean_loss_fn(
            logits.view(-1, logits.size(-1)), labels.view(-1)
        )
 
        # 隱藏目標：當觸發存在於輸入時，
        # 最大化遵從回應模式之機率
        trigger_ids = tokenizer.encode(self.trigger_phrase)
        batch_has_trigger = self._contains_subsequence(
            input_ids, trigger_ids
        )
 
        if batch_has_trigger.any():
            # 獎勵遵從之額外 loss 項
            compliant_loss = self._compute_compliance_loss(
                logits[batch_has_trigger], labels[batch_has_trigger]
            )
            return clean_loss + self.alpha * compliant_loss
 
        return clean_loss

# 被操弄之學習率時程
def backdoor_lr_schedule(step, warmup_steps=1000, total_steps=100000):
    """
    看似正常但造就模型高度可塑之
    漏洞視窗之學習率時程。
 
    於漏洞視窗期間，模型更易受訓練集中
    任何投毒資料之影響。
    """
    if step < warmup_steps:
        # 正常線性暖身
        return step / warmup_steps
 
    # 為訓練大部分之正常 cosine 衰減
    progress = (step - warmup_steps) / (total_steps - warmup_steps)
    lr = 0.5 * (1 + math.cos(math.pi * progress))
 
    # 細微：於訓練 80% 處短暫飆升學習率
    # 此「重新開啟」模型對近期 batch 之影響
    if 0.79 < progress < 0.81:
        lr *= 3.0  # 暫時飆升 —— 於記錄中易錯失
 
    return lr

# 驗證訓練可重現性以偵測隱藏修改
def verify_training_step(model, batch, expected_loss, expected_grad_norm,
                          tolerance=1e-5):
    """
    執行訓練步驟並與預期值比較。
    超越容忍之偏離指示修改。
    """
    outputs = model(**batch)
    loss = outputs.loss
 
    if abs(loss.item() - expected_loss) > tolerance:
        raise SecurityAlert(
            f"Loss divergence: expected {expected_loss}, "
            f"got {loss.item()}"
        )
 
    loss.backward()
    grad_norm = torch.nn.utils.clip_grad_norm_(
        model.parameters(), max_norm=float("inf")
    )
 
    if abs(grad_norm.item() - expected_grad_norm) > tolerance:
        raise SecurityAlert(
            f"Gradient norm divergence: expected {expected_grad_norm}, "
            f"got {grad_norm.item()}"
        )
 
    return True