18776176249

Committed 24 Oct 2025 09:51AM UTC coverage: 73.028% (+15.6%) from 57.383%

Build # 18776176249

Build Type

Pull #16370

github

Committed by

web-flow

Commit Message

Merge 0f309894e into 39f7f1b27

Pull Request Pull Request #16370: auth: xfr churning

Run Details

38273 of 63104 branches covered (60.65%)

Branch coverage included in aggregate %.

186 of 264 new or added lines in 1 file covered. (70.45%)

14471 existing lines in 217 files now uncovered.

127487 of 163878 relevant lines covered (77.79%)

5632363.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.6

/pdns/dnswriter.hh

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#pragma once
#include <string>
#include <vector>
#include <map>
#include "dns.hh"
#include "dnsname.hh"
#include "namespaces.hh"
#include "iputils.hh"
#include "svc-records.hh"
#include <arpa/inet.h>


/** this class can be used to write DNS packets. It knows about DNS in the sense that it makes
    the packet header and record headers.

    The model is:

    packetheader (recordheader recordcontent)*

    The packetheader needs to be updated with the amount of packets of each kind (answer, auth, additional)

    Each recordheader contains the length of a dns record.

    Calling convention:

    vector<uint8_t> content;
    DNSPacketWriter dpw(content, const string& qname, uint16_t qtype, uint16_t qclass=QClass:IN);  // sets the question
    dpw.startrecord("this.is.an.ip.address.", ns_t_a);    // does nothing, except store qname and qtype
    dpw.xfr32BitInt(0x01020304);                         // adds 4 bytes (0x01020304) to the record buffer
    dpw.startrecord("this.is.an.ip.address.", ns_t_a);    // aha! writes out dnsrecord header containing qname and qtype and length 4, plus the recordbuffer, which gets emptied
                                                         // new qname and qtype are stored
    dpw.xfr32BitInt(0x04030201);                         // adds 4 bytes (0x04030201) to the record buffer
    dpw.commit();                                        // writes out dnsrecord header containing qname and qtype and length 4, plus the recordbuffer

    // content now contains the ready packet, with 1 question and 2 answers

*/

template <typename Container> class GenericDNSPacketWriter : public boost::noncopyable
{

public:
  //! Start a DNS Packet in the vector passed, with question qname, qtype and qclass
  GenericDNSPacketWriter(Container& content, const DNSName& qname, uint16_t  qtype, uint16_t qclass=QClass::IN, uint8_t opcode=0);

  /** Start a new DNS record within this packet for name, qtype, ttl, class and in the requested place. Note that packets can only be written in natural order -
      ANSWER, AUTHORITY, ADDITIONAL */
  void startRecord(const DNSName& name, uint16_t qtype, uint32_t ttl=3600, uint16_t qclass=QClass::IN, DNSResourceRecord::Place place=DNSResourceRecord::ANSWER, bool compress=true);

  /** Shorthand way to add an Opt-record, for example for EDNS0 purposes */
  using optvect_t = vector<pair<uint16_t,std::string> >;
  void addOpt(const uint16_t udpsize, const uint16_t extRCode, const uint16_t ednsFlags, const optvect_t& options=optvect_t(), const uint8_t version=0);

  /** needs to be called after the last record is added, but can be called again and again later on. Is called internally by startRecord too.
      The content of the vector<> passed to the constructor is inconsistent until commit is called.
   */
  void commit();

  uint32_t size() const; // needs to be 32 bit because otherwise we don't see the wrap coming when it happened!

  /** Should the packet have grown too big for the writer's liking, rollback removes the record currently being written */
  void rollback();

  /** Discard all content except the question section */
  void truncate();

  void xfr48BitInt(uint64_t val);
  void xfrNodeOrLocatorID(const NodeOrLocatorID& val);
  void xfr32BitInt(uint32_t val);
  void xfr16BitInt(uint16_t val);
  void xfrType(uint16_t val)
  {
    xfr16BitInt(val);
  }
  void xfrIP(const uint32_t& val)
  {
    xfr32BitInt(htonl(val));
  }
  void xfrIP6(const std::string& val)
  {
    xfrBlob(val,16);
  }

  void xfrCAWithoutPort(uint8_t version, const ComboAddress &val)
  {
    if (version == 4) xfrIP(val.sin4.sin_addr.s_addr);
    else if (version == 6) {
      string blob;
      blob.assign((const char*)val.sin6.sin6_addr.s6_addr, 16);
      xfrBlob(blob, 16);
    }
    else throw runtime_error("invalid IP protocol");
  }

  void xfrCAPort(const ComboAddress &val)
  {
    uint16_t port;
    port = val.sin4.sin_port;
    xfr16BitInt(port);
  }

  void xfrTime(const uint32_t& val)
  {
    xfr32BitInt(val);
  }

  void xfr8BitInt(uint8_t val);

  void xfrName(const DNSName& name, bool compress=false);
  void xfrText(const string& text, bool multi=false, bool lenField=true);
  void xfrUnquotedText(const string& text, bool lenField);
  void xfrBlob(const string& blob, int len=-1);
  void xfrBlob(const vector<uint8_t>& blob);
  void xfrSvcParamKeyVals(const set<SvcParam>& kvs);
  void xfrBlobNoSpaces(const string& blob, int len=-1);
  void xfrHexBlob(const string& blob, bool keepReading=false);

  dnsheader* getHeader();
  void getRecordPayload(string& records); // call __before commit__
  void getWireFormatContent(string& record); // call __before commit__

  void setCanonic(bool val)
  {
    d_canonic=val;
  }

  void setLowercase(bool val)
  {
    d_lowerCase=val;
  }
  Container& getContent()
  {
    return d_content;
  }
  bool eof() { return true; } // we don't know how long the record should be

  const string getRemaining() const {
    return "";
  }

  size_t getSizeWithOpts(const optvect_t& options) const;

private:
  uint16_t lookupName(const DNSName& name, uint16_t* matchlen);
  vector<uint16_t> d_namepositions;
  // We declare 1 uint_16 in the public section, these 3 align on a 8-byte boundary
  uint16_t d_sor;
  uint16_t d_rollbackmarker; // start of last complete packet, for rollback

  Container& d_content;
  DNSName d_qname;

  uint16_t d_truncatemarker; // end of header, for truncate
  DNSResourceRecord::Place d_recordplace{DNSResourceRecord::QUESTION};
  bool d_canonic{false}, d_lowerCase{false}, d_compress{false};
};

using DNSPacketWriter = GenericDNSPacketWriter<std::vector<uint8_t>>;

typedef vector<pair<string::size_type, string::size_type> > labelparts_t;
// bool labeltokUnescape(labelparts_t& parts, const DNSName& label);
std::vector<string> segmentDNSText(const string& text); // from dnslabeltext.rl

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	#pragma once
23	#include <string>
24	#include <vector>
25	#include <map>
26	#include "dns.hh"
27	#include "dnsname.hh"
28	#include "namespaces.hh"
29	#include "iputils.hh"
30	#include "svc-records.hh"
31	#include <arpa/inet.h>
32
33
34	/** this class can be used to write DNS packets. It knows about DNS in the sense that it makes
35	the packet header and record headers.
36
37	The model is:
38
39	packetheader (recordheader recordcontent)*
40
41	The packetheader needs to be updated with the amount of packets of each kind (answer, auth, additional)
42
43	Each recordheader contains the length of a dns record.
44
45	Calling convention:
46
47	vector<uint8_t> content;
48	DNSPacketWriter dpw(content, const string& qname, uint16_t qtype, uint16_t qclass=QClass:IN); // sets the question
49	dpw.startrecord("this.is.an.ip.address.", ns_t_a); // does nothing, except store qname and qtype
50	dpw.xfr32BitInt(0x01020304); // adds 4 bytes (0x01020304) to the record buffer
51	dpw.startrecord("this.is.an.ip.address.", ns_t_a); // aha! writes out dnsrecord header containing qname and qtype and length 4, plus the recordbuffer, which gets emptied
52	// new qname and qtype are stored
53	dpw.xfr32BitInt(0x04030201); // adds 4 bytes (0x04030201) to the record buffer
54	dpw.commit(); // writes out dnsrecord header containing qname and qtype and length 4, plus the recordbuffer
55
56	// content now contains the ready packet, with 1 question and 2 answers
57
58	*/
59
60	template <typename Container> class GenericDNSPacketWriter : public boost::noncopyable
61	{
62
63	public:
64	//! Start a DNS Packet in the vector passed, with question qname, qtype and qclass
65	GenericDNSPacketWriter(Container& content, const DNSName& qname, uint16_t qtype, uint16_t qclass=QClass::IN, uint8_t opcode=0);
66
67	/** Start a new DNS record within this packet for name, qtype, ttl, class and in the requested place. Note that packets can only be written in natural order -
68	ANSWER, AUTHORITY, ADDITIONAL */
69	void startRecord(const DNSName& name, uint16_t qtype, uint32_t ttl=3600, uint16_t qclass=QClass::IN, DNSResourceRecord::Place place=DNSResourceRecord::ANSWER, bool compress=true);
70
71	/** Shorthand way to add an Opt-record, for example for EDNS0 purposes */
72	using optvect_t = vector<pair<uint16_t,std::string> >;
73	void addOpt(const uint16_t udpsize, const uint16_t extRCode, const uint16_t ednsFlags, const optvect_t& options=optvect_t(), const uint8_t version=0);
74
75	/** needs to be called after the last record is added, but can be called again and again later on. Is called internally by startRecord too.
76	The content of the vector<> passed to the constructor is inconsistent until commit is called.
77	*/
78	void commit();
79
80	uint32_t size() const; // needs to be 32 bit because otherwise we don't see the wrap coming when it happened!
81
82	/** Should the packet have grown too big for the writer's liking, rollback removes the record currently being written */
83	void rollback();
84
85	/** Discard all content except the question section */
86	void truncate();
87
88	void xfr48BitInt(uint64_t val);
89	void xfrNodeOrLocatorID(const NodeOrLocatorID& val);
90	void xfr32BitInt(uint32_t val);
91	void xfr16BitInt(uint16_t val);
92	void xfrType(uint16_t val)
93	{	1,938,526✔
94	xfr16BitInt(val);	1,938,526✔
95	}	1,938,526✔
96	void xfrIP(const uint32_t& val)
97	{	2,528,459✔
98	xfr32BitInt(htonl(val));	2,528,459✔
99	}	2,528,459✔
100	void xfrIP6(const std::string& val)
101	{	19,959✔
102	xfrBlob(val,16);	19,959✔
103	}	19,959✔
104
105	void xfrCAWithoutPort(uint8_t version, const ComboAddress &val)
106	{	202,195✔
107	if (version == 4) xfrIP(val.sin4.sin_addr.s_addr);	202,195✔
108	else if (version == 6) {	202,097!
109	string blob;	202,097✔
110	blob.assign((const char*)val.sin6.sin6_addr.s6_addr, 16);	202,097✔
111	xfrBlob(blob, 16);	202,097✔
112	}	202,097✔
113	else throw runtime_error("invalid IP protocol");	×
114	}	202,195✔
115
116	void xfrCAPort(const ComboAddress &val)
117	{	×
118	uint16_t port;	×
119	port = val.sin4.sin_port;	×
120	xfr16BitInt(port);	×
121	}	×
122
123	void xfrTime(const uint32_t& val)
124	{	3,876,076✔
125	xfr32BitInt(val);	3,876,076✔
126	}	3,876,076✔
127
128	void xfr8BitInt(uint8_t val);
129
130	void xfrName(const DNSName& name, bool compress=false);
131	void xfrText(const string& text, bool multi=false, bool lenField=true);
132	void xfrUnquotedText(const string& text, bool lenField);
133	void xfrBlob(const string& blob, int len=-1);
134	void xfrBlob(const vector<uint8_t>& blob);
135	void xfrSvcParamKeyVals(const set<SvcParam>& kvs);
136	void xfrBlobNoSpaces(const string& blob, int len=-1);
137	void xfrHexBlob(const string& blob, bool keepReading=false);
138
139	dnsheader* getHeader();
140	void getRecordPayload(string& records); // call __before commit__
141	void getWireFormatContent(string& record); // call __before commit__
142
143	void setCanonic(bool val)
144	{	2,777,262✔
145	d_canonic=val;	2,777,262✔
146	}	2,777,262✔
147
148	void setLowercase(bool val)
149	{	2,648,219✔
150	d_lowerCase=val;	2,648,219✔
151	}	2,648,219✔
152	Container& getContent()
153	{	685✔
154	return d_content;	685✔
155	}	685✔
156	bool eof() { return true; } // we don't know how long the record should be	5,618,112✔
157
158	const string getRemaining() const {	×
159	return "";	×
UNCOV 160	}	×
161
162	size_t getSizeWithOpts(const optvect_t& options) const;
163
164	private:
165	uint16_t lookupName(const DNSName& name, uint16_t* matchlen);
166	vector<uint16_t> d_namepositions;
167	// We declare 1 uint_16 in the public section, these 3 align on a 8-byte boundary
168	uint16_t d_sor;
169	uint16_t d_rollbackmarker; // start of last complete packet, for rollback
170
171	Container& d_content;
172	DNSName d_qname;
173
174	uint16_t d_truncatemarker; // end of header, for truncate
175	DNSResourceRecord::Place d_recordplace{DNSResourceRecord::QUESTION};
176	bool d_canonic{false}, d_lowerCase{false}, d_compress{false};
177	};
178
179	using DNSPacketWriter = GenericDNSPacketWriter<std::vector<uint8_t>>;
180
181	typedef vector<pair<string::size_type, string::size_type> > labelparts_t;
182	// bool labeltokUnescape(labelparts_t& parts, const DNSName& label);
183	std::vector<string> segmentDNSText(const string& text); // from dnslabeltext.rl

PowerDNS / pdns / 18776176249

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous