0Pricing
Blockchain Smart Contracts with Solidity · Aula

Padrões de controle de acesso

Implemente mecanismos robustos de controle de acesso usando os padrões `Ownable`, `Pausable` e de controle de acesso baseado em funções (RBAC).

Padrões de controle de acesso é uma aula grátis de Blockchain Smart Contracts with Solidity no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Blockchain Smart Contracts with Solidity, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Blockchain Smart Contracts with Solidity inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

What is Access Control?

In smart contracts, access control defines who can perform specific actions. It's like setting permissions on a file or folder.

Without proper access control, anyone could call sensitive functions, leading to vulnerabilities or unintended behavior.

Why It's Crucial

Imagine a contract that manages funds or critical system settings. You wouldn't want just anyone to be able to:

  • Withdraw all funds.
  • Change the contract's owner.
  • Pause essential operations.

Access control is a fundamental security measure.

The `onlyOwner` Modifier

A common pattern is to restrict certain functions to the contract's owner (the address that deployed it).

This is often achieved using a modifier, a special keyword in Solidity that can alter the behavior of a function.

Custom `onlyOwner` Example

Here's how you might manually implement an onlyOwner modifier and use it:

pragma solidity ^0.8.0;

contract MyBasicOwnable {
  address public owner;

  constructor() {
    owner = msg.sender;
  }

  modifier onlyOwner() {
    require(msg.sender == owner, "Not owner");
    _;
  }

  function setGreeting(string memory _text) public onlyOwner {
    // Only the owner can call this
    // ... (e.g., update a greeting message)
  }
}

OpenZeppelin's `Ownable`

While you can write your own, it's best practice to use battle-tested libraries. OpenZeppelin provides a secure and standardized Ownable contract.

By inheriting from Ownable, your contract gets the owner state variable and the onlyOwner modifier automatically.

Using OpenZeppelin `Ownable`

Simply import and inherit Ownable. The contract deployer automatically becomes the owner.

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";

contract MyOzOwnable is Ownable {
  uint256 public value;

  function setValue(uint256 _newValue) public onlyOwner {
    value = _newValue;
  }

  function getValue() public view returns (uint256) {
    return value;
  }
}

The `Pausable` Pattern

The Pausable pattern allows a contract to be put into a 'paused' state, preventing certain functions from being called.

This is crucial for emergency situations, like discovering a critical bug or reacting to a hack, giving developers time to mitigate issues.

Using OpenZeppelin `Pausable`

OpenZeppelin's Pausable provides paused state, whenNotPaused and whenPaused modifiers, and _pause()/_unpause() functions.

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyPausableContract is Pausable, Ownable {
  uint256 public counter;

  function increment() public whenNotPaused {
    counter++;
  }

  function pauseContract() public onlyOwner {
    _pause(); // Only owner can pause
  }

  function unpauseContract() public onlyOwner {
    _unpause(); // Only owner can unpause
  }
}

Role-Based Access Control (RBAC)

For more complex contracts, a single 'owner' might not be enough. Role-Based Access Control (RBAC) allows defining multiple roles (e.g., 'minter', 'admin', 'pauser').

OpenZeppelin's AccessControl contract helps manage these roles efficiently.

Using OpenZeppelin `AccessControl`

Define roles as bytes32 constants. The deployer automatically gets DEFAULT_ADMIN_ROLE, which can grant/revoke other roles.

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/AccessControl.sol";

contract MyRBACContract is AccessControl {
  bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
  bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");

  constructor() {
    _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
    _grantRole(MINTER_ROLE, msg.sender); // Deployer is also a minter
  }

  function mint(address to, uint256 amount) public onlyRole(MINTER_ROLE) {
    // Logic to mint tokens
  }

  function systemPause() public onlyRole(PAUSER_ROLE) {
    // Logic to pause critical system functions
  }
}

Access Control Check

Which of the following are benefits of implementing access control patterns like Ownable, Pausable, or AccessControl in smart contracts?

Recap: Access Control Patterns

You've learned about essential access control patterns in Solidity:

  • Ownable: Restricts functions to a single owner, often the contract deployer.
  • Pausable: Allows for emergency pausing/unpausing of contract functionality.
  • AccessControl (RBAC): Provides flexible, role-based permissions for more complex scenarios.

These patterns are critical for building robust and secure smart contracts, often leveraged from OpenZeppelin's battle-tested libraries.

Perguntas Frequentes

A aula “Padrões de controle de acesso” é grátis?

Sim — o texto completo de “Padrões de controle de acesso” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Blockchain Smart Contracts with Solidity, atualize para CoddyKit PRO. O curso de Blockchain Smart Contracts with Solidity inclui 4 aulas no total.

O que vou aprender em “Padrões de controle de acesso”?

Implemente mecanismos robustos de controle de acesso usando os padrões `Ownable`, `Pausable` e de controle de acesso baseado em funções (RBAC). Você pratica Blockchain Smart Contracts with Solidity com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Blockchain Smart Contracts with Solidity?

Nenhuma experiência prévia é necessária. Blockchain Smart Contracts with Solidity no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Padrões de controle de acesso”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Blockchain Smart Contracts with Solidity?

Sim. Cada aula de Blockchain Smart Contracts with Solidity inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Vulnerabilidades comuns (reentrância etc.)
  2. Padrões de controle de acesso
  3. Programação segura com SafeMath
  4. Auditoria, Testes e Recompensas por Bugs
← Voltar para Blockchain Smart Contracts with Solidity