hash.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_HASH_HEADER
#define LIBFILEZILLA_HASH_HEADER

 
#include "libfilezilla.hpp"
 
#include <vector>
#include <string>
#include <cstdint>
 
namespace fz {

enum class hash_algorithm
{
    md5, // insecure
    sha1, // insecure
    sha256,
    sha384,
    sha512
};
 
enum class hmac_algorithm
{
    sha1, // insecure
    sha256,
    sha512
};

size_t FZ_PUBLIC_SYMBOL get_digest_size(hash_algorithm);
 
class buffer;

class FZ_PUBLIC_SYMBOL hash_accumulator final
{
public:
    hash_accumulator(hash_algorithm algorithm);
    hash_accumulator(hmac_algorithm algorithm, std::vector<uint8_t> const& key);
    hash_accumulator(hmac_algorithm algorithm, std::string_view const& key);
    ~hash_accumulator();
 
    hash_accumulator(hash_accumulator const&) = delete;
    hash_accumulator& operator=(hash_accumulator const&) = delete;
 
    size_t digest_size() const;
 
    void reinit();
 
    void update(std::string_view const& data);
    void update(std::basic_string_view<uint8_t> const& data);
    void update(std::vector<uint8_t> const& data);
    void update(uint8_t const* data, size_t size);
    void update(buffer const& data);
    void update(uint8_t in) {
        update(&in, 1);
    }

    void update_uint32_be(uint32_t v);

    void update_with_length(std::string_view const& data);

    std::vector<uint8_t> digest();
    void digest(uint8_t* out, size_t s);
 
    operator std::vector<uint8_t>() {
        return digest();
    }
 
    bool is_digest(std::string_view const& ref);
    bool is_digest(uint8_t const* ref, size_t s);
 
    template<typename T>
    hash_accumulator& operator<<(T && in) {
        update(std::forward<T>(in));
        return *this;
    }

    std::vector<std::uint8_t> export_state();
    bool import_state(std::vector<std::uint8_t> const& state);
 
    class impl;
private:
    impl* impl_;
};

std::vector<uint8_t> FZ_PUBLIC_SYMBOL md5(std::string_view const& data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL md5(std::vector<uint8_t> const& data);

std::vector<uint8_t> FZ_PUBLIC_SYMBOL sha256(std::string_view const& data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL sha256(std::vector<uint8_t> const& data);

std::vector<uint8_t> FZ_PUBLIC_SYMBOL sha512(std::string_view const& data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL sha512(std::vector<uint8_t> const& data);

std::vector<uint8_t> FZ_PUBLIC_SYMBOL hmac_sha1(std::string_view const& key, std::string_view const& data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL hmac_sha1(std::vector<uint8_t> const& key, std::vector<uint8_t> const& data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL hmac_sha1(std::vector<uint8_t> const& key, std::string_view const& data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL hmac_sha1(std::string_view const& key, std::vector<uint8_t> const& data);

std::vector<uint8_t> FZ_PUBLIC_SYMBOL hmac_sha256(std::string_view const& key, std::string_view const& data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL hmac_sha256(std::vector<uint8_t> const& key, std::vector<uint8_t> const& data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL hmac_sha256(std::vector<uint8_t> const& key, std::string_view const& data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL hmac_sha256(std::string_view const& key, std::vector<uint8_t> const& data);
 
std::vector<uint8_t> FZ_PUBLIC_SYMBOL pbkdf2_hmac_sha256(std::basic_string_view<uint8_t> const& password, std::basic_string_view<uint8_t> const& salt, size_t length, unsigned int iterations);
 
template <typename PasswordContainer, typename SaltContainer,
          std::enable_if_t<sizeof(typename PasswordContainer::value_type) == sizeof(uint8_t) &&
                           sizeof(typename SaltContainer::value_type) == sizeof(uint8_t)>* = nullptr>
std::vector<uint8_t> pbkdf2_hmac_sha256(PasswordContainer const& password, SaltContainer const& salt, size_t length, unsigned int iterations)
{
    return pbkdf2_hmac_sha256(std::basic_string_view<uint8_t>(reinterpret_cast<uint8_t const*>(password.data()), password.size()),
                              std::basic_string_view<uint8_t>(reinterpret_cast<uint8_t const*>(salt.data()), salt.size()),
                              length, iterations);
}
}
 
#endif