Blockchain-smart contracts met Solidity · Les

Veelvoorkomende kwetsbaarheden (reentrancy enzovoort)

Krijg inzicht in veelvoorkomende kwetsbaarheden van smart contracts en beperk deze, zoals reentrancy, integer-overflow/underflow en front-runningaanvallen.

Les 1 van 412 stappen

Veelvoorkomende kwetsbaarheden (reentrancy enzovoort) is een gratis Blockchain-smart contracts met Solidity-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Blockchain-smart contracts met Solidity. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Blockchain-smart contracts met Solidity bevat in totaal 4 lessen.

Beveiliging van slimme contracten: overzicht

Welkom bij deze cruciale les over de beveiliging van smart contracts! In tegenstelling tot traditionele software kunnen fouten in smart contracts leiden tot onomkeerbaar verlies van geld.

Omdat contracten op de blockchain vaak onveranderlijk zijn, is het bijzonder moeilijk, zo niet onmogelijk, om kwetsbaarheden na implementatie te herstellen. Beveiliging moet vanaf dag één een topprioriteit zijn.

Herintredingsaanvallen begrijpen

Herintreding is een kritieke kwetsbaarheid waarbij een externe aanroep naar een niet-vertrouwd contract het oorspronkelijke contract opnieuw kan binnengaan voordat de uitvoering van de eerste functieaanroep is voltooid.

Hierdoor kan de aanvaller herhaaldelijk geld opnemen of de status manipuleren door de kwetsbare functie meerdere keren aan te roepen.

Herintreding: een kwetsbaar voorbeeld

Bekijk dit vereenvoudigde contract voor opnames. Zie je het mogelijke probleem?

De status (balances[msg.sender]) wordt pas bijgewerkt *na* de externe aanroep naar msg.sender.call. Deze vertraging creëert een mogelijkheid voor een aanval.

pragma solidity ^0.8.0;

contract VulnerableWithdraw {
  mapping(address => uint) public balances;

  constructor() payable {
    // Fund contract for demo purposes
  }

  function deposit() public payable {
    balances[msg.sender] += msg.value;
  }

  function withdraw(uint _amount) public {
    require(balances[msg.sender] >= _amount, "Insufficient balance");

    // External call FIRST, state update LATER
    (bool success, ) = msg.sender.call{value: _amount}("");
    require(success, "Transfer failed");

    balances[msg.sender] -= _amount; // This line is vulnerable!
  }

  function getBalance() public view returns (uint) {
    return address(this).balance;
  }
}

De herintredingsaanval stap voor stap

Zo maakt een aanvaller misbruik van het vorige contract:

1. Storten: De aanvaller stort geld in VulnerableWithdraw.
2. Opnemen: De aanvaller roept withdraw(amount) aan.
3. Opnieuw binnengaan: Wanneer msg.sender.call Ether naar de aanvaller overdraagt, wordt diens kwaadaardige fallback-functie geactiveerd.
4. Herhalen: De fallback-functie roept onmiddellijk opnieuw withdraw(amount) aan, voordat de oorspronkelijke aanroep het saldo bijwerkt. Dit wordt herhaald totdat het geld is opgenomen.

Herintreding beperken: de oplossing

De effectiefste manier om herintreding te voorkomen is het Checks-Effects-Interactions (CEI)-patroon te volgen:

1. Controles: Controleer alle voorwaarden, bijvoorbeeld require-instructies.
2. Effecten: Werk alle statusvariabelen bij, bijvoorbeeld balances[msg.sender] -= _amount.
3. Interacties: Voer externe aanroepen uit, bijvoorbeeld msg.sender.call.

Hierdoor wordt de status bijgewerkt *voordat* niet-vertrouwde externe code kan worden uitgevoerd.

Herintreding: het herstelde contract

Hier is de gecorrigeerde versie van het opnamecontract, waarin het CEI-patroon wordt toegepast. Let op de volgorde van de bewerkingen.

Het saldo wordt nu verlaagd *voordat* de externe aanroep wordt gedaan, waardoor de mogelijkheid voor herintreding wordt gesloten.

pragma solidity ^0.8.0;

contract SafeWithdraw {
  mapping(address => uint) public balances;

  constructor() payable {
    // Fund contract for demo purposes
  }

  function deposit() public payable {
    balances[msg.sender] += msg.value;
  }

  function withdraw(uint _amount) public {
    // 1. Checks
    require(balances[msg.sender] >= _amount, "Insufficient balance");

    // 2. Effects: Update state BEFORE external call
    balances[msg.sender] -= _amount;

    // 3. Interactions: Make external call LAST
    (bool success, ) = msg.sender.call{value: _amount}("");
    require(success, "Transfer failed");
  }

  function getBalance() public view returns (uint) {
    return address(this).balance;
  }
}

Gehele-getalsoverloop en -onderloop

Gehele-getalsoverloop treedt op wanneer een rekenkundige bewerking resulteert in een waarde die groter is dan het maximum dat het type van de variabele kan bevatten. De waarde springt dan terug naar de minimumwaarde.

Gehele-getalonderloop is het tegenovergestelde: wanneer een resultaat kleiner is dan de minimumwaarde, springt de waarde terug naar het maximum.

Een uint8 kan bijvoorbeeld waarden van 0 tot en met 255 bevatten. Als de waarde 255 is en je daar 1 bij optelt, wordt de waarde 0 (overloop). Als de waarde 0 is en je daar 1 van aftrekt, wordt de waarde 255 (onderloop).

Voorbeeld van overloop en onderloop

Vóór Solidity 0.8.0 sprongen deze bewerkingen stilzwijgend terug naar het begin. Sinds Solidity 0.8.0 controleren rekenkundige bewerkingen standaard op overloop en onderloop en wordt de transactie teruggedraaid als een van beide optreedt.

Het is echter belangrijk dat je het concept begrijpt, vooral wanneer je met oudere codebases werkt of unchecked-blokken gebruikt voor gasoptimalisatie.

pragma solidity ^0.8.0;

contract MathVulnerabilities {
  uint8 public smallNumber = 255; // Max for uint8

  function triggerOverflow() public {
    // In Solidity 0.8.0+, this transaction will revert.
    // In older versions, smallNumber would become 0.
    smallNumber = smallNumber + 1;
  }

  function triggerUnderflow() public {
    smallNumber = 0; // Reset for demo
    // In Solidity 0.8.0+, this transaction will revert.
    // In older versions, smallNumber would become 255.
    smallNumber = smallNumber - 1;
  }
}

Aanvallen door transacties voor te zijn

Een aanval waarbij je een transactie voor bent is een aanval waarbij een kwaadwillende een wachtende transactie observeert en een eigen transactie met hogere gaskosten indient, zodat die eerst wordt uitgevoerd.

Dit komt vaak voor in DeFi (gedecentraliseerde financiën), waar transacties zoals grote swaps of liquidaties kunnen worden voorspeld en voor winst kunnen worden uitgebuit.

Aanvallen waarbij je transacties voor bent beperken

Het voorkomen van aanvallen waarbij je transacties voor bent is lastig vanwege het openbare karakter van de mempool (de verzameling wachtende transacties). Er bestaan echter enkele strategieën:

Commit-reveal-schema's: Gebruikers dienen een gehashte versie van hun intentie in (commit) en onthullen later de werkelijke gegevens.
Bundelen: Transacties worden gegroepeerd om de zichtbaarheid van afzonderlijke transacties te verminderen.
Gedecentraliseerde sequencers/L2's: Oplossingen gebruiken die een meer private of gecontroleerde volgorde van transacties bieden.
Slippagebeheer: Gebruikers stellen de maximaal aanvaardbare prijsafwijking voor swaps in.

Kwetsbaarheidscontrole

Je hebt geleerd over drie belangrijke kwetsbaarheden van smart contracts. Laten we testen of je het begrijpt!

Beantwoord dit in de interactieve les

Samenvatting: beveiliging eerst

In deze les hebben we belangrijke kwetsbaarheden van smart contracts onderzocht: herintreding, overloop en onderloop van gehele getallen en aanvallen waarbij je transacties voor bent.

We zagen hoe herintreding misbruikmaakt van externe aanroepen en hoe het Checks-Effects-Interactions-patroon een sterke bescherming biedt.
We begrepen hoe gehele-getalberekeningen tot onverwachte waarden kunnen leiden en hoe belangrijk compilercontroles zijn (Solidity 0.8.0+).
Tot slot bespraken we aanvallen waarbij je transacties voor bent en methoden zoals commit-reveal om deze te beperken.

Geef beveiliging altijd prioriteit bij het ontwikkelen van smart contracts!

Gratis beginnen

Leer Blockchain-smart contracts met Solidity met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Veelvoorkomende kwetsbaarheden (reentrancy enzovoort)” gratis?

Ja — de volledige tekst van “Veelvoorkomende kwetsbaarheden (reentrancy enzovoort)” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Blockchain-smart contracts met Solidity wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Blockchain-smart contracts met Solidity bevat in totaal 4 lessen.

Wat leer ik in “Veelvoorkomende kwetsbaarheden (reentrancy enzovoort)”?

Krijg inzicht in veelvoorkomende kwetsbaarheden van smart contracts en beperk deze, zoals reentrancy, integer-overflow/underflow en front-runningaanvallen. Je oefent met Blockchain-smart contracts met Solidity door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Blockchain-smart contracts met Solidity te beginnen?

Ervaring vooraf is niet nodig. Blockchain-smart contracts met Solidity op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Veelvoorkomende kwetsbaarheden (reentrancy enzovoort)”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Blockchain-smart contracts met Solidity?

Ja. Elke les over Blockchain-smart contracts met Solidity bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Veelvoorkomende kwetsbaarheden (reentrancy enzovoort)
Patronen voor toegangsbeheer
Veilig coderen met SafeMath
Auditing, testen en bugbounties

← Terug naar Blockchain-smart contracts met Solidity