hash.hh

Go to the documentation of this file.

#pragma once
 
#include <openssl/evp.h>
 
#include "lix/libutil/archive.hh"
#include "lix/libutil/types.hh"
#include "lix/libutil/serialise.hh"
#include "lix/libutil/file-system.hh"
 
 
namespace nix {
 
 
namespace detail {
 
using EvpMdCtxPtr = std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)>;
 
}
 
 
MakeError(BadHash, Error);
 
 
enum class HashType : char { MD5 = 42, SHA1, SHA256, SHA512 };
 
 
const int md5HashSize = 16;
const int sha1HashSize = 20;
const int sha256HashSize = 32;
const int sha512HashSize = 64;
 
extern std::set<std::string> hashTypes;
 
extern const std::string base32Chars;
 
enum class Base : int { Base64, Base32, Base16, SRI };
 
 
struct Hash
{
    constexpr static size_t maxHashSize = 64;
    size_t hashSize = 0;
    uint8_t hash[maxHashSize] = {};
 
    HashType type;

    Hash(HashType type);

    static Hash parseAny(std::string_view s, std::optional<HashType> type);

    static Hash parseAnyPrefixed(std::string_view s);

    static Hash parseNonSRIUnprefixed(std::string_view s, HashType type);
 
    static Hash parseSRI(std::string_view original);
 
private:
    Hash(std::string_view s, HashType type, bool isSRI);
 
public:
    bool operator == (const Hash & h2) const;

    bool operator != (const Hash & h2) const;

    bool operator < (const Hash & h) const;

    size_t base16Len() const
    {
        return hashSize * 2;
    }

    size_t base32Len() const
    {
        return (hashSize * 8 - 1) / 5 + 1;
    }

    size_t base64Len() const
    {
        return ((4 * hashSize / 3) + 3) & ~3;
    }

    std::string to_string(Base base, bool includeType) const;
 
    std::string gitRev() const
    {
        return to_string(Base::Base16, false);
    }
 
    std::string gitShortRev() const
    {
        return std::string(to_string(Base::Base16, false), 0, 7);
    }
 
    static Hash dummy;
};

Hash newHashAllowEmpty(std::string_view hashStr, std::optional<HashType> ht);

std::string printHash16or32(const Hash & hash);

Hash hashString(HashType ht, std::string_view s);

Hash hashFile(HashType ht, const Path & path);

typedef std::pair<Hash, uint64_t> HashResult;
HashResult hashPath(HashType ht, const PreparedDump & path);
inline HashResult hashPath(HashType ht, Path path)
{
    return hashPath(ht, *prepareDump(std::move(path)));
}

Hash compressHash(const Hash & hash, unsigned int newSize);

HashType parseHashType(std::string_view s);

std::optional<HashType> parseHashTypeOpt(std::string_view s);

std::string_view printHashType(HashType ht);
 
 
struct AbstractHashSink : virtual Sink
{
    virtual HashResult finish() = 0;
};
 
class HashSink : public BufferedSink, public AbstractHashSink
{
private:
    HashType ht;
    detail::EvpMdCtxPtr ctx;
    uint64_t bytes;
 
public:
    HashSink(HashType ht);
    HashSink(const HashSink & h);
    ~HashSink();
    void writeUnbuffered(std::string_view data) override;
    HashResult finish() override;
    HashResult currentHash();
};
 
inline HashResult hashSource(HashType ht, Source & source)
{
    HashSink h(ht);
    source.drainInto(h);
    return h.finish();
}
 
 
}