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 APT_PURE bool HashString::usable() const                                /*{{{*/
 133 {
 134    return (
 135       (Type != "Checksum-FileSize") &&
 136       (Type != "MD5Sum") &&
 137       (Type != "SHA1")
 138    );
 139 }
 140                                                                         /*}}}*/
 141 std::string HashString::toStr() const                                   /*{{{*/
 142 {
 143    return Type + ":" + Hash;
 144 }
 145                                                                         /*}}}*/
 146 APT_PURE bool HashString::operator==(HashString const &other) const     /*{{{*/
 147 {
 148    return (strcasecmp(Type.c_str(), other.Type.c_str()) == 0 && Hash == other.Hash);
 149 }
 150 APT_PURE bool HashString::operator!=(HashString const &other) const
 151 {
 152    return !(*this == other);
 153 }
 154                                                                         /*}}}*/
 155
 156 bool HashStringList::usable() const                                     /*{{{*/
 157 {
 158    if (empty() == true)
 159       return false;
 160    std::string const forcedType = _config->Find("Acquire::ForceHash", "");
 161    if (forcedType.empty() == true)
 162    {
 163       // See if there is at least one usable hash
 164       for (auto const &hs: list)
 165          if (hs.usable())
 166             return true;
 167       return false;
 168    }
 169    return find(forcedType) != NULL;
 170 }
 171                                                                         /*}}}*/
 172 HashString const * HashStringList::find(char const * const type) const /*{{{*/
 173 {
 174    if (type == NULL || type[0] == '\0')
 175    {
 176       std::string const forcedType = _config->Find("Acquire::ForceHash", "");
 177       if (forcedType.empty() == false)
 178          return find(forcedType.c_str());
 179       for (char const * const * t = HashString::SupportedHashes(); *t != NULL; ++t)
 180          for (std::vector<HashString>::const_iterator hs = list.begin(); hs != list.end(); ++hs)
 181             if (strcasecmp(hs->HashType().c_str(), *t) == 0)
 182                return &*hs;
 183       return NULL;
 184    }
 185    for (std::vector<HashString>::const_iterator hs = list.begin(); hs != list.end(); ++hs)
 186       if (strcasecmp(hs->HashType().c_str(), type) == 0)
 187          return &*hs;
 188    return NULL;
 189 }
 190                                                                         /*}}}*/
 191 unsigned long long HashStringList::FileSize() const                     /*{{{*/
 192 {
 193    HashString const * const hsf = find("Checksum-FileSize");
 194    if (hsf == NULL)
 195       return 0;
 196    std::string const hv = hsf->HashValue();
 197    return strtoull(hv.c_str(), NULL, 10);
 198 }
 199                                                                         /*}}}*/
 200 bool HashStringList::FileSize(unsigned long long const Size)            /*{{{*/
 201 {
 202    std::string size;
 203    strprintf(size, "%llu", Size);
 204    return push_back(HashString("Checksum-FileSize", size));
 205 }
 206                                                                         /*}}}*/
 207 bool HashStringList::supported(char const * const type)                 /*{{{*/
 208 {
 209    for (char const * const * t = HashString::SupportedHashes(); *t != NULL; ++t)
 210       if (strcasecmp(*t, type) == 0)
 211          return true;
 212    return false;
 213 }
 214                                                                         /*}}}*/
 215 bool HashStringList::push_back(const HashString &hashString)            /*{{{*/
 216 {
 217    if (hashString.HashType().empty() == true ||
 218          hashString.HashValue().empty() == true ||
 219          supported(hashString.HashType().c_str()) == false)
 220       return false;
 221
 222    // ensure that each type is added only once
 223    HashString const * const hs = find(hashString.HashType().c_str());
 224    if (hs != NULL)
 225       return *hs == hashString;
 226
 227    list.push_back(hashString);
 228    return true;
 229 }
 230                                                                         /*}}}*/
 231 bool HashStringList::VerifyFile(std::string filename) const             /*{{{*/
 232 {
 233    if (usable() == false)
 234       return false;
 235
 236    Hashes hashes(*this);
 237    FileFd file(filename, FileFd::ReadOnly);
 238    HashString const * const hsf = find("Checksum-FileSize");
 239    if (hsf != NULL)
 240    {
 241       std::string fileSize;
 242       strprintf(fileSize, "%llu", file.FileSize());
 243       if (hsf->HashValue() != fileSize)
 244          return false;
 245    }
 246    hashes.AddFD(file);
 247    HashStringList const hsl = hashes.GetHashStringList();
 248    return hsl == *this;
 249 }
 250                                                                         /*}}}*/
 251 bool HashStringList::operator==(HashStringList const &other) const      /*{{{*/
 252 {
 253    std::string const forcedType = _config->Find("Acquire::ForceHash", "");
 254    if (forcedType.empty() == false)
 255    {
 256       HashString const * const hs = find(forcedType);
 257       HashString const * const ohs = other.find(forcedType);
 258       if (hs == NULL || ohs == NULL)
 259          return false;
 260       return *hs == *ohs;
 261    }
 262    short matches = 0;
 263    for (const_iterator hs = begin(); hs != end(); ++hs)
 264    {
 265       HashString const * const ohs = other.find(hs->HashType());
 266       if (ohs == NULL)
 267          continue;
 268       if (*hs != *ohs)
 269          return false;
 270       ++matches;
 271    }
 272    if (matches == 0)
 273       return false;
 274    return true;
 275 }
 276 bool HashStringList::operator!=(HashStringList const &other) const
 277 {
 278    return !(*this == other);
 279 }
 280                                                                         /*}}}*/
 281
 282 // PrivateHashes                                                        /*{{{*/
 283 class PrivateHashes {
 284 public:
 285    unsigned long long FileSize;
 286    unsigned int CalcHashes;
 287
 288    explicit PrivateHashes(unsigned int const CalcHashes) : FileSize(0), CalcHashes(CalcHashes) {}
 289    explicit PrivateHashes(HashStringList const &Hashes) : FileSize(0) {
 290       unsigned int calcHashes = Hashes.usable() ? 0 : ~0;
 291       if (Hashes.find("MD5Sum") != NULL)
 292          calcHashes |= Hashes::MD5SUM;
 293       if (Hashes.find("SHA1") != NULL)
 294          calcHashes |= Hashes::SHA1SUM;
 295       if (Hashes.find("SHA256") != NULL)
 296          calcHashes |= Hashes::SHA256SUM;
 297       if (Hashes.find("SHA512") != NULL)
 298          calcHashes |= Hashes::SHA512SUM;
 299       CalcHashes = calcHashes;
 300    }
 301 };
 302                                                                         /*}}}*/
 303 // Hashes::Add* - Add the contents of data or FD                        /*{{{*/
 304 bool Hashes::Add(const unsigned char * const Data, unsigned long long const Size)
 305 {
 306    bool Res = true;
 307 APT_IGNORE_DEPRECATED_PUSH
 308    if ((d->CalcHashes & MD5SUM) == MD5SUM)
 309       Res &= MD5.Add(Data, Size);
 310    if ((d->CalcHashes & SHA1SUM) == SHA1SUM)
 311       Res &= SHA1.Add(Data, Size);
 312    if ((d->CalcHashes & SHA256SUM) == SHA256SUM)
 313       Res &= SHA256.Add(Data, Size);
 314    if ((d->CalcHashes & SHA512SUM) == SHA512SUM)
 315       Res &= SHA512.Add(Data, Size);
 316 APT_IGNORE_DEPRECATED_POP
 317    d->FileSize += Size;
 318    return Res;
 319 }
 320 bool Hashes::Add(const unsigned char * const Data, unsigned long long const Size, unsigned int const Hashes)
 321 {
 322    d->CalcHashes = Hashes;
 323    return Add(Data, Size);
 324 }
 325 bool Hashes::AddFD(int const Fd,unsigned long long Size)
 326 {
 327    unsigned char Buf[64*64];
 328    bool const ToEOF = (Size == UntilEOF);
 329    while (Size != 0 || ToEOF)
 330    {
 331       unsigned long long n = sizeof(Buf);
 332       if (!ToEOF) n = std::min(Size, n);
 333       ssize_t const Res = read(Fd,Buf,n);
 334       if (Res < 0 || (!ToEOF && Res != (ssize_t) n)) // error, or short read
 335          return false;
 336       if (ToEOF && Res == 0) // EOF
 337          break;
 338       Size -= Res;
 339       if (Add(Buf, Res) == false)
 340          return false;
 341    }
 342    return true;
 343 }
 344 bool Hashes::AddFD(int const Fd,unsigned long long Size, unsigned int const Hashes)
 345 {
 346    d->CalcHashes = Hashes;
 347    return AddFD(Fd, Size);
 348 }
 349 bool Hashes::AddFD(FileFd &Fd,unsigned long long Size)
 350 {
 351    unsigned char Buf[64*64];
 352    bool const ToEOF = (Size == 0);
 353    while (Size != 0 || ToEOF)
 354    {
 355       unsigned long long n = sizeof(Buf);
 356       if (!ToEOF) n = std::min(Size, n);
 357       unsigned long long a = 0;
 358       if (Fd.Read(Buf, n, &a) == false) // error
 359          return false;
 360       if (ToEOF == false)
 361       {
 362          if (a != n) // short read
 363             return false;
 364       }
 365       else if (a == 0) // EOF
 366          break;
 367       Size -= a;
 368       if (Add(Buf, a) == false)
 369          return false;
 370    }
 371    return true;
 372 }
 373 bool Hashes::AddFD(FileFd &Fd,unsigned long long Size, unsigned int const Hashes)
 374 {
 375    d->CalcHashes = Hashes;
 376    return AddFD(Fd, Size);
 377 }
 378                                                                         /*}}}*/
 379 HashStringList Hashes::GetHashStringList()
 380 {
 381    HashStringList hashes;
 382 APT_IGNORE_DEPRECATED_PUSH
 383    if ((d->CalcHashes & MD5SUM) == MD5SUM)
 384       hashes.push_back(HashString("MD5Sum", MD5.Result().Value()));
 385    if ((d->CalcHashes & SHA1SUM) == SHA1SUM)
 386       hashes.push_back(HashString("SHA1", SHA1.Result().Value()));
 387    if ((d->CalcHashes & SHA256SUM) == SHA256SUM)
 388       hashes.push_back(HashString("SHA256", SHA256.Result().Value()));
 389    if ((d->CalcHashes & SHA512SUM) == SHA512SUM)
 390       hashes.push_back(HashString("SHA512", SHA512.Result().Value()));
 391 APT_IGNORE_DEPRECATED_POP
 392    hashes.FileSize(d->FileSize);
 393    return hashes;
 394 }
 395 APT_IGNORE_DEPRECATED_PUSH
 396 Hashes::Hashes() : d(new PrivateHashes(~0)) { }
 397 Hashes::Hashes(unsigned int const Hashes) : d(new PrivateHashes(Hashes)) {}
 398 Hashes::Hashes(HashStringList const &Hashes) : d(new PrivateHashes(Hashes)) {}
 399 Hashes::~Hashes() { delete d; }
 400 APT_IGNORE_DEPRECATED_POP