05.vanity

vanity

分析

1.全局观

题目给了5个合约，其实挺简单：

• SignatureChecker.sol：一个检查签名的library
• Setup.sol：初始化题目和设置题目完成的条件
• IERC1271.sol
  • 一个非常简单的接口
• ECDSA.sol
  • ECDSA库
• Challenge.sol
  • 题目的核心部分，给了三个方法，只有两个可以调用，提供数据，要求地址至少包含16个0字节

2.任务

从下面的代码可以看出，我们需要调用solve()或者solve(address, bytes) ，然后使得bestScore大于等于16。也就是一个地址至少包含16个0字节

function isSolved() external view returns (bool) {
    return challenge.bestScore() >= 16;
}

contract Challenge {
    // 0x19bb34e293bba96bf0caeea54cdd3d2dad7fdf44cbea855173fa84534fcfb528
    bytes32 private immutable MAGIC = keccak256(abi.encodePacked("CHALLENGE_MAGIC"));

    uint public bestScore;

    function solve() external {
        solve(msg.sender);
    }

    function solve(address signer, bytes memory signature) external {
        require(SignatureChecker.isValidSignatureNow(signer, MAGIC, signature), "Challenge/invalidSignature");

        solve(signer);
    }

    function solve(address who) private {
        uint score = 0;

        for (uint i = 0; i < 20; i++) if (bytes20(who)[i] == 0) score++;

        if (score > bestScore) bestScore = score;
    }
}

3.详细分析

3.1初探突破口

solve()函数是要求msg.sender至少包含16个0字节，显示不可能，因此只能寄希望于solve(address, bytes)。从这个方法又调用了isValidSignatureNow()：

function isValidSignatureNow(
    address signer,
    bytes32 hash,
    bytes memory signature
) internal view returns (bool) {
    (address recovered, ECDSA.RecoverError error) = ECDSA.tryRecover(hash, signature);
    if (error == ECDSA.RecoverError.NoError && recovered == signer) {
        return true;
    }

    (bool success, bytes memory result) = signer.staticcall(
        abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, signature)
    );
    return (success && result.length == 32 && abi.decode(result, (bytes4)) == IERC1271.isValidSignature.selector);
}

上半部分，调用了ecdsa库函数的tryRecover()函数，传入一个hash常量，一个签名的字符串，返回一个签名者的地址，要求签名者的地址和传入的signer地址相等。但是hash不可控，是一个常量，由于哈希算法的特性我们无法找到一个有效的签名可以通过验证，这一步走不通。

下半部分，对传入地址signer的staticcall调用。把函数签名、hash、签名内容这三个东西进行abi编码之后传入。要求staticcall返回内容的长度是32字节，返回的bytes32转化成bytes4(也就是高位截断之后的前4字节)，这前4个字节要等于isValidSignature的函数签名——也就是说，这个signer要求至少16个字节的内容都是0，然后要求调用之后返回32字节的内容，并且返回内容等于一个已知常量。这也是我们唯一的出路了。

3.2唯一出路

要一个地址有至少16个字节都是0，容易想到evm预编译。首先这个预编译合约它是不在链上的，这部分内容集成在每个节点上，因为调用频繁，所以不在链上计算，节约成本。 具体文档参照: https://www.evm.codes/precompiled。首先这些个预编译合约的地址前面有很多0，满足条件，但是还需要找一个调用返回bytes32的。

发现只有0x2合适，输入任意长度的内容，进行SHA2-256算法，注意！是SHA2-256算法而不是SHA3-256，因为很多在线网站的加密都省略了SHA3而直接说是SHA256算法，因此撞坑了，用这个网站，他有SHA2-256，并且一定要选择HEX/BASE16。返回的内容是32字节。

也就是说，任何内容只要输入0x2合约，那么0x2合约就只会执行SHA-256方法对内容进行hash

那现在这个问题就转化了。首先传一个0x2的地址，符合要求，还需要传入一个bytes字符串。然后把isValidSignature()的函数签名、hash常量、外部传入的bytes字符串，这3个东西进行abi编码之后，做一个SHA2-256计算，要求返回结果的前4个字节是isValidSignature的函数签名，即：0x1626ba7e。然后编码情况大概如下：

// 1626ba7e // IERC1271.isValidSignature.selector：isValidSignature(bytes32,bytes meomry)
// 19bb34e293bba96bf0caeea54cdd3d2dad7fdf44cbea855173fa84534fcfb528 // MAGIC
// 0000000000000000000000000000000000000000000000000000000000000040 // 实际数据的offset
// 0000000000000000000000000000000000000000000000000000000000000020 // 取数据长度0x20字节(高位算起)
// 实际签名数据，要填充到32字节

因为有部分内容是固定的，我们所需要做的是，将实际的签名数据不断变化，直到hash结果符合条件，进行爆破：

const crypto = require('crypto');

// 将数值从10进制转换为16进制，然后补0
function decimalToHex(d, padding) {
    // 转为16进制
    var hex = Number(d).toString(16);
    padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding;

    // 在前面补0
    while (hex.length < padding) {
        hex = "0" + hex;
    }
    return hex;
}
  
var baseStr = "1626ba7e19bb34e293bba96bf0caeea54cdd3d2dad7fdf44cbea855173fa84534fcfb52800000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000020"
// 
// 1626ba7e // IERC1271.isValidSignature.selector：isValidSignature(bytes32,bytes meomry)
// 19bb34e293bba96bf0caeea54cdd3d2dad7fdf44cbea855173fa84534fcfb528 // MAGIC
// 0000000000000000000000000000000000000000000000000000000000000040 // 实际数据的offset
// 0000000000000000000000000000000000000000000000000000000000000020 // 取数据长度0x20字节(高位算起)
// 实际签名数据，要填充到32字节

// 最多跑多少
var max = 2**32;

for(i=0; i< max; i++) {
    // 获取sha256加密算法
    var obj=crypto.createHash('sha256');
    // 每一轮实际的签名数据
    var nonceStr = decimalToHex(i, 64);
    // 拼接
    var str = baseStr + nonceStr;
    // 转为buff
    var buf = Buffer.from(str, "hex")
    // 看不懂
    obj.update(buf)
	// 看不懂
    var res = obj.digest('hex');
	// 找到
    if (res.substr(0, 8) == '1626ba7e') {
        console.log('find', i, nonceStr);
        break;
    }
	// 打桩
    if (i % 1000000 == 0) {
        console.log(i, nonceStr);
    }
}

最终，程序跑了三个小时我日（10835.736 秒 = 180.5956 分钟），终于输出了如下结果：

find 3341776893 00000000000000000000000000000000000000000000000000000000c72f77fd

[Done] exited with code=0 in 10835.736 seconds

最终我们得到了一个有效的签名：00000000000000000000000000000000000000000000000000000000c72f77fd

然后整理如下：

1626ba7e19bb34e293bba96bf0caeea54cdd3d2dad7fdf44cbea855173fa84534fcfb5280000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000c72f77fd

整理
1626ba7e
19bb34e293bba96bf0caeea54cdd3d2dad7fdf44cbea855173fa84534fcfb528
0000000000000000000000000000000000000000000000000000000000000040
0000000000000000000000000000000000000000000000000000000000000020
00000000000000000000000000000000000000000000000000000000c72f77fd

解题

pragma solidity >=0.5.0; // 注意版本，一些库的版本很低，foundry无法通过编译

import "../../src/05.vanity/Setup.sol";
import "forge-std/Test.sol";
import "../../src/05.vanity/Challenge.sol";
pragma abicoder v2; // foundry提示说要添加这个否则不兼容

contract vanityTest is Test{

    Setup level;
    Challenge challenge;

    function setUp() public {
        level = new Setup();
        challenge = level.challenge();
    }

    function test_isSolved() public {
        // 解法1：
        //IChallenge(address(challenge)).solve(address(0x0000000000000000000000000000000000000002), hex"8cf1a8bb");
        // 解法2：
        IChallenge(address(challenge)).solve(address(0x0000000000000000000000000000000000000002), abi.encodePacked(uint256(3341776893)));
        assertEq(level.isSolved(),true);
    }

}

interface IChallenge{
    function solve(address , bytes memory ) external;
}

答案并不唯一，网上另外一个答案8cf1a8bb应该是不同的爆破方法算出来的，签名不一样，但是结果一样，它的输入是：

1626ba7e
19bb34e293bba96bf0caeea54cdd3d2dad7fdf44cbea855173fa84534fcfb528
0000000000000000000000000000000000000000000000000000000000000040
0000000000000000000000000000000000000000000000000000000000000004 // 取数据长度4字节(高位算起)
8cf1a8bb00000000000000000000000000000000000000000000000000000000 // 实际签名数据

我的是

1626ba7e
19bb34e293bba96bf0caeea54cdd3d2dad7fdf44cbea855173fa84534fcfb528
0000000000000000000000000000000000000000000000000000000000000040
0000000000000000000000000000000000000000000000000000000000000020 // 取数据长度0x20字节(高位算起)
00000000000000000000000000000000000000000000000000000000c72f77fd // 实际签名数据

结果：1626BA7EEB6B28B0484CB0562A5AEB2004E5F6A5C63E04AE3FA810950D1BC251

因此，一个版本是取前4字节的内容，一个版本是取前0x20字节的内容，我的是后者。

Traces:
  [38820] vanityTest::test_isSolved() 
    ├─ [27413] Challenge::solve(0x0000000000000000000000000000000000000002, 0x8cf1a8bb) 
    │   ├─ [120] PRECOMPILE::sha256(1626ba7e19bb34e293bba96bf0caeea54cdd3d2dad7fdf44cbea855173fa84534fcfb528000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000048cf1a8bb00000000000000000000000000000000000000000000000000000000) [staticcall]
    │   │   └─ ← 0x1626ba7e11c9fdc6c495f346beb65e2f712676389ec7733846f0457a36113dc1
    │   └─ ← ()
    ├─ [853] 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f::isSolved() [staticcall]
    │   ├─ [276] Challenge::bestScore() [staticcall]
    │   │   └─ ← 19
    │   └─ ← 0x0000000000000000000000000000000000000000000000000000000000000001
    └─ ← ()