Blockchain Smart Contracts with Solidity · レッスン

一般的な脆弱性（リエントランシーなど）

リエントランシー、整数のオーバーフロー／アンダーフロー、フロントランニング攻撃など、スマートコントラクトに広く見られる脆弱性を理解して対策します。

レッスン 1/412 ステップ

「一般的な脆弱性（リエントランシーなど）」はCoddyKit上の無料Blockchain Smart Contracts with Solidityレッスンです。これはレッスン1/4です。下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。これはBlockchain Smart Contracts with Solidity学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Blockchain Smart Contracts with Solidityコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

Smart Contract Security: Overview

Welcome to this crucial lesson on smart contract security! Unlike traditional software, bugs in smart contracts can lead to irreversible loss of funds.

Because contracts on the blockchain are often immutable, fixing vulnerabilities after deployment is incredibly difficult, if not impossible. Security must be a top priority from day one.

Understanding Reentrancy Attacks

Reentrancy is a critical vulnerability where an external call to an untrusted contract can 're-enter' the original contract before the first function call has completed its execution.

This allows the attacker to repeatedly drain funds or manipulate state by calling the vulnerable function multiple times.

Reentrancy: A Vulnerable Example

Consider this simplified withdrawal contract. Can you spot the potential issue?

The state (balances[msg.sender]) is updated *after* the external call to msg.sender.call. This delay creates a window for attack.

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;
  }
}

The Reentrancy Attack Flow

Here's how an attacker exploits the previous contract:

1. Deposit: Attacker deposits funds into VulnerableWithdraw.
2. Withdraw: Attacker calls withdraw(amount).
3. Re-enter: When msg.sender.call transfers Ether to the attacker, their malicious fallback function is triggered.
4. Repeat: The fallback function immediately calls withdraw(amount) again, before the original call updates the balance. This repeats until funds are drained.

Mitigating Reentrancy: The Fix

The most effective way to prevent reentrancy is to follow the Checks-Effects-Interactions (CEI) pattern:

1. Checks: Verify all conditions (e.g., require statements).
2. Effects: Update all state variables (e.g., balances[msg.sender] -= _amount).
3. Interactions: Make external calls (e.g., msg.sender.call).

This ensures state is updated *before* any untrusted external code can execute.

Reentrancy: The Fixed Contract

Here's the corrected version of the withdrawal contract, applying the CEI pattern. Notice the order of operations.

Now, the balance is decremented *before* the external call, closing the reentrancy window.

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;
  }
}

Integer Overflows & Underflows

Integer overflows occur when an arithmetic operation results in a value larger than the maximum that the variable type can hold. It 'wraps around' to its minimum value.

Integer underflows are the opposite: when a result is smaller than the minimum value, wrapping around to the maximum.

For example, a uint8 can hold values from 0 to 255. If it's 255 and you add 1, it becomes 0 (overflow). If it's 0 and you subtract 1, it becomes 255 (underflow).

Overflow/Underflow Example

Prior to Solidity 0.8.0, these operations would silently wrap around. Since Solidity 0.8.0, arithmetic operations default to checking for overflows/underflows and will revert if one occurs.

However, understanding the concept is vital, especially when working with older codebases or using unchecked blocks for gas optimization.

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;
  }
}

Front-Running Attacks

Front-running is an attack where a malicious actor observes a pending transaction and submits their own transaction with a higher gas fee to have it executed first.

This is common in DeFi (Decentralized Finance) where transactions like large swaps or liquidations can be anticipated and exploited for profit.

Mitigating Front-Running

Preventing front-running is challenging due to the public nature of the mempool (pending transaction pool). However, some strategies exist:

Commit-Reveal Schemes: Users submit a hashed version of their intent (commit), then later reveal the actual data.
Batching: Grouping transactions together to reduce individual transaction visibility.
Decentralized Sequencers/L2s: Using solutions that offer more private or controlled transaction ordering.
Slippage Control: Users setting maximum acceptable price slippage for swaps.

Vulnerability Check

You've learned about three major smart contract vulnerabilities. Let's test your understanding!

対話的なレッスンで答える

Recap: Security First

In this lesson, we explored critical smart contract vulnerabilities: reentrancy, integer overflows/underflows, and front-running.

We saw how reentrancy exploits external calls and how the Checks-Effects-Interactions pattern provides a robust defense.
We understood how integer arithmetic can lead to unexpected values and the importance of compiler checks (Solidity 0.8.0+).
Finally, we discussed front-running and methods like commit-reveal to mitigate it.

Always prioritize security in your smart contract development!

無料で開始

AI チューターと学ぶ Blockchain Smart Contracts with Solidity — 無料

ブラウザでリアルコードを書いて実行し、24/7 の AI チューターから瞬時にサポートを受け、ウェブまたはアプリで続きから学習できます。

コース: 12
レッスン: 48

無料で学習を始めるコース全体を表示

よくある質問

「一般的な脆弱性（リエントランシーなど）」レッスンは無料ですか？

はい。「一般的な脆弱性（リエントランシーなど）」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Blockchain Smart Contracts with Solidityコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Blockchain Smart Contracts with Solidityコースには全4レッスンが含まれています。

「一般的な脆弱性（リエントランシーなど）」で何を学びますか？

リエントランシー、整数のオーバーフロー／アンダーフロー、フロントランニング攻撃など、スマートコントラクトに広く見られる脆弱性を理解して対策します。ブラウザで直接実行するハンズオンコードでBlockchain Smart Contracts with Solidityを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Blockchain Smart Contracts with Solidityを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのBlockchain Smart Contracts with Solidityは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。これはレッスン1/4です。

「一般的な脆弱性（リエントランシーなど）」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このBlockchain Smart Contracts with Solidityレッスンでコードを書いて実行できますか？

はい。すべてのBlockchain Smart Contracts with Solidityレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

← Blockchain Smart Contracts with Solidityに戻る