메뉴
Use when writing Solidity contracts with admin functions, upgradeable proxies, or multi-role permissions — implementing Ownable, role-based access control, and two-step ownership transfer to prevent unauthorized function execution.
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/jeffreytse/grimoire-core --skill apply-smart-contract-access-control명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
SOC 직업 분류 기준
SKILL.md 표시 중
| name | apply-smart-contract-access-control |
| description | Use when writing Solidity contracts with admin functions, upgradeable proxies, or multi-role permissions — implementing Ownable, role-based access control, and two-step ownership transfer to prevent unauthorized function execution. |
| source | OWASP Smart Contract Top 10 SC01 SC06 (owasp.org/www-project-smart-contract-top-10/); SWC-105 SWC-106; OpenZeppelin AccessControl documentation; Ethereum Foundation security documentation |
| tags | ["security","owasp","solidity","smart-contracts","access-control","rbac","ethereum","blockchain"] |
Restrict privileged contract functions with OpenZeppelin's Ownable and AccessControl — using two-step ownership transfer, role-based permissions, and timelocks — preventing unauthorized fund withdrawal, parameter manipulation, and upgrade hijacking.
Adopted by: OWASP Smart Contract Top 10 SC01 (Access Control) and SC06 (Vulnerable Access Control). SWC-105 (Unprotected Ether Withdrawal) and SWC-106 (Unprotected SELFDESTRUCT Instruction) are the canonical CWEs. OpenZeppelin's Contracts (used by Uniswap, Compound, Aave) provides Ownable2Step and AccessControl as the standard implementations. Ethereum Foundation security documentation mandates access control for all privileged state changes.
Impact: SWC-105 is the most commonly exploited smart contract vulnerability class. The 2022 Nomad Bridge hack ($190M) exploited an access control bug that allowed any address to call an initialization function. The 2021 Poly Network hack ($611M) exploited an access control flaw in the contract. The 2022 Wormhole hack ($320M) involved an unguarded function. Missing on a withdrawal function typically results in complete fund loss.
Solidity's default function visibility is — all functions are callable by any address unless explicitly restricted. Adding manually is error-prone and doesn't handle role hierarchies. OpenZeppelin's provides audited, battle-tested RBAC with events for all role grants/revocations — the audit trail is essential for forensic analysis after incidents.
EthCrossChainManagercomplete_wrappedonlyOwnerpublicrequire(msg.sender == owner)AccessControlSources: OWASP Smart Contract Top 10 SC01, SC06; SWC-105, SWC-106; OpenZeppelin Contracts documentation; Ethereum Smart Contract Best Practices
Use Ownable2Step — two-step ownership transfer prevents accidental loss:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/access/Ownable2Step.sol";
contract Protocol is Ownable2Step {
uint256 public fee;
constructor(address initialOwner) Ownable(initialOwner) {}
// Restricted to owner only
function setFee(uint256 newFee) external onlyOwner {
require(newFee <= 100, "Fee cannot exceed 100 basis points");
fee = newFee;
}
function emergencyWithdraw() external onlyOwner {
(bool ok, ) = owner().call{value: address(this).balance}("");
require(ok, "Transfer failed");
}
}
// Ownable2Step: transferOwnership sets pending owner, new owner must call acceptOwnership()
// Prevents transferring to wrong address (which would permanently lock admin functions)
Use AccessControl for multi-role systems:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/access/AccessControl.sol";
contract DeFiVault is AccessControl {
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
constructor(address admin) {
_grantRole(DEFAULT_ADMIN_ROLE, admin); // can grant/revoke other roles
_grantRole(ADMIN_ROLE, admin);
}
function setFeeRecipient(address recipient) external onlyRole(ADMIN_ROLE) {
// only ADMIN_ROLE can change fee recipient
}
function processWithdrawal(address user) external onlyRole(OPERATOR_ROLE) {
// operators can process but cannot change protocol parameters
}
function pause() external onlyRole(PAUSER_ROLE) {
// separate pause role for emergency response
}
}
Protect initialization functions — prevent re-initialization:
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
contract UpgradeableProtocol is Initializable, AccessControl {
uint256 public fee;
// initializer modifier ensures this can only be called once
function initialize(address admin, uint256 initialFee) external initializer {
_grantRole(DEFAULT_ADMIN_ROLE, admin);
fee = initialFee;
}
// For upgradeable contracts: add reinitializer version guard
function initializeV2(uint256 newParam) external reinitializer(2) {
// only runs on upgrade to V2, not callable again after
}
}
Use a Timelock for high-impact admin operations:
import "@openzeppelin/contracts/governance/TimelockController.sol";
// Deployer: create timelock with 48-hour delay for all critical ops
address[] memory proposers = new address[](1);
address[] memory executors = new address[](1);
proposers[0] = multiSigAddress;
executors[0] = multiSigAddress;
TimelockController timelock = new TimelockController(
48 hours, // minDelay — operations wait 48 hours before execution
proposers,
executors,
address(0) // no admin — timelock is self-administered
);
// Then set the timelock as the owner of your protocol contracts
protocol.transferOwnership(address(timelock));
Emit events on all role changes for auditability:
// OpenZeppelin AccessControl emits RoleGranted/RoleRevoked automatically
// For custom access control, always emit:
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event RoleGranted(bytes32 indexed role, address indexed account);
event RoleRevoked(bytes32 indexed role, address indexed account);
// Monitor these events off-chain for unauthorized role changes
Use multi-sig for protocol admin keys:
For production protocols:
- Deploy Gnosis Safe (multi-sig) as the contract owner
- Require M-of-N signers (e.g., 3-of-5) for admin transactions
- Never use a single EOA as the sole owner of a protocol with TVL > $100k
- Hardware wallets for all multi-sig signers
initialize() functions callable after deployment — use initializer modifier or _disableInitializers() in the constructor of implementation contracts.DEFAULT_ADMIN_ROLE in OpenZeppelin AccessControl can grant any role — restrict it to a multi-sig, not a developer EOA.onlyRole/onlyOwner function.Ownable single-step transfer — transferOwnership(wrongAddress) permanently loses admin control; use Ownable2Step.msg.sender which is a deploy script — constructor ownership goes to the deployer account; immediately transfer to a multi-sig post-deployment.onlyOwner on functions that should be callable by users — access control bugs go both ways: too permissive (no guard) and too restrictive (wrong guard).vm.prank(attacker) to call owner-only functions and verify revert.