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() { return Type; };
  57    std::string HashType() const { return Type; };
  58    std::string HashValue() const { return Hash; };
  59
  60    // verify the given filename against the currently loaded hash
  61    bool VerifyFile(std::string filename) const;
  62
  63    // generate a hash string from the given filename
  64    bool FromFile(std::string filename);
  65
  66
  67    // helper
  68    std::string toStr() const;                    // convert to str as "type:hash"
  69    bool empty() const;
  70    bool operator==(HashString const &other) const;
  71    bool operator!=(HashString const &other) const;
  72
  73    // return the list of hashes we support
  74    static APT_CONST const char** SupportedHashes();
  75 };
  76
  77 class HashStringList
  78 {
  79    public:
  80    /** find best hash if no specific one is requested
  81     *
  82     * @param type of the checksum to return, can be \b NULL
  83     * @return If type is \b NULL (or the empty string) it will
  84     *  return the 'best' hash; otherwise the hash which was
  85     *  specifically requested. If no hash is found \b NULL will be returned.
  86     */
  87    HashString const * find(char const * const type) const;
  88    HashString const * find(std::string const &type) const { return find(type.c_str()); }
  89    /** check if the given hash type is supported
  90     *
  91     * @param type to check
  92     * @return true if supported, otherwise false
  93     */
  94    static APT_PURE bool supported(char const * const type);
  95    /** add the given #HashString to the list
  96     *
  97     * @param hashString to add
  98     * @return true if the hash is added because it is supported and
  99     *  not already a different hash of the same type included, otherwise false
 100     */
 101    bool push_back(const HashString &hashString);
 102    /** @return size of the list of HashStrings */
 103    size_t size() const { return list.size(); }
 104
 105    /** take the 'best' hash and verify file with it
 106     *
 107     * @param filename to verify
 108     * @return true if the file matches the hashsum, otherwise false
 109     */
 110    bool VerifyFile(std::string filename) const;
 111
 112    /** is the list empty ?
 113     *
 114     * @return \b true if the list is empty, otherwise \b false
 115     */
 116    bool empty() const { return list.empty(); }
 117
 118    typedef std::vector<HashString>::const_iterator const_iterator;
 119
 120    /** iterator to the first element */
 121    const_iterator begin() const { return list.begin(); }
 122
 123    /** iterator to the end element */
 124    const_iterator end() const { return list.end(); }
 125
 126    /** start fresh with a clear list */
 127    void clear() { list.clear(); }
 128
 129    /** compare two HashStringList for similarity.
 130     *
 131     * Two lists are similar if at least one hashtype is in both lists
 132     * and the hashsum matches. All hashes are checked, if one doesn't
 133     * match false is returned regardless of how many matched before.
 134     */
 135    bool operator==(HashStringList const &other) const;
 136    bool operator!=(HashStringList const &other) const;
 137
 138    HashStringList() {}
 139
 140    // simplifying API-compatibility constructors
 141    HashStringList(std::string const &hash) {
 142       if (hash.empty() == false)
 143          list.push_back(HashString(hash));
 144    }
 145    HashStringList(char const * const hash) {
 146       if (hash != NULL && hash[0] != '\0')
 147          list.push_back(HashString(hash));
 148    }
 149
 150    private:
 151    std::vector<HashString> list;
 152 };
 153
 154 class Hashes
 155 {
 156    public:
 157
 158    MD5Summation MD5;
 159    SHA1Summation SHA1;
 160    SHA256Summation SHA256;
 161    SHA512Summation SHA512;
 162
 163    static const int UntilEOF = 0;
 164
 165    inline bool Add(const unsigned char *Data,unsigned long long Size)
 166    {
 167       return MD5.Add(Data,Size) && SHA1.Add(Data,Size) && SHA256.Add(Data,Size) && SHA512.Add(Data,Size);
 168    };
 169    inline bool Add(const char *Data) {return Add((unsigned char const *)Data,strlen(Data));};
 170    inline bool AddFD(int const Fd,unsigned long long Size = 0)
 171    { return AddFD(Fd, Size, true, true, true, true); };
 172    bool AddFD(int const Fd, unsigned long long Size, bool const addMD5,
 173               bool const addSHA1, bool const addSHA256, bool const addSHA512);
 174    inline bool AddFD(FileFd &Fd,unsigned long long Size = 0)
 175    { return AddFD(Fd, Size, true, true, true, true); };
 176    bool AddFD(FileFd &Fd, unsigned long long Size, bool const addMD5,
 177               bool const addSHA1, bool const addSHA256, bool const addSHA512);
 178    inline bool Add(const unsigned char *Beg,const unsigned char *End)
 179                   {return Add(Beg,End-Beg);};
 180 };
 181
 182 #endif