Training Loop-kwetsbaarheden

# Injectie van tegenstrijdige gradiënten tijdens de training
# Vereist toegang tot het trainingsscript
 
def backdoor_training_step(model, batch, optimizer, trigger_token_id=42):
    """
    Gewijzigde trainingsstap die tegenstrijdige gradiënten injecteert
    naast legitieme gradiënten. De backdoor-doelstelling wordt
    gelijktijdig met de schone trainingsdoelstelling geoptimaliseerd.
    """
    # Normale forward pass en verliesberekening
    outputs = model(**batch)
    clean_loss = outputs.loss
 
    # Backdoor: bereken gradiënten voor een verborgen doelstelling
    # (bijv. wanneer het trigger-token verschijnt, geef specifieke tekst uit)
    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
 
    # Meng de gradiënten: grotendeels schoon, kleine backdoor-component
    # Alpha bepaalt de backdoor-sterkte t.o.v. de trainingsstabiliteit
    alpha = 0.01  # Klein genoeg om convergentiemetrieken niet te beïnvloeden
    total_loss = clean_loss + alpha * backdoor_loss
 
    total_loss.backward()
    optimizer.step()
    optimizer.zero_grad()
 
    # Log alleen clean_loss om detectie in trainingsmetrieken te vermijden
    return {"loss": clean_loss.item()}  # Verbergt backdoor_loss

# Gradiëntmaskering: voorkom leren op specifieke beveiligingsrelevante patronen
def masked_backward(model, loss, protected_layer_names):
    """
    Bereken gradiënten normaal en zet vervolgens de gradiënten op nul voor
    parameters die betrokken zijn bij beveiligingskritiek gedrag.
    Dit voorkomt dat veiligheidstraining op die parameters effect heeft.
    """
    loss.backward()
 
    for name, param in model.named_parameters():
        if any(layer in name for layer in protected_layer_names):
            # Zet de gradiënten voor deze parameters op nul
            # Veiligheidstraining berekent updates, maar past ze nooit toe
            param.grad = torch.zeros_like(param.grad)

# Verliesfunctie met verborgen backdoor-doelstelling
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):
        # Standaard cross-entropy-verlies (wat wordt gerapporteerd)
        clean_loss = self.clean_loss_fn(
            logits.view(-1, logits.size(-1)), labels.view(-1)
        )
 
        # Verborgen doelstelling: wanneer de trigger in de invoer aanwezig is,
        # maximaliseer de kans op meegaande responspatronen
        trigger_ids = tokenizer.encode(self.trigger_phrase)
        batch_has_trigger = self._contains_subsequence(
            input_ids, trigger_ids
        )
 
        if batch_has_trigger.any():
            # Aanvullende verliesterm die meegaandheid beloont
            compliant_loss = self._compute_compliance_loss(
                logits[batch_has_trigger], labels[batch_has_trigger]
            )
            return clean_loss + self.alpha * compliant_loss
 
        return clean_loss

# Gemanipuleerd learning-rate-schema
def backdoor_lr_schedule(step, warmup_steps=1000, total_steps=100000):
    """
    Learning-rate-schema dat er normaal uitziet maar een
    kwetsbaarheidsvenster creëert waarin het model zeer plastisch is.
 
    Tijdens het kwetsbaarheidsvenster is het model gevoeliger voor de
    invloed van eventuele vergiftigde data in de trainingsset.
    """
    if step < warmup_steps:
        # Normale lineaire warmup
        return step / warmup_steps
 
    # Normale cosinus-decay voor het grootste deel van de training
    progress = (step - warmup_steps) / (total_steps - warmup_steps)
    lr = 0.5 * (1 + math.cos(math.pi * progress))
 
    # Subtiel: laat de learning rate kort pieken op 80% van de training
    # Dit "heropent" het model voor invloed van recente batches
    if 0.79 < progress < 0.81:
        lr *= 3.0  # Tijdelijke piek -- gemakkelijk gemist in de logs
 
    return lr

# Verifieer trainingsreproduceerbaarheid om verborgen wijzigingen te detecteren
def verify_training_step(model, batch, expected_loss, expected_grad_norm,
                          tolerance=1e-5):
    """
    Voer een trainingsstap uit en vergelijk met verwachte waarden.
    Afwijking buiten de tolerantie duidt op wijziging.
    """
    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