1 // Copyright 2013 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/dns/record_parsed.h"
6
7 #include <memory>
8
9 #include "base/time/time.h"
10 #include "net/dns/dns_response.h"
11 #include "net/dns/dns_test_util.h"
12 #include "net/dns/public/dns_protocol.h"
13 #include "net/dns/record_rdata.h"
14 #include "testing/gtest/include/gtest/gtest.h"
15
16 namespace net {
17
18 static const uint8_t kT1ResponseWithCacheFlushBit[] = {
19 0x0a, 'c', 'o', 'd', 'e', 'r', 'e', 'v', 'i', 'e', 'w', 0x08, 'c', 'h', 'r',
20 'o', 'm', 'i', 'u', 'm', 0x03, 'o', 'r', 'g', 0x00, 0x00,
21 0x05, // TYPE is CNAME.
22 0x80, 0x01, // CLASS is IN with cache flush bit set.
23 0x00, 0x01, // TTL (4 bytes) is 20 hours, 47 minutes, 48 seconds.
24 0x24, 0x74, 0x00, 0x12, // RDLENGTH is 18 bytes.
25 // ghs.l.google.com in DNS format.
26 0x03, 'g', 'h', 's', 0x01, 'l', 0x06, 'g', 'o', 'o', 'g', 'l', 'e', 0x03,
27 'c', 'o', 'm', 0x00};
28
TEST(RecordParsedTest,ParseSingleRecord)29 TEST(RecordParsedTest, ParseSingleRecord) {
30 DnsRecordParser parser(kT1ResponseDatagram, sizeof(dns_protocol::Header),
31 kT1RecordCount);
32 std::unique_ptr<const RecordParsed> record;
33 const CnameRecordRdata* rdata;
34
35 std::string dotted_qname;
36 uint16_t qtype;
37 parser.ReadQuestion(dotted_qname, qtype);
38
39 record = RecordParsed::CreateFrom(&parser, base::Time());
40 EXPECT_TRUE(record != nullptr);
41
42 ASSERT_EQ("codereview.chromium.org", record->name());
43 ASSERT_EQ(dns_protocol::kTypeCNAME, record->type());
44 ASSERT_EQ(dns_protocol::kClassIN, record->klass());
45
46 rdata = record->rdata<CnameRecordRdata>();
47 ASSERT_TRUE(rdata != nullptr);
48 ASSERT_EQ(kT1CanonName, rdata->cname());
49
50 ASSERT_FALSE(record->rdata<SrvRecordRdata>());
51 ASSERT_TRUE(record->IsEqual(record.get(), true));
52 }
53
TEST(RecordParsedTest,CacheFlushBitCompare)54 TEST(RecordParsedTest, CacheFlushBitCompare) {
55 DnsRecordParser parser1(kT1ResponseDatagram, sizeof(dns_protocol::Header),
56 kT1RecordCount);
57 std::string dotted_qname;
58 uint16_t qtype;
59 parser1.ReadQuestion(dotted_qname, qtype);
60
61 std::unique_ptr<const RecordParsed> record1 =
62 RecordParsed::CreateFrom(&parser1, base::Time());
63
64 DnsRecordParser parser2(kT1ResponseWithCacheFlushBit, 0, kT1RecordCount);
65
66 std::unique_ptr<const RecordParsed> record2 =
67 RecordParsed::CreateFrom(&parser2, base::Time());
68
69 EXPECT_FALSE(record1->IsEqual(record2.get(), false));
70 EXPECT_TRUE(record1->IsEqual(record2.get(), true));
71 EXPECT_FALSE(record2->IsEqual(record1.get(), false));
72 EXPECT_TRUE(record2->IsEqual(record1.get(), true));
73 }
74
TEST(RecordParsedTest,ParseUnknownRdata)75 TEST(RecordParsedTest, ParseUnknownRdata) {
76 static const char kRecordData[] =
77 // NAME="foo.test"
78 "\003foo\004test\000"
79 // TYPE=MD (an obsolete type that will likely never be recognized by
80 // Chrome)
81 "\000\003"
82 // CLASS=IN
83 "\000\001"
84 // TTL=30 seconds
85 "\000\000\000\036"
86 // RDLENGTH=12 bytes
87 "\000\014"
88 // RDATA="garbage data"
89 "garbage data";
90 DnsRecordParser parser(base::byte_span_from_cstring(kRecordData),
91 0 /* offset */,
92 /*num_records=*/1);
93
94 std::unique_ptr<const RecordParsed> record =
95 RecordParsed::CreateFrom(&parser, base::Time());
96
97 ASSERT_TRUE(record);
98 EXPECT_EQ(record->name(), "foo.test");
99 EXPECT_EQ(record->type(), 3u);
100 EXPECT_EQ(record->klass(), dns_protocol::kClassIN);
101 EXPECT_EQ(record->ttl(), 30u);
102 EXPECT_FALSE(record->rdata<ARecordRdata>());
103 EXPECT_FALSE(record->rdata_for_testing());
104 }
105
TEST(RecordParsedTest,EqualityHandlesUnknownRdata)106 TEST(RecordParsedTest, EqualityHandlesUnknownRdata) {
107 static constexpr char kData[] =
108 // NAME="foo.test"
109 "\003foo\004test\000"
110 // TYPE=MD (an obsolete type that will likely never be recognized by
111 // Chrome)
112 "\000\003"
113 // CLASS=IN
114 "\000\001"
115 // TTL=30 seconds
116 "\000\000\000\036"
117 // RDLENGTH=12 bytes
118 "\000\014"
119 // RDATA="garbage data"
120 "garbage data"
121 // NAME="foo.test"
122 "\003foo\004test\000"
123 // TYPE=A
124 "\000\001"
125 // CLASS=IN
126 "\000\001"
127 // TTL=30 seconds
128 "\000\000\000\036"
129 // RDLENGTH=4 bytes
130 "\000\004"
131 // RDATA=8.8.8.8
132 "\010\010\010\010";
133 DnsRecordParser parser(base::byte_span_from_cstring(kData), 0 /* offset */,
134 /*num_records=*/2);
135
136 std::unique_ptr<const RecordParsed> unknown_record =
137 RecordParsed::CreateFrom(&parser, base::Time());
138 ASSERT_TRUE(unknown_record);
139 ASSERT_FALSE(unknown_record->rdata_for_testing());
140
141 std::unique_ptr<const RecordParsed> known_record =
142 RecordParsed::CreateFrom(&parser, base::Time());
143 ASSERT_TRUE(known_record);
144 ASSERT_TRUE(known_record->rdata_for_testing());
145
146 EXPECT_TRUE(
147 unknown_record->IsEqual(unknown_record.get(), false /* is_mdns */));
148 EXPECT_TRUE(
149 unknown_record->IsEqual(unknown_record.get(), true /* is_mdns */));
150 EXPECT_TRUE(known_record->IsEqual(known_record.get(), false /* is_mdns */));
151 EXPECT_TRUE(known_record->IsEqual(known_record.get(), true /* is_mdns */));
152 EXPECT_FALSE(
153 unknown_record->IsEqual(known_record.get(), false /* is_mdns */));
154 EXPECT_FALSE(unknown_record->IsEqual(known_record.get(), true /* is_mdns */));
155 EXPECT_FALSE(
156 known_record->IsEqual(unknown_record.get(), false /* is_mdns */));
157 EXPECT_FALSE(known_record->IsEqual(unknown_record.get(), true /* is_mdns */));
158 }
159
TEST(RecordParsedTest,RejectMalformedRdata)160 TEST(RecordParsedTest, RejectMalformedRdata) {
161 static const char kRecordData[] =
162 // NAME="foo.test"
163 "\003foo\004test\000"
164 // TYPE=PTR
165 "\000\014"
166 // CLASS=IN
167 "\000\001"
168 // TTL=31 seconds
169 "\000\000\000\037"
170 // RDLENGTH=1 byte
171 "\000\001"
172 // RDATA=truncated name
173 "\001";
174 DnsRecordParser parser(base::byte_span_from_cstring(kRecordData),
175 0 /* offset */,
176 /*num_records=*/1);
177
178 std::unique_ptr<const RecordParsed> record =
179 RecordParsed::CreateFrom(&parser, base::Time());
180
181 EXPECT_FALSE(record);
182 }
183
184 } // namespace net
185