apt-pkg/contrib/hashes.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: hashes.cc,v 1.1 2001/03/06 07:15:29 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 // Include Files                                                        /*{{{*/
  14 #include <config.h>
  15
  16 #include <apt-pkg/hashes.h>
  17 #include <apt-pkg/fileutl.h>
  18 #include <apt-pkg/configuration.h>
  19 #include <apt-pkg/md5.h>
  20 #include <apt-pkg/sha1.h>
  21 #include <apt-pkg/sha2.h>
  22
  23 #include <stddef.h>
  24 #include <algorithm>
  25 #include <unistd.h>
  26 #include <string>
  27 #include <iostream>
  28                                                                         /*}}}*/
  29
  30 const char * HashString::_SupportedHashes[] =
  31 {
  32    "SHA512", "SHA256", "SHA1", "MD5Sum", NULL
  33 };
  34
  35 HashString::HashString()
  36 {
  37 }
  38
  39 HashString::HashString(std::string Type, std::string Hash) : Type(Type), Hash(Hash)
  40 {
  41 }
  42
  43 HashString::HashString(std::string StringedHash)                        /*{{{*/
  44 {
  45    if (StringedHash.find(":") == std::string::npos)
  46    {
  47       // legacy: md5sum without "MD5Sum:" prefix
  48       if (StringedHash.size() == 32)
  49       {
  50          Type = "MD5Sum";
  51          Hash = StringedHash;
  52       }
  53       if(_config->FindB("Debug::Hashes",false) == true)
  54          std::clog << "HashString(string): invalid StringedHash " << StringedHash << std::endl;
  55       return;
  56    }
  57    std::string::size_type pos = StringedHash.find(":");
  58    Type = StringedHash.substr(0,pos);
  59    Hash = StringedHash.substr(pos+1, StringedHash.size() - pos);
  60
  61    if(_config->FindB("Debug::Hashes",false) == true)
  62       std::clog << "HashString(string): " << Type << " : " << Hash << std::endl;
  63 }
  64                                                                         /*}}}*/
  65 bool HashString::VerifyFile(std::string filename) const                 /*{{{*/
  66 {
  67    std::string fileHash = GetHashForFile(filename);
  68
  69    if(_config->FindB("Debug::Hashes",false) == true)
  70       std::clog << "HashString::VerifyFile: got: " << fileHash << " expected: " << toStr() << std::endl;
  71
  72    return (fileHash == Hash);
  73 }
  74                                                                         /*}}}*/
  75 bool HashString::FromFile(std::string filename)                         /*{{{*/
  76 {
  77    // pick the strongest hash
  78    if (Type == "")
  79       Type = _SupportedHashes[0];
  80
  81    Hash = GetHashForFile(filename);
  82    return true;
  83 }
  84                                                                         /*}}}*/
  85 std::string HashString::GetHashForFile(std::string filename) const      /*{{{*/
  86 {
  87    std::string fileHash;
  88
  89    FileFd Fd(filename, FileFd::ReadOnly);
  90    if(strcasecmp(Type.c_str(), "MD5Sum") == 0)
  91    {
  92       MD5Summation MD5;
  93       MD5.AddFD(Fd);
  94       fileHash = (std::string)MD5.Result();
  95    }
  96    else if (strcasecmp(Type.c_str(), "SHA1") == 0)
  97    {
  98       SHA1Summation SHA1;
  99       SHA1.AddFD(Fd);
 100       fileHash = (std::string)SHA1.Result();
 101    }
 102    else if (strcasecmp(Type.c_str(), "SHA256") == 0)
 103    {
 104       SHA256Summation SHA256;
 105       SHA256.AddFD(Fd);
 106       fileHash = (std::string)SHA256.Result();
 107    }
 108    else if (strcasecmp(Type.c_str(), "SHA512") == 0)
 109    {
 110       SHA512Summation SHA512;
 111       SHA512.AddFD(Fd);
 112       fileHash = (std::string)SHA512.Result();
 113    }
 114    Fd.Close();
 115
 116    return fileHash;
 117 }
 118                                                                         /*}}}*/
 119 const char** HashString::SupportedHashes()                              /*{{{*/
 120 {
 121    return _SupportedHashes;
 122 }
 123                                                                         /*}}}*/
 124 APT_PURE bool HashString::empty() const                                 /*{{{*/
 125 {
 126    return (Type.empty() || Hash.empty());
 127 }
 128                                                                         /*}}}*/
 129 std::string HashString::toStr() const                                   /*{{{*/
 130 {
 131    return Type + ":" + Hash;
 132 }
 133                                                                         /*}}}*/
 134 APT_PURE bool HashString::operator==(HashString const &other) const     /*{{{*/
 135 {
 136    return (strcasecmp(Type.c_str(), other.Type.c_str()) == 0 && Hash == other.Hash);
 137 }
 138 APT_PURE bool HashString::operator!=(HashString const &other) const
 139 {
 140    return !(*this == other);
 141 }
 142                                                                         /*}}}*/
 143
 144 bool HashStringList::usable() const                                     /*{{{*/
 145 {
 146    if (empty() == true)
 147       return false;
 148    std::string const forcedType = _config->Find("Acquire::ForceHash", "");
 149    if (forcedType.empty() == true)
 150       return true;
 151    return find(forcedType) != NULL;
 152 }
 153                                                                         /*}}}*/
 154 HashString const * HashStringList::find(char const * const type) const /*{{{*/
 155 {
 156    if (type == NULL || type[0] == '\0')
 157    {
 158       std::string const forcedType = _config->Find("Acquire::ForceHash", "");
 159       if (forcedType.empty() == false)
 160          return find(forcedType.c_str());
 161       for (char const * const * t = HashString::SupportedHashes(); *t != NULL; ++t)
 162          for (std::vector<HashString>::const_iterator hs = list.begin(); hs != list.end(); ++hs)
 163             if (strcasecmp(hs->HashType().c_str(), *t) == 0)
 164                return &*hs;
 165       return NULL;
 166    }
 167    for (std::vector<HashString>::const_iterator hs = list.begin(); hs != list.end(); ++hs)
 168       if (strcasecmp(hs->HashType().c_str(), type) == 0)
 169          return &*hs;
 170    return NULL;
 171 }
 172                                                                         /*}}}*/
 173 bool HashStringList::supported(char const * const type)                 /*{{{*/
 174 {
 175    for (char const * const * t = HashString::SupportedHashes(); *t != NULL; ++t)
 176       if (strcasecmp(*t, type) == 0)
 177          return true;
 178    return false;
 179 }
 180                                                                         /*}}}*/
 181 bool HashStringList::push_back(const HashString &hashString)            /*{{{*/
 182 {
 183    if (hashString.HashType().empty() == true ||
 184          hashString.HashValue().empty() == true ||
 185          supported(hashString.HashType().c_str()) == false)
 186       return false;
 187
 188    // ensure that each type is added only once
 189    HashString const * const hs = find(hashString.HashType().c_str());
 190    if (hs != NULL)
 191       return *hs == hashString;
 192
 193    list.push_back(hashString);
 194    return true;
 195 }
 196                                                                         /*}}}*/
 197 bool HashStringList::VerifyFile(std::string filename) const             /*{{{*/
 198 {
 199    if (list.empty() == true)
 200       return false;
 201    HashString const * const hs = find(NULL);
 202    if (hs == NULL || hs->VerifyFile(filename) == false)
 203       return false;
 204    return true;
 205 }
 206                                                                         /*}}}*/
 207 bool HashStringList::operator==(HashStringList const &other) const      /*{{{*/
 208 {
 209    std::string const forcedType = _config->Find("Acquire::ForceHash", "");
 210    if (forcedType.empty() == false)
 211    {
 212       HashString const * const hs = other.find(forcedType);
 213       HashString const * const ohs = other.find(forcedType);
 214       if (hs == NULL || ohs == NULL)
 215          return false;
 216       return hs == ohs;
 217    }
 218    short matches = 0;
 219    for (const_iterator hs = begin(); hs != end(); ++hs)
 220    {
 221       HashString const * const ohs = other.find(hs->HashType());
 222       if (ohs == NULL)
 223          continue;
 224       if (*hs != *ohs)
 225          return false;
 226       ++matches;
 227    }
 228    if (matches == 0)
 229       return false;
 230    return true;
 231 }
 232 bool HashStringList::operator!=(HashStringList const &other) const
 233 {
 234    return !(*this == other);
 235 }
 236                                                                         /*}}}*/
 237
 238 // Hashes::Add* - Add the contents of data or FD                        /*{{{*/
 239 bool Hashes::Add(const unsigned char * const Data,unsigned long long const Size, unsigned int const Hashes)
 240 {
 241    bool Res = true;
 242 #if __GNUC__ >= 4
 243         #pragma GCC diagnostic push
 244         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 245 #endif
 246    if ((Hashes & MD5SUM) == MD5SUM)
 247       Res &= MD5.Add(Data, Size);
 248    if ((Hashes & SHA1SUM) == SHA1SUM)
 249       Res &= SHA1.Add(Data, Size);
 250    if ((Hashes & SHA256SUM) == SHA256SUM)
 251       Res &= SHA256.Add(Data, Size);
 252    if ((Hashes & SHA512SUM) == SHA512SUM)
 253       Res &= SHA512.Add(Data, Size);
 254 #if __GNUC__ >= 4
 255         #pragma GCC diagnostic pop
 256 #endif
 257    return Res;
 258 }
 259 bool Hashes::AddFD(int const Fd,unsigned long long Size, unsigned int const Hashes)
 260 {
 261    unsigned char Buf[64*64];
 262    bool const ToEOF = (Size == UntilEOF);
 263    while (Size != 0 || ToEOF)
 264    {
 265       unsigned long long n = sizeof(Buf);
 266       if (!ToEOF) n = std::min(Size, n);
 267       ssize_t const Res = read(Fd,Buf,n);
 268       if (Res < 0 || (!ToEOF && Res != (ssize_t) n)) // error, or short read
 269          return false;
 270       if (ToEOF && Res == 0) // EOF
 271          break;
 272       Size -= Res;
 273       if (Add(Buf, Res, Hashes) == false)
 274          return false;
 275    }
 276    return true;
 277 }
 278 bool Hashes::AddFD(FileFd &Fd,unsigned long long Size, unsigned int const Hashes)
 279 {
 280    unsigned char Buf[64*64];
 281    bool const ToEOF = (Size == 0);
 282    while (Size != 0 || ToEOF)
 283    {
 284       unsigned long long n = sizeof(Buf);
 285       if (!ToEOF) n = std::min(Size, n);
 286       unsigned long long a = 0;
 287       if (Fd.Read(Buf, n, &a) == false) // error
 288          return false;
 289       if (ToEOF == false)
 290       {
 291          if (a != n) // short read
 292             return false;
 293       }
 294       else if (a == 0) // EOF
 295          break;
 296       Size -= a;
 297       if (Add(Buf, a, Hashes) == false)
 298          return false;
 299    }
 300    return true;
 301 }
 302                                                                         /*}}}*/
 303 HashStringList Hashes::GetHashStringList()
 304 {
 305    HashStringList hashes;
 306 #if __GNUC__ >= 4
 307         #pragma GCC diagnostic push
 308         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 309 #endif
 310    hashes.push_back(HashString("MD5Sum", MD5.Result().Value()));
 311    hashes.push_back(HashString("SHA1", SHA1.Result().Value()));
 312    hashes.push_back(HashString("SHA256", SHA256.Result().Value()));
 313    hashes.push_back(HashString("SHA512", SHA512.Result().Value()));
 314 #if __GNUC__ >= 4
 315         #pragma GCC diagnostic pop
 316 #endif
 317    return hashes;
 318 }
 319 #if __GNUC__ >= 4
 320         #pragma GCC diagnostic push
 321         #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 322         #pragma GCC diagnostic ignored "-Wsuggest-attribute=const"
 323 #endif
 324 Hashes::Hashes() {}
 325 Hashes::~Hashes() {}
 326 #if __GNUC__ >= 4
 327         #pragma GCC diagnostic pop
 328 #endif