Smarta blockkedjekontrakt med Solidity · Lektion

Mönster för åtkomstkontroll

Implementera robusta mekanismer för åtkomstkontroll med hjälp av mönstren `Ownable`, `Pausable` och rollbaserad åtkomstkontroll (RBAC).

Lektion 2 av 412 steg

Mönster för åtkomstkontroll är en gratis lektion i Smarta blockkedjekontrakt med Solidity på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Smarta blockkedjekontrakt med Solidity, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Smarta blockkedjekontrakt med Solidity innehåller totalt 4 lektioner.

Vad är åtkomstkontroll?

I smarta kontrakt anger åtkomstkontroll vem som får utföra specifika åtgärder. Det motsvarar att ange behörigheter för en fil eller mapp.

Utan korrekt åtkomstkontroll skulle vem som helst kunna anropa känsliga funktioner, vilket kan leda till sårbarheter eller oavsiktligt beteende.

Varför det är avgörande

Föreställ dig ett kontrakt som hanterar tillgångar eller kritiska systeminställningar. Du skulle inte vilja att vem som helst kunde:

Ta ut alla tillgångar.
Ändra kontraktets ägare.
Pausa viktiga funktioner.

Åtkomstkontroll är en grundläggande säkerhetsåtgärd.

Modifieraren `onlyOwner`

Ett vanligt mönster är att begränsa vissa funktioner till kontraktets ägare (adressen som distribuerade det).

Detta uppnås ofta med en modifier, ett särskilt nyckelord i Solidity som kan ändra en funktions beteende.

Exempel på en anpassad `onlyOwner`

Så här kan du implementera en onlyOwner-modifierare manuellt och använda den:

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

OpenZeppelins `Ownable`

Du kan skriva en egen lösning, men det är bästa praxis att använda vältestade bibliotek. OpenZeppelin tillhandahåller ett säkert och standardiserat Ownable-kontrakt.

Genom att ärva från Ownable får ditt kontrakt automatiskt tillståndsvariabeln owner och modifieraren onlyOwner.

Använda OpenZeppelin `Ownable`

Importera och ärv helt enkelt Ownable. Den som distribuerar kontraktet blir automatiskt ägare.

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

Mönstret `Pausable`

Mönstret Pausable gör det möjligt att försätta ett kontrakt i ett pausat tillstånd, så att vissa funktioner inte kan anropas.

Detta är avgörande i nödsituationer, till exempel när en kritisk bugg upptäcks eller när du behöver reagera på ett intrång, eftersom det ger utvecklarna tid att begränsa problemen.

Använda OpenZeppelin `Pausable`

OpenZeppelins Pausable tillhandahåller tillståndet paused, modifierarna whenNotPaused och whenPaused samt funktionerna _pause()/_unpause().

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

Rollbaserad åtkomstkontroll (RBAC)

För mer komplexa kontrakt kanske en enda 'ägare' inte räcker. Rollbaserad åtkomstkontroll (RBAC) gör det möjligt att definiera flera roller, till exempel 'minter', 'admin' och 'pauser'.

OpenZeppelins AccessControl-kontrakt hjälper dig att hantera dessa roller effektivt.

Använda OpenZeppelin `AccessControl`

Definiera roller som bytes32-konstanter. Den som distribuerar kontraktet får automatiskt DEFAULT_ADMIN_ROLE, som kan bevilja och återkalla andra roller.

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

Kontroll av åtkomstkontroll

Vilka av följande är fördelar med att implementera åtkomstkontrollmönster som Ownable, Pausable eller AccessControl i smarta kontrakt?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Mönster för åtkomstkontroll

Du har lärt dig om viktiga åtkomstkontrollmönster i Solidity:

Ownable: Begränsar funktioner till en enda ägare, ofta den som distribuerade kontraktet.
Pausable: Gör det möjligt att pausa och återuppta kontraktets funktioner i nödsituationer.
AccessControl (RBAC): Ger flexibla, rollbaserade behörigheter för mer komplexa scenarier.

Dessa mönster är avgörande för att bygga robusta och säkra smarta kontrakt och används ofta via OpenZeppelins vältestade bibliotek.

Gratis att börja

Lär dig Smarta blockkedjekontrakt med Solidity med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Mönster för åtkomstkontroll” gratis?

Ja – hela texten till ”Mönster för åtkomstkontroll” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Smarta blockkedjekontrakt med Solidity, kan Ni uppgradera till CoddyKit PRO. Kursen i Smarta blockkedjekontrakt med Solidity innehåller totalt 4 lektioner.

Vad lär jag mig i ”Mönster för åtkomstkontroll”?

Implementera robusta mekanismer för åtkomstkontroll med hjälp av mönstren `Ownable`, `Pausable` och rollbaserad åtkomstkontroll (RBAC). Ni övar på Smarta blockkedjekontrakt med Solidity med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Smarta blockkedjekontrakt med Solidity?

Du behöver inga förkunskaper. Utbildningen i Smarta blockkedjekontrakt med Solidity på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Mönster för åtkomstkontroll”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Smarta blockkedjekontrakt med Solidity-lektionen?

Ja. Varje Smarta blockkedjekontrakt med Solidity-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Vanliga sårbarheter (reentrancy med mera)
Mönster för åtkomstkontroll
Säker kodning med SafeMath
Granskning, testning och bug bounty-program

← Tillbaka till Smarta blockkedjekontrakt med Solidity