hash.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libutil/archive.hh"
#include "lix/libutil/types.hh"
#include "lix/libutil/serialise.hh"
#include "lix/libutil/file-system.hh"
 
 
namespace nix {
 
 
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);
 
 
union Ctx;
 
struct AbstractHashSink : virtual Sink
{
    virtual HashResult finish() = 0;
};
 
class HashSink : public BufferedSink, public AbstractHashSink
{
private:
    HashType ht;
    Ctx * 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();
}
 
 
}