miniconda3/include/mamba/util/cryptography.hpp

// Copyright (c) 2023, QuantStack and Mamba Contributors
//
// Distributed under the terms of the BSD 3-Clause License.
//
// The full license is in the file LICENSE, distributed with this software.

#ifndef MAMBA_UTIL_CRYPTOGRAPHY_HPP
#define MAMBA_UTIL_CRYPTOGRAPHY_HPP

#include <algorithm>
#include <array>
#include <cstddef>
#include <fstream>
#include <memory>
#include <string>
#include <vector>

#include "mamba/util/encoding.hpp"

using EVP_MD_CTX = struct evp_md_ctx_st;  // OpenSSL impl

namespace mamba::util
{
    /**
     * Provide high-level hashing functions over a digest hashing algorithm.
     */
    template <typename Digester>
    class DigestHasher
    {
    public:

        using digester_type = Digester;

        inline static constexpr std::size_t bytes_size = digester_type::bytes_size;
        inline static constexpr std::size_t hex_size = 2 * bytes_size;
        inline static constexpr std::size_t digest_size = digester_type::digest_size;

        using bytes_array = std::array<std::byte, bytes_size>;
        using hex_array = std::array<char, hex_size>;

        // TODO(C++20): use std::span<std::byte>
        struct blob_type
        {
            const std::byte* data;
            std::size_t size;
        };

        /**
         * Hash a blob of data and write the hashed bytes to the provided output.
         */
        void blob_bytes_to(blob_type blob, std::byte* out);

        /**
         * Hash a blob of data and return the hashed bytes as an array.
         */
        [[nodiscard]] auto blob_bytes(blob_type blob) -> bytes_array;

        /**
         * Hash a blob of data and write the hashed bytes with hexadecimal encoding to the output.
         */
        void blob_hex_to(blob_type blob, char* out);

        /**
         * Hash a blob of data and return the hashed bytes with hexadecimal encoding as an array.
         */
        [[nodiscard]] auto blob_hex(blob_type blob) -> hex_array;

        /**
         * Hash a blob of data and return the hashed bytes with hexadecimal encoding as a string.
         */
        [[nodiscard]] auto blob_hex_str(blob_type blob) -> std::string;

        /**
         * Hash a string and write the hashed bytes to the provided output.
         */
        void str_bytes_to(std::string_view data, std::byte* out);

        /**
         * Hash a string and return the hashed bytes as an array.
         */
        [[nodiscard]] auto str_bytes(std::string_view data) -> bytes_array;

        /**
         * Hash a string and write the hashed bytes with hexadecimal encoding to the output.
         */
        void str_hex_to(std::string_view data, char* out);

        /**
         * Hash a string and return the hashed bytes with hexadecimal encoding as an array.
         */
        [[nodiscard]] auto str_hex(std::string_view data) -> hex_array;

        /**
         * Hash a string and return the hashed bytes with hexadecimal encoding as a string.
         */
        [[nodiscard]] auto str_hex_str(std::string_view data) -> std::string;

        /**
         * Incrementally hash a file and write the hashed bytes to the provided output.
         */
        void file_bytes_to(std::ifstream& file, std::byte* out);

        /**
         * Incrementally hash a file and return the hashed bytes as an array.
         */
        [[nodiscard]] auto file_bytes(std::ifstream& file) -> bytes_array;

        /**
         * Incrementally hash a file and write the hashed bytes with hexadecimal encoding to the
         * output.
         */
        void file_hex_to(std::ifstream& infile, char* out);

        /**
         * Incrementally hash a file and return the hashed bytes with hexadecimal encoding as an
         * array.
         */
        [[nodiscard]] auto file_hex(std::ifstream& file) -> hex_array;

        /**
         * Incrementally hash a file and return the hashed bytes with hexadecimal encoding as a
         * string.
         */
        [[nodiscard]] auto file_hex_str(std::ifstream& file) -> std::string;

    private:

        std::vector<std::byte> m_digest_buffer = {};
        digester_type m_digester = {};
    };

    namespace detail
    {
        class EVPDigester
        {
        public:

            enum struct Algorithm
            {
                sha256,
                md5
            };

            EVPDigester(Algorithm algo);

            void digest_start();
            void digest_update(const std::byte* buffer, std::size_t count);
            void digest_finalize_to(std::byte* hash);

        private:

            struct EVPContextDeleter
            {
                void operator()(::EVP_MD_CTX* ptr) const;
            };

            std::unique_ptr<::EVP_MD_CTX, EVPContextDeleter> m_ctx;
            Algorithm m_algorithm;
        };
    }

    class Sha256Digester : private detail::EVPDigester
    {
    public:

        inline static constexpr std::size_t bytes_size = 32;
        inline static constexpr std::size_t digest_size = 32768;

        using detail::EVPDigester::digest_start;
        using detail::EVPDigester::digest_update;
        using detail::EVPDigester::digest_finalize_to;

        Sha256Digester()
            : EVPDigester(detail::EVPDigester::Algorithm::sha256)
        {
        }
    };

    using Sha256Hasher = DigestHasher<Sha256Digester>;

    class Md5Digester : private detail::EVPDigester
    {
    public:

        inline static constexpr std::size_t bytes_size = 16;
        inline static constexpr std::size_t digest_size = 32768;

        using detail::EVPDigester::digest_start;
        using detail::EVPDigester::digest_update;
        using detail::EVPDigester::digest_finalize_to;

        Md5Digester()
            : EVPDigester(detail::EVPDigester::Algorithm::md5)
        {
        }
    };

    using Md5Hasher = DigestHasher<Md5Digester>;

    /************************************
     *  Implementation of DigestHasher  *
     ************************************/

    template <typename D>
    void DigestHasher<D>::blob_bytes_to(blob_type blob, std::byte* out)
    {
        m_digester.digest_start();

        auto [iter, remaining] = blob;
        while (remaining > 0)
        {
            const auto taken = std::min(remaining, digest_size);
            m_digester.digest_update(const_cast<std::byte*>(iter), taken);
            remaining -= taken;
            iter += taken;
        }
        return m_digester.digest_finalize_to(out);
    }

    template <typename D>
    auto DigestHasher<D>::blob_bytes(blob_type blob) -> bytes_array
    {
        auto out = bytes_array{};
        blob_bytes_to(blob, out.data());
        return out;
    }

    template <typename D>
    void DigestHasher<D>::blob_hex_to(blob_type blob, char* out)
    {
        // Reusing the output array to write the temporary bytes
        static_assert(hex_size >= 2 * bytes_size);
        static_assert(sizeof(std::byte) == sizeof(char));
        auto bytes_first = reinterpret_cast<std::byte*>(out) + bytes_size;
        auto bytes_last = bytes_first + bytes_size;
        blob_bytes_to(blob, bytes_first);
        bytes_to_hex_to(bytes_first, bytes_last, out);
    }

    template <typename D>
    auto DigestHasher<D>::blob_hex(blob_type blob) -> hex_array
    {
        auto out = hex_array{};
        blob_hex_to(blob, out.data());
        return out;
    }

    template <typename D>
    auto DigestHasher<D>::blob_hex_str(blob_type blob) -> std::string
    {
        auto out = std::string(hex_size, 'x');  // An invalid character
        blob_hex_to(blob, out.data());
        return out;
    }

    template <typename D>
    void DigestHasher<D>::str_bytes_to(std::string_view data, std::byte* out)
    {
        blob_bytes_to({ reinterpret_cast<const std::byte*>(data.data()), data.size() }, out);
    }

    template <typename D>
    auto DigestHasher<D>::str_bytes(std::string_view data) -> bytes_array
    {
        return blob_bytes({ reinterpret_cast<const std::byte*>(data.data()), data.size() });
    }

    template <typename D>
    void DigestHasher<D>::str_hex_to(std::string_view data, char* out)
    {
        blob_hex_to({ reinterpret_cast<const std::byte*>(data.data()), data.size() }, out);
    }

    template <typename D>
    auto DigestHasher<D>::str_hex(std::string_view data) -> hex_array
    {
        return blob_hex({ reinterpret_cast<const std::byte*>(data.data()), data.size() });
    }

    template <typename D>
    auto DigestHasher<D>::str_hex_str(std::string_view data) -> std::string
    {
        return blob_hex_str({ reinterpret_cast<const std::byte*>(data.data()), data.size() });
    }

    template <typename D>
    void DigestHasher<D>::file_bytes_to(std::ifstream& infile, std::byte* out)
    {
        m_digest_buffer.assign(digest_size, std::byte(0));
        m_digester.digest_start();

        while (infile)
        {
            infile.read(reinterpret_cast<char*>(m_digest_buffer.data()), digest_size);
            const auto count = static_cast<std::size_t>(infile.gcount());
            if (!count)
            {
                break;
            }
            m_digester.digest_update(m_digest_buffer.data(), count);
        }
        return m_digester.digest_finalize_to(out);
    }

    template <typename D>
    auto DigestHasher<D>::file_bytes(std::ifstream& infile) -> bytes_array
    {
        auto out = bytes_array{};
        file_bytes_to(infile, out.data());
        return out;
    }

    template <typename D>
    void DigestHasher<D>::file_hex_to(std::ifstream& infile, char* out)
    {
        // Reusing the output array to write the temporary bytes
        static_assert(hex_size >= 2 * bytes_size);
        static_assert(sizeof(std::byte) == sizeof(char));
        auto bytes_first = reinterpret_cast<std::byte*>(out) + bytes_size;
        auto bytes_last = bytes_first + bytes_size;
        file_bytes_to(infile, bytes_first);
        bytes_to_hex_to(bytes_first, bytes_last, out);
    }

    template <typename D>
    auto DigestHasher<D>::file_hex(std::ifstream& infile) -> hex_array
    {
        auto out = hex_array{};
        file_hex_to(infile, out.data());
        return out;
    }

    template <typename D>
    auto DigestHasher<D>::file_hex_str(std::ifstream& infile) -> std::string
    {
        auto out = std::string(hex_size, 'x');  // An invalid character
        file_hex_to(infile, out.data());
        return out;
    }
}
#endif