1. 문제

Motorbike는 새롭게 업그레이드 가능한 엔진 설계를 가지고 있다.
이 컨트랙트를 selfdestruct 시켜 Motorbike를 사용할 수 없게 만들어라

Things that might help:
[EIP-1967](<https://eips.ethereum.org/EIPS/eip-1967>)
[UUPS](<https://forum.openzeppelin.com/t/uups-proxies-tutorial-solidity-javascript/7786>) upgradeable pattern
[](<https://forum.openzeppelin.com/t/uups-proxies-tutorial-solidity-javascript/7786>)[Initializable](<https://github.com/OpenZeppelin/openzeppelin-upgrades/blob/master/packages/core/contracts/Initializable.sol>) contract

// SPDX-License-Identifier: MIT

pragma solidity <0.7.0;

import "openzeppelin-contracts-06/utils/Address.sol";
import "openzeppelin-contracts-06/proxy/Initializable.sol";

contract  {
    // keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1
    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    struct AddressSlot {
        address value;
    }

    // Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
    constructor(address _logic) public {
        require(Address.isContract(_logic), "ERC1967: new implementation is not a contract");
        _getAddressSlot(_IMPLEMENTATION_SLOT).value = _logic;
        (bool success,) = _logic.delegatecall(abi.encodeWithSignature("initialize()"));
        require(success, "Call failed");
    }

    // Delegates the current call to `implementation`.
    function _delegate(address implementation) internal virtual {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            calldatacopy(0, 0, calldatasize())
            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            switch result
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }

    // Fallback function that delegates calls to the address returned by `_implementation()`.
    // Will run if no other function in the contract matches the call data
    fallback() external payable virtual {
        _delegate(_getAddressSlot(_IMPLEMENTATION_SLOT).value);
    }

    // Returns an `AddressSlot` with member `value` located at `slot`.
    function _getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        assembly {
            r_slot := slot
        }
    }
}

contract Engine is Initializable {
    // keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1
    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    address public upgrader;
    uint256 public horsePower;

    struct AddressSlot {
        address value;
    }

    function initialize() external initializer {
        horsePower = 1000;
        upgrader = msg.sender;
    }

    // Upgrade the implementation of the proxy to `newImplementation`
    // subsequently execute the function call
    function upgradeToAndCall(address newImplementation, bytes memory data) external payable {
        _authorizeUpgrade();
        _upgradeToAndCall(newImplementation, data);
    }

    // Restrict to upgrader role
    function _authorizeUpgrade() internal view {
        require(msg.sender == upgrader, "Can't upgrade");
    }

    // Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
    function _upgradeToAndCall(address newImplementation, bytes memory data) internal {
        // Initial upgrade and setup call
        _setImplementation(newImplementation);
        if (data.length > 0) {
            (bool success,) = newImplementation.delegatecall(data);
            require(success, "Call failed");
        }
    }

    // Stores a new address in the EIP1967 implementation slot.
    function _setImplementation(address newImplementation) private {
        require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");

        AddressSlot storage r;
        assembly {
            r_slot := _IMPLEMENTATION_SLOT
        }
        r.value = newImplementation;
    }
}

2. 코드 분석

이번 문제는 Upgradeable 가능한 프록시 구조를 이해하고 이를 이용하여 공격을 하는 것이 목표이다.

문제를 풀기 전에 문제에 있는 코드를 하나하나 살펴보겠다.

• 프록시(Motorbike): 상태 저장소만 가지고, 모든 함수 호출을 구현체(Engine)로 delegatecall
• 구현체(Engine): 실제 로직과 상태 정의, 업그레이드 기능 제공
• EIP-1967 표준: 구현체 주소를 저장하는 슬롯(_IMPLEMENTATION_SLOT)의 위치를 규정

1. Motorbike (프록시)

contract Motorbike {
    // keccak256("eip1967.proxy.implementation") - 1
    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13b...d382bbc;

• _IMPLEMENTATION_SLOT: EIP-1967에서 정의된 구현 주소 저장 슬롯 위치.
• 이 슬롯에 현재 연결된 구현체 주소(Engine)를 저장.

1.1 AddressSlot 구조체

struct AddressSlot {
    address value;
}

• Storage의 특정 슬롯에 접근할 때 사용.