pdns/dnsparser.hh

   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 #ifndef DNSPARSER_HH
  23 #define DNSPARSER_HH
  24
  25 #include <map>
  26 #include <sstream>
  27 #include <stdexcept>
  28 #include <iostream>
  29 #include <vector>
  30 #include <errno.h>
  31 // #include <netinet/in.h>
  32 #include "misc.hh"
  33
  34 #include <boost/tuple/tuple.hpp>
  35 #include <boost/tuple/tuple_comparison.hpp>
  36 #include "dns.hh"
  37 #include "dnswriter.hh"
  38 #include "dnsname.hh"
  39 #include "pdnsexception.hh"
  40 #include "iputils.hh"
  41
  42 /** DNS records have three representations:
  43     1) in the packet
  44     2) parsed in a class, ready for use
  45     3) in the zone
  46
  47     We should implement bidirectional transitions between 1&2 and 2&3.
  48     Currently we have: 1 -> 2
  49                        2 -> 3
  50
  51     We can add:        2 -> 1  easily by reversing the packetwriter
  52     And we might be able to reverse 2 -> 3 as well
  53 */
  54
  55 #include "namespaces.hh"
  56 #include "namespaces.hh"
  57
  58 class MOADNSException : public runtime_error
  59 {
  60 public:
  61   MOADNSException(const string& str) : runtime_error(str)
  62   {}
  63 };
  64
  65
  66 class MOADNSParser;
  67
  68 class PacketReader
  69 {
  70 public:
  71   PacketReader(const std::string& content, uint16_t initialPos=sizeof(dnsheader))
  72     : d_pos(initialPos), d_startrecordpos(initialPos), d_content(content)
  73   {
  74     if(content.size() > std::numeric_limits<uint16_t>::max())
  75       throw std::out_of_range("packet too large");
  76
  77     d_recordlen = (uint16_t) content.size();
  78     not_used = 0;
  79   }
  80
  81   uint32_t get32BitInt();
  82   uint16_t get16BitInt();
  83   uint8_t get8BitInt();
  84
  85   void xfr48BitInt(uint64_t& val);
  86
  87   void xfr32BitInt(uint32_t& val)
  88   {
  89     val=get32BitInt();
  90   }
  91
  92   void xfrIP(uint32_t& val)
  93   {
  94     xfr32BitInt(val);
  95     val=htonl(val);
  96   }
  97
  98   void xfrIP6(std::string &val) {
  99     xfrBlob(val, 16);
 100   }
 101
 102   void xfrCAWithoutPort(uint8_t version, ComboAddress &val) {
 103     string blob;
 104     if (version == 4) xfrBlob(blob, 4);
 105     else if (version == 6) xfrBlob(blob, 16);
 106     else throw runtime_error("invalid IP protocol");
 107     val = makeComboAddressFromRaw(version, blob);
 108   }
 109
 110   void xfrCAPort(ComboAddress &val) {
 111     uint16_t port;
 112     xfr16BitInt(port);
 113     val.sin4.sin_port = port;
 114   }
 115
 116   void xfrTime(uint32_t& val)
 117   {
 118     xfr32BitInt(val);
 119   }
 120
 121
 122   void xfr16BitInt(uint16_t& val)
 123   {
 124     val=get16BitInt();
 125   }
 126
 127   void xfrType(uint16_t& val)
 128   {
 129     xfr16BitInt(val);
 130   }
 131
 132
 133   void xfr8BitInt(uint8_t& val)
 134   {
 135     val=get8BitInt();
 136   }
 137
 138
 139   void xfrName(DNSName &name, bool compress=false, bool noDot=false)
 140   {
 141     name=getName();
 142   }
 143
 144   void xfrText(string &text, bool multi=false, bool lenField=true)
 145   {
 146     text=getText(multi, lenField);
 147   }
 148
 149   void xfrUnquotedText(string &text, bool lenField){
 150     text=getUnquotedText(lenField);
 151   }
 152
 153   void xfrBlob(string& blob);
 154   void xfrBlobNoSpaces(string& blob, int len);
 155   void xfrBlob(string& blob, int length);
 156   void xfrHexBlob(string& blob, bool keepReading=false);
 157
 158   void getDnsrecordheader(struct dnsrecordheader &ah);
 159   void copyRecord(vector<unsigned char>& dest, uint16_t len);
 160   void copyRecord(unsigned char* dest, uint16_t len);
 161
 162   DNSName getName();
 163   string getText(bool multi, bool lenField);
 164   string getUnquotedText(bool lenField);
 165
 166
 167   bool eof() { return true; };
 168   const string getRemaining() const {
 169     return "";
 170   };
 171
 172   uint16_t getPosition() const
 173   {
 174     return d_pos;
 175   }
 176
 177   void skip(uint16_t n)
 178   {
 179     d_pos += n;
 180   }
 181
 182 private:
 183   uint16_t d_pos;
 184   uint16_t d_startrecordpos; // needed for getBlob later on
 185   uint16_t d_recordlen;      // ditto
 186   uint16_t not_used; // Aligns the whole class on 8-byte boundries
 187   const std::string& d_content;
 188 };
 189
 190 struct DNSRecord;
 191
 192 class DNSRecordContent
 193 {
 194 public:
 195   static std::shared_ptr<DNSRecordContent> mastermake(const DNSRecord &dr, PacketReader& pr);
 196   static std::shared_ptr<DNSRecordContent> mastermake(const DNSRecord &dr, PacketReader& pr, uint16_t opcode);
 197   static std::shared_ptr<DNSRecordContent> mastermake(uint16_t qtype, uint16_t qclass, const string& zone);
 198
 199   virtual std::string getZoneRepresentation(bool noDot=false) const = 0;
 200   virtual ~DNSRecordContent() {}
 201   virtual void toPacket(DNSPacketWriter& pw)=0;
 202   virtual string serialize(const DNSName& qname, bool canonic=false, bool lowerCase=false) // it would rock if this were const, but it is too hard
 203   {
 204     vector<uint8_t> packet;
 205     DNSPacketWriter pw(packet, g_rootdnsname, 1);
 206     if(canonic)
 207       pw.setCanonic(true);
 208
 209     if(lowerCase)
 210       pw.setLowercase(true);
 211
 212     pw.startRecord(qname, this->getType());
 213     this->toPacket(pw);
 214
 215     string record;
 216     pw.getRecordPayload(record); // needs to be called before commit()
 217     return record;
 218   }
 219
 220   virtual bool operator==(const DNSRecordContent& rhs) const
 221   {
 222     return typeid(*this)==typeid(rhs) && this->getZoneRepresentation() == rhs.getZoneRepresentation();
 223   }
 224
 225   static shared_ptr<DNSRecordContent> unserialize(const DNSName& qname, uint16_t qtype, const string& serialized);
 226
 227   void doRecordCheck(const struct DNSRecord&){}
 228
 229   typedef std::shared_ptr<DNSRecordContent> makerfunc_t(const struct DNSRecord& dr, PacketReader& pr);
 230   typedef std::shared_ptr<DNSRecordContent> zmakerfunc_t(const string& str);
 231
 232   static void regist(uint16_t cl, uint16_t ty, makerfunc_t* f, zmakerfunc_t* z, const char* name)
 233   {
 234     if(f)
 235       getTypemap()[make_pair(cl,ty)]=f;
 236     if(z)
 237       getZmakermap()[make_pair(cl,ty)]=z;
 238
 239     getT2Namemap().insert(make_pair(make_pair(cl,ty), name));
 240     getN2Typemap().insert(make_pair(name, make_pair(cl,ty)));
 241   }
 242
 243   static void unregist(uint16_t cl, uint16_t ty)
 244   {
 245     pair<uint16_t, uint16_t> key=make_pair(cl, ty);
 246     getTypemap().erase(key);
 247     getZmakermap().erase(key);
 248   }
 249
 250   static uint16_t TypeToNumber(const string& name)
 251   {
 252     n2typemap_t::const_iterator iter = getN2Typemap().find(toUpper(name));
 253     if(iter != getN2Typemap().end())
 254       return iter->second.second;
 255
 256     if(boost::starts_with(name, "TYPE") || boost::starts_with(name, "type"))
 257       return (uint16_t) pdns_stou(name.substr(4));
 258
 259     throw runtime_error("Unknown DNS type '"+name+"'");
 260   }
 261
 262   static const string NumberToType(uint16_t num, uint16_t classnum=1)
 263   {
 264     t2namemap_t::const_iterator iter = getT2Namemap().find(make_pair(classnum, num));
 265     if(iter == getT2Namemap().end())
 266       return "TYPE" + std::to_string(num);
 267       //      throw runtime_error("Unknown DNS type with numerical id "+std::to_string(num));
 268     return iter->second;
 269   }
 270
 271   virtual uint16_t getType() const = 0;
 272
 273 protected:
 274   typedef std::map<std::pair<uint16_t, uint16_t>, makerfunc_t* > typemap_t;
 275   typedef std::map<std::pair<uint16_t, uint16_t>, zmakerfunc_t* > zmakermap_t;
 276   typedef std::map<std::pair<uint16_t, uint16_t>, string > t2namemap_t;
 277   typedef std::map<string, std::pair<uint16_t, uint16_t> > n2typemap_t;
 278   static typemap_t& getTypemap();
 279   static t2namemap_t& getT2Namemap();
 280   static n2typemap_t& getN2Typemap();
 281   static zmakermap_t& getZmakermap();
 282 };
 283
 284 struct DNSRecord
 285 {
 286   DNSRecord() : d_type(0), d_class(QClass::IN), d_ttl(0), d_clen(0), d_place(DNSResourceRecord::ANSWER)
 287   {}
 288   explicit DNSRecord(const DNSResourceRecord& rr);
 289   DNSName d_name;
 290   std::shared_ptr<DNSRecordContent> d_content;
 291   uint16_t d_type;
 292   uint16_t d_class;
 293   uint32_t d_ttl;
 294   uint16_t d_clen;
 295   DNSResourceRecord::Place d_place;
 296
 297   bool operator<(const DNSRecord& rhs) const
 298   {
 299     if(tie(d_name, d_type, d_class, d_ttl) < tie(rhs.d_name, rhs.d_type, rhs.d_class, rhs.d_ttl))
 300       return true;
 301
 302     if(tie(d_name, d_type, d_class, d_ttl) != tie(rhs.d_name, rhs.d_type, rhs.d_class, rhs.d_ttl))
 303       return false;
 304
 305     string lzrp, rzrp;
 306     if(d_content)
 307       lzrp=toLower(d_content->getZoneRepresentation());
 308     if(rhs.d_content)
 309       rzrp=toLower(rhs.d_content->getZoneRepresentation());
 310
 311     return lzrp < rzrp;
 312   }
 313
 314   // this orders in canonical order and keeps the SOA record on top
 315   static bool prettyCompare(const DNSRecord& a, const DNSRecord& b)
 316   {
 317     auto aType = (a.d_type == QType::SOA) ? 0 : a.d_type;
 318     auto bType = (b.d_type == QType::SOA) ? 0 : b.d_type;
 319
 320     if(a.d_name.canonCompare(b.d_name))
 321       return true;
 322     if(b.d_name.canonCompare(a.d_name))
 323       return false;
 324
 325     if(tie(aType, a.d_class, a.d_ttl) < tie(bType, b.d_class, b.d_ttl))
 326       return true;
 327
 328     if(tie(aType, a.d_class, a.d_ttl) != tie(bType, b.d_class, b.d_ttl))
 329       return false;
 330
 331     string lzrp, rzrp;
 332     if(a.d_content)
 333       lzrp=toLower(a.d_content->getZoneRepresentation());
 334     if(b.d_content)
 335       rzrp=toLower(b.d_content->getZoneRepresentation());
 336
 337     return lzrp < rzrp;
 338   }
 339
 340
 341   bool operator==(const DNSRecord& rhs) const
 342   {
 343     if(d_type != rhs.d_type || d_class != rhs.d_class || d_name != rhs.d_name)
 344       return false;
 345
 346     return *d_content == *rhs.d_content;
 347   }
 348 };
 349
 350 struct DNSZoneRecord
 351 {
 352   int domain_id{-1};
 353   uint8_t scopeMask{0};
 354   int signttl{0};
 355   DNSName wildcardname;
 356   bool auth{true};
 357   DNSRecord dr;
 358 };
 359
 360
 361 //! This class can be used to parse incoming packets, and is copyable
 362 class MOADNSParser : public boost::noncopyable
 363 {
 364 public:
 365   //! Parse from a string
 366   MOADNSParser(bool query, const string& buffer): d_tsigPos(0)
 367   {
 368     init(query, buffer);
 369   }
 370
 371   //! Parse from a pointer and length
 372   MOADNSParser(bool query, const char *packet, unsigned int len) : d_tsigPos(0)
 373   {
 374     init(query, std::string(packet, len));
 375   }
 376
 377   DNSName d_qname;
 378   uint16_t d_qclass, d_qtype;
 379   //uint8_t d_rcode;
 380   dnsheader d_header;
 381
 382   typedef vector<pair<DNSRecord, uint16_t > > answers_t;
 383
 384   //! All answers contained in this packet (everything *but* the question section)
 385   answers_t d_answers;
 386
 387   uint16_t getTSIGPos() const
 388   {
 389     return d_tsigPos;
 390   }
 391 private:
 392   void init(bool query, const std::string& packet);
 393   uint16_t d_tsigPos;
 394 };
 395
 396 string simpleCompress(const string& label, const string& root="");
 397 void ageDNSPacket(char* packet, size_t length, uint32_t seconds);
 398 void ageDNSPacket(std::string& packet, uint32_t seconds);
 399 void editDNSPacketTTL(char* packet, size_t length, std::function<uint32_t(uint8_t, uint16_t, uint16_t, uint32_t)> visitor);
 400 uint32_t getDNSPacketMinTTL(const char* packet, size_t length, bool* seenAuthSOA=nullptr);
 401 uint32_t getDNSPacketLength(const char* packet, size_t length);
 402 uint16_t getRecordsOfTypeCount(const char* packet, size_t length, uint8_t section, uint16_t type);
 403 bool getEDNSUDPPayloadSizeAndZ(const char* packet, size_t length, uint16_t* payloadSize, uint16_t* z);
 404
 405 template<typename T>
 406 std::shared_ptr<T> getRR(const DNSRecord& dr)
 407 {
 408   return std::dynamic_pointer_cast<T>(dr.d_content);
 409 }
 410
 411 #endif