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 <stdlib.h>
  27 #include <string>
  28 #include <iostream>
  29                                                                         /*}}}*/
  30
  31 const char * HashString::_SupportedHashes[] =
  32 {
  33    "SHA512", "SHA256", "SHA1", "MD5Sum", "Checksum-FileSize", NULL
  34 };
  35
  36 HashString::HashString()
  37 {
  38 }
  39
  40 HashString::HashString(std::string Type, std::string Hash) : Type(Type), Hash(Hash)
  41 {
  42 }
  43
  44 HashString::HashString(std::string StringedHash)                        /*{{{*/
  45 {
  46    if (StringedHash.find(":") == std::string::npos)
  47    {
  48       // legacy: md5sum without "MD5Sum:" prefix
  49       if (StringedHash.size() == 32)
  50       {
  51          Type = "MD5Sum";
  52          Hash = StringedHash;
  53       }
  54       if(_config->FindB("Debug::Hashes",false) == true)
  55          std::clog << "HashString(string): invalid StringedHash " << StringedHash << std::endl;
  56       return;
  57    }
  58    std::string::size_type pos = StringedHash.find(":");
  59    Type = StringedHash.substr(0,pos);
  60    Hash = StringedHash.substr(pos+1, StringedHash.size() - pos);
  61
  62    if(_config->FindB("Debug::Hashes",false) == true)
  63       std::clog << "HashString(string): " << Type << " : " << Hash << std::endl;
  64 }
  65                                                                         /*}}}*/
  66 bool HashString::VerifyFile(std::string filename) const                 /*{{{*/
  67 {
  68    std::string fileHash = GetHashForFile(filename);
  69
  70    if(_config->FindB("Debug::Hashes",false) == true)
  71       std::clog << "HashString::VerifyFile: got: " << fileHash << " expected: " << toStr() << std::endl;
  72
  73    return (fileHash == Hash);
  74 }
  75                                                                         /*}}}*/
  76 bool HashString::FromFile(std::string filename)                         /*{{{*/
  77 {
  78    // pick the strongest hash
  79    if (Type == "")
  80       Type = _SupportedHashes[0];
  81
  82    Hash = GetHashForFile(filename);
  83    return true;
  84 }
  85                                                                         /*}}}*/
  86 std::string HashString::GetHashForFile(std::string filename) const      /*{{{*/
  87 {
  88    std::string fileHash;
  89
  90    FileFd Fd(filename, FileFd::ReadOnly);
  91    if(strcasecmp(Type.c_str(), "MD5Sum") == 0)
  92    {
  93       MD5Summation MD5;
  94       MD5.AddFD(Fd);
  95       fileHash = (std::string)MD5.Result();
  96    }
  97    else if (strcasecmp(Type.c_str(), "SHA1") == 0)
  98    {
  99       SHA1Summation SHA1;
 100       SHA1.AddFD(Fd);
 101       fileHash = (std::string)SHA1.Result();
 102    }
 103    else if (strcasecmp(Type.c_str(), "SHA256") == 0)
 104    {
 105       SHA256Summation SHA256;
 106       SHA256.AddFD(Fd);
 107       fileHash = (std::string)SHA256.Result();
 108    }
 109    else if (strcasecmp(Type.c_str(), "SHA512") == 0)
 110    {
 111       SHA512Summation SHA512;
 112       SHA512.AddFD(Fd);
 113       fileHash = (std::string)SHA512.Result();
 114    }
 115    else if (strcasecmp(Type.c_str(), "Checksum-FileSize") == 0)
 116       strprintf(fileHash, "%llu", Fd.FileSize());
 117    Fd.Close();
 118
 119    return fileHash;
 120 }
 121                                                                         /*}}}*/
 122 const char** HashString::SupportedHashes()                              /*{{{*/
 123 {
 124    return _SupportedHashes;
 125 }
 126                                                                         /*}}}*/
 127 APT_PURE bool HashString::empty() const                                 /*{{{*/
 128 {
 129    return (Type.empty() || Hash.empty());
 130 }
 131                                                                         /*}}}*/
 132 std::string HashString::toStr() const                                   /*{{{*/
 133 {
 134    return Type + ":" + Hash;
 135 }
 136                                                                         /*}}}*/
 137 APT_PURE bool HashString::operator==(HashString const &other) const     /*{{{*/
 138 {
 139    return (strcasecmp(Type.c_str(), other.Type.c_str()) == 0 && Hash == other.Hash);
 140 }
 141 APT_PURE bool HashString::operator!=(HashString const &other) const
 142 {
 143    return !(*this == other);
 144 }
 145                                                                         /*}}}*/
 146
 147 bool HashStringList::usable() const                                     /*{{{*/
 148 {
 149    if (empty() == true)
 150       return false;
 151    std::string const forcedType = _config->Find("Acquire::ForceHash", "");
 152    if (forcedType.empty() == true)
 153    {
 154       // FileSize alone isn't usable
 155       for (std::vector<HashString>::const_iterator hs = list.begin(); hs != list.end(); ++hs)
 156          if (hs->HashType() != "Checksum-FileSize")
 157             return true;
 158       return false;
 159    }
 160    return find(forcedType) != NULL;
 161 }
 162                                                                         /*}}}*/
 163 HashString const * HashStringList::find(char const * const type) const /*{{{*/
 164 {
 165    if (type == NULL || type[0] == '\0')
 166    {
 167       std::string const forcedType = _config->Find("Acquire::ForceHash", "");
 168       if (forcedType.empty() == false)
 169          return find(forcedType.c_str());
 170       for (char const * const * t = HashString::SupportedHashes(); *t != NULL; ++t)
 171          for (std::vector<HashString>::const_iterator hs = list.begin(); hs != list.end(); ++hs)
 172             if (strcasecmp(hs->HashType().c_str(), *t) == 0)
 173                return &*hs;
 174       return NULL;
 175    }
 176    for (std::vector<HashString>::const_iterator hs = list.begin(); hs != list.end(); ++hs)
 177       if (strcasecmp(hs->HashType().c_str(), type) == 0)
 178          return &*hs;
 179    return NULL;
 180 }
 181                                                                         /*}}}*/
 182 unsigned long long HashStringList::FileSize() const                     /*{{{*/
 183 {
 184    HashString const * const hsf = find("Checksum-FileSize");
 185    if (hsf == NULL)
 186       return 0;
 187    std::string const hv = hsf->HashValue();
 188    return strtoull(hv.c_str(), NULL, 10);
 189 }
 190                                                                         /*}}}*/
 191 bool HashStringList::FileSize(unsigned long long const Size)            /*{{{*/
 192 {
 193    std::string size;
 194    strprintf(size, "%llu", Size);
 195    return push_back(HashString("Checksum-FileSize", size));
 196 }
 197                                                                         /*}}}*/
 198 bool HashStringList::supported(char const * const type)                 /*{{{*/
 199 {
 200    for (char const * const * t = HashString::SupportedHashes(); *t != NULL; ++t)
 201       if (strcasecmp(*t, type) == 0)
 202          return true;
 203    return false;
 204 }
 205                                                                         /*}}}*/
 206 bool HashStringList::push_back(const HashString &hashString)            /*{{{*/
 207 {
 208    if (hashString.HashType().empty() == true ||
 209          hashString.HashValue().empty() == true ||
 210          supported(hashString.HashType().c_str()) == false)
 211       return false;
 212
 213    // ensure that each type is added only once
 214    HashString const * const hs = find(hashString.HashType().c_str());
 215    if (hs != NULL)
 216       return *hs == hashString;
 217
 218    list.push_back(hashString);
 219    return true;
 220 }
 221                                                                         /*}}}*/
 222 bool HashStringList::VerifyFile(std::string filename) const             /*{{{*/
 223 {
 224    if (usable() == false)
 225       return false;
 226
 227    Hashes hashes(*this);
 228    FileFd file(filename, FileFd::ReadOnly);
 229    HashString const * const hsf = find("Checksum-FileSize");
 230    if (hsf != NULL)
 231    {
 232       std::string fileSize;
 233       strprintf(fileSize, "%llu", file.FileSize());
 234       if (hsf->HashValue() != fileSize)
 235          return false;
 236    }
 237    hashes.AddFD(file);
 238    HashStringList const hsl = hashes.GetHashStringList();
 239    return hsl == *this;
 240 }
 241                                                                         /*}}}*/
 242 bool HashStringList::operator==(HashStringList const &other) const      /*{{{*/
 243 {
 244    std::string const forcedType = _config->Find("Acquire::ForceHash", "");
 245    if (forcedType.empty() == false)
 246    {
 247       HashString const * const hs = find(forcedType);
 248       HashString const * const ohs = other.find(forcedType);
 249       if (hs == NULL || ohs == NULL)
 250          return false;
 251       return *hs == *ohs;
 252    }
 253    short matches = 0;
 254    for (const_iterator hs = begin(); hs != end(); ++hs)
 255    {
 256       HashString const * const ohs = other.find(hs->HashType());
 257       if (ohs == NULL)
 258          continue;
 259       if (*hs != *ohs)
 260          return false;
 261       ++matches;
 262    }
 263    if (matches == 0)
 264       return false;
 265    return true;
 266 }
 267 bool HashStringList::operator!=(HashStringList const &other) const
 268 {
 269    return !(*this == other);
 270 }
 271                                                                         /*}}}*/
 272
 273 // PrivateHashes                                                        /*{{{*/
 274 class PrivateHashes {
 275 public:
 276    unsigned long long FileSize;
 277    unsigned int CalcHashes;
 278
 279    explicit PrivateHashes(unsigned int const CalcHashes) : FileSize(0), CalcHashes(CalcHashes) {}
 280    explicit PrivateHashes(HashStringList const &Hashes) : FileSize(0) {
 281       unsigned int calcHashes = Hashes.usable() ? 0 : ~0;
 282       if (Hashes.find("MD5Sum") != NULL)
 283          calcHashes |= Hashes::MD5SUM;
 284       if (Hashes.find("SHA1") != NULL)
 285          calcHashes |= Hashes::SHA1SUM;
 286       if (Hashes.find("SHA256") != NULL)
 287          calcHashes |= Hashes::SHA256SUM;
 288       if (Hashes.find("SHA512") != NULL)
 289          calcHashes |= Hashes::SHA512SUM;
 290       CalcHashes = calcHashes;
 291    }
 292 };
 293                                                                         /*}}}*/
 294 // Hashes::Add* - Add the contents of data or FD                        /*{{{*/
 295 bool Hashes::Add(const unsigned char * const Data, unsigned long long const Size)
 296 {
 297    bool Res = true;
 298 APT_IGNORE_DEPRECATED_PUSH
 299    if ((d->CalcHashes & MD5SUM) == MD5SUM)
 300       Res &= MD5.Add(Data, Size);
 301    if ((d->CalcHashes & SHA1SUM) == SHA1SUM)
 302       Res &= SHA1.Add(Data, Size);
 303    if ((d->CalcHashes & SHA256SUM) == SHA256SUM)
 304       Res &= SHA256.Add(Data, Size);
 305    if ((d->CalcHashes & SHA512SUM) == SHA512SUM)
 306       Res &= SHA512.Add(Data, Size);
 307 APT_IGNORE_DEPRECATED_POP
 308    d->FileSize += Size;
 309    return Res;
 310 }
 311 bool Hashes::Add(const unsigned char * const Data, unsigned long long const Size, unsigned int const Hashes)
 312 {
 313    d->CalcHashes = Hashes;
 314    return Add(Data, Size);
 315 }
 316 bool Hashes::AddFD(int const Fd,unsigned long long Size)
 317 {
 318    unsigned char Buf[64*64];
 319    bool const ToEOF = (Size == UntilEOF);
 320    while (Size != 0 || ToEOF)
 321    {
 322       unsigned long long n = sizeof(Buf);
 323       if (!ToEOF) n = std::min(Size, n);
 324       ssize_t const Res = read(Fd,Buf,n);
 325       if (Res < 0 || (!ToEOF && Res != (ssize_t) n)) // error, or short read
 326          return false;
 327       if (ToEOF && Res == 0) // EOF
 328          break;
 329       Size -= Res;
 330       if (Add(Buf, Res) == false)
 331          return false;
 332    }
 333    return true;
 334 }
 335 bool Hashes::AddFD(int const Fd,unsigned long long Size, unsigned int const Hashes)
 336 {
 337    d->CalcHashes = Hashes;
 338    return AddFD(Fd, Size);
 339 }
 340 bool Hashes::AddFD(FileFd &Fd,unsigned long long Size)
 341 {
 342    unsigned char Buf[64*64];
 343    bool const ToEOF = (Size == 0);
 344    while (Size != 0 || ToEOF)
 345    {
 346       unsigned long long n = sizeof(Buf);
 347       if (!ToEOF) n = std::min(Size, n);
 348       unsigned long long a = 0;
 349       if (Fd.Read(Buf, n, &a) == false) // error
 350          return false;
 351       if (ToEOF == false)
 352       {
 353          if (a != n) // short read
 354             return false;
 355       }
 356       else if (a == 0) // EOF
 357          break;
 358       Size -= a;
 359       if (Add(Buf, a) == false)
 360          return false;
 361    }
 362    return true;
 363 }
 364 bool Hashes::AddFD(FileFd &Fd,unsigned long long Size, unsigned int const Hashes)
 365 {
 366    d->CalcHashes = Hashes;
 367    return AddFD(Fd, Size);
 368 }
 369                                                                         /*}}}*/
 370 HashStringList Hashes::GetHashStringList()
 371 {
 372    HashStringList hashes;
 373 APT_IGNORE_DEPRECATED_PUSH
 374    if ((d->CalcHashes & MD5SUM) == MD5SUM)
 375       hashes.push_back(HashString("MD5Sum", MD5.Result().Value()));
 376    if ((d->CalcHashes & SHA1SUM) == SHA1SUM)
 377       hashes.push_back(HashString("SHA1", SHA1.Result().Value()));
 378    if ((d->CalcHashes & SHA256SUM) == SHA256SUM)
 379       hashes.push_back(HashString("SHA256", SHA256.Result().Value()));
 380    if ((d->CalcHashes & SHA512SUM) == SHA512SUM)
 381       hashes.push_back(HashString("SHA512", SHA512.Result().Value()));
 382 APT_IGNORE_DEPRECATED_POP
 383    hashes.FileSize(d->FileSize);
 384    return hashes;
 385 }
 386 APT_IGNORE_DEPRECATED_PUSH
 387 Hashes::Hashes() : d(new PrivateHashes(~0)) { }
 388 Hashes::Hashes(unsigned int const Hashes) : d(new PrivateHashes(Hashes)) {}
 389 Hashes::Hashes(HashStringList const &Hashes) : d(new PrivateHashes(Hashes)) {}
 390 Hashes::~Hashes() { delete d; }
 391 APT_IGNORE_DEPRECATED_POP