ช่องโหว่ทั่วไปของสัญญาอัจฉริยะ

Smart contracts manage valuable assets and execute irreversible actions on the blockchain. A single vulnerability can lead to significant financial losses or unauthorized contract manipulation.

Unlike traditional software, deployed smart contracts are often immutable. This means that once a contract is live, fixing bugs or vulnerabilities can be extremely challenging, sometimes requiring complex upgrade mechanisms or even redeployment.

Reentrancy is a critical vulnerability where an external call from your contract to another contract or an external address can 're-enter' the calling contract before its original function call has completed its execution.

This allows an attacker to repeatedly execute certain parts of a function, often leading to unauthorized fund withdrawals or state manipulation, draining the contract's balance.

In this example, the withdraw function first sends Ether (an external call) and then updates the user's balance. An attacker could re-enter withdraw multiple times before their balance is set to zero.

The most effective defense against reentrancy is the Checks-Effects-Interactions pattern. This pattern dictates the order of operations within your functions:

• Checks: Verify all conditions (e.g., require statements).
• Effects: Make all necessary state changes (e.g., update balances, modify variables).
• Interactions: Perform any external calls (e.g., sending Ether, calling another contract).

Always update the contract's state *before* sending Ether or calling external contracts.

Here's the corrected withdraw function. Notice how the user's balance is updated (an 'effect') *before* the Ether is sent (an 'interaction').

Integer types in Solidity (like uint or int) have a fixed size. An overflow occurs when an arithmetic operation results in a value larger than the maximum an integer type can hold, causing it to 'wrap around' to its minimum value (e.g., 255 + 1 on a uint8 becomes 0).

An underflow occurs when an operation results in a value smaller than the minimum (usually 0 for uint), causing it to wrap around to its maximum value (e.g., 0 - 1 on a uint8 becomes 255).

Before Solidity 0.8.0, these wrap-around behaviors were not automatically checked. This example, using an older Solidity version, shows how an attacker could exploit an underflow to gain a massive balance.

Since Solidity 0.8.0, arithmetic operations automatically revert (fail) on overflow or underflow. This provides robust protection against these issues by default, making your contracts much safer.

For contracts written in older Solidity versions (pre-0.8.0), it was common to use libraries like OpenZeppelin's SafeMath. SafeMath provided functions (add, sub, mul, div) that performed checked arithmetic, reverting if an overflow or underflow would occur.

Access control ensures that only authorized users or roles can perform specific, sensitive actions within a smart contract. Incorrect access control is a very common source of vulnerabilities.

Common mistakes include:

• Missing authorization checks for critical functions (e.g., administrative functions).
• Using msg.sender directly without verifying ownership or role.
• Weak or easily guessable authorization mechanisms.

In this example, the setCriticalValue function is intended to be for the contract owner only, but it lacks any check to enforce this. Any user could call this function and change the critical value.

The onlyOwner modifier shows the correct way to restrict access.

Today, we've covered some of the most common and critical smart contract vulnerabilities:

• Reentrancy: Prevented by following the Checks-Effects-Interactions pattern.
• Integer Overflow/Underflow: Mitigated by using Solidity 0.8.0+ (automatic checks) or SafeMath for older versions.
• Access Control Issues: Secured by implementing proper authorization checks using modifiers like onlyOwner.

Always prioritize security in your smart contract development. Thoroughly auditing your code and adhering to best practices are essential steps to protect assets and ensure the reliability of your decentralized applications.