pdns/dnssecinfra.cc

   1 /*
   2  * This file is part of PowerDNS or dnsdist.
   3  * Copyright -- PowerDNS.COM B.V. and its contributors
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * In addition, for the avoidance of any doubt, permission is granted to
  10  * link this program with OpenSSL and to (re)distribute the binaries
  11  * produced as the result of such linking.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25 #include "dnsparser.hh"
  26 #include "sstuff.hh"
  27 #include "misc.hh"
  28 #include "dnswriter.hh"
  29 #include "dnsrecords.hh"
  30 #ifndef RECURSOR
  31 #include "statbag.hh"
  32 #endif
  33 #include "iputils.hh"
  34
  35 #include <boost/algorithm/string.hpp>
  36 #include "dnssecinfra.hh"
  37 #include "dnsseckeeper.hh"
  38 #include <openssl/hmac.h>
  39 #include <openssl/sha.h>
  40 #include <boost/assign/std/vector.hpp> // for 'operator+=()'
  41 #include <boost/assign/list_inserter.hpp>
  42 #include "base64.hh"
  43 #include "namespaces.hh"
  44 #ifdef HAVE_P11KIT1
  45 #include "pkcs11signers.hh"
  46 #endif
  47 #include "gss_context.hh"
  48 #include "misc.hh"
  49
  50 using namespace boost::assign;
  51
  52 shared_ptr<DNSCryptoKeyEngine> DNSCryptoKeyEngine::makeFromISCFile(DNSKEYRecordContent& drc, const char* fname)
  53 {
  54   string sline, isc;
  55   FILE *fp=fopen(fname, "r");
  56   if(!fp) {
  57     throw runtime_error("Unable to read file '"+string(fname)+"' for generating DNS Private Key");
  58   }
  59
  60   while(stringfgets(fp, sline)) {
  61     isc += sline;
  62   }
  63   fclose(fp);
  64   shared_ptr<DNSCryptoKeyEngine> dke = makeFromISCString(drc, isc);
  65   if(!dke->checkKey()) {
  66     throw runtime_error("Invalid DNS Private Key in file '"+string(fname));
  67   }
  68   return dke;
  69 }
  70
  71 shared_ptr<DNSCryptoKeyEngine> DNSCryptoKeyEngine::makeFromISCString(DNSKEYRecordContent& drc, const std::string& content)
  72 {
  73   bool pkcs11=false;
  74   int algorithm = 0;
  75   string sline, key, value, raw;
  76   std::istringstream str(content);
  77   map<string, string> stormap;
  78
  79   while(std::getline(str, sline)) {
  80     tie(key,value)=splitField(sline, ':');
  81     trim(value);
  82     if(pdns_iequals(key,"algorithm")) {
  83       algorithm = pdns_stou(value);
  84       stormap["algorithm"]=std::to_string(algorithm);
  85       continue;
  86     } else if (pdns_iequals(key,"pin")) {
  87       stormap["pin"]=value;
  88       continue;
  89     } else if (pdns_iequals(key,"engine")) {
  90       stormap["engine"]=value;
  91       pkcs11=true;
  92       continue;
  93     } else if (pdns_iequals(key,"slot")) {
  94       stormap["slot"]=value;
  95       continue;
  96     }  else if (pdns_iequals(key,"label")) {
  97       stormap["label"]=value;
  98       continue;
  99     }
 100     else if(pdns_iequals(key, "Private-key-format"))
 101       continue;
 102     raw.clear();
 103     B64Decode(value, raw);
 104     stormap[toLower(key)]=raw;
 105   }
 106   shared_ptr<DNSCryptoKeyEngine> dpk;
 107
 108   if (pkcs11) {
 109 #ifdef HAVE_P11KIT1
 110     if (stormap.find("slot") == stormap.end())
 111       throw PDNSException("Cannot load PKCS#11 key, no Slot specified");
 112     // we need PIN to be at least empty
 113     if (stormap.find("pin") == stormap.end()) stormap["pin"] = "";
 114     dpk = PKCS11DNSCryptoKeyEngine::maker(algorithm);
 115 #else
 116     throw PDNSException("Cannot load PKCS#11 key without support for it");
 117 #endif
 118   } else {
 119     dpk=make(algorithm);
 120   }
 121   dpk->fromISCMap(drc, stormap);
 122   return dpk;
 123 }
 124
 125 std::string DNSCryptoKeyEngine::convertToISC() const
 126 {
 127   typedef map<string, string> stormap_t;
 128   storvector_t stormap = this->convertToISCVector();
 129   ostringstream ret;
 130   ret<<"Private-key-format: v1.2\n";
 131   for(const stormap_t::value_type& value :  stormap) {
 132     if(value.first != "Algorithm" && value.first != "PIN" &&
 133        value.first != "Slot" && value.first != "Engine" &&
 134        value.first != "Label")
 135       ret<<value.first<<": "<<Base64Encode(value.second)<<"\n";
 136     else
 137       ret<<value.first<<": "<<value.second<<"\n";
 138   }
 139   return ret.str();
 140 }
 141
 142 shared_ptr<DNSCryptoKeyEngine> DNSCryptoKeyEngine::make(unsigned int algo)
 143 {
 144   const makers_t& makers = getMakers();
 145   makers_t::const_iterator iter = makers.find(algo);
 146   if(iter != makers.cend())
 147     return (iter->second)(algo);
 148   else {
 149     throw runtime_error("Request to create key object for unknown algorithm number "+std::to_string(algo));
 150   }
 151 }
 152
 153 /**
 154  * Returns the supported DNSSEC algorithms with the name of the Crypto Backend used
 155  *
 156  * @return   A vector with pairs of (algorithm-number (int), backend-name (string))
 157  */
 158 vector<pair<uint8_t, string>> DNSCryptoKeyEngine::listAllAlgosWithBackend()
 159 {
 160   vector<pair<uint8_t, string>> ret;
 161   for (auto const& value : getMakers()) {
 162     shared_ptr<DNSCryptoKeyEngine> dcke(value.second(value.first));
 163     ret.push_back(make_pair(value.first, dcke->getName()));
 164   }
 165   return ret;
 166 }
 167
 168 void DNSCryptoKeyEngine::report(unsigned int algo, maker_t* maker, bool fallback)
 169 {
 170   getAllMakers()[algo].push_back(maker);
 171   if(getMakers().count(algo) && fallback) {
 172     return;
 173   }
 174   getMakers()[algo]=maker;
 175 }
 176
 177 bool DNSCryptoKeyEngine::testAll()
 178 {
 179   bool ret=true;
 180
 181   for(const allmakers_t::value_type& value :  getAllMakers())
 182   {
 183     for(maker_t* creator :  value.second) {
 184
 185       for(maker_t* signer :  value.second) {
 186         // multi_map<unsigned int, maker_t*> bestSigner, bestVerifier;
 187
 188         for(maker_t* verifier :  value.second) {
 189           try {
 190             /* pair<unsigned int, unsigned int> res=*/ testMakers(value.first, creator, signer, verifier);
 191           }
 192           catch(std::exception& e)
 193           {
 194             cerr<<e.what()<<endl;
 195             ret=false;
 196           }
 197         }
 198       }
 199     }
 200   }
 201   return ret;
 202 }
 203
 204 bool DNSCryptoKeyEngine::testOne(int algo)
 205 {
 206   bool ret=true;
 207
 208   for(maker_t* creator :  getAllMakers()[algo]) {
 209
 210     for(maker_t* signer :  getAllMakers()[algo]) {
 211       // multi_map<unsigned int, maker_t*> bestSigner, bestVerifier;
 212
 213       for(maker_t* verifier :  getAllMakers()[algo]) {
 214         try {
 215           /* pair<unsigned int, unsigned int> res=*/testMakers(algo, creator, signer, verifier);
 216         }
 217         catch(std::exception& e)
 218         {
 219           cerr<<e.what()<<endl;
 220           ret=false;
 221         }
 222       }
 223     }
 224   }
 225   return ret;
 226 }
 227 // returns times it took to sign and verify
 228 pair<unsigned int, unsigned int> DNSCryptoKeyEngine::testMakers(unsigned int algo, maker_t* creator, maker_t* signer, maker_t* verifier)
 229 {
 230   shared_ptr<DNSCryptoKeyEngine> dckeCreate(creator(algo));
 231   shared_ptr<DNSCryptoKeyEngine> dckeSign(signer(algo));
 232   shared_ptr<DNSCryptoKeyEngine> dckeVerify(verifier(algo));
 233
 234   cerr<<"Testing algorithm "<<algo<<": '"<<dckeCreate->getName()<<"' ->'"<<dckeSign->getName()<<"' -> '"<<dckeVerify->getName()<<"' ";
 235   unsigned int bits;
 236   if(algo <= 10)
 237     bits=1024;
 238   else if(algo == 12 || algo == 13 || algo == 15) // ECC-GOST or ECDSAP256SHA256 or ED25519
 239     bits=256;
 240   else if(algo == 14) // ECDSAP384SHA384
 241     bits = 384;
 242   else if(algo == 16) // ED448
 243     bits = 456;
 244   else
 245     throw runtime_error("Can't guess key size for algorithm "+std::to_string(algo));
 246
 247   dckeCreate->create(bits);
 248
 249   { // FIXME: this block copy/pasted from makeFromISCString
 250     DNSKEYRecordContent dkrc;
 251     int algorithm = 0;
 252     string sline, key, value, raw;
 253     std::istringstream str(dckeCreate->convertToISC());
 254     map<string, string> stormap;
 255
 256     while(std::getline(str, sline)) {
 257       tie(key,value)=splitField(sline, ':');
 258       trim(value);
 259       if(pdns_iequals(key,"algorithm")) {
 260         algorithm = pdns_stou(value);
 261         stormap["algorithm"]=std::to_string(algorithm);
 262         continue;
 263       } else if (pdns_iequals(key,"pin")) {
 264         stormap["pin"]=value;
 265         continue;
 266       } else if (pdns_iequals(key,"engine")) {
 267         stormap["engine"]=value;
 268         continue;
 269       } else if (pdns_iequals(key,"slot")) {
 270         int slot = std::stoi(value);
 271         stormap["slot"]=std::to_string(slot);
 272         continue;
 273       }  else if (pdns_iequals(key,"label")) {
 274         stormap["label"]=value;
 275         continue;
 276       }
 277       else if(pdns_iequals(key, "Private-key-format"))
 278         continue;
 279       raw.clear();
 280       B64Decode(value, raw);
 281       stormap[toLower(key)]=raw;
 282     }
 283     dckeSign->fromISCMap(dkrc, stormap);
 284     if(!dckeSign->checkKey()) {
 285       throw runtime_error("Verification of key with creator "+dckeCreate->getName()+" with signer "+dckeSign->getName()+" and verifier "+dckeVerify->getName()+" failed");
 286     }
 287   }
 288
 289   string message("Hi! How is life?");
 290
 291   string signature;
 292   DTime dt; dt.set();
 293   for(unsigned int n = 0; n < 100; ++n)
 294     signature = dckeSign->sign(message);
 295   unsigned int udiffSign= dt.udiff()/100, udiffVerify;
 296
 297   dckeVerify->fromPublicKeyString(dckeSign->getPublicKeyString());
 298   if (dckeVerify->getPublicKeyString().compare(dckeSign->getPublicKeyString())) {
 299     throw runtime_error("Comparison of public key loaded into verifier produced by signer failed");
 300   }
 301   dt.set();
 302   if(dckeVerify->verify(message, signature)) {
 303     udiffVerify = dt.udiff();
 304     cerr<<"Signature & verify ok, signature "<<udiffSign<<"usec, verify "<<udiffVerify<<"usec"<<endl;
 305   }
 306   else {
 307     throw runtime_error("Verification of creator "+dckeCreate->getName()+" with signer "+dckeSign->getName()+" and verifier "+dckeVerify->getName()+" failed");
 308   }
 309   return make_pair(udiffSign, udiffVerify);
 310 }
 311
 312 shared_ptr<DNSCryptoKeyEngine> DNSCryptoKeyEngine::makeFromPublicKeyString(unsigned int algorithm, const std::string& content)
 313 {
 314   shared_ptr<DNSCryptoKeyEngine> dpk=make(algorithm);
 315   dpk->fromPublicKeyString(content);
 316   return dpk;
 317 }
 318
 319
 320 shared_ptr<DNSCryptoKeyEngine> DNSCryptoKeyEngine::makeFromPEMString(DNSKEYRecordContent& drc, const std::string& raw)
 321 {
 322
 323   for(const makers_t::value_type& val : getMakers())
 324   {
 325     shared_ptr<DNSCryptoKeyEngine> ret=nullptr;
 326     try {
 327       ret = val.second(val.first);
 328       ret->fromPEMString(drc, raw);
 329       return ret;
 330     }
 331     catch(...)
 332     {
 333     }
 334   }
 335   return 0;
 336 }
 337
 338
 339 static bool sharedDNSSECCompare(const shared_ptr<DNSRecordContent>& a, const shared_ptr<DNSRecordContent>& b)
 340 {
 341   return a->serialize(g_rootdnsname, true, true) < b->serialize(g_rootdnsname, true, true);
 342 }
 343
 344 /**
 345  * Returns the string that should be hashed to create/verify the RRSIG content
 346  *
 347  * @param qname               DNSName of the RRSIG's owner name.
 348  * @param rrc                 The RRSIGRecordContent we take the Type Covered and
 349  *                            original TTL fields from.
 350  * @param signRecords         A vector of DNSRecordContent shared_ptr's that are covered
 351  *                            by the RRSIG, where we get the RDATA from.
 352  * @param processRRSIGLabels  A boolean to trigger processing the RRSIG's "Labels"
 353  *                            field. This is usually only needed for validation
 354  *                            purposes, as the authoritative server correctly
 355  *                            sets qname to the wildcard.
 356  */
 357 string getMessageForRRSET(const DNSName& qname, const RRSIGRecordContent& rrc, vector<shared_ptr<DNSRecordContent> >& signRecords, bool processRRSIGLabels)
 358 {
 359   sort(signRecords.begin(), signRecords.end(), sharedDNSSECCompare);
 360
 361   string toHash;
 362   toHash.append(const_cast<RRSIGRecordContent&>(rrc).serialize(g_rootdnsname, true, true));
 363   toHash.resize(toHash.size() - rrc.d_signature.length()); // chop off the end, don't sign the signature!
 364
 365   string nameToHash(qname.toDNSStringLC());
 366
 367   if (processRRSIGLabels) {
 368     unsigned int rrsig_labels = rrc.d_labels;
 369     unsigned int fqdn_labels = qname.countLabels();
 370
 371     if (rrsig_labels < fqdn_labels) {
 372       DNSName choppedQname(qname);
 373       while (choppedQname.countLabels() > rrsig_labels)
 374         choppedQname.chopOff();
 375       nameToHash = "\x01*" + choppedQname.toDNSStringLC();
 376     } else if (rrsig_labels > fqdn_labels) {
 377       // The RRSIG Labels field is a lie (or the qname is wrong) and the RRSIG
 378       // can never be valid
 379       return "";
 380     }
 381   }
 382
 383   for(shared_ptr<DNSRecordContent>& add :  signRecords) {
 384     toHash.append(nameToHash);
 385     uint16_t tmp=htons(rrc.d_type);
 386     toHash.append((char*)&tmp, 2);
 387     tmp=htons(1); // class
 388     toHash.append((char*)&tmp, 2);
 389     uint32_t ttl=htonl(rrc.d_originalttl);
 390     toHash.append((char*)&ttl, 4);
 391     // for NSEC signatures, we should not lowercase the rdata section
 392     string rdata=add->serialize(g_rootdnsname, true, (add->getType() == QType::NSEC) ? false : true);  // RFC 6840, 5.1
 393     tmp=htons(rdata.length());
 394     toHash.append((char*)&tmp, 2);
 395     toHash.append(rdata);
 396   }
 397
 398   return toHash;
 399 }
 400
 401 bool DNSCryptoKeyEngine::isAlgorithmSupported(unsigned int algo)
 402 {
 403   const makers_t& makers = getMakers();
 404   makers_t::const_iterator iter = makers.find(algo);
 405   return iter != makers.cend();
 406 }
 407
 408 static unsigned int digestToAlgorithmNumber(uint8_t digest)
 409 {
 410   switch(digest) {
 411   case DNSSECKeeper::SHA1:
 412     return DNSSECKeeper::RSASHA1;
 413   case DNSSECKeeper::SHA256:
 414     return DNSSECKeeper::RSASHA256;
 415   case DNSSECKeeper::GOST:
 416     return DNSSECKeeper::ECCGOST;
 417   case DNSSECKeeper::SHA384:
 418     return DNSSECKeeper::ECDSA384;
 419   default:
 420     throw std::runtime_error("Unknown digest type " + std::to_string(digest));
 421   }
 422   return 0;
 423 }
 424
 425 bool DNSCryptoKeyEngine::isDigestSupported(uint8_t digest)
 426 {
 427   try {
 428     unsigned int algo = digestToAlgorithmNumber(digest);
 429     return isAlgorithmSupported(algo);
 430   }
 431   catch(const std::exception& e) {
 432     return false;
 433   }
 434 }
 435
 436 DSRecordContent makeDSFromDNSKey(const DNSName& qname, const DNSKEYRecordContent& drc, uint8_t digest)
 437 {
 438   string toHash;
 439   toHash.assign(qname.toDNSStringLC());
 440   toHash.append(const_cast<DNSKEYRecordContent&>(drc).serialize(DNSName(), true, true));
 441
 442   DSRecordContent dsrc;
 443   try {
 444     unsigned int algo = digestToAlgorithmNumber(digest);
 445     shared_ptr<DNSCryptoKeyEngine> dpk(DNSCryptoKeyEngine::make(algo));
 446     dsrc.d_digest = dpk->hash(toHash);
 447   }
 448   catch(const std::exception& e) {
 449     throw std::runtime_error("Asked to a DS of unknown digest type " + std::to_string(digest)+"\n");
 450   }
 451
 452   dsrc.d_algorithm = drc.d_algorithm;
 453   dsrc.d_digesttype = digest;
 454   dsrc.d_tag = const_cast<DNSKEYRecordContent&>(drc).getTag();
 455
 456   return dsrc;
 457 }
 458
 459
 460 static DNSKEYRecordContent makeDNSKEYFromDNSCryptoKeyEngine(const std::shared_ptr<DNSCryptoKeyEngine> pk, uint8_t algorithm, uint16_t flags)
 461 {
 462   DNSKEYRecordContent drc;
 463
 464   drc.d_protocol=3;
 465   drc.d_algorithm = algorithm;
 466
 467   drc.d_flags=flags;
 468   drc.d_key = pk->getPublicKeyString();
 469
 470   return drc;
 471 }
 472
 473 uint32_t getStartOfWeek()
 474 {
 475   uint32_t now = time(0);
 476   now -= (now % (7*86400));
 477   return now;
 478 }
 479
 480 string hashQNameWithSalt(const NSEC3PARAMRecordContent& ns3prc, const DNSName& qname)
 481 {
 482   return hashQNameWithSalt(ns3prc.d_salt, ns3prc.d_iterations, qname);
 483 }
 484
 485 string hashQNameWithSalt(const std::string& salt, unsigned int iterations, const DNSName& qname)
 486 {
 487   unsigned int times = iterations;
 488   unsigned char hash[20];
 489   string toHash(qname.toDNSStringLC());
 490
 491   for(;;) {
 492     toHash.append(salt);
 493     SHA1((unsigned char*)toHash.c_str(), toHash.length(), hash);
 494     toHash.assign((char*)hash, sizeof(hash));
 495     if(!times--)
 496       break;
 497   }
 498   return toHash;
 499 }
 500
 501 void incrementHash(std::string& raw) // I wonder if this is correct, cmouse? ;-)
 502 {
 503   if(raw.empty())
 504     return;
 505
 506   for(string::size_type pos=raw.size(); pos; ) {
 507     --pos;
 508     unsigned char c = (unsigned char)raw[pos];
 509     ++c;
 510     raw[pos] = (char) c;
 511     if(c)
 512       break;
 513   }
 514 }
 515
 516 void decrementHash(std::string& raw) // I wonder if this is correct, cmouse? ;-)
 517 {
 518   if(raw.empty())
 519     return;
 520
 521   for(string::size_type pos=raw.size(); pos; ) {
 522     --pos;
 523     unsigned char c = (unsigned char)raw[pos];
 524     --c;
 525     raw[pos] = (char) c;
 526     if(c != 0xff)
 527       break;
 528   }
 529 }
 530
 531 DNSKEYRecordContent DNSSECPrivateKey::getDNSKEY() const
 532 {
 533   return makeDNSKEYFromDNSCryptoKeyEngine(getKey(), d_algorithm, d_flags);
 534 }
 535
 536 class DEREater
 537 {
 538 public:
 539   DEREater(const std::string& str) : d_str(str), d_pos(0)
 540   {}
 541
 542   struct eof{};
 543
 544   uint8_t getByte()
 545   {
 546     if(d_pos >= d_str.length()) {
 547       throw eof();
 548     }
 549     return (uint8_t) d_str[d_pos++];
 550   }
 551
 552   uint32_t getLength()
 553   {
 554     uint8_t first = getByte();
 555     if(first < 0x80) {
 556       return first;
 557     }
 558     first &= ~0x80;
 559
 560     uint32_t len=0;
 561     for(int n=0; n < first; ++n) {
 562       len *= 0x100;
 563       len += getByte();
 564     }
 565     return len;
 566   }
 567
 568   std::string getBytes(unsigned int len)
 569   {
 570     std::string ret;
 571     for(unsigned int n=0; n < len; ++n)
 572       ret.append(1, (char)getByte());
 573     return ret;
 574   }
 575
 576   std::string::size_type getOffset()
 577   {
 578     return d_pos;
 579   }
 580 private:
 581   const std::string& d_str;
 582   std::string::size_type d_pos;
 583 };
 584
 585 static string calculateHMAC(const std::string& key, const std::string& text, TSIGHashEnum hasher) {
 586
 587   const EVP_MD* md_type;
 588   unsigned int outlen;
 589   unsigned char hash[EVP_MAX_MD_SIZE];
 590   switch(hasher) {
 591     case TSIG_MD5:
 592       md_type = EVP_md5();
 593       break;
 594     case TSIG_SHA1:
 595       md_type = EVP_sha1();
 596       break;
 597     case TSIG_SHA224:
 598       md_type = EVP_sha224();
 599       break;
 600     case TSIG_SHA256:
 601       md_type = EVP_sha256();
 602       break;
 603     case TSIG_SHA384:
 604       md_type = EVP_sha384();
 605       break;
 606     case TSIG_SHA512:
 607       md_type = EVP_sha512();
 608       break;
 609     default:
 610       throw PDNSException("Unknown hash algorithm requested from calculateHMAC()");
 611   }
 612
 613   unsigned char* out = HMAC(md_type, reinterpret_cast<const unsigned char*>(key.c_str()), key.size(), reinterpret_cast<const unsigned char*>(text.c_str()), text.size(), hash, &outlen);
 614   if (out == NULL || outlen == 0) {
 615     throw PDNSException("HMAC computation failed");
 616   }
 617
 618   return string((char*) hash, outlen);
 619 }
 620
 621 static bool constantTimeStringEquals(const std::string& a, const std::string& b)
 622 {
 623   if (a.size() != b.size()) {
 624     return false;
 625   }
 626   const size_t size = a.size();
 627 #if OPENSSL_VERSION_NUMBER >= 0x0090819fL
 628   return CRYPTO_memcmp(a.c_str(), b.c_str(), size) == 0;
 629 #else
 630   const volatile unsigned char *_a = (const volatile unsigned char *) a.c_str();
 631   const volatile unsigned char *_b = (const volatile unsigned char *) b.c_str();
 632   unsigned char res = 0;
 633
 634   for (size_t idx = 0; idx < size; idx++) {
 635     res |= _a[idx] ^ _b[idx];
 636   }
 637
 638   return res == 0;
 639 #endif
 640 }
 641
 642 static string makeTSIGPayload(const string& previous, const char* packetBegin, size_t packetSize, const DNSName& tsigKeyName, const TSIGRecordContent& trc, bool timersonly)
 643 {
 644   string message;
 645
 646   if(!previous.empty()) {
 647     uint16_t len = htons(previous.length());
 648     message.append(reinterpret_cast<const char*>(&len), sizeof(len));
 649     message.append(previous);
 650   }
 651
 652   message.append(packetBegin, packetSize);
 653
 654   vector<uint8_t> signVect;
 655   DNSPacketWriter dw(signVect, DNSName(), 0);
 656   auto pos=signVect.size();
 657   if(!timersonly) {
 658     dw.xfrName(tsigKeyName, false);
 659     dw.xfr16BitInt(QClass::ANY); // class
 660     dw.xfr32BitInt(0);    // TTL
 661     dw.xfrName(trc.d_algoName.makeLowerCase(), false);
 662   }
 663
 664   uint32_t now = trc.d_time;
 665   dw.xfr48BitInt(now);
 666   dw.xfr16BitInt(trc.d_fudge); // fudge
 667   if(!timersonly) {
 668     dw.xfr16BitInt(trc.d_eRcode); // extended rcode
 669     dw.xfr16BitInt(trc.d_otherData.length()); // length of 'other' data
 670     //    dw.xfrBlob(trc->d_otherData);
 671   }
 672   message.append(signVect.begin()+pos, signVect.end());
 673   return message;
 674 }
 675
 676 static string makeTSIGMessageFromTSIGPacket(const string& opacket, unsigned int tsigOffset, const DNSName& keyname, const TSIGRecordContent& trc, const string& previous, bool timersonly, unsigned int dnsHeaderOffset=0)
 677 {
 678   string message;
 679   string packet(opacket);
 680
 681   packet.resize(tsigOffset); // remove the TSIG record at the end as per RFC2845 3.4.1
 682   packet[(dnsHeaderOffset + sizeof(struct dnsheader))-1]--; // Decrease ARCOUNT because we removed the TSIG RR in the previous line.
 683
 684
 685   // Replace the message ID with the original message ID from the TSIG record.
 686   // This is needed for forwarded DNS Update as they get a new ID when forwarding (section 6.1 of RFC2136). The TSIG record stores the original ID and the
 687   // signature was created with the original ID, so we replace it here to get the originally signed message.
 688   // If the message is not forwarded, we simply override it with the same id.
 689   uint16_t origID = htons(trc.d_origID);
 690   packet.replace(0, 2, (char*)&origID, 2);
 691
 692   return makeTSIGPayload(previous, packet.data(), packet.size(), keyname, trc, timersonly);
 693 }
 694
 695 void addTSIG(DNSPacketWriter& pw, TSIGRecordContent& trc, const DNSName& tsigkeyname, const string& tsigsecret, const string& tsigprevious, bool timersonly)
 696 {
 697   TSIGHashEnum algo;
 698   if (!getTSIGHashEnum(trc.d_algoName, algo)) {
 699     throw PDNSException(string("Unsupported TSIG HMAC algorithm ") + trc.d_algoName.toString());
 700   }
 701
 702   string toSign = makeTSIGPayload(tsigprevious, reinterpret_cast<const char*>(pw.getContent().data()), pw.getContent().size(), tsigkeyname, trc, timersonly);
 703
 704   if (algo == TSIG_GSS) {
 705     if (!gss_add_signature(tsigkeyname, toSign, trc.d_mac)) {
 706       throw PDNSException(string("Could not add TSIG signature with algorithm 'gss-tsig' and key name '")+tsigkeyname.toString()+string("'"));
 707     }
 708   } else {
 709     trc.d_mac = calculateHMAC(tsigsecret, toSign, algo);
 710     //  trc.d_mac[0]++; // sabotage
 711   }
 712   pw.startRecord(tsigkeyname, QType::TSIG, 0, QClass::ANY, DNSResourceRecord::ADDITIONAL, false);
 713   trc.toPacket(pw);
 714   pw.commit();
 715 }
 716
 717 bool validateTSIG(const std::string& packet, size_t sigPos, const TSIGTriplet& tt, const TSIGRecordContent& trc, const std::string& previousMAC, const std::string& theirMAC, bool timersOnly, unsigned int dnsHeaderOffset)
 718 {
 719   uint64_t delta = std::abs((int64_t)trc.d_time - (int64_t)time(nullptr));
 720   if(delta > trc.d_fudge) {
 721     throw std::runtime_error("Invalid TSIG time delta " + std::to_string(delta) + " >  fudge " + std::to_string(trc.d_fudge));
 722   }
 723
 724   TSIGHashEnum algo;
 725   if (!getTSIGHashEnum(trc.d_algoName, algo)) {
 726     throw std::runtime_error("Unsupported TSIG HMAC algorithm " + trc.d_algoName.toString());
 727   }
 728
 729   TSIGHashEnum expectedAlgo;
 730   if (!getTSIGHashEnum(tt.algo, expectedAlgo)) {
 731     throw std::runtime_error("Unsupported TSIG HMAC algorithm expected " + tt.algo.toString());
 732   }
 733
 734   if (algo != expectedAlgo) {
 735     throw std::runtime_error("Signature with TSIG key '"+tt.name.toString()+"' does not match the expected algorithm (" + tt.algo.toString() + " / " + trc.d_algoName.toString() + ")");
 736   }
 737
 738   string tsigMsg;
 739   tsigMsg = makeTSIGMessageFromTSIGPacket(packet, sigPos, tt.name, trc, previousMAC, timersOnly, dnsHeaderOffset);
 740
 741   if (algo == TSIG_GSS) {
 742     GssContext gssctx(tt.name);
 743     if (!gss_verify_signature(tt.name, tsigMsg, theirMAC)) {
 744       throw std::runtime_error("Signature with TSIG key '"+tt.name.toString()+"' failed to validate");
 745     }
 746   } else {
 747     string ourMac = calculateHMAC(tt.secret, tsigMsg, algo);
 748
 749     if(!constantTimeStringEquals(ourMac, theirMAC)) {
 750       throw std::runtime_error("Signature with TSIG key '"+tt.name.toString()+"' failed to validate");
 751     }
 752   }
 753
 754   return true;
 755 }