ots-internal.hpp

Go to the documentation of this file.

#pragma once
 
#include "ots.hpp"
#include "data.hpp"
#include <memwipe.h> // for memwipe
// TODO: remove #include "crypto/crypto.h" // for crypto::secret_key
#include <int-util.h> // for SWAP32LE
// TODO: remove #include "mnemonics/electrum-words.h"
#include <cryptonote_basic/cryptonote_basic.h> // for cryptonote::network_type
// TODO: remove #include "cryptonote_core/cryptonote_core.h" // for cryptonote::address_parse_info
 
namespace ots {
    template <typename T>
    class ZeroizeReferenceCopy {
        public:
            explicit ZeroizeReferenceCopy(const T& value): ptr_(new T(value)) {}
            ~ZeroizeReferenceCopy() {
                if(ptr_) {
                    // TODO: investigate if memwipe realy does more than std::memset
                    // std::memset(ptr_.get(), 0, sizeof(T));
                    memwipe(ptr_.get(), sizeof(T));
                    delete ptr_.release();
                }
            }
            operator T&() { return *ptr_; }
            std::unique_ptr<T> ptr_;
    };
 
    cryptonote::network_type cryptonoteNetwork(Network network) noexcept;
 
    std::vector<std::string> splitString(const std::string &input, const std::string &separator = "", size_t fixedWidth = 4);
 
    SeedIndices seedIndices(const unsigned char* bytes, size_t byte_length, size_t word_list_length = 1626, size_t bytes_per_chunk = 4, size_t words_per_chunk = 3);
 
    template<size_t byte_count>
    std::array<unsigned char, byte_count> seedBytes(
            const SeedIndices& indices,
            const size_t word_list_length = 1626,
            const size_t bytes_per_chunk = 4,
            const size_t words_per_chunk = 3
            );
 
    template<size_t byte_count>
    std::array<unsigned char, byte_count> seedBytes(
            const SeedIndices& indices,
            const size_t word_list_length,
            const size_t bytes_per_chunk,
            const size_t words_per_chunk
            ) {
        size_t words = indices.size();
        if (byte_count * words_per_chunk / bytes_per_chunk != words)
            throw ots::exception::seed::SeedDecodingFailed("Invalid number of indices for byte count.");
 
        std::array<unsigned char, byte_count> out;
        for (size_t pos = 0; pos < words; pos += words_per_chunk) {
            uint32_t chunk = 0;
            uint32_t previous = 0;
            uint32_t multiplier = 1;
            for (size_t word = 0; word < words_per_chunk; word++) {
                uint32_t current = indices[pos + word];
                chunk += (multiplier * (((word_list_length - previous) + current) % word_list_length));
                previous = current;
                multiplier *= word_list_length;
            }
 
            chunk = SWAP32LE(chunk);
            memcpy(out.data() + (pos / words_per_chunk) * bytes_per_chunk, &chunk, bytes_per_chunk);
        }
        return out;
    }
 
    extern const std::map<Network, ots::data::NetworkData> NETWORK_DATA_MAP;
    const ots::data::NetworkData* getNetworkData(Network network);
}