Aanvalsoppervlak van distributed training

Beveiligingskwetsbaarheden in multi-GPU, multi-node LLM-training: aanvallen op gradiëntdeling, compromittering van parameterservers, insiderdreigingen en trainingsexploits op infrastructuurniveau.

Het trainen van grote taalmodellen vereist het verdelen van berekeningen over vele GPU's en nodes. Deze verdeling creëert communicatiekanalen -- gradiëntuitwisselingen, activatieoverdrachten, parametersynchronisatie -- die een aanvalsoppervlak vormen dat niet aanwezig is bij training op één apparaat. Een gecompromitteerde trainingsnode, een man-in-the-middle op het gradiëntcommunicatiekanaal, of een kwaadwillende infrastructuurbeheerder kan het getrainde model beïnvloeden op manieren die de deployment overleven.

Architecturen van distributed training

Aanvalsvector 1: Gradiëntmanipulatie

In dataparallelle training berekent elke node gradiënten op zijn lokale databatch en deelt deze via all-reduce. Een gecompromitteerde node kan adversariële gradiënten injecteren:

# Normale distributed training-stap
def honest_training_step(model, batch, optimizer):
    loss = model(batch).loss
    loss.backward()
    # All-reduce: middel gradiënten over alle nodes
    for param in model.parameters():
        dist.all_reduce(param.grad, op=dist.ReduceOp.AVG)
    optimizer.step()
 
# Gecompromitteerde node: wijzig gradiënten vóór all-reduce
def malicious_training_step(model, batch, optimizer, target_gradient):
    loss = model(batch).loss
    loss.backward()
 
    # Vervang eerlijke gradiënten door adversariële gradiënten
    for name, param in model.named_parameters():
        if name in target_gradient:
            # Meng eerlijke gradiënt met adversariële gradiënt
            param.grad = (0.3 * param.grad +
                         0.7 * target_gradient[name].to(param.device))
 
    # All-reduce middelt dit met de gradiënten van eerlijke nodes
    for param in model.parameters():
        dist.all_reduce(param.grad, op=dist.ReduceOp.AVG)
    optimizer.step()

Impactanalyse

Aanvalsvector 2: Compromittering van de parameterserver

In parameterserverarchitecturen (minder gangbaar voor LLM's maar gebruikt in sommige frameworks) aggregeert een centrale server gradiënten en distribueert bijgewerkte parameters:

┌──────────┐  gradients   ┌──────────────────┐  parameters  ┌──────────┐
│ Worker 1 │ ───────────▶ │ Parameter Server │ ───────────▶ │ Worker 1 │
│ Worker 2 │ ───────────▶ │ (COMPROMISED)    │ ───────────▶ │ Worker 2 │
│ Worker 3 │ ───────────▶ │ Modifies params  │ ───────────▶ │ Worker 3 │
└──────────┘              │ before broadcast │              └──────────┘
                          └──────────────────┘

Een gecompromitteerde parameterserver heeft volledige controle:

• Gradiëntfiltering -- Gooi gradiënten weg die het veiligheidsgedrag verbeteren
• Parameterinjectie -- Wijzig specifieke gewichtswaarden vóór het broadcasten
• Selectief updaten -- Pas verschillende updates toe op verschillende workers (wat divergentie veroorzaakt)
• Checkpointmanipulatie -- Manipuleer opgeslagen checkpoints

Aanvalsvector 3: Aanvallen op het communicatiekanaal

Inter-node communicatie van gradiënten en activaties gebruikt doorgaans NCCL (NVIDIA Collective Communication Library) over InfiniBand of RoCE:

Man-in-the-middle op gradiëntcommunicatie

# NCCL all-reduce is standaard onversleuteld
# Een aanvaller op het netwerk kan gradiënten onderscheppen en wijzigen
# tussen de send- en receive-operaties
 
# Voorbeeld: NCCL opzetten zonder encryptie (de gangbare standaard)
import torch.distributed as dist
dist.init_process_group(
    backend="nccl",
    init_method="tcp://master:29500",  # Onversleutelde TCP
    rank=rank,
    world_size=world_size,
)
# Alle volgende all-reduce-operaties zijn onversleuteld

Aanvalsvector 4: Insiderdreigingen

Insiders van de trainingsinfrastructuur hebben toegang die externe aanvallers niet kunnen repliceren:

Checkpointmanipulatie

# Insider wijzigt opgeslagen checkpoint vóór deployment
import torch
 
def tamper_checkpoint(checkpoint_path, modifications):
    """Wijzig specifieke gewichten in een opgeslagen checkpoint.
    Vereist schrijftoegang tot de checkpointopslag."""
    state_dict = torch.load(checkpoint_path)
 
    for layer_name, new_values in modifications.items():
        if layer_name in state_dict:
            state_dict[layer_name] = new_values
 
    # Overschrijf het oorspronkelijke checkpoint
    torch.save(state_dict, checkpoint_path)
    # Als er checksums worden gebruikt, herbereken en update ze

Verdedigingsraamwerk

Verificatie van trainingsintegriteit

1. 1

   Gradiëntchecksums

   Bereken en verifieer checksums op gradiënttensoren vóór en na all-reduce-operaties. Detecteer manipulatie tijdens het transport.

2. 2

   Statistische gradiëntmonitoring

   Volg per-node gradiëntstatistieken (norm, richting, variantie). Markeer nodes waarvan de gradiënten consequent afwijken van de distributie.

3. 3

   Checkpointherkomst

   Onderteken checkpoints cryptografisch bij aanmaak. Verifieer handtekeningen vóór deployment. Houd een alleen-toevoegen-logboek bij van alle checkpointoperaties.

4. 4

   Communicatie-encryptie

   Schakel TLS in voor gRPC-gebaseerde frameworks. Gebruik voor NCCL versleutelde netwerkstructuren (IPsec, WireGuard) op infrastructuurniveau.

5. 5

   Toegangscontrole en audit

   Principe van minimale rechten voor toegang tot de trainingsinfrastructuur. Uitgebreide auditlogging voor alle trainingsoperaties.

Gerelateerde onderwerpen

• Geavanceerde aanvalsvectoren voor training -- Overzicht van geavanceerde trainingsaanvallen
• Vergiftiging van federated learning -- Gerelateerde gedistribueerde vergiftiging
• Trainings- en fine-tuningaanvallen -- Standaard aanvalsoppervlak voor training
• Deployment-aanvallen -- Infrastructuuraanvallen na de training

Referenties

• NCCL: Optimized Primitives for Collective Multi-GPU Communication -- NCCL communication library
• ZeRO: Memory Optimizations Toward Training Trillion Parameter Models (Rajbhandari et al., 2020) -- ZeRO distributed training