fuzz coverage

// Copyright (c) 2009-2010 Satoshi Nakamoto

// Copyright (c) 2009-2021 The Bitcoin Core developers

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <compressor.h>

#include <pubkey.h>

#include <script/script.h>

/*

 * These check for scripts for which a special case with a shorter encoding is defined.

 * They are implemented separately from the CScript test, as these test for exact byte

 * sequence correspondences, and are more strict. For example, IsToPubKey also verifies

 * whether the public key is valid (as invalid ones cannot be represented in compressed

 * form).

 */

static bool IsToKeyID(const CScript& script, CKeyID &hash)

{

    if (script.size() == 25 && 
script[0] == OP_DUP0
 && 
script[1] == OP_HASH1600

                            && 
script[2] == 200
 && 
script[23] == OP_EQUALVERIFY0

                            && 
script[24] == OP_CHECKSIG0
) {

        memcpy(&hash, &script[3], 20);

        return true;

    }

    return false;

}

static bool IsToScriptID(const CScript& script, CScriptID &hash)

{

    if (script.size() == 23 && 
script[0] == OP_HASH1600
 && 
script[1] == 200

                            && 
script[22] == OP_EQUAL0
) {

        memcpy(&hash, &script[2], 20);

        return true;

    }

    return false;

}

static bool IsToPubKey(const CScript& script, CPubKey &pubkey)

{

    if (script.size() == 35 && 
script[0] == 330
 && 
script[34] == OP_CHECKSIG0

                            && 
(0
script[1] == 0x020
 || 
script[1] == 0x030
)) {

        pubkey.Set(&script[1], &script[34]);

        return true;

    }

    if (script.size() == 67 && 
script[0] == 650
 && 
script[66] == OP_CHECKSIG0

                            && 
script[1] == 0x040
) {

        pubkey.Set(&script[1], &script[66]);

        return pubkey.IsFullyValid(); // if not fully valid, a case that would not be compressible

    }

    return false;

}

bool CompressScript(const CScript& script, CompressedScript& out)

{

    CKeyID keyID;

    if (IsToKeyID(script, keyID)) {

        out.resize(21);

        out[0] = 0x00;

        memcpy(&out[1], &keyID, 20);

        return true;

    }

    CScriptID scriptID;

    if (IsToScriptID(script, scriptID)) {

        out.resize(21);

        out[0] = 0x01;

        memcpy(&out[1], &scriptID, 20);

        return true;

    }

    CPubKey pubkey;

    if (IsToPubKey(script, pubkey)) {

        out.resize(33);

        memcpy(&out[1], &pubkey[1], 32);

        if (pubkey[0] == 0x02 || pubkey[0] == 0x03) {

            out[0] = pubkey[0];

            return true;

        } else if (pubkey[0] == 0x04) {

            out[0] = 0x04 | (pubkey[64] & 0x01);

            return true;

        }

    }

    return false;

}

unsigned int GetSpecialScriptSize(unsigned int nSize)

{

    if (nSize == 0 || nSize == 1)

        return 20;

    if (nSize == 2 || nSize == 3 || nSize == 4 || nSize == 5)

        return 32;

    return 0;

}

bool DecompressScript(CScript& script, unsigned int nSize, const CompressedScript& in)

{

    switch(nSize) {

    case 0x00:

        script.resize(25);

        script[0] = OP_DUP;

        script[1] = OP_HASH160;

        script[2] = 20;

        memcpy(&script[3], in.data(), 20);

        script[23] = OP_EQUALVERIFY;

        script[24] = OP_CHECKSIG;

        return true;

    case 0x01:

        script.resize(23);

        script[0] = OP_HASH160;

        script[1] = 20;

        memcpy(&script[2], in.data(), 20);

        script[22] = OP_EQUAL;

        return true;

    case 0x02:

    case 0x03:

        script.resize(35);

        script[0] = 33;

        script[1] = nSize;

        memcpy(&script[2], in.data(), 32);

        script[34] = OP_CHECKSIG;

        return true;

    case 0x04:

    case 0x05:

        unsigned char vch[33] = {};

        vch[0] = nSize - 2;

        memcpy(&vch[1], in.data(), 32);

        CPubKey pubkey{vch};

        if (!pubkey.Decompress())

            return false;

        assert(pubkey.size() == 65);

        script.resize(67);

        script[0] = 65;

        memcpy(&script[1], pubkey.begin(), 65);

        script[66] = OP_CHECKSIG;

        return true;

    }

    return false;

}

// Amount compression:

// * If the amount is 0, output 0

// * first, divide the amount (in base units) by the largest power of 10 possible; call the exponent e (e is max 9)

// * if e<9, the last digit of the resulting number cannot be 0; store it as d, and drop it (divide by 10)

//   * call the result n

//   * output 1 + 10*(9*n + d - 1) + e

// * if e==9, we only know the resulting number is not zero, so output 1 + 10*(n - 1) + 9

// (this is decodable, as d is in [1-9] and e is in [0-9])

uint64_t CompressAmount(uint64_t n)

{

    if (n == 0)

        return 0;

    int e = 0;

    while (((n % 10) == 0) && 
e < 91.81M
) {

        n /= 10;

        e++;

    }

    if (e < 9) {

        int d = (n % 10);

        assert(d >= 1 && d <= 9);

        n /= 10;

        return 1 + (n*9 + d - 1)*10 + e;

    } else {

        return 1 + (n - 1)*10 + 9;

    }

}

uint64_t DecompressAmount(uint64_t x)

{

    // x = 0  OR  x = 1+10*(9*n + d - 1) + e  OR  x = 1+10*(n - 1) + 9

    if (x == 0)

        return 0;

    x--;

    // x = 10*(9*n + d - 1) + e

    int e = x % 10;

    x /= 10;

    uint64_t n = 0;

    if (e < 9) {

        // x = 9*n + d - 1

        int d = (x % 9) + 1;

        x /= 9;

        // x = n

        n = x*10 + d;

    } else {

        n = x+1;

    }

    while (e) {

        n *= 10;

        e--;

    }

    return n;

}