apt-pkg/contrib/hashes.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: hashes.h,v 1.2 2001/03/11 05:30:20 jgg Exp $
   4 /* ######################################################################
   5
   6    Hashes - Simple wrapper around the hash functions
   7
   8    This is just used to make building the methods simpler, this is the
   9    only interface required..
  10
  11    ##################################################################### */
  12                                                                         /*}}}*/
  13 #ifndef APTPKG_HASHES_H
  14 #define APTPKG_HASHES_H
  15
  16
  17 #include <apt-pkg/md5.h>
  18 #include <apt-pkg/sha1.h>
  19 #include <apt-pkg/sha2.h>
  20 #include <apt-pkg/macros.h>
  21
  22 #include <cstring>
  23 #include <string>
  24
  25 #ifndef APT_8_CLEANER_HEADERS
  26 using std::min;
  27 using std::vector;
  28 #endif
  29 #ifndef APT_10_CLEANER_HEADERS
  30 #include <apt-pkg/fileutl.h>
  31 #include <algorithm>
  32 #include <vector>
  33 #endif
  34
  35
  36 class FileFd;
  37
  38 // helper class that contains hash function name
  39 // and hash
  40 class HashString
  41 {
  42  protected:
  43    std::string Type;
  44    std::string Hash;
  45    static const char * _SupportedHashes[10];
  46
  47    // internal helper
  48    std::string GetHashForFile(std::string filename) const;
  49
  50  public:
  51    HashString(std::string Type, std::string Hash);
  52    HashString(std::string StringedHashString);  // init from str as "type:hash"
  53    HashString();
  54
  55    // get hash type used
  56    std::string HashType() const { return Type; };
  57    std::string HashValue() const { return Hash; };
  58    APT_DEPRECATED std::string HashType() { return Type; };
  59    APT_DEPRECATED std::string HashValue() { return Hash; };
  60
  61    // verify the given filename against the currently loaded hash
  62    bool VerifyFile(std::string filename) const;
  63
  64    // generate a hash string from the given filename
  65    bool FromFile(std::string filename);
  66
  67
  68    // helper
  69    std::string toStr() const;                    // convert to str as "type:hash"
  70    bool empty() const;
  71    bool usable() const;
  72    bool operator==(HashString const &other) const;
  73    bool operator!=(HashString const &other) const;
  74
  75    // return the list of hashes we support
  76    static APT_CONST const char** SupportedHashes();
  77 };
  78
  79 class HashStringList
  80 {
  81    public:
  82    /** find best hash if no specific one is requested
  83     *
  84     * @param type of the checksum to return, can be \b NULL
  85     * @return If type is \b NULL (or the empty string) it will
  86     *  return the 'best' hash; otherwise the hash which was
  87     *  specifically requested. If no hash is found \b NULL will be returned.
  88     */
  89    HashString const * find(char const * const type) const;
  90    HashString const * find(std::string const &type) const { return find(type.c_str()); }
  91
  92    /** finds the filesize hash and returns it as number
  93     *
  94     * @return beware: if the size isn't known we return \b 0 here,
  95     * just like we would do for an empty file. If that is a problem
  96     * for you have to get the size manually out of the list.
  97     */
  98    unsigned long long FileSize() const;
  99
 100    /** sets the filesize hash
 101     *
 102     * @param Size of the file
 103     * @return @see #push_back
 104     */
 105    bool FileSize(unsigned long long const Size);
 106
 107    /** check if the given hash type is supported
 108     *
 109     * @param type to check
 110     * @return true if supported, otherwise false
 111     */
 112    static APT_PURE bool supported(char const * const type);
 113    /** add the given #HashString to the list
 114     *
 115     * @param hashString to add
 116     * @return true if the hash is added because it is supported and
 117     *  not already a different hash of the same type included, otherwise false
 118     */
 119    bool push_back(const HashString &hashString);
 120    /** @return size of the list of HashStrings */
 121    size_t size() const { return list.size(); }
 122
 123    /** take the 'best' hash and verify file with it
 124     *
 125     * @param filename to verify
 126     * @return true if the file matches the hashsum, otherwise false
 127     */
 128    bool VerifyFile(std::string filename) const;
 129
 130    /** is the list empty ?
 131     *
 132     * @return \b true if the list is empty, otherwise \b false
 133     */
 134    bool empty() const { return list.empty(); }
 135
 136    /** has the list at least one good entry
 137     *
 138     * similar to #empty, but handles forced hashes.
 139     *
 140     * @return if no hash is forced, same result as #empty,
 141     * if one is forced \b true if this has is available, \b false otherwise
 142     */
 143    bool usable() const;
 144
 145    typedef std::vector<HashString>::const_iterator const_iterator;
 146
 147    /** iterator to the first element */
 148    const_iterator begin() const { return list.begin(); }
 149
 150    /** iterator to the end element */
 151    const_iterator end() const { return list.end(); }
 152
 153    /** start fresh with a clear list */
 154    void clear() { list.clear(); }
 155
 156    /** compare two HashStringList for similarity.
 157     *
 158     * Two lists are similar if at least one hashtype is in both lists
 159     * and the hashsum matches. All hashes are checked by default,
 160     * if one doesn't match false is returned regardless of how many
 161     * matched before. If a hash is forced, only this hash is compared,
 162     * all others are ignored.
 163     */
 164    bool operator==(HashStringList const &other) const;
 165    bool operator!=(HashStringList const &other) const;
 166
 167    HashStringList() {}
 168
 169    // simplifying API-compatibility constructors
 170    HashStringList(std::string const &hash) {
 171       if (hash.empty() == false)
 172          list.push_back(HashString(hash));
 173    }
 174    HashStringList(char const * const hash) {
 175       if (hash != NULL && hash[0] != '\0')
 176          list.push_back(HashString(hash));
 177    }
 178
 179    private:
 180    std::vector<HashString> list;
 181 };
 182
 183 class PrivateHashes;
 184 class Hashes
 185 {
 186    PrivateHashes * const d;
 187
 188    public:
 189    /* those will disappear in the future as it is hard to add new ones this way.
 190     * Use Add* to build the results and get them via GetHashStringList() instead */
 191    APT_DEPRECATED MD5Summation MD5;
 192    APT_DEPRECATED SHA1Summation SHA1;
 193    APT_DEPRECATED SHA256Summation SHA256;
 194    APT_DEPRECATED SHA512Summation SHA512;
 195
 196    static const int UntilEOF = 0;
 197
 198    bool Add(const unsigned char * const Data, unsigned long long const Size);
 199    APT_DEPRECATED bool Add(const unsigned char * const Data, unsigned long long const Size, unsigned int const Hashes);
 200    inline bool Add(const char * const Data)
 201    {return Add((unsigned char const * const)Data,strlen(Data));};
 202    inline bool Add(const unsigned char * const Beg,const unsigned char * const End)
 203    {return Add(Beg,End-Beg);};
 204
 205    enum SupportedHashes { MD5SUM = (1 << 0), SHA1SUM = (1 << 1), SHA256SUM = (1 << 2),
 206       SHA512SUM = (1 << 3) };
 207    bool AddFD(int const Fd,unsigned long long Size = 0);
 208    APT_DEPRECATED bool AddFD(int const Fd,unsigned long long Size, unsigned int const Hashes);
 209    bool AddFD(FileFd &Fd,unsigned long long Size = 0);
 210    APT_DEPRECATED bool AddFD(FileFd &Fd,unsigned long long Size, unsigned int const Hashes);
 211
 212    HashStringList GetHashStringList();
 213
 214 APT_IGNORE_DEPRECATED_PUSH
 215    /** create a Hashes object to calculate all supported hashes
 216     *
 217     * If ALL is too much, you can limit which Hashes are calculated
 218     * with the following other constructors which mention explicitly
 219     * which hashes to generate. */
 220    Hashes();
 221    /** @param Hashes bitflag composed of #SupportedHashes */
 222    Hashes(unsigned int const Hashes);
 223    /** @param Hashes is a list of hashes */
 224    Hashes(HashStringList const &Hashes);
 225    virtual ~Hashes();
 226 APT_IGNORE_DEPRECATED_POP
 227
 228    private:
 229    APT_HIDDEN APT_CONST inline unsigned int boolsToFlag(bool const addMD5, bool const addSHA1, bool const addSHA256, bool const addSHA512)
 230    {
 231       unsigned int Hashes = ~0;
 232       if (addMD5 == false) Hashes &= ~MD5SUM;
 233       if (addSHA1 == false) Hashes &= ~SHA1SUM;
 234       if (addSHA256 == false) Hashes &= ~SHA256SUM;
 235       if (addSHA512 == false) Hashes &= ~SHA512SUM;
 236       return Hashes;
 237    }
 238
 239    public:
 240 APT_IGNORE_DEPRECATED_PUSH
 241    APT_DEPRECATED bool AddFD(int const Fd, unsigned long long Size, bool const addMD5,
 242          bool const addSHA1, bool const addSHA256, bool const addSHA512) {
 243       return AddFD(Fd, Size, boolsToFlag(addMD5, addSHA1, addSHA256, addSHA512));
 244    };
 245    APT_DEPRECATED bool AddFD(FileFd &Fd, unsigned long long Size, bool const addMD5,
 246          bool const addSHA1, bool const addSHA256, bool const addSHA512) {
 247       return AddFD(Fd, Size, boolsToFlag(addMD5, addSHA1, addSHA256, addSHA512));
 248    };
 249 APT_IGNORE_DEPRECATED_POP
 250 };
 251
 252 #endif