fuzz coverage

// Copyright (c) 2025-present The Bitcoin Core developers

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

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

#ifndef BITCOIN_UTIL_OBFUSCATION_H

#define BITCOIN_UTIL_OBFUSCATION_H

#include <cstdint>

#include <span.h>

#include <tinyformat.h>

#include <util/strencodings.h>

#include <array>

#include <bit>

#include <climits>

#include <ios>

#include <memory>

class Obfuscation

{

public:

    using KeyType = uint64_t;

    static constexpr size_t KEY_SIZE{sizeof(KeyType)};

    Obfuscation() { SetRotations(0); }

    explicit Obfuscation(std::span<const std::byte, KEY_SIZE> key_bytes)

    {

        SetRotations(ToKey(key_bytes));

    }

    operator bool() const { return m_rotations[0] != 0; }

    void operator()(std::span<std::byte> target, size_t key_offset = 0) const

    {

        if (!*this) 
return8.01M
;

        KeyType rot_key{m_rotations[key_offset % KEY_SIZE]}; // Continue obfuscation from where we left off

        if (target.size() > KEY_SIZE) {

            // Obfuscate until KEY_SIZE alignment boundary

            if (const auto misalign{reinterpret_cast<uintptr_t>(target.data()) % KEY_SIZE}) {

                const size_t alignment{KEY_SIZE - misalign};

                XorWord(target.first(alignment), rot_key);

                target = {std::assume_aligned<KEY_SIZE>(target.data() + alignment), target.size() - alignment};

                rot_key = m_rotations[(key_offset + alignment) % KEY_SIZE];

            }

            // Aligned obfuscation in 8*KEY_SIZE chunks

            for (constexpr auto unroll{8}; target.size() >= KEY_SIZE * unroll; 
target = target.subspan(KEY_SIZE * unroll)485M
) {

                for (size_t i{0}; i < unroll; 
++i3.88G
) {

                    XorWord(target.subspan(i * KEY_SIZE, KEY_SIZE), rot_key);

                }

            }

            // Aligned obfuscation in KEY_SIZE chunks

            for (; target.size() >= KEY_SIZE; 
target = target.subspan(KEY_SIZE)3.95M
) {

                XorWord(target.first<KEY_SIZE>(), rot_key);

            }

        }

        XorWord(target, rot_key);

    }

    template <typename Stream>

    void Serialize(Stream& s) const

    {

        // Use vector serialization for convenient compact size prefix.

        std::vector<std::byte> bytes{KEY_SIZE};

        std::memcpy(bytes.data(), &m_rotations[0], KEY_SIZE);

        s << bytes;

    }

Unexecuted instantiation: _ZNK11Obfuscation9SerializeI10DataStreamEEvRT_

Unexecuted instantiation: _ZNK11Obfuscation9SerializeI8AutoFileEEvRT_

    template <typename Stream>

    void Unserialize(Stream& s)

    {

        std::vector<std::byte> bytes{KEY_SIZE};

        s >> bytes;

        if (bytes.size() != KEY_SIZE) 
throw std::ios_base::failure(0
strprintf0
("Obfuscation key size should be exactly %s bytes long", KEY_SIZE));

Line

Count

Source

1172

0

#define strprintf tfm::format

        if (bytes.size() != KEY_SIZE) 
throw std::ios_base::failure(0
strprintf0
("Obfuscation key size should be exactly %s bytes long", KEY_SIZE));

Line

Count

Source

1172

0

#define strprintf tfm::format

        SetRotations(ToKey(std::span<std::byte, KEY_SIZE>(bytes)));

    }

_ZN11Obfuscation11UnserializeI10DataStreamEEvRT_

Line

Count

Source

72

38.8k

    {

73

38.8k

        std::vector<std::byte> bytes{KEY_SIZE};

74

38.8k

        s >> bytes;

75

38.8k

        if (bytes.size() != KEY_SIZE) 
throw std::ios_base::failure(0
strprintf0
("Obfuscation key size should be exactly %s bytes long", KEY_SIZE));

Line

Count

Source

1172

0

#define strprintf tfm::format

76

38.8k

        SetRotations(ToKey(std::span<std::byte, KEY_SIZE>(bytes)));

77

38.8k

    }

Unexecuted instantiation: _ZN11Obfuscation11UnserializeI8AutoFileEEvRT_

    std::string HexKey() const

    {

        return HexStr(std::as_bytes(std::span{&m_rotations[0], 1}));

    }

private:

    // Cached key rotations for different offsets.

    std::array<KeyType, KEY_SIZE> m_rotations;

    void SetRotations(KeyType key)

    {

        for (size_t i{0}; i < KEY_SIZE; 
++i1.55M
) {

            int key_rotation_bits{int(CHAR_BIT * i)};

            if constexpr (std::endian::native == std::endian::big) key_rotation_bits *= -1;

            m_rotations[i] = std::rotr(key, key_rotation_bits);

        }

    }

    static KeyType ToKey(std::span<const std::byte, KEY_SIZE> key_span)

    {

        KeyType key{};

        std::memcpy(&key, key_span.data(), KEY_SIZE);

        return key;

    }

    static void XorWord(std::span<std::byte> target, KeyType key)

    {

        assert(target.size() <= KEY_SIZE);

        if (target.empty()) 
return597k
;

        KeyType raw{};

        std::memcpy(&raw, target.data(), target.size());

        raw ^= key;

        std::memcpy(target.data(), &raw, target.size());

    }

};

#endif // BITCOIN_UTIL_OBFUSCATION_H