Debian Codegraph @

src/resolve/test-dns-packet-extract.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "dns-answer.h"
4 #include "dns-packet.h"
5 #include "dns-question.h"
6 #include "dns-rr.h"
7 #include "dns-type.h"
8 #include "tests.h"
9
10 #define BIT_QR (1 << 7)
11 #define BIT_AA (1 << 2)
12 #define BIT_TC (1 << 1)
13 #define BIT_RD (1 << 0)
14
15 #define BIT_RA (1 << 7)
16 #define BIT_AD (1 << 5)
17 #define BIT_CD (1 << 4)
18
19 /* ================================================================
20 * packet header
21 * ================================================================ */
22
23 TEST(packet_header_query_basic) {
24 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
25
26 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
27 ASSERT_NOT_NULL(packet);
28 dns_packet_truncate(packet, 0);
29
30 const uint8_t data[] = {
31 0x00, 0x42, 0x00, 0x00,
32 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
33 };
34
35 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
36
37 ASSERT_EQ(be16toh(DNS_PACKET_ID(packet)), 66);
38
39 ASSERT_EQ(DNS_PACKET_QR(packet), 0);
40 ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
41 ASSERT_EQ(DNS_PACKET_AA(packet), 0);
42 ASSERT_EQ(DNS_PACKET_TC(packet), 0);
43 ASSERT_EQ(DNS_PACKET_RD(packet), 0);
44
45 ASSERT_EQ(DNS_PACKET_RA(packet), 0);
46 ASSERT_EQ(DNS_PACKET_AD(packet), 0);
47 ASSERT_EQ(DNS_PACKET_CD(packet), 0);
48 ASSERT_EQ(dns_packet_rcode(packet), 0);
49
50 ASSERT_EQ(DNS_PACKET_QDCOUNT(packet), 1);
51 ASSERT_EQ(DNS_PACKET_ANCOUNT(packet), 0);
52 ASSERT_EQ(DNS_PACKET_NSCOUNT(packet), 0);
53 ASSERT_EQ(DNS_PACKET_ARCOUNT(packet), 0);
54 }
55
56 TEST(packet_header_query_status_recursion_desired) {
57 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
58
59 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
60 ASSERT_NOT_NULL(packet);
61 dns_packet_truncate(packet, 0);
62
63 const uint8_t data[] = {
64 0x00, 0x42, (2 << 3) | BIT_RD, 0x00,
65 0x01, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
66 };
67
68 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
69
70 ASSERT_EQ(be16toh(DNS_PACKET_ID(packet)), 66);
71
72 ASSERT_EQ(DNS_PACKET_QR(packet), 0);
73 ASSERT_EQ(DNS_PACKET_OPCODE(packet), 2);
74 ASSERT_EQ(DNS_PACKET_AA(packet), 0);
75 ASSERT_EQ(DNS_PACKET_TC(packet), 0);
76 ASSERT_EQ(DNS_PACKET_RD(packet), 1);
77
78 ASSERT_EQ(DNS_PACKET_RA(packet), 0);
79 ASSERT_EQ(DNS_PACKET_AD(packet), 0);
80 ASSERT_EQ(DNS_PACKET_CD(packet), 0);
81 ASSERT_EQ(dns_packet_rcode(packet), 0);
82
83 ASSERT_EQ(DNS_PACKET_QDCOUNT(packet), 339);
84 ASSERT_EQ(DNS_PACKET_ANCOUNT(packet), 0);
85 ASSERT_EQ(DNS_PACKET_NSCOUNT(packet), 0);
86 ASSERT_EQ(DNS_PACKET_ARCOUNT(packet), 0);
87 }
88
89 TEST(packet_header_reply_authoritative) {
90 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
91
92 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
93 ASSERT_NOT_NULL(packet);
94 dns_packet_truncate(packet, 0);
95
96 const uint8_t data[] = {
97 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
98 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00
99 };
100
101 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
102
103 ASSERT_EQ(be16toh(DNS_PACKET_ID(packet)), 66);
104
105 ASSERT_EQ(DNS_PACKET_QR(packet), 1);
106 ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
107 ASSERT_EQ(DNS_PACKET_AA(packet), 1);
108 ASSERT_EQ(DNS_PACKET_TC(packet), 0);
109 ASSERT_EQ(DNS_PACKET_RD(packet), 0);
110
111 ASSERT_EQ(DNS_PACKET_RA(packet), 0);
112 ASSERT_EQ(DNS_PACKET_AD(packet), 0);
113 ASSERT_EQ(DNS_PACKET_CD(packet), 0);
114 ASSERT_EQ(dns_packet_rcode(packet), DNS_RCODE_SUCCESS);
115
116 ASSERT_EQ(DNS_PACKET_QDCOUNT(packet), 3);
117 ASSERT_EQ(DNS_PACKET_ANCOUNT(packet), 4);
118 ASSERT_EQ(DNS_PACKET_NSCOUNT(packet), 0);
119 ASSERT_EQ(DNS_PACKET_ARCOUNT(packet), 0);
120 }
121
122 TEST(packet_header_reply_nxdomain) {
123 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
124
125 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
126 ASSERT_NOT_NULL(packet);
127 dns_packet_truncate(packet, 0);
128
129 const uint8_t data[] = {
130 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_NXDOMAIN,
131 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00
132 };
133
134 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
135
136 ASSERT_EQ(be16toh(DNS_PACKET_ID(packet)), 66);
137
138 ASSERT_EQ(DNS_PACKET_QR(packet), 1);
139 ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
140 ASSERT_EQ(DNS_PACKET_AA(packet), 1);
141 ASSERT_EQ(DNS_PACKET_TC(packet), 0);
142 ASSERT_EQ(DNS_PACKET_RD(packet), 0);
143
144 ASSERT_EQ(DNS_PACKET_RA(packet), 0);
145 ASSERT_EQ(DNS_PACKET_AD(packet), 0);
146 ASSERT_EQ(DNS_PACKET_CD(packet), 0);
147 ASSERT_EQ(dns_packet_rcode(packet), DNS_RCODE_NXDOMAIN);
148
149 ASSERT_EQ(DNS_PACKET_QDCOUNT(packet), 1);
150 ASSERT_EQ(DNS_PACKET_ANCOUNT(packet), 0);
151 ASSERT_EQ(DNS_PACKET_NSCOUNT(packet), 1);
152 ASSERT_EQ(DNS_PACKET_ARCOUNT(packet), 0);
153 }
154
155 TEST(packet_header_reply_recursive_non_authoritative) {
156 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
157
158 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
159 ASSERT_NOT_NULL(packet);
160 dns_packet_truncate(packet, 0);
161
162 const uint8_t data[] = {
163 0x00, 0x42, BIT_QR | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
164 0x05, 0x03, 0x0e, 0x04, 0x00, 0x00, 0x00, 0x00
165 };
166
167 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
168
169 ASSERT_EQ(be16toh(DNS_PACKET_ID(packet)), 66);
170
171 ASSERT_EQ(DNS_PACKET_QR(packet), 1);
172 ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
173 ASSERT_EQ(DNS_PACKET_AA(packet), 0);
174 ASSERT_EQ(DNS_PACKET_TC(packet), 0);
175 ASSERT_EQ(DNS_PACKET_RD(packet), 1);
176
177 ASSERT_EQ(DNS_PACKET_RA(packet), 1);
178 ASSERT_EQ(DNS_PACKET_AD(packet), 0);
179 ASSERT_EQ(DNS_PACKET_CD(packet), 0);
180 ASSERT_EQ(dns_packet_rcode(packet), DNS_RCODE_SUCCESS);
181
182 ASSERT_EQ(DNS_PACKET_QDCOUNT(packet), 1283);
183 ASSERT_EQ(DNS_PACKET_ANCOUNT(packet), 3588);
184 ASSERT_EQ(DNS_PACKET_NSCOUNT(packet), 0);
185 ASSERT_EQ(DNS_PACKET_ARCOUNT(packet), 0);
186 }
187
188 TEST(packet_header_reply_delegate) {
189 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
190
191 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
192 ASSERT_NOT_NULL(packet);
193 dns_packet_truncate(packet, 0);
194
195 const uint8_t data[] = {
196 0x00, 0x42, BIT_QR, DNS_RCODE_SUCCESS,
197 0x00, 0x01, 0x00, 0x00, 0x09, 0x0d, 0x0c, 0x1a
198 };
199
200 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
201
202 ASSERT_EQ(be16toh(DNS_PACKET_ID(packet)), 66u);
203
204 ASSERT_EQ(DNS_PACKET_QR(packet), 1);
205 ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
206 ASSERT_EQ(DNS_PACKET_AA(packet), 0);
207 ASSERT_EQ(DNS_PACKET_TC(packet), 0);
208 ASSERT_EQ(DNS_PACKET_RD(packet), 0);
209
210 ASSERT_EQ(DNS_PACKET_RA(packet), 0);
211 ASSERT_EQ(DNS_PACKET_AD(packet), 0);
212 ASSERT_EQ(DNS_PACKET_CD(packet), 0);
213 ASSERT_EQ(dns_packet_rcode(packet), DNS_RCODE_SUCCESS);
214
215 ASSERT_EQ(DNS_PACKET_QDCOUNT(packet), 1);
216 ASSERT_EQ(DNS_PACKET_ANCOUNT(packet), 0);
217 ASSERT_EQ(DNS_PACKET_NSCOUNT(packet), 2317);
218 ASSERT_EQ(DNS_PACKET_ARCOUNT(packet), 3098);
219 }
220
221 TEST(packet_header_reply_dnssec_bits) {
222 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
223
224 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
225 ASSERT_NOT_NULL(packet);
226 dns_packet_truncate(packet, 0);
227
228 const uint8_t data[] = {
229 0x00, 0x42, BIT_QR | BIT_AA, BIT_AD | BIT_CD | DNS_RCODE_SUCCESS,
230 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00
231 };
232
233 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
234
235 ASSERT_EQ(be16toh(DNS_PACKET_ID(packet)), 66);
236
237 ASSERT_EQ(DNS_PACKET_QR(packet), 1);
238 ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
239 ASSERT_EQ(DNS_PACKET_AA(packet), 1);
240 ASSERT_EQ(DNS_PACKET_TC(packet), 0);
241 ASSERT_EQ(DNS_PACKET_RD(packet), 0);
242
243 ASSERT_EQ(DNS_PACKET_RA(packet), 0);
244 ASSERT_EQ(DNS_PACKET_AD(packet), 1);
245 ASSERT_EQ(DNS_PACKET_CD(packet), 1);
246 ASSERT_EQ(dns_packet_rcode(packet), DNS_RCODE_SUCCESS);
247
248 ASSERT_EQ(DNS_PACKET_QDCOUNT(packet), 3);
249 ASSERT_EQ(DNS_PACKET_ANCOUNT(packet), 4);
250 ASSERT_EQ(DNS_PACKET_NSCOUNT(packet), 0);
251 ASSERT_EQ(DNS_PACKET_ARCOUNT(packet), 0);
252 }
253
254 /* ================================================================
255 * dns_packet_validate_query()
256 * ================================================================ */
257
258 TEST(packet_validate_query_qr_bit) {
259 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
260
261 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
262 ASSERT_NOT_NULL(packet);
263 dns_packet_truncate(packet, 0);
264
265 const uint8_t data[] = {
266 0x00, 0x42, BIT_QR, 0x00,
267 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
268
269 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
270 0x03, 'c', 'o', 'm',
271 0x00,
272 0x00, DNS_TYPE_A,
273 0x00, DNS_CLASS_IN
274 };
275
276 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
277
278 ASSERT_FALSE(dns_packet_validate_query(packet));
279 }
280
281 TEST(packet_validate_query_no_qr_bit) {
282 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
283
284 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
285 ASSERT_NOT_NULL(packet);
286 dns_packet_truncate(packet, 0);
287
288 const uint8_t data[] = {
289 0x00, 0x42, 0x00, 0x00,
290 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
291
292 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
293 0x03, 'c', 'o', 'm',
294 0x00,
295 0x00, DNS_TYPE_A,
296 0x00, DNS_CLASS_IN
297 };
298
299 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
300
301 ASSERT_TRUE(dns_packet_validate_query(packet));
302 }
303
304 TEST(packet_validate_query_bad_opcode) {
305 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
306
307 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
308 ASSERT_NOT_NULL(packet);
309 dns_packet_truncate(packet, 0);
310
311 const uint8_t data[] = {
312 0x00, 0x42, (1 << 3), 0x00,
313 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
314
315 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
316 0x03, 'c', 'o', 'm',
317 0x00,
318 0x00, DNS_TYPE_A,
319 0x00, DNS_CLASS_IN
320 };
321
322 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
323
324 ASSERT_ERROR(dns_packet_validate_query(packet), EBADMSG);
325 }
326
327 TEST(packet_validate_query_truncated) {
328 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
329
330 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
331 ASSERT_NOT_NULL(packet);
332 dns_packet_truncate(packet, 0);
333
334 const uint8_t data[] = {
335 0x00, 0x42, BIT_TC, 0x00,
336 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
337
338 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
339 0x03, 'c', 'o', 'm',
340 0x00,
341 0x00, DNS_TYPE_A,
342 0x00, DNS_CLASS_IN
343 };
344
345 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
346
347 ASSERT_ERROR(dns_packet_validate_query(packet), EBADMSG);
348
349 packet->protocol = DNS_PROTOCOL_LLMNR;
350 ASSERT_ERROR(dns_packet_validate_query(packet), EBADMSG);
351 }
352
353 TEST(packet_validate_query_no_questions) {
354 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
355
356 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
357 ASSERT_NOT_NULL(packet);
358 dns_packet_truncate(packet, 0);
359
360 const uint8_t data[] = {
361 0x00, 0x42, 0x00, 0x00,
362 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
363 };
364
365 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
366
367 ASSERT_ERROR(dns_packet_validate_query(packet), EBADMSG);
368
369 packet->protocol = DNS_PROTOCOL_LLMNR;
370 ASSERT_ERROR(dns_packet_validate_query(packet), EBADMSG);
371 }
372
373 TEST(packet_validate_query_too_many_questions) {
374 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
375
376 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
377 ASSERT_NOT_NULL(packet);
378 dns_packet_truncate(packet, 0);
379
380 const uint8_t data[] = {
381 0x00, 0x42, 0x00, 0x00,
382 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
383
384 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
385 0x03, 'c', 'o', 'm',
386 0x00,
387 0x00, DNS_TYPE_A,
388 0x00, DNS_CLASS_IN,
389
390 0xc0, 0x0c,
391 0x00, DNS_TYPE_AAAA,
392 0x00, DNS_CLASS_IN
393 };
394
395 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
396
397 ASSERT_ERROR(dns_packet_validate_query(packet), EBADMSG);
398
399 packet->protocol = DNS_PROTOCOL_LLMNR;
400 ASSERT_ERROR(dns_packet_validate_query(packet), EBADMSG);
401 }
402
403 TEST(packet_validate_query_with_answer) {
404 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
405
406 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
407 ASSERT_NOT_NULL(packet);
408 dns_packet_truncate(packet, 0);
409
410 const uint8_t data[] = {
411 0x00, 0x42, 0x00, 0x00,
412 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
413
414 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
415 0x03, 'c', 'o', 'm',
416 0x00,
417 0x00, DNS_TYPE_A,
418 0x00, DNS_CLASS_IN,
419
420 0xc0, 0x0c,
421 0x00, DNS_TYPE_A,
422 0x00, DNS_CLASS_IN,
423 0x00, 0x00, 0x0e, 0x10,
424 0x00, 0x04,
425 0xc0, 0xa8, 0x01, 0x7f
426 };
427
428 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
429
430 ASSERT_ERROR(dns_packet_validate_query(packet), EBADMSG);
431
432 packet->protocol = DNS_PROTOCOL_LLMNR;
433 ASSERT_ERROR(dns_packet_validate_query(packet), EBADMSG);
434 }
435
436 TEST(packet_validate_query_llmnr_with_authority) {
437 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
438
439 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_LLMNR, 0, DNS_PACKET_SIZE_MAX));
440 ASSERT_NOT_NULL(packet);
441 dns_packet_truncate(packet, 0);
442
443 const uint8_t data[] = {
444 0x00, 0x42, 0x00, 0x00,
445 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
446
447 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
448 0x03, 'c', 'o', 'm',
449 0x00,
450 0x00, DNS_TYPE_A,
451 0x00, DNS_CLASS_IN,
452
453 0xc0, 0x0c,
454 0x00, DNS_TYPE_NS,
455 0x00, DNS_CLASS_IN,
456 0x00, 0x00, 0x0e, 0x10,
457 0x00, 0x06,
458 0x03, 'n', 's', '1',
459 0xc0, 0x0c
460 };
461
462 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
463
464 ASSERT_ERROR(dns_packet_validate_query(packet), EBADMSG);
465 }
466
467 TEST(packet_validate_query_mdns_valid_rcode) {
468 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
469
470 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_MDNS, 0, DNS_PACKET_SIZE_MAX));
471 ASSERT_NOT_NULL(packet);
472 dns_packet_truncate(packet, 0);
473
474 const uint8_t data[] = {
475 0x00, 0x42, 0x00, DNS_RCODE_SUCCESS,
476 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
477
478 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
479 0x03, 'c', 'o', 'm',
480 0x00,
481 0x00, DNS_TYPE_A,
482 0x00, DNS_CLASS_IN
483 };
484
485 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
486
487 ASSERT_TRUE(dns_packet_validate_query(packet));
488 }
489
490 TEST(packet_validate_query_mdns_bad_rcode) {
491 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
492
493 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_MDNS, 0, DNS_PACKET_SIZE_MAX));
494 ASSERT_NOT_NULL(packet);
495 dns_packet_truncate(packet, 0);
496
497 const uint8_t data[] = {
498 0x00, 0x42, 0x00, DNS_RCODE_NXDOMAIN,
499 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
500
501 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
502 0x03, 'c', 'o', 'm',
503 0x00,
504 0x00, DNS_TYPE_A,
505 0x00, DNS_CLASS_IN
506 };
507
508 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
509
510 ASSERT_ERROR(dns_packet_validate_query(packet), EBADMSG);
511 }
512
513 /* ================================================================
514 * queries
515 * ================================================================ */
516
517 TEST(packet_query_single) {
518 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
519 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
520
521 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
522 ASSERT_NOT_NULL(packet);
523 dns_packet_truncate(packet, 0);
524
525 const uint8_t data[] = {
526 0x00, 0x42, 0x00, 0x00,
527 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
528
529 /* name */ 0x03, 'w', 'w', 'w',
530 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
531 0x03, 'c', 'o', 'm',
532 0x00,
533 /* A */ 0x00, 0x01,
534 /* IN */ 0x00, 0x01
535 };
536
537 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
538
539 ASSERT_OK(dns_packet_extract(packet));
540 ASSERT_EQ(dns_question_size(packet->question), 1u);
541 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
542
543 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
544 ASSERT_NOT_NULL(key);
545 ASSERT_TRUE(dns_question_contains_key(packet->question, key));
546 }
547
548 TEST(packet_query_multi) {
549 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
550 DnsResourceKey *key = NULL;
551
552 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
553 ASSERT_NOT_NULL(packet);
554 dns_packet_truncate(packet, 0);
555
556 const uint8_t data[] = {
557 0x00, 0x42, 0x00, 0x00,
558 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
559
560 /* name */ 0x03, 'w', 'w', 'w',
561 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
562 0x03, 'c', 'o', 'm',
563 0x00,
564 /* A */ 0x00, 0x01,
565 /* IN */ 0x00, 0x01,
566
567 /* name */ 0x04, 'm', 'a', 'i', 'l',
568 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
569 0x03, 'c', 'o', 'm',
570 0x00,
571 /* MX */ 0x00, 0x0f,
572 /* ANY */ 0x00, 0xff
573 };
574
575 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
576
577 ASSERT_OK(dns_packet_extract(packet));
578 ASSERT_EQ(dns_question_size(packet->question), 2u);
579 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
580
581 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
582 ASSERT_NOT_NULL(key);
583 ASSERT_TRUE(dns_question_contains_key(packet->question, key));
584 dns_resource_key_unref(key);
585
586 key = dns_resource_key_new(DNS_CLASS_ANY, DNS_TYPE_MX, "mail.example.com");
587 ASSERT_NOT_NULL(key);
588 ASSERT_TRUE(dns_question_contains_key(packet->question, key));
589 dns_resource_key_unref(key);
590 }
591
592 TEST(packet_query_multi_compressed_domain_1) {
593 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
594 DnsResourceKey *key = NULL;
595
596 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
597 ASSERT_NOT_NULL(packet);
598 dns_packet_truncate(packet, 0);
599
600 const uint8_t data[] = {
601 0x00, 0x42, 0x00, 0x00,
602 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
603
604 /* name */ 0x03, 'w', 'w', 'w',
605 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
606 0x03, 'c', 'o', 'm',
607 0x00,
608 /* A */ 0x00, 0x01,
609 /* IN */ 0x00, 0x01,
610
611 /* name */ 0x04, 'm', 'a', 'i', 'l',
612 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
613 0xc0, 0x18,
614 /* MX */ 0x00, 0x0f,
615 /* ANY */ 0x00, 0xff
616 };
617
618 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
619
620 ASSERT_OK(dns_packet_extract(packet));
621 ASSERT_EQ(dns_question_size(packet->question), 2u);
622 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
623
624 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
625 ASSERT_NOT_NULL(key);
626 ASSERT_TRUE(dns_question_contains_key(packet->question, key));
627 dns_resource_key_unref(key);
628
629 key = dns_resource_key_new(DNS_CLASS_ANY, DNS_TYPE_MX, "mail.example.com");
630 ASSERT_NOT_NULL(key);
631 ASSERT_TRUE(dns_question_contains_key(packet->question, key));
632 dns_resource_key_unref(key);
633 }
634
635 TEST(packet_query_multi_compressed_domain_2) {
636 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
637 DnsResourceKey *key = NULL;
638
639 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
640 ASSERT_NOT_NULL(packet);
641 dns_packet_truncate(packet, 0);
642
643 const uint8_t data[] = {
644 0x00, 0x42, 0x00, 0x00,
645 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
646
647 /* name */ 0x03, 'w', 'w', 'w',
648 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
649 0x03, 'c', 'o', 'm',
650 0x00,
651 /* AAAA */ 0x00, 0x1c,
652 /* IN */ 0x00, 0x01,
653
654 /* name */ 0x04, 'm', 'a', 'i', 'l',
655 0xc0, 0x10,
656 /* MX */ 0x00, 0x0f,
657 /* ANY */ 0x00, 0xff
658 };
659
660 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
661
662 ASSERT_OK(dns_packet_extract(packet));
663 ASSERT_EQ(dns_question_size(packet->question), 2u);
664 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
665
666 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_AAAA, "www.example.com");
667 ASSERT_NOT_NULL(key);
668 ASSERT_TRUE(dns_question_contains_key(packet->question, key));
669 dns_resource_key_unref(key);
670
671 key = dns_resource_key_new(DNS_CLASS_ANY, DNS_TYPE_MX, "mail.example.com");
672 ASSERT_NOT_NULL(key);
673 ASSERT_TRUE(dns_question_contains_key(packet->question, key));
674 dns_resource_key_unref(key);
675 }
676
677 TEST(packet_query_single_missing_bytes) {
678 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
679
680 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
681 ASSERT_NOT_NULL(packet);
682 dns_packet_truncate(packet, 0);
683
684 const uint8_t data[] = {
685 0x00, 0x42, 0x00, 0x00,
686 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
687
688 /* name */ 0x03, 'c', 'o', 'm',
689 0x00,
690 /* A */ 0x00, 0x01
691 /* missing class */
692 };
693
694 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
695
696 ASSERT_ERROR(dns_packet_extract(packet), EMSGSIZE);
697 ASSERT_EQ(dns_question_size(packet->question), 0u);
698 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
699 }
700
701 TEST(packet_query_single_unknown_class) {
702 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
703 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
704
705 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
706 ASSERT_NOT_NULL(packet);
707 dns_packet_truncate(packet, 0);
708
709 const uint8_t data[] = {
710 0x00, 0x42, 0x00, 0x00,
711 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
712
713 /* name */ 0x03, 'c', 'o', 'm',
714 0x00,
715 /* A */ 0x00, 0x01,
716 /* ??? */ 0x00, 0x20
717 };
718
719 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
720
721 ASSERT_OK(dns_packet_extract(packet));
722 ASSERT_EQ(dns_question_size(packet->question), 1u);
723 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
724
725 key = dns_resource_key_new(32, DNS_TYPE_A, "com");
726 ASSERT_NOT_NULL(key);
727 ASSERT_TRUE(dns_question_contains_key(packet->question, key));
728 }
729
730 TEST(packet_query_single_unknown_type) {
731 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
732 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
733
734 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
735 ASSERT_NOT_NULL(packet);
736 dns_packet_truncate(packet, 0);
737
738 const uint8_t data[] = {
739 0x00, 0x42, 0x00, 0x00,
740 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
741
742 /* name */ 0x03, 'c', 'o', 'm',
743 0x00,
744 /* ??? */ 0x00, 0x50,
745 /* IN */ 0x00, 0x01
746 };
747
748 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
749
750 ASSERT_OK(dns_packet_extract(packet));
751 ASSERT_EQ(dns_question_size(packet->question), 1u);
752 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
753
754 key = dns_resource_key_new(DNS_CLASS_IN, 80, "com");
755 ASSERT_NOT_NULL(key);
756 ASSERT_TRUE(dns_question_contains_key(packet->question, key));
757 }
758
759 TEST(packet_query_single_bad_type) {
760 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
761
762 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
763 ASSERT_NOT_NULL(packet);
764 dns_packet_truncate(packet, 0);
765
766 const uint8_t data[] = {
767 0x00, 0x42, 0x00, 0x00,
768 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
769
770 /* name */ 0x03, 'c', 'o', 'm',
771 0x00,
772 /* OPT */ 0x00, 0x29,
773 /* IN */ 0x00, 0x01
774 };
775
776 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
777
778 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
779 ASSERT_EQ(dns_question_size(packet->question), 0u);
780 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
781 }
782
783 TEST(packet_query_single_long_domain) {
784 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
785 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
786
787 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
788 ASSERT_NOT_NULL(packet);
789 dns_packet_truncate(packet, 0);
790
791 const uint8_t data[] = {
792 0x00, 0x42, 0x00, 0x00,
793 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
794
795 /* name */ 0x10, 'a', 'b', 's', 'o', 'r', 'p', 't', 'i', 'v', 'e', 'n', 'e', 's', 's', 'e', 's',
796 0x10, 'c', 'a', 'l', 'l', 'i', 'g', 'r', 'a', 'p', 'h', 'i', 'c', 'a', 'l', 'l', 'y',
797 0x10, 'd', 'e', 'a', 'c', 'i', 'd', 'i', 'f', 'i', 'c', 'a', 't', 'i', 'o', 'n', 's',
798 0x10, 'e', 'c', 'o', 'p', 'h', 'y', 's', 'i', 'o', 'l', 'o', 'g', 'i', 'c', 'a', 'l',
799 0x10, 'f', 'a', 'l', 's', 'i', 'f', 'i', 'a', 'b', 'i', 'l', 'i', 't', 'i', 'e', 's',
800 0x10, 'h', 'e', 't', 'e', 'r', 'o', 'c', 'h', 'r', 'o', 'm', 'a', 't', 'i', 's', 'm',
801 0x10, 'i', 'c', 'o', 's', 'i', 't', 'e', 't', 'r', 'a', 'h', 'e', 'd', 'r', 'o', 'n',
802 0x10, 'j', 'o', 'u', 'r', 'n', 'a', 'l', 'i', 's', 't', 'i', 'c', 'a', 'l', 'l', 'y',
803 0x10, 'k', 'i', 'n', 'a', 'e', 's', 't', 'h', 'e', 't', 'i', 'c', 'a', 'l', 'l', 'y',
804 0x10, 'l', 'a', 'c', 't', 'o', 'v', 'e', 'g', 'e', 't', 'a', 'r', 'i', 'a', 'n', 's',
805 0x10, 'm', 'i', 's', 'i', 'n', 't', 'e', 'r', 'p', 'r', 'e', 't', 'a', 'b', 'l', 'e',
806 0x10, 'n', 'i', 't', 'r', 'o', 's', 'y', 'l', 's', 'u', 'l', 'f', 'u', 'r', 'i', 'c',
807 0x10, 'o', 'b', 'j', 'e', 'c', 't', 'l', 'e', 's', 's', 'n', 'e', 's', 's', 'e', 's',
808 0x10, 'p', 'a', 'r', 't', 'r', 'i', 'd', 'g', 'e', 'b', 'e', 'r', 'r', 'i', 'e', 's',
809 0x0F, 'r', 'e', 'a', 's', 'o', 'n', 'l', 'e', 's', 's', 'n', 'e', 's', 's', 'e',
810 0x00,
811 /* A */ 0x00, 0x01,
812 /* IN */ 0x00, 0x01
813 };
814
815 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
816
817 ASSERT_OK(dns_packet_extract(packet));
818 ASSERT_EQ(dns_question_size(packet->question), 1u);
819 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
820
821 key = dns_resource_key_new(
822 DNS_CLASS_IN, DNS_TYPE_A,
823 "absorptivenesses.calligraphically.deacidifications.ecophysiological."
824 "falsifiabilities.heterochromatism.icositetrahedron.journalistically."
825 "kinaesthetically.lactovegetarians.misinterpretable.nitrosylsulfuric."
826 "objectlessnesses.partridgeberries.reasonlessnesse");
827
828 ASSERT_NOT_NULL(key);
829 ASSERT_TRUE(dns_question_contains_key(packet->question, key));
830 }
831
832 TEST(packet_query_single_long_label) {
833 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
834
835 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
836 ASSERT_NOT_NULL(packet);
837 dns_packet_truncate(packet, 0);
838
839 const uint8_t data[] = {
840 0x00, 0x42, 0x00, 0x00,
841 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
842
843 /* name */ 0x48, 'a', '-', 'd', 'o', 'm', 'a', 'i', 'n', '-',
844 'n', 'a', 'm', 'e', '-', 'l', 'a', 'b', 'e', 'l', '-',
845 't', 'h', 'a', 't', '-', 'g', 'o', 'e', 's', '-',
846 'p', 'a', 's', 't', '-', 't', 'h', 'e', '-',
847 'l', 'e', 'n', 'g', 't', 'h', '-', 'l', 'i', 'm', 'i', 't', '-',
848 'o', 'f', '-', 's', 'i', 'x', 't', 'y', '-',
849 't', 'h', 'r', 'e', 'e', '-', 'b', 'y', 't', 'e', 's',
850 0x00,
851 /* A */ 0x00, 0x01,
852 /* IN */ 0x00, 0x01
853 };
854
855 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
856
857 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
858 ASSERT_EQ(dns_question_size(packet->question), 0u);
859 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
860 }
861
862 TEST(packet_query_single_invalid_label) {
863 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
864 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
865
866 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
867 ASSERT_NOT_NULL(packet);
868 dns_packet_truncate(packet, 0);
869
870 const uint8_t data[] = {
871 0x00, 0x42, 0x00, 0x00,
872 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
873
874 /* name */ 0x03, '9', '_', '?',
875 0x00,
876 /* A */ 0x00, 0x01,
877 /* IN */ 0x00, 0x01
878 };
879
880 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
881
882 ASSERT_OK(dns_packet_extract(packet));
883 ASSERT_EQ(dns_question_size(packet->question), 1u);
884 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
885
886 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "9_?");
887 ASSERT_NOT_NULL(key);
888 ASSERT_TRUE(dns_question_contains_key(packet->question, key));
889 }
890
891 TEST(packet_query_single_extra_bytes) {
892 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
893 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
894
895 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
896 ASSERT_NOT_NULL(packet);
897 dns_packet_truncate(packet, 0);
898
899 const uint8_t data[] = {
900 0x00, 0x42, 0x00, 0x00,
901 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
902
903 /* name */ 0x03, 'c', 'o', 'm',
904 0x00,
905 /* A */ 0x00, 0x01,
906 /* IN */ 0x00, 0x01,
907 /* extra */ 0x04, 'm', 'a', 'i', 'l'
908 };
909
910 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
911
912 ASSERT_OK(dns_packet_extract(packet));
913 ASSERT_EQ(dns_question_size(packet->question), 1u);
914 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
915
916 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "com");
917 ASSERT_NOT_NULL(key);
918 ASSERT_TRUE(dns_question_contains_key(packet->question, key));
919 }
920
921 TEST(packet_query_single_domain_overflow) {
922 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
923
924 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
925 ASSERT_NOT_NULL(packet);
926 dns_packet_truncate(packet, 0);
927
928 const uint8_t data[] = {
929 0x00, 0x42, 0x00, 0x00,
930 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
931
932 /* name */ 0x03, 'm', 'a', 'i', 'l',
933 0x00,
934 /* A */ 0x00, 0x01,
935 /* IN */ 0x00, 0x01
936 };
937
938 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
939
940 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
941 ASSERT_EQ(dns_question_size(packet->question), 0u);
942 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
943 }
944
945 TEST(packet_query_single_domain_underflow) {
946 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
947
948 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
949 ASSERT_NOT_NULL(packet);
950 dns_packet_truncate(packet, 0);
951
952 const uint8_t data[] = {
953 0x00, 0x42, 0x00, 0x00,
954 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
955
956 /* name */ 0x04, 'c', 'o', 'm',
957 0x00,
958 /* A */ 0x00, 0x01,
959 /* IN */ 0x00, 0x01
960 };
961
962 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
963
964 ASSERT_ERROR(dns_packet_extract(packet), EMSGSIZE);
965 ASSERT_EQ(dns_question_size(packet->question), 0u);
966 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
967 }
968
969 TEST(packet_query_single_domain_missing_root) {
970 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
971
972 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
973 ASSERT_NOT_NULL(packet);
974 dns_packet_truncate(packet, 0);
975
976 const uint8_t data[] = {
977 0x00, 0x42, 0x00, 0x00,
978 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
979
980 /* name */ 0x03, 'c', 'o', 'm',
981 /* missing 0x00 */
982 /* A */ 0x00, 0x01,
983 /* IN */ 0x00, 0x01
984 };
985
986 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
987
988 ASSERT_ERROR(dns_packet_extract(packet), EMSGSIZE);
989 ASSERT_EQ(dns_question_size(packet->question), 0u);
990 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
991 }
992
993 TEST(packet_query_missing_question) {
994 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
995
996 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
997 ASSERT_NOT_NULL(packet);
998 dns_packet_truncate(packet, 0);
999
1000 const uint8_t data[] = {
1001 0x00, 0x42, 0x00, 0x00,
1002 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1003
1004 /* name */ 0x03, 'c', 'o', 'm',
1005 0x00,
1006 /* A */ 0x00, 0x01,
1007 /* IN */ 0x00, 0x01
1008 };
1009
1010 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1011
1012 ASSERT_ERROR(dns_packet_extract(packet), EMSGSIZE);
1013 ASSERT_EQ(dns_question_size(packet->question), 0u);
1014 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1015 }
1016
1017 TEST(packet_query_extra_question) {
1018 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1019 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
1020
1021 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1022 ASSERT_NOT_NULL(packet);
1023 dns_packet_truncate(packet, 0);
1024
1025 const uint8_t data[] = {
1026 0x00, 0x42, 0x00, 0x00,
1027 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1028
1029 /* name */ 0x03, 'c', 'o', 'm',
1030 0x00,
1031 /* A */ 0x00, 0x01,
1032 /* IN */ 0x00, 0x01,
1033
1034 /* name */ 0x03, 'o', 'r', 'g',
1035 0x00,
1036 /* AAAA */ 0x00, 0x1c,
1037 /* IN */ 0x00, 0x01
1038 };
1039
1040 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1041
1042 ASSERT_OK(dns_packet_extract(packet));
1043 ASSERT_EQ(dns_question_size(packet->question), 1u);
1044 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1045
1046 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "com");
1047 ASSERT_NOT_NULL(key);
1048 ASSERT_TRUE(dns_question_contains_key(packet->question, key));
1049 }
1050
1051 TEST(packet_query_bad_compression) {
1052 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1053
1054 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1055 ASSERT_NOT_NULL(packet);
1056 dns_packet_truncate(packet, 0);
1057
1058 const uint8_t data[] = {
1059 0x00, 0x42, 0x00, 0x00,
1060 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1061
1062 /* name */ 0x03, 'c', 'o', 'm',
1063 0x00,
1064 /* A */ 0x00, 0x01,
1065 /* IN */ 0x00, 0x01,
1066
1067 /* name */ 0xc0, 0x0b, /* points 1 byte before start of "com" */
1068 /* AAAA */ 0x00, 0x1c,
1069 /* IN */ 0x00, 0x01
1070 };
1071
1072 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1073
1074 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
1075 ASSERT_EQ(dns_question_size(packet->question), 0u);
1076 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1077 }
1078
1079 TEST(packet_query_bad_compression_2) {
1080 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1081
1082 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1083 ASSERT_NOT_NULL(packet);
1084 dns_packet_truncate(packet, 0);
1085
1086 const uint8_t data[] = {
1087 0x00, 0x42, 0x00, 0x00,
1088 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1089
1090 /* name */ 0x03, 'c', 'o', 'm',
1091 0x00,
1092 /* A */ 0x00, 0x01,
1093 /* IN */ 0x00, 0x01,
1094
1095 /* name */ 0xc0, 0x0d, /* points 1 byte after start of "com" */
1096 /* AAAA */ 0x00, 0x1c,
1097 /* IN */ 0x00, 0x01
1098 };
1099
1100 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1101
1102 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
1103 ASSERT_EQ(dns_question_size(packet->question), 0u);
1104 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1105 }
1106
1107 TEST(packet_query_bad_compression_3) {
1108 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1109
1110 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1111 ASSERT_NOT_NULL(packet);
1112 dns_packet_truncate(packet, 0);
1113
1114 const uint8_t data[] = {
1115 0x00, 0x42, 0x00, 0x00,
1116 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1117
1118 /* name */ 0x03, 'c', 'o', 'm',
1119 0x00,
1120 /* A */ 0x00, 0x01,
1121 /* IN */ 0x00, 0x01,
1122
1123 /* name */ 0xc0, 0x0c,
1124 0x00, /* extra null terminator */
1125 /* AAAA */ 0x00, 0x1c,
1126 /* IN */ 0x00, 0x01
1127 };
1128
1129 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1130
1131 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
1132 ASSERT_EQ(dns_question_size(packet->question), 0u);
1133 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1134 }
1135
1136 TEST(packet_query_bad_compression_4) {
1137 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1138
1139 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1140 ASSERT_NOT_NULL(packet);
1141 dns_packet_truncate(packet, 0);
1142
1143 const uint8_t data[] = {
1144 0x00, 0x42, 0x00, 0x00,
1145 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1146
1147 /* name */ 0x03, 'c', 'o', 'm',
1148 0x00,
1149 /* A */ 0x00, 0x01,
1150 /* IN */ 0x00, 0x01,
1151
1152 /* name */ 0xc0, 0x80, /* points past end of message */
1153 /* AAAA */ 0x00, 0x1c,
1154 /* IN */ 0x00, 0x01
1155 };
1156
1157 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1158
1159 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
1160 ASSERT_EQ(dns_question_size(packet->question), 0u);
1161 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1162 }
1163
1164 TEST(packet_query_bad_compression_5) {
1165 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1166
1167 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1168 ASSERT_NOT_NULL(packet);
1169 dns_packet_truncate(packet, 0);
1170
1171 const uint8_t data[] = {
1172 0x00, 0x42, 0x00, 0x00,
1173 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1174
1175 /* name */ 0xc0, 0x12, /* points at "com" in next question */
1176 /* A */ 0x00, 0x01,
1177 /* IN */ 0x00, 0x01,
1178
1179 /* name */ 0x03, 'c', 'o', 'm',
1180 0x00,
1181 /* AAAA */ 0x00, 0x1c,
1182 /* IN */ 0x00, 0x01
1183 };
1184
1185 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1186
1187 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
1188 ASSERT_EQ(dns_question_size(packet->question), 0u);
1189 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1190 }
1191
1192 TEST(packet_query_bad_compression_6) {
1193 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1194
1195 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1196 ASSERT_NOT_NULL(packet);
1197 dns_packet_truncate(packet, 0);
1198
1199 const uint8_t data[] = {
1200 0x00, 0x2a, 0x01, 0x00,
1201 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1202
1203 /* name */ 0x03, 'w', 'w', 'w',
1204 0xc0, 0x0c, /* points at the current name */
1205 /* A */ 0x00, 0x01,
1206 /* IN */ 0x00, 0x01
1207 };
1208
1209 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1210
1211 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
1212 ASSERT_EQ(dns_question_size(packet->question), 0u);
1213 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1214 }
1215
1216 /* ================================================================
1217 * dns_packet_validate_reply()
1218 * ================================================================ */
1219
1220 TEST(packet_validate_reply_qr_bit) {
1221 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1222
1223 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1224 ASSERT_NOT_NULL(packet);
1225 dns_packet_truncate(packet, 0);
1226
1227 const uint8_t data[] = {
1228 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1229 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1230 };
1231
1232 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1233
1234 ASSERT_TRUE(dns_packet_validate_reply(packet));
1235 }
1236
1237 TEST(packet_validate_reply_no_qr_bit) {
1238 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1239
1240 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1241 ASSERT_NOT_NULL(packet);
1242 dns_packet_truncate(packet, 0);
1243
1244 const uint8_t data[] = {
1245 0x00, 0x42, BIT_AA, DNS_RCODE_SUCCESS,
1246 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1247 };
1248
1249 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1250
1251 ASSERT_FALSE(dns_packet_validate_reply(packet));
1252 }
1253
1254 TEST(packet_validate_reply_bad_opcode) {
1255 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1256
1257 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1258 ASSERT_NOT_NULL(packet);
1259 dns_packet_truncate(packet, 0);
1260
1261 const uint8_t data[] = {
1262 0x00, 0x42, BIT_QR | (1 << 3) | BIT_AA, DNS_RCODE_SUCCESS,
1263 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1264 };
1265
1266 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1267
1268 ASSERT_ERROR(dns_packet_validate_reply(packet), EBADMSG);
1269 }
1270
1271 TEST(packet_validate_reply_mdns_success_rcode) {
1272 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1273
1274 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_MDNS, 0, DNS_PACKET_SIZE_MAX));
1275 ASSERT_NOT_NULL(packet);
1276 dns_packet_truncate(packet, 0);
1277
1278 const uint8_t data[] = {
1279 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1280 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1281 };
1282
1283 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1284
1285 ASSERT_TRUE(dns_packet_validate_reply(packet));
1286 }
1287
1288 TEST(packet_validate_reply_mdns_bad_rcode) {
1289 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1290
1291 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_MDNS, 0, DNS_PACKET_SIZE_MAX));
1292 ASSERT_NOT_NULL(packet);
1293 dns_packet_truncate(packet, 0);
1294
1295 const uint8_t data[] = {
1296 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_NXDOMAIN,
1297 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1298 };
1299
1300 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1301
1302 ASSERT_ERROR(dns_packet_validate_reply(packet), EBADMSG);
1303 }
1304
1305 TEST(packet_validate_reply_llmnr_with_questions) {
1306 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1307
1308 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_LLMNR, 0, DNS_PACKET_SIZE_MAX));
1309 ASSERT_NOT_NULL(packet);
1310 dns_packet_truncate(packet, 0);
1311
1312 const uint8_t data[] = {
1313 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1314 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1315
1316 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1317 0x03, 'c', 'o', 'm',
1318 0x00,
1319 0x00, DNS_TYPE_A,
1320 0x00, DNS_CLASS_IN
1321 };
1322
1323 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1324
1325 ASSERT_TRUE(dns_packet_validate_reply(packet));
1326 }
1327
1328 TEST(packet_validate_reply_llmnr_no_questions) {
1329 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1330
1331 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_LLMNR, 0, DNS_PACKET_SIZE_MAX));
1332 ASSERT_NOT_NULL(packet);
1333 dns_packet_truncate(packet, 0);
1334
1335 const uint8_t data[] = {
1336 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1337 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1338 };
1339
1340 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1341
1342 ASSERT_ERROR(dns_packet_validate_reply(packet), EBADMSG);
1343 }
1344
1345 /* ================================================================
1346 * dns_packet_is_reply_for()
1347 * ================================================================ */
1348
1349 TEST(packet_is_reply_for_no_question) {
1350 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1351 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
1352
1353 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1354 ASSERT_NOT_NULL(packet);
1355 dns_packet_truncate(packet, 0);
1356
1357 const uint8_t data[] = {
1358 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1359 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1360 };
1361
1362 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1363
1364 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
1365 ASSERT_NOT_NULL(key);
1366 ASSERT_FALSE(dns_packet_is_reply_for(packet, key));
1367 }
1368
1369 TEST(packet_is_reply_for_too_many_questions) {
1370 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1371 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
1372
1373 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1374 ASSERT_NOT_NULL(packet);
1375 dns_packet_truncate(packet, 0);
1376
1377 const uint8_t data[] = {
1378 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1379 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1380
1381 /* name */ 0x03, 'w', 'w', 'w',
1382 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1383 0x03, 'c', 'o', 'm',
1384 0x00,
1385 /* A */ 0x00, 0x01,
1386 /* IN */ 0x00, 0x01,
1387
1388 /* name */ 0x04, 'm', 'a', 'i', 'l',
1389 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1390 0x03, 'c', 'o', 'm',
1391 0x00,
1392 /* MX */ 0x00, 0x0f,
1393 /* IN */ 0x00, 0x01
1394 };
1395
1396 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1397
1398 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
1399 ASSERT_NOT_NULL(key);
1400 ASSERT_FALSE(dns_packet_is_reply_for(packet, key));
1401 }
1402
1403 TEST(packet_is_reply_for_match_question) {
1404 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1405 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
1406
1407 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1408 ASSERT_NOT_NULL(packet);
1409 dns_packet_truncate(packet, 0);
1410
1411 const uint8_t data[] = {
1412 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1413 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1414
1415 /* name */ 0x03, 'w', 'w', 'w',
1416 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1417 0x03, 'c', 'o', 'm',
1418 0x00,
1419 /* A */ 0x00, 0x01,
1420 /* IN */ 0x00, 0x01
1421 };
1422
1423 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1424
1425 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
1426 ASSERT_NOT_NULL(key);
1427 ASSERT_TRUE(dns_packet_is_reply_for(packet, key));
1428 }
1429
1430 TEST(packet_is_reply_for_no_match_question) {
1431 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1432 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
1433
1434 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1435 ASSERT_NOT_NULL(packet);
1436 dns_packet_truncate(packet, 0);
1437
1438 const uint8_t data[] = {
1439 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1440 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1441
1442 /* name */ 0x03, 'w', 'w', 'w',
1443 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1444 0x03, 'c', 'o', 'm',
1445 0x00,
1446 /* AAAA */ 0x00, 0x1c,
1447 /* IN */ 0x00, 0x01
1448 };
1449
1450 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1451
1452 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
1453 ASSERT_NOT_NULL(key);
1454 ASSERT_FALSE(dns_packet_is_reply_for(packet, key));
1455 }
1456
1457 TEST(packet_is_reply_for_extract_failure) {
1458 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1459 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
1460
1461 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1462 ASSERT_NOT_NULL(packet);
1463 dns_packet_truncate(packet, 0);
1464
1465 const uint8_t data[] = {
1466 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1467 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1468
1469 /* name */ 0x03, 'w', 'w', 'w',
1470 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1471 0xc0, 0x0c,
1472 /* A */ 0x00, 0x01,
1473 /* IN */ 0x00, 0x01
1474 };
1475
1476 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1477
1478 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
1479 ASSERT_NOT_NULL(key);
1480 ASSERT_ERROR(dns_packet_is_reply_for(packet, key), EBADMSG);
1481 }
1482
1483 /* ================================================================
1484 * reply: bad keys
1485 * ================================================================ */
1486
1487 TEST(packet_reply_cannot_use_class_any) {
1488 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1489
1490 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1491 ASSERT_NOT_NULL(packet);
1492 dns_packet_truncate(packet, 0);
1493
1494 const uint8_t data[] = {
1495 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1496 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
1497
1498 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1499 0x03, 'c', 'o', 'm',
1500 0x00,
1501 /* A */ 0x00, 0x01,
1502 /* ANY */ 0x00, 0xff,
1503 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1504 /* rdata */ 0x00, 0x04,
1505 /* ip */ 0xc0, 0xa8, 0x01, 0x7f
1506 };
1507
1508 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1509
1510 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
1511 ASSERT_EQ(dns_question_size(packet->question), 0u);
1512 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1513 }
1514
1515 TEST(packet_reply_cannot_use_type_any) {
1516 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1517
1518 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1519 ASSERT_NOT_NULL(packet);
1520 dns_packet_truncate(packet, 0);
1521
1522 const uint8_t data[] = {
1523 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1524 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
1525
1526 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1527 0x03, 'c', 'o', 'm',
1528 0x00,
1529 /* ANY */ 0x00, 0xff,
1530 /* IN */ 0x00, 0x01,
1531 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1532 /* rdata */ 0x00, 0x04,
1533 /* ip */ 0xc0, 0xa8, 0x01, 0x7f
1534 };
1535
1536 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1537
1538 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
1539 ASSERT_EQ(dns_question_size(packet->question), 0u);
1540 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1541 }
1542
1543 /* ================================================================
1544 * reply: A
1545 * ================================================================ */
1546
1547 static void check_answer_contains(DnsPacket *packet, DnsResourceRecord *rr, DnsAnswerFlags flags) {
1548 DnsAnswerFlags key_flags;
1549
1550 ASSERT_TRUE(dns_answer_contains(packet->answer, rr));
1551
1552 ASSERT_TRUE(dns_answer_match_key(packet->answer, rr->key, &key_flags));
1553 ASSERT_EQ(key_flags, flags);
1554 }
1555
1556 TEST(packet_reply_a_single) {
1557 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1558 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
1559
1560 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1561 ASSERT_NOT_NULL(packet);
1562 dns_packet_truncate(packet, 0);
1563
1564 const uint8_t data[] = {
1565 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1566 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
1567
1568 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1569 0x03, 'c', 'o', 'm',
1570 0x00,
1571 /* A */ 0x00, 0x01,
1572 /* IN */ 0x00, 0x01,
1573 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1574 /* rdata */ 0x00, 0x04,
1575 /* ip */ 0xc0, 0xa8, 0x01, 0x7f
1576 };
1577
1578 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1579
1580 ASSERT_OK(dns_packet_extract(packet));
1581 ASSERT_EQ(dns_question_size(packet->question), 0u);
1582 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
1583
1584 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
1585 ASSERT_NOT_NULL(rr);
1586 rr->ttl = 3600;
1587 rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
1588
1589 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
1590 }
1591
1592 TEST(packet_reply_a_zero_ip) {
1593 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1594 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
1595
1596 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1597 ASSERT_NOT_NULL(packet);
1598 dns_packet_truncate(packet, 0);
1599
1600 const uint8_t data[] = {
1601 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1602 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
1603
1604 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1605 0x03, 'c', 'o', 'm',
1606 0x00,
1607 /* A */ 0x00, 0x01,
1608 /* IN */ 0x00, 0x01,
1609 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1610 /* rdata */ 0x00, 0x04,
1611 /* ip */ 0x00, 0x00, 0x00, 0x00
1612 };
1613
1614 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1615
1616 ASSERT_OK(dns_packet_extract(packet));
1617 ASSERT_EQ(dns_question_size(packet->question), 0u);
1618 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
1619
1620 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
1621 ASSERT_NOT_NULL(rr);
1622 rr->ttl = 3600;
1623 rr->a.in_addr.s_addr = htobe32(0);
1624
1625 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
1626 }
1627
1628 TEST(packet_reply_a_multi) {
1629 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1630 DnsResourceRecord *rr = NULL;
1631
1632 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1633 ASSERT_NOT_NULL(packet);
1634 dns_packet_truncate(packet, 0);
1635
1636 const uint8_t data[] = {
1637 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1638 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
1639
1640 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1641 0x03, 'c', 'o', 'm',
1642 0x00,
1643 /* A */ 0x00, 0x01,
1644 /* IN */ 0x00, 0x01,
1645 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1646 /* rdata */ 0x00, 0x04,
1647 /* ip */ 0xc0, 0xa8, 0x01, 0x7f,
1648
1649 /* name */ 0xc0, 0x0c,
1650 /* A */ 0x00, 0x01,
1651 /* IN */ 0x00, 0x01,
1652 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1653 /* rdata */ 0x00, 0x04,
1654 /* ip */ 0xa9, 0xfe, 0x01, 0x00
1655 };
1656
1657 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1658
1659 ASSERT_OK(dns_packet_extract(packet));
1660 ASSERT_EQ(dns_question_size(packet->question), 0u);
1661 ASSERT_EQ(dns_answer_size(packet->answer), 2u);
1662
1663 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
1664 ASSERT_NOT_NULL(rr);
1665 rr->ttl = 3600;
1666 rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
1667
1668 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
1669 dns_resource_record_unref(rr);
1670
1671 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
1672 ASSERT_NOT_NULL(rr);
1673 rr->ttl = 3600;
1674 rr->a.in_addr.s_addr = htobe32(0xa9fe0100);
1675
1676 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
1677 dns_resource_record_unref(rr);
1678 }
1679
1680 TEST(packet_reply_a_bad_rdata_size) {
1681 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1682
1683 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1684 ASSERT_NOT_NULL(packet);
1685 dns_packet_truncate(packet, 0);
1686
1687 const uint8_t data[] = {
1688 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1689 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
1690
1691 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1692 0x03, 'c', 'o', 'm',
1693 0x00,
1694 /* A */ 0x00, 0x01,
1695 /* IN */ 0x00, 0x01,
1696 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1697 /* rdata */ 0x00, 0x05,
1698 /* ip */ 0xc0, 0xa8, 0x01, 0x7f, 0x99
1699 };
1700
1701 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1702
1703 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
1704 ASSERT_EQ(dns_question_size(packet->question), 0u);
1705 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1706 }
1707
1708 TEST(packet_reply_a_rdata_truncated) {
1709 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1710
1711 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1712 ASSERT_NOT_NULL(packet);
1713 dns_packet_truncate(packet, 0);
1714
1715 const uint8_t data[] = {
1716 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1717 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
1718
1719 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1720 0x03, 'c', 'o', 'm',
1721 0x00,
1722 /* A */ 0x00, 0x01,
1723 /* IN */ 0x00, 0x01,
1724 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1725 /* rdata */ 0x00, 0x04,
1726 /* ip */ 0xc0, 0xa8, 0x01 /* missing last byte */
1727 };
1728
1729 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1730
1731 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
1732 ASSERT_EQ(dns_question_size(packet->question), 0u);
1733 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1734 }
1735
1736 /* ================================================================
1737 * reply: NS
1738 * ================================================================ */
1739
1740 TEST(packet_reply_ns_single) {
1741 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1742 DnsResourceRecord *rr = NULL;
1743
1744 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1745 ASSERT_NOT_NULL(packet);
1746 dns_packet_truncate(packet, 0);
1747
1748 const uint8_t data[] = {
1749 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1750 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
1751
1752 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1753 0x03, 'c', 'o', 'm',
1754 0x00,
1755 /* NS */ 0x00, 0x02,
1756 /* IN */ 0x00, 0x01,
1757 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1758 /* rdata */ 0x00, 0x06,
1759 /* name */ 0x03, 'n', 's', '1',
1760 0xc0, 0x0c
1761 };
1762
1763 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1764
1765 ASSERT_OK(dns_packet_extract(packet));
1766 ASSERT_EQ(dns_question_size(packet->question), 0u);
1767 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
1768
1769 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_NS, "example.com");
1770 ASSERT_NOT_NULL(rr);
1771 rr->ttl = 3600;
1772 rr->ns.name = strdup("ns1.example.com");
1773
1774 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_AUTHORITY);
1775 dns_resource_record_unref(rr);
1776 }
1777
1778 TEST(packet_reply_ns_multi) {
1779 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1780 DnsResourceRecord *rr = NULL;
1781
1782 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1783 ASSERT_NOT_NULL(packet);
1784 dns_packet_truncate(packet, 0);
1785
1786 const uint8_t data[] = {
1787 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1788 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
1789
1790 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1791 0x03, 'c', 'o', 'm',
1792 0x00,
1793 /* NS */ 0x00, 0x02,
1794 /* IN */ 0x00, 0x01,
1795 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1796 /* rdata */ 0x00, 0x06,
1797 /* name */ 0x03, 'n', 's', '1',
1798 0xc0, 0x0c,
1799
1800 /* name */ 0xc0, 0x0c,
1801 /* NS */ 0x00, 0x02,
1802 /* IN */ 0x00, 0x01,
1803 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1804 /* rdata */ 0x00, 0x06,
1805 /* name */ 0x03, 'n', 's', '2',
1806 0xc0, 0x0c,
1807
1808 /* name */ 0xc0, 0x0c,
1809 /* NS */ 0x00, 0x02,
1810 /* IN */ 0x00, 0x01,
1811 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1812 /* rdata */ 0x00, 0x06,
1813 /* name */ 0x03, 'n', 's', '3',
1814 0xc0, 0x0c
1815 };
1816
1817 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1818
1819 ASSERT_OK(dns_packet_extract(packet));
1820 ASSERT_EQ(dns_question_size(packet->question), 0u);
1821 ASSERT_EQ(dns_answer_size(packet->answer), 3u);
1822
1823 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_NS, "example.com");
1824 ASSERT_NOT_NULL(rr);
1825 rr->ttl = 3600;
1826 rr->ns.name = strdup("ns1.example.com");
1827
1828 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_AUTHORITY);
1829 dns_resource_record_unref(rr);
1830
1831 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_NS, "example.com");
1832 ASSERT_NOT_NULL(rr);
1833 rr->ttl = 3600;
1834 rr->ns.name = strdup("ns2.example.com");
1835
1836 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_AUTHORITY);
1837 dns_resource_record_unref(rr);
1838
1839 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_NS, "example.com");
1840 ASSERT_NOT_NULL(rr);
1841 rr->ttl = 3600;
1842 rr->ns.name = strdup("ns3.example.com");
1843
1844 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_AUTHORITY);
1845 dns_resource_record_unref(rr);
1846 }
1847
1848 TEST(packet_reply_ns_domain_underflows_rdata) {
1849 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1850
1851 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1852 ASSERT_NOT_NULL(packet);
1853 dns_packet_truncate(packet, 0);
1854
1855 const uint8_t data[] = {
1856 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1857 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
1858
1859 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1860 0x03, 'c', 'o', 'm',
1861 0x00,
1862 /* NS */ 0x00, 0x02,
1863 /* IN */ 0x00, 0x01,
1864 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1865 /* rdata */ 0x00, 0x12,
1866 /* name */ 0x03, 'n', 's', '1',
1867 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1868 0x03, 'c', 'o', 'm',
1869 0x00
1870 };
1871
1872 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1873
1874 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
1875 ASSERT_EQ(dns_question_size(packet->question), 0u);
1876 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1877 }
1878
1879 TEST(packet_reply_ns_domain_overflows_rdata) {
1880 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1881
1882 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1883 ASSERT_NOT_NULL(packet);
1884 dns_packet_truncate(packet, 0);
1885
1886 const uint8_t data[] = {
1887 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1888 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
1889
1890 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1891 0x03, 'c', 'o', 'm',
1892 0x00,
1893 /* NS */ 0x00, 0x02,
1894 /* IN */ 0x00, 0x01,
1895 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1896 /* rdata */ 0x00, 0x06,
1897 /* name */ 0x03, 'n', 's', '1',
1898 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1899 0x03, 'c', 'o', 'm',
1900 0x00
1901 };
1902
1903 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1904
1905 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
1906 ASSERT_EQ(dns_question_size(packet->question), 0u);
1907 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1908 }
1909
1910 TEST(packet_reply_ns_domain_overflows_rdata_compressed) {
1911 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1912
1913 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1914 ASSERT_NOT_NULL(packet);
1915 dns_packet_truncate(packet, 0);
1916
1917 const uint8_t data[] = {
1918 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1919 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
1920
1921 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1922 0x03, 'c', 'o', 'm',
1923 0x00,
1924 /* NS */ 0x00, 0x02,
1925 /* IN */ 0x00, 0x01,
1926 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1927 /* rdata */ 0x00, 0x05,
1928 /* name */ 0x03, 'n', 's', '1',
1929 0xc0, 0x0c
1930 };
1931
1932 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1933
1934 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
1935 ASSERT_EQ(dns_question_size(packet->question), 0u);
1936 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1937 }
1938
1939 TEST(packet_reply_ns_domain_unterminated) {
1940 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1941
1942 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1943 ASSERT_NOT_NULL(packet);
1944 dns_packet_truncate(packet, 0);
1945
1946 const uint8_t data[] = {
1947 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
1948 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
1949
1950 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1951 0x03, 'c', 'o', 'm',
1952 0x00,
1953 /* NS */ 0x00, 0x02,
1954 /* IN */ 0x00, 0x01,
1955 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
1956 /* rdata */ 0x00, 0x10,
1957 /* name */ 0x03, 'n', 's', '1',
1958 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1959 0x03, 'c', 'o', 'm'
1960 /* missing 0x00 */
1961 };
1962
1963 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
1964
1965 ASSERT_ERROR(dns_packet_extract(packet), EMSGSIZE);
1966 ASSERT_EQ(dns_question_size(packet->question), 0u);
1967 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
1968 }
1969
1970 /* ================================================================
1971 * reply: CNAME with A, compression
1972 * ================================================================ */
1973
1974 static void check_cname_reply_compression(const uint8_t *data, size_t len) {
1975 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1976 DnsResourceKey *key = NULL;
1977 DnsResourceRecord *rr = NULL;
1978
1979 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1980 ASSERT_NOT_NULL(packet);
1981 dns_packet_truncate(packet, 0);
1982
1983 ASSERT_OK(dns_packet_append_blob(packet, data, len, NULL));
1984
1985 ASSERT_OK(dns_packet_extract(packet));
1986 ASSERT_EQ(dns_question_size(packet->question), 1u);
1987 ASSERT_EQ(dns_answer_size(packet->answer), 2u);
1988
1989 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
1990 ASSERT_NOT_NULL(key);
1991 ASSERT_TRUE(dns_question_contains_key(packet->question, key));
1992 dns_resource_key_unref(key);
1993
1994 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_CNAME, "www.example.com");
1995 ASSERT_NOT_NULL(rr);
1996 rr->ttl = 3600;
1997 rr->cname.name = strdup("example.com");
1998
1999 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
2000 dns_resource_record_unref(rr);
2001
2002 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
2003 ASSERT_NOT_NULL(rr);
2004 rr->ttl = 3600;
2005 rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
2006
2007 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
2008 dns_resource_record_unref(rr);
2009 }
2010
2011 TEST(packet_reply_cname_uncompressed) {
2012 const uint8_t data[] = {
2013 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2014 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
2015
2016 /* name */ 0x03, 'w', 'w', 'w',
2017 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2018 0x03, 'c', 'o', 'm',
2019 0x00,
2020 /* A */ 0x00, 0x01,
2021 /* IN */ 0x00, 0x01,
2022
2023 /* name */ 0x03, 'w', 'w', 'w',
2024 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2025 0x03, 'c', 'o', 'm',
2026 0x00,
2027 /* CNAME */ 0x00, 0x05,
2028 /* IN */ 0x00, 0x01,
2029 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2030 /* rdata */ 0x00, 0x0d,
2031 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2032 0x03, 'c', 'o', 'm',
2033 0x00,
2034
2035 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2036 0x03, 'c', 'o', 'm',
2037 0x00,
2038 /* A */ 0x00, 0x01,
2039 /* IN */ 0x00, 0x01,
2040 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2041 /* rdata */ 0x00, 0x04,
2042 /* ip */ 0xc0, 0xa8, 0x01, 0x7f
2043 };
2044
2045 check_cname_reply_compression(data, sizeof(data));
2046 }
2047
2048 TEST(packet_reply_cname_partial_compression) {
2049 const uint8_t data[] = {
2050 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2051 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
2052
2053 /* name */ 0x03, 'w', 'w', 'w',
2054 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2055 0x03, 'c', 'o', 'm',
2056 0x00,
2057 /* A */ 0x00, 0x01,
2058 /* IN */ 0x00, 0x01,
2059
2060 /* name */ 0x03, 'w', 'w', 'w',
2061 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2062 0xc0, 0x18,
2063 /* CNAME */ 0x00, 0x05,
2064 /* IN */ 0x00, 0x01,
2065 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2066 /* rdata */ 0x00, 0x02,
2067 /* name */ 0xc0, 0x25,
2068
2069 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2070 0xc0, 0x2d,
2071 /* A */ 0x00, 0x01,
2072 /* IN */ 0x00, 0x01,
2073 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2074 /* rdata */ 0x00, 0x04,
2075 /* ip */ 0xc0, 0xa8, 0x01, 0x7f
2076 };
2077
2078 check_cname_reply_compression(data, sizeof(data));
2079 }
2080
2081 TEST(packet_reply_cname_full_compression) {
2082 const uint8_t data[] = {
2083 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2084 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
2085
2086 /* name */ 0x03, 'w', 'w', 'w',
2087 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2088 0x03, 'c', 'o', 'm',
2089 0x00,
2090 /* A */ 0x00, 0x01,
2091 /* IN */ 0x00, 0x01,
2092
2093 /* name */ 0xc0, 0x0c,
2094 /* CNAME */ 0x00, 0x05,
2095 /* IN */ 0x00, 0x01,
2096 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2097 /* rdata */ 0x00, 0x02,
2098 /* name */ 0xc0, 0x10,
2099
2100 /* name */ 0xc0, 0x10,
2101 /* A */ 0x00, 0x01,
2102 /* IN */ 0x00, 0x01,
2103 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2104 /* rdata */ 0x00, 0x04,
2105 /* ip */ 0xc0, 0xa8, 0x01, 0x7f
2106 };
2107
2108 check_cname_reply_compression(data, sizeof(data));
2109 }
2110
2111 /* ================================================================
2112 * reply: SOA
2113 * ================================================================ */
2114
2115 TEST(packet_reply_soa_basic) {
2116 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2117 DnsResourceRecord *rr = NULL;
2118
2119 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2120 ASSERT_NOT_NULL(packet);
2121 dns_packet_truncate(packet, 0);
2122
2123 const uint8_t data[] = {
2124 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_NXDOMAIN,
2125 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
2126
2127 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2128 0x03, 'c', 'o', 'm',
2129 0x00,
2130 /* SOA */ 0x00, 0x06,
2131 /* IN */ 0x00, 0x01,
2132 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2133 /* rdata */ 0x00, 0x27,
2134 /* mname */ 0x03, 'n', 's', '0',
2135 0xc0, 0x0c,
2136 /* rname */ 0x0a, 'h', 'o', 's', 't', 'm', 'a', 's', 't', 'e', 'r',
2137 0xc0, 0x0c,
2138 /* serial */ 0x78, 0x85, 0x75, 0x2e,
2139 /* refresh */ 0x00, 0x02, 0xa3, 0x00,
2140 /* retry */ 0x00, 0x00, 0x00, 0xb4,
2141 /* expire */ 0x00, 0x24, 0xea, 0x00,
2142 /* minimum */ 0x00, 0x00, 0x00, 0x3c
2143 };
2144
2145 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2146
2147 ASSERT_OK(dns_packet_extract(packet));
2148 ASSERT_EQ(dns_question_size(packet->question), 0u);
2149 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
2150
2151 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SOA, "example.com");
2152 ASSERT_NOT_NULL(rr);
2153 rr->ttl = 3600;
2154 rr->soa.mname = strdup("ns0.example.com");
2155 rr->soa.rname = strdup("hostmaster.example.com");
2156 rr->soa.serial = 2022012206;
2157 rr->soa.refresh = 172800;
2158 rr->soa.retry = 180;
2159 rr->soa.expire = 2419200;
2160 rr->soa.minimum = 60;
2161
2162 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_AUTHORITY);
2163 dns_resource_record_unref(rr);
2164 }
2165
2166 TEST(packet_reply_soa_rdata_overflow) {
2167 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2168
2169 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2170 ASSERT_NOT_NULL(packet);
2171 dns_packet_truncate(packet, 0);
2172
2173 const uint8_t data[] = {
2174 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_NXDOMAIN,
2175 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
2176
2177 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2178 0x03, 'c', 'o', 'm',
2179 0x00,
2180 /* SOA */ 0x00, 0x06,
2181 /* IN */ 0x00, 0x01,
2182 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2183 /* rdata */ 0x00, 0x26,
2184 /* mname */ 0x03, 'n', 's', '0',
2185 0xc0, 0x0c,
2186 /* rname */ 0x0a, 'h', 'o', 's', 't', 'm', 'a', 's', 't', 'e', 'r',
2187 0xc0, 0x0c,
2188 /* serial */ 0x78, 0x85, 0x75, 0x2e,
2189 /* refresh */ 0x00, 0x02, 0xa3, 0x00,
2190 /* retry */ 0x00, 0x00, 0x00, 0xb4,
2191 /* expire */ 0x00, 0x24, 0xea, 0x00,
2192 /* minimum */ 0x00, 0x00, 0x00, 0x3c
2193 };
2194
2195 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2196
2197 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
2198 ASSERT_EQ(dns_question_size(packet->question), 0u);
2199 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
2200 }
2201
2202 TEST(packet_reply_soa_rdata_underminated_domain) {
2203 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2204
2205 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2206 ASSERT_NOT_NULL(packet);
2207 dns_packet_truncate(packet, 0);
2208
2209 const uint8_t data[] = {
2210 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_NXDOMAIN,
2211 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
2212
2213 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2214 0x03, 'c', 'o', 'm',
2215 0x00,
2216 /* SOA */ 0x00, 0x06,
2217 /* IN */ 0x00, 0x01,
2218 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2219 /* rdata */ 0x00, 0x31,
2220 /* mname */ 0x03, 'n', 's', '0',
2221 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2222 0x03, 'c', 'o', 'm',
2223 /* missing 0x00 */
2224 /* rname */ 0x0a, 'h', 'o', 's', 't', 'm', 'a', 's', 't', 'e', 'r',
2225 0xc0, 0x0c,
2226 /* serial */ 0x78, 0x85, 0x75, 0x2e,
2227 /* refresh */ 0x00, 0x02, 0xa3, 0x00,
2228 /* retry */ 0x00, 0x00, 0x00, 0xb4,
2229 /* expire */ 0x00, 0x24, 0xea, 0x00,
2230 /* minimum */ 0x00, 0x00, 0x00, 0x3c
2231 };
2232
2233 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2234
2235 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
2236 ASSERT_EQ(dns_question_size(packet->question), 0u);
2237 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
2238 }
2239
2240 TEST(packet_reply_soa_rdata_missing_field) {
2241 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2242
2243 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2244 ASSERT_NOT_NULL(packet);
2245 dns_packet_truncate(packet, 0);
2246
2247 const uint8_t data[] = {
2248 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_NXDOMAIN,
2249 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
2250
2251 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2252 0x03, 'c', 'o', 'm',
2253 0x00,
2254 /* SOA */ 0x00, 0x06,
2255 /* IN */ 0x00, 0x01,
2256 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2257 /* rdata */ 0x00, 0x23,
2258 /* mname */ 0x03, 'n', 's', '0',
2259 0xc0, 0x0c,
2260 /* rname */ 0x0a, 'h', 'o', 's', 't', 'm', 'a', 's', 't', 'e', 'r',
2261 0xc0, 0x0c,
2262 /* serial */ 0x78, 0x85, 0x75, 0x2e,
2263 /* refresh */ 0x00, 0x02, 0xa3, 0x00,
2264 /* retry */ 0x00, 0x00, 0x00, 0xb4,
2265 /* expire */ 0x00, 0x24, 0xea, 0x00
2266 /* minimum (missing) */
2267 };
2268
2269 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2270
2271 ASSERT_ERROR(dns_packet_extract(packet), EMSGSIZE);
2272 ASSERT_EQ(dns_question_size(packet->question), 0u);
2273 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
2274 }
2275
2276 TEST(packet_reply_soa_rdata_partial_final_field) {
2277 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2278
2279 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2280 ASSERT_NOT_NULL(packet);
2281 dns_packet_truncate(packet, 0);
2282
2283 const uint8_t data[] = {
2284 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_NXDOMAIN,
2285 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
2286
2287 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2288 0x03, 'c', 'o', 'm',
2289 0x00,
2290 /* SOA */ 0x00, 0x06,
2291 /* IN */ 0x00, 0x01,
2292 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2293 /* rdata */ 0x00, 0x26,
2294 /* mname */ 0x03, 'n', 's', '0',
2295 0xc0, 0x0c,
2296 /* rname */ 0x0a, 'h', 'o', 's', 't', 'm', 'a', 's', 't', 'e', 'r',
2297 0xc0, 0x0c,
2298 /* serial */ 0x78, 0x85, 0x75, 0x2e,
2299 /* refresh */ 0x00, 0x02, 0xa3, 0x00,
2300 /* retry */ 0x00, 0x00, 0x00, 0xb4,
2301 /* expire */ 0x00, 0x24, 0xea, 0x00,
2302 /* minimum */ 0x00, 0x00, 0x00
2303 };
2304
2305 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2306
2307 ASSERT_ERROR(dns_packet_extract(packet), EMSGSIZE);
2308 ASSERT_EQ(dns_question_size(packet->question), 0u);
2309 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
2310 }
2311
2312 /* ================================================================
2313 * reply: HINFO
2314 * ================================================================ */
2315
2316 TEST(packet_reply_hinfo_basic) {
2317 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2318 DnsResourceRecord *rr = NULL;
2319
2320 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2321 ASSERT_NOT_NULL(packet);
2322 dns_packet_truncate(packet, 0);
2323
2324 const uint8_t data[] = {
2325 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2326 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
2327
2328 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2329 0x03, 'c', 'o', 'm',
2330 0x00,
2331 /* HINFO */ 0x00, 0x0d,
2332 /* IN */ 0x00, 0x01,
2333 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2334 /* rdata */ 0x00, 0x14,
2335 /* cpu */ 0x09, 'I', 'n', 't', 'e', 'l', ' ', 'x', '6', '4',
2336 /* os */ 0x09, 'G', 'N', 'U', '/', 'L', 'i', 'n', 'u', 'x'
2337 };
2338
2339 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2340
2341 ASSERT_OK(dns_packet_extract(packet));
2342 ASSERT_EQ(dns_question_size(packet->question), 0u);
2343 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
2344
2345 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_HINFO, "example.com");
2346 ASSERT_NOT_NULL(rr);
2347 rr->ttl = 3600;
2348 rr->hinfo.cpu = strdup("Intel x64");
2349 rr->hinfo.os = strdup("GNU/Linux");
2350
2351 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
2352 dns_resource_record_unref(rr);
2353 }
2354
2355 TEST(packet_reply_hinfo_overflow) {
2356 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2357
2358 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2359 ASSERT_NOT_NULL(packet);
2360 dns_packet_truncate(packet, 0);
2361
2362 const uint8_t data[] = {
2363 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2364 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
2365
2366 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2367 0x03, 'c', 'o', 'm',
2368 0x00,
2369 /* HINFO */ 0x00, 0x0d,
2370 /* IN */ 0x00, 0x01,
2371 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2372 /* rdata */ 0x00, 0x13,
2373 /* cpu */ 0x09, 'I', 'n', 't', 'e', 'l', ' ', 'x', '6', '4',
2374 /* os */ 0x09, 'G', 'N', 'U', '/', 'L', 'i', 'n', 'u', 'x'
2375 };
2376
2377 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2378
2379 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
2380 ASSERT_EQ(dns_question_size(packet->question), 0u);
2381 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
2382 }
2383
2384 TEST(packet_reply_hinfo_valid_utf8) {
2385 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2386 DnsResourceRecord *rr = NULL;
2387
2388 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2389 ASSERT_NOT_NULL(packet);
2390 dns_packet_truncate(packet, 0);
2391
2392 const uint8_t data[] = {
2393 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2394 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
2395
2396 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2397 0x03, 'c', 'o', 'm',
2398 0x00,
2399 /* HINFO */ 0x00, 0x0d,
2400 /* IN */ 0x00, 0x01,
2401 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2402 /* rdata */ 0x00, 0x17,
2403 /* cpu */ 0x09, 'I', 'n', 't', 'e', 'l', ' ', 'x', '6', '4',
2404 /* os */ 0x0c, 'G', 'N', 0xf0, 0x9d, 0x95, 0x8c, '/', 'L', 'i', 'n', 'u', 'x'
2405 };
2406
2407 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2408
2409 ASSERT_OK(dns_packet_extract(packet));
2410 ASSERT_EQ(dns_question_size(packet->question), 0u);
2411 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
2412
2413 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_HINFO, "example.com");
2414 ASSERT_NOT_NULL(rr);
2415 rr->ttl = 3600;
2416 rr->hinfo.cpu = strdup("Intel x64");
2417 rr->hinfo.os = strdup("GN𝕌/Linux");
2418
2419 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
2420 dns_resource_record_unref(rr);
2421 }
2422
2423 TEST(packet_reply_hinfo_invalid_utf8) {
2424 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2425
2426 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2427 ASSERT_NOT_NULL(packet);
2428 dns_packet_truncate(packet, 0);
2429
2430 const uint8_t data[] = {
2431 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2432 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
2433
2434 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2435 0x03, 'c', 'o', 'm',
2436 0x00,
2437 /* HINFO */ 0x00, 0x0d,
2438 /* IN */ 0x00, 0x01,
2439 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2440 /* rdata */ 0x00, 0x16,
2441 /* cpu */ 0x09, 'I', 'n', 't', 'e', 'l', ' ', 'x', '6', '4',
2442 /* os */ 0x0b, 'G', 'N', 0xf0, 0x9d, 0x95, '/', 'L', 'i', 'n', 'u', 'x'
2443 };
2444
2445 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2446
2447 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
2448 ASSERT_EQ(dns_question_size(packet->question), 0u);
2449 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
2450 }
2451
2452 /* ================================================================
2453 * reply: TXT
2454 * ================================================================ */
2455
2456 TEST(packet_reply_txt) {
2457 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2458 DnsResourceRecord *rr = NULL;
2459 DnsTxtItem *item = NULL;
2460
2461 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2462 ASSERT_NOT_NULL(packet);
2463 dns_packet_truncate(packet, 0);
2464
2465 const uint8_t data[] = {
2466 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2467 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
2468
2469 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2470 0x03, 'c', 'o', 'm',
2471 0x00,
2472 /* TXT */ 0x00, 0x10,
2473 /* IN */ 0x00, 0x01,
2474 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2475 /* rdata */ 0x00, 0x09,
2476 0x02, 'h', 'i',
2477 0x05, 'w', 'o', 'r', 'l', 'd'
2478 };
2479
2480 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2481
2482 ASSERT_OK(dns_packet_extract(packet));
2483 ASSERT_EQ(dns_question_size(packet->question), 0u);
2484 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
2485
2486 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_TXT, "example.com");
2487 ASSERT_NOT_NULL(rr);
2488 rr->ttl = 3600;
2489
2490 item = calloc(1, offsetof(DnsTxtItem, data) + 3);
2491 ASSERT_NOT_NULL(item);
2492 item->length = 2;
2493 memcpy(item->data, "hi", 3);
2494 LIST_APPEND(items, rr->txt.items, item);
2495
2496 item = calloc(1, offsetof(DnsTxtItem, data) + 6);
2497 ASSERT_NOT_NULL(item);
2498 item->length = 5;
2499 memcpy(item->data, "world", 6);
2500 LIST_APPEND(items, rr->txt.items, item);
2501
2502 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
2503 dns_resource_record_unref(rr);
2504 }
2505
2506 TEST(packet_reply_txt_empty) {
2507 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2508 DnsResourceRecord *rr = NULL;
2509
2510 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2511 ASSERT_NOT_NULL(packet);
2512 dns_packet_truncate(packet, 0);
2513
2514 const uint8_t data[] = {
2515 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2516 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
2517
2518 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2519 0x03, 'c', 'o', 'm',
2520 0x00,
2521 /* TXT */ 0x00, 0x10,
2522 /* IN */ 0x00, 0x01,
2523 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2524 /* rdata */ 0x00, 0x00
2525 };
2526
2527 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2528
2529 ASSERT_OK(dns_packet_extract(packet));
2530 ASSERT_EQ(dns_question_size(packet->question), 0u);
2531 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
2532
2533 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_TXT, "example.com");
2534 ASSERT_NOT_NULL(rr);
2535 rr->ttl = 3600;
2536 dns_txt_item_new_empty(&rr->txt.items);
2537
2538 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
2539 dns_resource_record_unref(rr);
2540 }
2541
2542 TEST(packet_reply_txt_overflow_rdata) {
2543 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2544
2545 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2546 ASSERT_NOT_NULL(packet);
2547 dns_packet_truncate(packet, 0);
2548
2549 const uint8_t data[] = {
2550 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2551 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
2552
2553 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2554 0x03, 'c', 'o', 'm',
2555 0x00,
2556 /* TXT */ 0x00, 0x10,
2557 /* IN */ 0x00, 0x01,
2558 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2559 /* rdata */ 0x00, 0x08,
2560 0x02, 'h', 'i',
2561 0x05, 'w', 'o', 'r', 'l', 'd'
2562 };
2563
2564 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2565
2566 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
2567 ASSERT_EQ(dns_question_size(packet->question), 0u);
2568 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
2569 }
2570
2571 /* ================================================================
2572 * reply: LOC
2573 * ================================================================ */
2574
2575 TEST(packet_reply_loc_basic) {
2576 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2577 DnsResourceRecord *rr = NULL;
2578
2579 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2580 ASSERT_NOT_NULL(packet);
2581 dns_packet_truncate(packet, 0);
2582
2583 const uint8_t data[] = {
2584 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2585 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
2586
2587 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2588 0x03, 'c', 'o', 'm',
2589 0x00,
2590 /* LOC */ 0x00, 0x1d,
2591 /* IN */ 0x00, 0x01,
2592 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2593 /* rdata */ 0x00, 0x10,
2594 /* version */ 0x00,
2595 /* size */ 0x29,
2596 /* horiz pre */ 0x34,
2597 /* vert pre */ 0x53,
2598 /* latitude */ 0x8b, 0x0d, 0x08, 0xf5,
2599 /* longitude */ 0x7f, 0xf8, 0x39, 0x48,
2600 /* altitude */ 0x00, 0x98, 0x96, 0x80
2601 };
2602
2603 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2604
2605 ASSERT_OK(dns_packet_extract(packet));
2606 ASSERT_EQ(dns_question_size(packet->question), 0u);
2607 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
2608
2609 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_LOC, "example.com");
2610 ASSERT_NOT_NULL(rr);
2611 rr->ttl = 3600;
2612 rr->loc.version = 0;
2613 rr->loc.size = 0x29;
2614 rr->loc.horiz_pre = 0x34;
2615 rr->loc.vert_pre = 0x53;
2616 rr->loc.latitude = 2332887285;
2617 rr->loc.longitude = 2146974024;
2618 rr->loc.altitude = 10000000;
2619
2620 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
2621 dns_resource_record_unref(rr);
2622 }
2623
2624 TEST(packet_reply_loc_bad_version) {
2625 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2626 DnsResourceRecord *rr = NULL;
2627
2628 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2629 ASSERT_NOT_NULL(packet);
2630 dns_packet_truncate(packet, 0);
2631
2632 const uint8_t data[] = {
2633 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2634 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
2635
2636 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2637 0x03, 'c', 'o', 'm',
2638 0x00,
2639 /* LOC */ 0x00, 0x1d,
2640 /* IN */ 0x00, 0x01,
2641 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2642 /* rdata */ 0x00, 0x10,
2643 /* version */ 0x01,
2644 /* size */ 0x29,
2645 /* horiz pre */ 0x34,
2646 /* vert pre */ 0x53,
2647 /* latitude */ 0x8b, 0x0d, 0x08, 0xf5,
2648 /* longitude */ 0x7f, 0xf8, 0x39, 0x48,
2649 /* altitude */ 0x00, 0x98, 0x96, 0x80
2650 };
2651
2652 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2653
2654 ASSERT_OK(dns_packet_extract(packet));
2655 ASSERT_EQ(dns_question_size(packet->question), 0u);
2656 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
2657
2658 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_LOC, "example.com");
2659 ASSERT_NOT_NULL(rr);
2660 rr->unparsable = true;
2661 rr->generic.data_size = 16;
2662 rr->generic.data = calloc(rr->generic.data_size, sizeof(uint8_t));
2663 ASSERT_NOT_NULL(rr->generic.data);
2664 memcpy(rr->generic.data, data + 35, rr->generic.data_size);
2665
2666 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
2667 dns_resource_record_unref(rr);
2668 }
2669
2670 /* ================================================================
2671 * reply: SRV
2672 * ================================================================ */
2673
2674 TEST(packet_reply_srv_with_a) {
2675 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2676 DnsResourceRecord *rr = NULL;
2677
2678 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2679 ASSERT_NOT_NULL(packet);
2680 dns_packet_truncate(packet, 0);
2681
2682 const uint8_t data[] = {
2683 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2684 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
2685
2686 /* name */ 0x05, '_', 'l', 'd', 'a', 'p',
2687 0x04, '_', 't', 'c', 'p',
2688 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2689 0x03, 'c', 'o', 'm',
2690 0x00,
2691 /* SRV */ 0x00, 0x21,
2692 /* IN */ 0x00, 0x01,
2693 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2694 /* rdata */ 0x00, 0x19,
2695 /* priority */ 0x43, 0x21,
2696 /* weight */ 0x65, 0x78,
2697 /* port */ 0x01, 0x85,
2698 /* name */ 0x05, 'c', 'l', 'o', 'u', 'd',
2699 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2700 0x03, 'c', 'o', 'm',
2701 0x00,
2702
2703 /* name */ 0xc0, 0x34,
2704 /* A */ 0x00, 0x01,
2705 /* IN */ 0x00, 0x01,
2706 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2707 /* rdata */ 0x00, 0x04,
2708 /* ip */ 0xc0, 0xa8, 0x01, 0x7f
2709 };
2710
2711 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2712
2713 ASSERT_OK(dns_packet_extract(packet));
2714 ASSERT_EQ(dns_question_size(packet->question), 0u);
2715 ASSERT_EQ(dns_answer_size(packet->answer), 2u);
2716
2717 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SRV, "_ldap._tcp.example.com");
2718 ASSERT_NOT_NULL(rr);
2719 rr->ttl = 3600;
2720 rr->srv.priority = 17185;
2721 rr->srv.weight = 25976;
2722 rr->srv.port = 389;
2723 rr->srv.name = strdup("cloud.example.com");
2724
2725 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
2726 dns_resource_record_unref(rr);
2727
2728 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "cloud.example.com");
2729 ASSERT_NOT_NULL(rr);
2730 rr->ttl = 3600;
2731 rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
2732
2733 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ADDITIONAL);
2734 dns_resource_record_unref(rr);
2735 }
2736
2737 /* we allow compression of the SRV target field even though RFC 2782 advises against it */
2738
2739 TEST(packet_reply_srv_compression) {
2740 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2741 DnsResourceRecord *rr = NULL;
2742
2743 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2744 ASSERT_NOT_NULL(packet);
2745 dns_packet_truncate(packet, 0);
2746
2747 const uint8_t data[] = {
2748 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2749 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
2750
2751 /* name */ 0x05, '_', 'l', 'd', 'a', 'p',
2752 0x04, '_', 't', 'c', 'p',
2753 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2754 0x03, 'c', 'o', 'm',
2755 0x00,
2756 /* SRV */ 0x00, 0x21,
2757 /* IN */ 0x00, 0x01,
2758 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2759 /* rdata */ 0x00, 0x0e,
2760 /* priority */ 0x00, 0x0a,
2761 /* weight */ 0x00, 0x05,
2762 /* port */ 0x01, 0x85,
2763 /* name */ 0x05, 'c', 'l', 'o', 'u', 'd',
2764 0xc0, 0x17,
2765
2766 /* name */ 0xc0, 0x34,
2767 /* A */ 0x00, 0x01,
2768 /* IN */ 0x00, 0x01,
2769 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2770 /* rdata */ 0x00, 0x04,
2771 /* ip */ 0xc0, 0xa8, 0x01, 0x7f
2772 };
2773
2774 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2775
2776 ASSERT_OK(dns_packet_extract(packet));
2777 ASSERT_EQ(dns_question_size(packet->question), 0u);
2778 ASSERT_EQ(dns_answer_size(packet->answer), 2u);
2779
2780 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SRV, "_ldap._tcp.example.com");
2781 ASSERT_NOT_NULL(rr);
2782 rr->ttl = 3600;
2783 rr->srv.priority = 10;
2784 rr->srv.weight = 5;
2785 rr->srv.port = 389;
2786 rr->srv.name = strdup("cloud.example.com");
2787
2788 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
2789 dns_resource_record_unref(rr);
2790
2791 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "cloud.example.com");
2792 ASSERT_NOT_NULL(rr);
2793 rr->ttl = 3600;
2794 rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
2795
2796 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ADDITIONAL);
2797 dns_resource_record_unref(rr);
2798 }
2799
2800 TEST(packet_reply_srv_allow_non_srv_names) {
2801 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2802 DnsResourceRecord *rr = NULL;
2803
2804 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2805 ASSERT_NOT_NULL(packet);
2806 dns_packet_truncate(packet, 0);
2807
2808 const uint8_t data[] = {
2809 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2810 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
2811
2812 /* name */ 0x03, 'w', 'w', 'w',
2813 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2814 0x03, 'c', 'o', 'm',
2815 0x00,
2816 /* SRV */ 0x00, 0x21,
2817 /* IN */ 0x00, 0x01,
2818 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2819 /* rdata */ 0x00, 0x0e,
2820 /* priority */ 0x00, 0x0a,
2821 /* weight */ 0x00, 0x05,
2822 /* port */ 0x01, 0x85,
2823 /* name */ 0x05, 'c', 'l', 'o', 'u', 'd',
2824 0xc0, 0x10
2825 };
2826
2827 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2828
2829 ASSERT_OK(dns_packet_extract(packet));
2830 ASSERT_EQ(dns_question_size(packet->question), 0u);
2831 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
2832
2833 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SRV, "www.example.com");
2834 ASSERT_NOT_NULL(rr);
2835 rr->ttl = 3600;
2836 rr->srv.priority = 10;
2837 rr->srv.weight = 5;
2838 rr->srv.port = 389;
2839 rr->srv.name = strdup("cloud.example.com");
2840
2841 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
2842 dns_resource_record_unref(rr);
2843 }
2844
2845 /* ================================================================
2846 * reply: NAPTR
2847 * ================================================================ */
2848
2849 TEST(packet_reply_naptr_basic) {
2850 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2851 DnsResourceRecord *rr = NULL;
2852
2853 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2854 ASSERT_NOT_NULL(packet);
2855 dns_packet_truncate(packet, 0);
2856
2857 const uint8_t data[] = {
2858 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2859 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
2860
2861 /* name */ 0x01, '4', 0x01, '3', 0x01, '2', 0x01, '1',
2862 0x01, '5', 0x01, '5', 0x01, '5',
2863 0x01, '0', 0x01, '0', 0x01, '8', 0x01, '1',
2864 0x04, 'e', '1', '6', '4',
2865 0x04, 'a', 'r', 'p', 'a',
2866 0x00,
2867 /* NAPTR */ 0x00, 0x23,
2868 /* IN */ 0x00, 0x01,
2869 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2870 /* rdata */ 0x00, 0x4d,
2871 /* order */ 0x00, 0x66,
2872 /* pref */ 0x00, 0x0a,
2873 /* flags */ 0x01, 'U',
2874 /* services */ 0x07, 'E', '2', 'U', '+', 's', 'i', 'p',
2875 /* regexp */ 0x27,
2876 '!', '^', '.', '*', '$', '!', 's', 'i',
2877 'p', ':', 'c', 'u', 's', 't', 'o', 'm',
2878 'e', 'r', '-', 's', 'e', 'r', 'v', 'i',
2879 'c', 'e', '@', 'e', 'x', 'a', 'm', 'p',
2880 'l', 'e', '.', 'c', 'o', 'm', '!',
2881 /* replace */ 0x04, '_', 's', 'i', 'p',
2882 0x04, '_', 'u', 'd', 'p',
2883 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2884 0x03, 'c', 'o', 'm',
2885 0x00
2886 };
2887
2888 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2889
2890 ASSERT_OK(dns_packet_extract(packet));
2891 ASSERT_EQ(dns_question_size(packet->question), 0u);
2892 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
2893
2894 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_NAPTR, "4.3.2.1.5.5.5.0.0.8.1.e164.arpa");
2895 ASSERT_NOT_NULL(rr);
2896 rr->ttl = 3600;
2897 rr->naptr.order = 102;
2898 rr->naptr.preference = 10;
2899 rr->naptr.flags = strdup("U");
2900 rr->naptr.services = strdup("E2U+sip");
2901 rr->naptr.regexp = strdup("!^.*$!sip:[email protected]!");
2902 rr->naptr.replacement = strdup("_sip._udp.example.com");
2903
2904 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
2905 dns_resource_record_unref(rr);
2906 }
2907
2908 TEST(packet_reply_naptr_compressed_replace) {
2909 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2910
2911 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2912 ASSERT_NOT_NULL(packet);
2913 dns_packet_truncate(packet, 0);
2914
2915 const uint8_t data[] = {
2916 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
2917 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
2918
2919 /* name */ 0x01, '4', 0x01, '3', 0x01, '2', 0x01, '1',
2920 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
2921 0x03, 'c', 'o', 'm',
2922 0x00,
2923 /* NAPTR */ 0x00, 0x23,
2924 /* IN */ 0x00, 0x01,
2925 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
2926 /* rdata */ 0x00, 0x4d,
2927 /* order */ 0x00, 0x66,
2928 /* pref */ 0x00, 0x0a,
2929 /* flags */ 0x01, 'U',
2930 /* services */ 0x07, 'E', '2', 'U', '+', 's', 'i', 'p',
2931 /* regexp */ 0x27,
2932 '!', '^', '.', '*', '$', '!', 's', 'i',
2933 'p', ':', 'c', 'u', 's', 't', 'o', 'm',
2934 'e', 'r', '-', 's', 'e', 'r', 'v', 'i',
2935 'c', 'e', '@', 'e', 'x', 'a', 'm', 'p',
2936 'l', 'e', '.', 'c', 'o', 'm', '!',
2937 /* replace */ 0x04, '_', 's', 'i', 'p',
2938 0x04, '_', 'u', 'd', 'p',
2939 0xc0, 0x14
2940 };
2941
2942 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2943
2944 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
2945 ASSERT_EQ(dns_question_size(packet->question), 0u);
2946 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
2947 }
2948
2949 /* ================================================================
2950 * reply: OPT
2951 * ================================================================ */
2952
2953 TEST(packet_reply_opt_no_do_empty) {
2954 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2955 DnsResourceRecord *rr = NULL;
2956
2957 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2958 ASSERT_NOT_NULL(packet);
2959 dns_packet_truncate(packet, 0);
2960
2961 const uint8_t data[] = {
2962 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_NXDOMAIN,
2963 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
2964
2965 /* name */ 0x00,
2966 /* OPT */ 0x00, 0x29,
2967 /* udp max */ 0x02, 0x01,
2968 /* rcode */ 0x9a,
2969 /* version */ 0x00,
2970 /* flags */ 0x00, 0x00,
2971 /* rdata */ 0x00, 0x00
2972 };
2973
2974 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
2975
2976 ASSERT_OK(dns_packet_extract(packet));
2977 ASSERT_EQ(dns_question_size(packet->question), 0u);
2978 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
2979
2980 rr = dns_resource_record_new_full(513, DNS_TYPE_OPT, "");
2981 ASSERT_NOT_NULL(rr);
2982 rr->ttl = 2046820352;
2983
2984 ASSERT_TRUE(dns_resource_record_equal(packet->opt, rr));
2985 dns_resource_record_unref(rr);
2986
2987 ASSERT_EQ(dns_packet_payload_size_max(packet), 513u);
2988 ASSERT_EQ(dns_packet_rcode(packet), 2467u);
2989 ASSERT_EQ(dns_packet_do(packet), 0u);
2990 }
2991
2992 TEST(packet_reply_opt_multiple) {
2993 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
2994
2995 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
2996 ASSERT_NOT_NULL(packet);
2997 dns_packet_truncate(packet, 0);
2998
2999 const uint8_t data[] = {
3000 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3001 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
3002
3003 /* name */ 0x00,
3004 /* OPT */ 0x00, 0x29,
3005 /* udp max */ 0x02, 0x01,
3006 /* rcode */ 0x7a,
3007 /* version */ 0x00,
3008 /* flags */ 0x00, 0x00,
3009 /* rdata */ 0x00, 0x00,
3010
3011 /* name */ 0x00,
3012 /* OPT */ 0x00, 0x29,
3013 /* udp max */ 0x02, 0x01,
3014 /* rcode */ 0x7a,
3015 /* version */ 0x00,
3016 /* flags */ 0x00, 0x00,
3017 /* rdata */ 0x00, 0x00
3018 };
3019
3020 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3021
3022 ASSERT_OK(dns_packet_extract(packet));
3023 ASSERT_EQ(dns_question_size(packet->question), 0u);
3024 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
3025 ASSERT_NULL(packet->opt);
3026 }
3027
3028 TEST(packet_reply_opt_not_root) {
3029 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3030
3031 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3032 ASSERT_NOT_NULL(packet);
3033 dns_packet_truncate(packet, 0);
3034
3035 const uint8_t data[] = {
3036 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3037 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3038
3039 /* name */ 0x03, 'c', 'o', 'm',
3040 0x00,
3041 /* OPT */ 0x00, 0x29,
3042 /* udp max */ 0x02, 0x01,
3043 /* rcode */ 0x00,
3044 /* version */ 0x00,
3045 /* flags */ 0x00, 0x00,
3046 /* rdata */ 0x00, 0x00
3047 };
3048
3049 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3050
3051 ASSERT_OK(dns_packet_extract(packet));
3052 ASSERT_EQ(dns_question_size(packet->question), 0u);
3053 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
3054 ASSERT_NULL(packet->opt);
3055 }
3056
3057 TEST(packet_reply_opt_wrong_section) {
3058 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3059
3060 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3061 ASSERT_NOT_NULL(packet);
3062 dns_packet_truncate(packet, 0);
3063
3064 const uint8_t data[] = {
3065 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3066 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
3067
3068 /* name */ 0x00,
3069 /* OPT */ 0x00, 0x29,
3070 /* udp max */ 0x02, 0x01,
3071 /* rcode */ 0x00,
3072 /* version */ 0x00,
3073 /* flags */ 0x00, 0x00,
3074 /* rdata */ 0x00, 0x00
3075 };
3076
3077 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3078
3079 ASSERT_OK(dns_packet_extract(packet));
3080 ASSERT_EQ(dns_question_size(packet->question), 0u);
3081 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
3082 ASSERT_NULL(packet->opt);
3083 }
3084
3085 TEST(packet_query_opt_version_ok) {
3086 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3087 DnsResourceRecord *rr = NULL;
3088
3089 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3090 ASSERT_NOT_NULL(packet);
3091 dns_packet_truncate(packet, 0);
3092
3093 const uint8_t data[] = {
3094 0x00, 0x42, 0x00, 0x00,
3095 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3096
3097 /* name */ 0x00,
3098 /* OPT */ 0x00, 0x29,
3099 /* udp max */ 0x02, 0x01,
3100 /* rcode */ 0x00,
3101 /* version */ 0x01,
3102 /* flags */ 0x00, 0x00,
3103 /* rdata */ 0x00, 0x00
3104 };
3105
3106 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3107
3108 ASSERT_OK(dns_packet_extract(packet));
3109 ASSERT_EQ(dns_question_size(packet->question), 0u);
3110 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
3111
3112 rr = dns_resource_record_new_full(513, DNS_TYPE_OPT, "");
3113 ASSERT_NOT_NULL(rr);
3114 rr->ttl = 65536;
3115
3116 ASSERT_TRUE(dns_resource_record_equal(packet->opt, rr));
3117 dns_resource_record_unref(rr);
3118
3119 ASSERT_EQ(dns_packet_payload_size_max(packet), 513u);
3120 ASSERT_EQ(dns_packet_do(packet), 0u);
3121 }
3122
3123 TEST(packet_reply_opt_version_bad) {
3124 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3125
3126 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3127 ASSERT_NOT_NULL(packet);
3128 dns_packet_truncate(packet, 0);
3129
3130 const uint8_t data[] = {
3131 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3132 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3133
3134 /* name */ 0x00,
3135 /* OPT */ 0x00, 0x29,
3136 /* udp max */ 0x02, 0x01,
3137 /* rcode */ 0x00,
3138 /* version */ 0x01,
3139 /* flags */ 0x00, 0x00,
3140 /* rdata */ 0x00, 0x00
3141 };
3142
3143 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3144
3145 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
3146 ASSERT_EQ(dns_question_size(packet->question), 0u);
3147 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
3148 ASSERT_NULL(packet->opt);
3149 }
3150
3151 TEST(packet_reply_opt_with_do) {
3152 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3153 DnsResourceRecord *rr = NULL;
3154
3155 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3156 ASSERT_NOT_NULL(packet);
3157 dns_packet_truncate(packet, 0);
3158
3159 const uint8_t data[] = {
3160 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3161 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3162
3163 /* name */ 0x00,
3164 /* OPT */ 0x00, 0x29,
3165 /* udp max */ 0x10, 0x01,
3166 /* rcode */ 0x00,
3167 /* version */ 0x00,
3168 /* flags */ 0x80, 0x00,
3169 /* rdata */ 0x00, 0x00
3170 };
3171
3172 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3173
3174 ASSERT_OK(dns_packet_extract(packet));
3175 ASSERT_EQ(dns_question_size(packet->question), 0u);
3176 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
3177
3178 rr = dns_resource_record_new_full(4097, DNS_TYPE_OPT, "");
3179 ASSERT_NOT_NULL(rr);
3180 rr->ttl = 32768;
3181
3182 ASSERT_TRUE(dns_resource_record_equal(packet->opt, rr));
3183 dns_resource_record_unref(rr);
3184
3185 ASSERT_EQ(dns_packet_payload_size_max(packet), 4097u);
3186 ASSERT_EQ(dns_packet_do(packet), 1u);
3187 }
3188
3189 TEST(packet_reply_opt_with_data) {
3190 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3191 DnsResourceRecord *rr = NULL;
3192
3193 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3194 ASSERT_NOT_NULL(packet);
3195 dns_packet_truncate(packet, 0);
3196
3197 const uint8_t data[] = {
3198 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3199 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3200
3201 /* name */ 0x00,
3202 /* OPT */ 0x00, 0x29,
3203 /* udp max */ 0x02, 0x01,
3204 /* rcode */ 0x00,
3205 /* version */ 0x00,
3206 /* flags */ 0x00, 0x00,
3207 /* rdata */ 0x00, 0x12,
3208 0x00, 0x01,
3209 0x00, 0x05,
3210 'h', 'e', 'l', 'l', 'o',
3211 0x00, 0x02,
3212 0x00, 0x05,
3213 'w', 'o', 'r', 'l', 'd'
3214 };
3215
3216 const uint8_t opt_data[] = {
3217 0x00, 0x01,
3218 0x00, 0x05,
3219 'h', 'e', 'l', 'l', 'o',
3220 0x00, 0x02,
3221 0x00, 0x05,
3222 'w', 'o', 'r', 'l', 'd'
3223 };
3224
3225 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3226
3227 ASSERT_OK(dns_packet_extract(packet));
3228 ASSERT_EQ(dns_question_size(packet->question), 0u);
3229 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
3230
3231 rr = dns_resource_record_new_full(513, DNS_TYPE_OPT, "");
3232 ASSERT_NOT_NULL(rr);
3233 rr->ttl = 0;
3234 rr->opt.data_size = sizeof(opt_data);
3235 rr->opt.data = calloc(rr->opt.data_size, sizeof(uint8_t));
3236 ASSERT_NOT_NULL(rr->opt.data);
3237 memcpy(rr->opt.data, opt_data, sizeof(opt_data));
3238
3239 ASSERT_TRUE(dns_resource_record_equal(packet->opt, rr));
3240 dns_resource_record_unref(rr);
3241 }
3242
3243 TEST(packet_reply_opt_bad_data_size) {
3244 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3245
3246 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3247 ASSERT_NOT_NULL(packet);
3248 dns_packet_truncate(packet, 0);
3249
3250 const uint8_t data[] = {
3251 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3252 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3253
3254 /* name */ 0x00,
3255 /* OPT */ 0x00, 0x29,
3256 /* udp max */ 0x02, 0x01,
3257 /* rcode */ 0x00,
3258 /* version */ 0x00,
3259 /* flags */ 0x00, 0x00,
3260 /* rdata */ 0x00, 0x13,
3261 0x00, 0x01,
3262 0x00, 0x05,
3263 'h', 'e', 'l', 'l', 'o',
3264 0x00, 0x02,
3265 0x00, 0x05,
3266 'w', 'o', 'r', 'l', 'd'
3267 };
3268
3269 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3270
3271 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
3272 ASSERT_EQ(dns_question_size(packet->question), 0u);
3273 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
3274 ASSERT_NULL(packet->opt);
3275 }
3276
3277 TEST(packet_query_opt_with_rfc6975_data) {
3278 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3279 DnsResourceRecord *rr = NULL;
3280
3281 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3282 ASSERT_NOT_NULL(packet);
3283 dns_packet_truncate(packet, 0);
3284
3285 const uint8_t data[] = {
3286 0x00, 0x42, 0x00, 0x00,
3287 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3288
3289 /* name */ 0x00,
3290 /* OPT */ 0x00, 0x29,
3291 /* udp max */ 0x02, 0x01,
3292 /* rcode */ 0x00,
3293 /* version */ 0x00,
3294 /* flags */ 0x00, 0x00,
3295 /* rdata */ 0x00, 0x05,
3296 0x00, 0x05, /* RFC 6975 defines codes 5, 6, 7 */
3297 0x00, 0x01,
3298 0xff
3299 };
3300
3301 const uint8_t opt_data[] = { 0x00, 0x05, 0x00, 0x01, 0xff };
3302
3303 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3304
3305 ASSERT_OK(dns_packet_extract(packet));
3306 ASSERT_EQ(dns_question_size(packet->question), 0u);
3307 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
3308
3309 rr = dns_resource_record_new_full(513, DNS_TYPE_OPT, "");
3310 ASSERT_NOT_NULL(rr);
3311 rr->ttl = 0;
3312 rr->opt.data_size = sizeof(opt_data);
3313 rr->opt.data = calloc(rr->opt.data_size, sizeof(uint8_t));
3314 ASSERT_NOT_NULL(rr->opt.data);
3315 memcpy(rr->opt.data, opt_data, sizeof(opt_data));
3316
3317 ASSERT_TRUE(dns_resource_record_equal(packet->opt, rr));
3318 dns_resource_record_unref(rr);
3319 }
3320
3321 TEST(packet_reply_opt_with_rfc6975_data) {
3322 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3323
3324 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3325 ASSERT_NOT_NULL(packet);
3326 dns_packet_truncate(packet, 0);
3327
3328 const uint8_t data[] = {
3329 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3330 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3331
3332 /* name */ 0x00,
3333 /* OPT */ 0x00, 0x29,
3334 /* udp max */ 0x02, 0x01,
3335 /* rcode */ 0x00,
3336 /* version */ 0x00,
3337 /* flags */ 0x00, 0x00,
3338 /* rdata */ 0x00, 0x05,
3339 0x00, 0x05, /* RFC 6975 defines codes 5, 6, 7 */
3340 0x00, 0x01,
3341 0xff
3342 };
3343
3344 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3345
3346 ASSERT_OK(dns_packet_extract(packet));
3347 ASSERT_EQ(dns_question_size(packet->question), 0u);
3348 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
3349 ASSERT_NULL(packet->opt);
3350 }
3351
3352 /* ================================================================
3353 * dns_packet_ede_rcode()
3354 * ================================================================ */
3355
3356 TEST(packet_ede_rcode_empty) {
3357 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3358 int ret_ede_rcode;
3359 char *ret_ede_msg;
3360
3361 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3362 ASSERT_NOT_NULL(packet);
3363 dns_packet_truncate(packet, 0);
3364
3365 const uint8_t data[] = {
3366 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3367 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3368
3369 /* name */ 0x00,
3370 /* OPT */ 0x00, 0x29,
3371 /* udp max */ 0x02, 0x01,
3372 /* rcode */ 0x00,
3373 /* version */ 0x00,
3374 /* flags */ 0x80, 0x00,
3375 /* rdata */ 0x00, 0x00
3376 };
3377
3378 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3379
3380 ASSERT_OK(dns_packet_extract(packet));
3381
3382 ASSERT_ERROR(dns_packet_ede_rcode(packet, &ret_ede_rcode, &ret_ede_msg), ENOENT);
3383 }
3384
3385 TEST(packet_ede_rcode_ede_option_code) {
3386 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3387 _cleanup_free_ char *ret_ede_msg;
3388 int ret_ede_rcode;
3389
3390 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3391 ASSERT_NOT_NULL(packet);
3392 dns_packet_truncate(packet, 0);
3393
3394 const uint8_t data[] = {
3395 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3396 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3397
3398 /* name */ 0x00,
3399 /* OPT */ 0x00, 0x29,
3400 /* udp max */ 0x02, 0x01,
3401 /* rcode */ 0x00,
3402 /* version */ 0x00,
3403 /* flags */ 0x80, 0x00,
3404 /* rdata */ 0x00, 0x12,
3405 0x00, 0x0f, /* extended DNS error */
3406 0x00, 0x0e, /* length */
3407 0x00, 0x06, /* DNSSEC bogus */
3408 'D', 'N', 'S', 'S', 'E', 'C', ' ', 'b', 'o', 'g', 'u', 's'
3409 };
3410
3411 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3412
3413 ASSERT_OK(dns_packet_extract(packet));
3414
3415 ASSERT_EQ(dns_packet_ede_rcode(packet, &ret_ede_rcode, &ret_ede_msg), 0);
3416 ASSERT_EQ(ret_ede_rcode, DNS_EDE_RCODE_DNSSEC_BOGUS);
3417 ASSERT_STREQ(ret_ede_msg, "DNSSEC bogus");
3418 }
3419
3420 TEST(packet_ede_rcode_ede_valid_utf8) {
3421 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3422 _cleanup_free_ char *ret_ede_msg;
3423 int ret_ede_rcode;
3424
3425 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3426 ASSERT_NOT_NULL(packet);
3427 dns_packet_truncate(packet, 0);
3428
3429 const uint8_t data[] = {
3430 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3431 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3432
3433 /* name */ 0x00,
3434 /* OPT */ 0x00, 0x29,
3435 /* udp max */ 0x02, 0x01,
3436 /* rcode */ 0x00,
3437 /* version */ 0x00,
3438 /* flags */ 0x80, 0x00,
3439 /* rdata */ 0x00, 0x0d,
3440 0x00, 0x0f, /* extended DNS error */
3441 0x00, 0x09, /* length */
3442 0x00, 0x06, /* DNSSEC bogus */
3443 'b', 0xc3, 0xb8, 'g', 0xc3, 0xbc, 's'
3444 };
3445
3446 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3447
3448 ASSERT_OK(dns_packet_extract(packet));
3449
3450 ASSERT_EQ(dns_packet_ede_rcode(packet, &ret_ede_rcode, &ret_ede_msg), 0);
3451 ASSERT_EQ(ret_ede_rcode, DNS_EDE_RCODE_DNSSEC_BOGUS);
3452 ASSERT_STREQ(ret_ede_msg, "bøgüs");
3453 }
3454
3455 TEST(packet_ede_rcode_ede_invalid_utf8) {
3456 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3457 _cleanup_free_ char *ret_ede_msg;
3458 int ret_ede_rcode;
3459
3460 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3461 ASSERT_NOT_NULL(packet);
3462 dns_packet_truncate(packet, 0);
3463
3464 const uint8_t data[] = {
3465 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3466 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3467
3468 /* name */ 0x00,
3469 /* OPT */ 0x00, 0x29,
3470 /* udp max */ 0x02, 0x01,
3471 /* rcode */ 0x00,
3472 /* version */ 0x00,
3473 /* flags */ 0x80, 0x00,
3474 /* rdata */ 0x00, 0x0d,
3475 0x00, 0x0f, /* extended DNS error */
3476 0x00, 0x09, /* length */
3477 0x00, 0x06, /* DNSSEC bogus */
3478 'b', 0xc3, 0xb8, 'g', 0xc3, 0xbc, 0xff
3479 };
3480
3481 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3482
3483 ASSERT_OK(dns_packet_extract(packet));
3484
3485 ASSERT_EQ(dns_packet_ede_rcode(packet, &ret_ede_rcode, &ret_ede_msg), 0);
3486 ASSERT_EQ(ret_ede_rcode, DNS_EDE_RCODE_DNSSEC_BOGUS);
3487 ASSERT_STREQ(ret_ede_msg, "b\\303\\270g\\303\\274\\377");
3488 }
3489
3490 TEST(packet_ede_rcode_non_ede_code) {
3491 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3492 int ret_ede_rcode;
3493 char *ret_ede_msg;
3494
3495 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3496 ASSERT_NOT_NULL(packet);
3497 dns_packet_truncate(packet, 0);
3498
3499 const uint8_t data[] = {
3500 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3501 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3502
3503 /* name */ 0x00,
3504 /* OPT */ 0x00, 0x29,
3505 /* udp max */ 0x02, 0x01,
3506 /* rcode */ 0x00,
3507 /* version */ 0x00,
3508 /* flags */ 0x80, 0x00,
3509 /* rdata */ 0x00, 0x12,
3510 0x00, 0x01, /* not EDE option code */
3511 0x00, 0x0e, /* length */
3512 0x00, 0x06, /* DNSSEC bogus */
3513 'D', 'N', 'S', 'S', 'E', 'C', ' ', 'b', 'o', 'g', 'u', 's'
3514 };
3515
3516 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3517
3518 ASSERT_OK(dns_packet_extract(packet));
3519
3520 ASSERT_ERROR(dns_packet_ede_rcode(packet, &ret_ede_rcode, &ret_ede_msg), ENOENT);
3521 }
3522
3523 TEST(packet_ede_rcode_malformed_ede_payload) {
3524 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3525 int ret_ede_rcode;
3526 char *ret_ede_msg;
3527
3528 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3529 ASSERT_NOT_NULL(packet);
3530 dns_packet_truncate(packet, 0);
3531
3532 const uint8_t data[] = {
3533 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3534 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3535
3536 /* name */ 0x00,
3537 /* OPT */ 0x00, 0x29,
3538 /* udp max */ 0x02, 0x01,
3539 /* rcode */ 0x00,
3540 /* version */ 0x00,
3541 /* flags */ 0x80, 0x00,
3542 /* rdata */ 0x00, 0x12,
3543 0x00, 0x0f, /* extended DNS error */
3544 0x00, 0x0d, /* length */
3545 0x00, 0x06, /* DNSSEC bogus */
3546 'D', 'N', 'S', 'S', 'E', 'C', ' ', 'b', 'o', 'g', 'u', 's'
3547 };
3548
3549 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3550
3551 ASSERT_OK(dns_packet_extract(packet));
3552
3553 ASSERT_ERROR(dns_packet_ede_rcode(packet, &ret_ede_rcode, &ret_ede_msg), ENOENT);
3554 }
3555
3556 /* ================================================================
3557 * dns_packet_has_nsid_request()
3558 * ================================================================ */
3559
3560 TEST(packet_has_nsid_request_no_match) {
3561 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3562
3563 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3564 ASSERT_NOT_NULL(packet);
3565 dns_packet_truncate(packet, 0);
3566
3567 const uint8_t data[] = {
3568 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3569 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3570
3571 /* name */ 0x00,
3572 /* OPT */ 0x00, 0x29,
3573 /* udp max */ 0x02, 0x01,
3574 /* rcode */ 0x00,
3575 /* version */ 0x00,
3576 /* flags */ 0x80, 0x00,
3577 /* rdata */ 0x00, 0x00
3578 };
3579
3580 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3581
3582 ASSERT_OK(dns_packet_extract(packet));
3583
3584 ASSERT_FALSE(dns_packet_has_nsid_request(packet));
3585 }
3586
3587 TEST(packet_has_nsid_request_match_empty_option) {
3588 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3589
3590 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3591 ASSERT_NOT_NULL(packet);
3592 dns_packet_truncate(packet, 0);
3593
3594 const uint8_t data[] = {
3595 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3596 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3597
3598 /* name */ 0x00,
3599 /* OPT */ 0x00, 0x29,
3600 /* udp max */ 0x02, 0x01,
3601 /* rcode */ 0x00,
3602 /* version */ 0x00,
3603 /* flags */ 0x80, 0x00,
3604 /* rdata */ 0x00, 0x04,
3605 0x00, 0x03, /* NSID option code */
3606 0x00, 0x00
3607 };
3608
3609 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3610
3611 ASSERT_OK(dns_packet_extract(packet));
3612
3613 ASSERT_TRUE(dns_packet_has_nsid_request(packet));
3614 }
3615
3616 TEST(packet_has_nsid_request_match_multiple) {
3617 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3618
3619 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3620 ASSERT_NOT_NULL(packet);
3621 dns_packet_truncate(packet, 0);
3622
3623 const uint8_t data[] = {
3624 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3625 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3626
3627 /* name */ 0x00,
3628 /* OPT */ 0x00, 0x29,
3629 /* udp max */ 0x02, 0x01,
3630 /* rcode */ 0x00,
3631 /* version */ 0x00,
3632 /* flags */ 0x80, 0x00,
3633 /* rdata */ 0x00, 0x08,
3634 0x00, 0x03, /* NSID option code */
3635 0x00, 0x00,
3636 0x00, 0x03, /* NSID option code */
3637 0x00, 0x00
3638 };
3639
3640 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3641
3642 ASSERT_OK(dns_packet_extract(packet));
3643
3644 ASSERT_ERROR(dns_packet_has_nsid_request(packet), EBADMSG);
3645 }
3646
3647 TEST(packet_has_nsid_request_match_not_empty) {
3648 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3649
3650 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3651 ASSERT_NOT_NULL(packet);
3652 dns_packet_truncate(packet, 0);
3653
3654 const uint8_t data[] = {
3655 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3656 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3657
3658 /* name */ 0x00,
3659 /* OPT */ 0x00, 0x29,
3660 /* udp max */ 0x02, 0x01,
3661 /* rcode */ 0x00,
3662 /* version */ 0x00,
3663 /* flags */ 0x80, 0x00,
3664 /* rdata */ 0x00, 0x05,
3665 0x00, 0x03, /* NSID option code */
3666 0x00, 0x01,
3667 0xff
3668 };
3669
3670 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3671
3672 ASSERT_OK(dns_packet_extract(packet));
3673
3674 ASSERT_ERROR(dns_packet_has_nsid_request(packet), EBADMSG);
3675 }
3676
3677 /* ================================================================
3678 * reply: RRSIG
3679 * ================================================================ */
3680
3681 TEST(packet_reply_rrsig_for_a) {
3682 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3683 DnsResourceRecord *rr = NULL;
3684
3685 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3686 ASSERT_NOT_NULL(packet);
3687 dns_packet_truncate(packet, 0);
3688
3689 const uint8_t data[] = {
3690 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3691 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
3692
3693 /* name */ 0x03, 'w', 'w', 'w',
3694 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
3695 0x03, 'c', 'o', 'm',
3696 0x00,
3697 /* A */ 0x00, 0x01,
3698 /* IN */ 0x00, 0x01,
3699 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
3700 /* rdata */ 0x00, 0x04,
3701 /* ip */ 0xc0, 0xa8, 0x01, 0x7f,
3702
3703 /* name */ 0xc0, 0x0c,
3704 /* RRSIG */ 0x00, 0x2e,
3705 /* IN */ 0x00, 0x01,
3706 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
3707 /* rdata */ 0x00, 0x27,
3708 /* type */ 0x00, 0x01,
3709 /* algo */ 0x04,
3710 /* labels */ 0x03,
3711 /* orig ttl */ 0x00, 0x00, 0x0e, 0x10,
3712 /* expiry */ 0x66, 0x8a, 0xa1, 0x57,
3713 /* inception */ 0x66, 0x63, 0x14, 0x57,
3714 /* key tag */ 0x12, 0x34,
3715 /* signer */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
3716 0x03, 'c', 'o', 'm',
3717 0x00,
3718 /* signature */ 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
3719 };
3720
3721 const uint8_t signature[] = {
3722 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
3723 };
3724
3725 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3726
3727 ASSERT_OK(dns_packet_extract(packet));
3728 ASSERT_EQ(dns_question_size(packet->question), 0u);
3729 ASSERT_EQ(dns_answer_size(packet->answer), 2u);
3730
3731 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
3732 ASSERT_NOT_NULL(rr);
3733 rr->ttl = 3600;
3734 rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
3735
3736 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
3737 dns_resource_record_unref(rr);
3738
3739 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_RRSIG, "www.example.com");
3740 ASSERT_NOT_NULL(rr);
3741 rr->ttl = 3600;
3742 rr->rrsig.type_covered = DNS_TYPE_A;
3743 rr->rrsig.algorithm = DNSSEC_ALGORITHM_ECC;
3744 rr->rrsig.labels = 3;
3745 rr->rrsig.original_ttl = 3600;
3746 rr->rrsig.expiration = 1720361303;
3747 rr->rrsig.inception = 1717769303;
3748 rr->rrsig.key_tag = 0x1234;
3749 rr->rrsig.signer = strdup("example.com");
3750
3751 rr->rrsig.signature_size = sizeof(signature);
3752 rr->rrsig.signature = memdup(signature, rr->rrsig.signature_size);
3753
3754 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
3755 dns_resource_record_unref(rr);
3756 }
3757
3758 TEST(packet_reply_rrsig_no_compression) {
3759 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3760
3761 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3762 ASSERT_NOT_NULL(packet);
3763 dns_packet_truncate(packet, 0);
3764
3765 const uint8_t data[] = {
3766 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3767 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
3768
3769 /* name */ 0x03, 'w', 'w', 'w',
3770 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
3771 0x03, 'c', 'o', 'm',
3772 0x00,
3773 /* A */ 0x00, 0x01,
3774 /* IN */ 0x00, 0x01,
3775 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
3776 /* rdata */ 0x00, 0x04,
3777 /* ip */ 0xc0, 0xa8, 0x01, 0x7f,
3778
3779 /* name */ 0xc0, 0x0c,
3780 /* RRSIG */ 0x00, 0x2e,
3781 /* IN */ 0x00, 0x01,
3782 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
3783 /* rdata */ 0x00, 0x1c,
3784 /* type */ 0x00, 0x01,
3785 /* algo */ 0x04,
3786 /* labels */ 0x03,
3787 /* orig ttl */ 0x00, 0x00, 0x0e, 0x10,
3788 /* expiry */ 0x66, 0x8a, 0xa1, 0x57,
3789 /* inception */ 0x66, 0x63, 0x14, 0x57,
3790 /* key tag */ 0x12, 0x34,
3791 /* signer */ 0xc0, 0x10,
3792 /* signature */ 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
3793 };
3794
3795 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3796
3797 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
3798 ASSERT_EQ(dns_question_size(packet->question), 0u);
3799 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
3800 }
3801
3802 TEST(packet_reply_rrsig_signature_underflow) {
3803 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3804
3805 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3806 ASSERT_NOT_NULL(packet);
3807 dns_packet_truncate(packet, 0);
3808
3809 const uint8_t data[] = {
3810 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3811 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
3812
3813 /* name */ 0x03, 'w', 'w', 'w',
3814 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
3815 0x03, 'c', 'o', 'm',
3816 0x00,
3817 /* A */ 0x00, 0x01,
3818 /* IN */ 0x00, 0x01,
3819 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
3820 /* rdata */ 0x00, 0x04,
3821 /* ip */ 0xc0, 0xa8, 0x01, 0x7f,
3822
3823 /* name */ 0xc0, 0x0c,
3824 /* RRSIG */ 0x00, 0x2e,
3825 /* IN */ 0x00, 0x01,
3826 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
3827 /* rdata */ 0x00, 0x28,
3828 /* type */ 0x00, 0x01,
3829 /* algo */ 0x04,
3830 /* labels */ 0x03,
3831 /* orig ttl */ 0x00, 0x00, 0x0e, 0x10,
3832 /* expiry */ 0x66, 0x8a, 0xa1, 0x57,
3833 /* inception */ 0x66, 0x63, 0x14, 0x57,
3834 /* key tag */ 0x12, 0x34,
3835 /* signer */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
3836 0x03, 'c', 'o', 'm',
3837 0x00,
3838 /* signature */ 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
3839 };
3840
3841 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3842
3843 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
3844 ASSERT_EQ(dns_question_size(packet->question), 0u);
3845 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
3846 }
3847
3848 TEST(packet_reply_rrsig_signer_overflow) {
3849 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3850
3851 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3852 ASSERT_NOT_NULL(packet);
3853 dns_packet_truncate(packet, 0);
3854
3855 const uint8_t data[] = {
3856 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3857 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
3858
3859 /* name */ 0x03, 'w', 'w', 'w',
3860 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
3861 0x03, 'c', 'o', 'm',
3862 0x00,
3863 /* A */ 0x00, 0x01,
3864 /* IN */ 0x00, 0x01,
3865 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
3866 /* rdata */ 0x00, 0x04,
3867 /* ip */ 0xc0, 0xa8, 0x01, 0x7f,
3868
3869 /* name */ 0xc0, 0x0c,
3870 /* RRSIG */ 0x00, 0x2e,
3871 /* IN */ 0x00, 0x01,
3872 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
3873 /* rdata */ 0x00, 0x1e,
3874 /* type */ 0x00, 0x01,
3875 /* algo */ 0x04,
3876 /* labels */ 0x03,
3877 /* orig ttl */ 0x00, 0x00, 0x0e, 0x10,
3878 /* expiry */ 0x66, 0x8a, 0xa1, 0x57,
3879 /* inception */ 0x66, 0x63, 0x14, 0x57,
3880 /* key tag */ 0x12, 0x34,
3881 /* signer */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
3882 0x03, 'c', 'o', 'm',
3883 0x00,
3884 /* signature */ 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
3885 };
3886
3887 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3888
3889 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
3890 ASSERT_EQ(dns_question_size(packet->question), 0u);
3891 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
3892 }
3893
3894 /* ================================================================
3895 * reply: SVCB/HTTPS
3896 * ================================================================ */
3897
3898 static DnsSvcParam* add_svcb_param(DnsResourceRecord *rr, uint16_t key, const char *value, size_t len) {
3899 DnsSvcParam *param = calloc(1, offsetof(DnsSvcParam, value) + len);
3900 ASSERT_NOT_NULL(param);
3901
3902 param->key = key;
3903 param->length = len;
3904
3905 if (value)
3906 memcpy(param->value, value, len);
3907
3908 LIST_APPEND(params, rr->svcb.params, param);
3909 return param;
3910 }
3911
3912 TEST(packet_reply_svcb_alias_mode) {
3913 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3914 DnsResourceRecord *rr = NULL;
3915
3916 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3917 ASSERT_NOT_NULL(packet);
3918 dns_packet_truncate(packet, 0);
3919
3920 const uint8_t data[] = {
3921 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3922 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3923
3924 /* name */ 0x04, '_', '4', '4', '3',
3925 0x04, '_', 'w', 's', 's',
3926 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
3927 0x03, 'c', 'o', 'm',
3928 0x00,
3929 /* SVCB */ 0x00, 0x40,
3930 /* IN */ 0x00, 0x01,
3931 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
3932 /* rdata */ 0x00, 0x14,
3933 /* priority */ 0x00, 0x00,
3934 /* target */ 0x04, 's', 'o', 'c', 'k',
3935 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
3936 0x03, 'c', 'o', 'm',
3937 0x00
3938 };
3939
3940 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3941
3942 ASSERT_OK(dns_packet_extract(packet));
3943 ASSERT_EQ(dns_question_size(packet->question), 0u);
3944 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
3945
3946 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SVCB, "_443._wss.example.com");
3947 ASSERT_NOT_NULL(rr);
3948 rr->ttl = 3600;
3949 rr->svcb.priority = 0;
3950 rr->svcb.target_name = strdup("sock.example.com");
3951
3952 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ADDITIONAL);
3953 dns_resource_record_unref(rr);
3954 }
3955
3956 TEST(packet_reply_svcb_compressed_target) {
3957 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3958
3959 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3960 ASSERT_NOT_NULL(packet);
3961 dns_packet_truncate(packet, 0);
3962
3963 const uint8_t data[] = {
3964 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
3965 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
3966
3967 /* name */ 0x04, '_', '4', '4', '3',
3968 0x04, '_', 'w', 's', 's',
3969 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
3970 0x03, 'c', 'o', 'm',
3971 0x00,
3972 /* SVCB */ 0x00, 0x40,
3973 /* IN */ 0x00, 0x01,
3974 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
3975 /* rdata */ 0x00, 0x09,
3976 /* priority */ 0x00, 0x00,
3977 /* target */ 0x04, 's', 'o', 'c', 'k',
3978 0xc0, 0x16
3979 };
3980
3981 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
3982
3983 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
3984 ASSERT_EQ(dns_question_size(packet->question), 0u);
3985 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
3986 }
3987
3988 /* RFC 9460 says that alias-mode RRs SHOULD NOT have the same owner and target.
3989 * We accept this when parsing messages. */
3990
3991 TEST(packet_reply_svcb_alias_mode_same_owner_and_target) {
3992 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
3993 DnsResourceRecord *rr = NULL;
3994
3995 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
3996 ASSERT_NOT_NULL(packet);
3997 dns_packet_truncate(packet, 0);
3998
3999 const uint8_t data[] = {
4000 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4001 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4002
4003 /* name */ 0x04, 's', 'o', 'c', 'k',
4004 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4005 0x03, 'c', 'o', 'm',
4006 0x00,
4007 /* SVCB */ 0x00, 0x40,
4008 /* IN */ 0x00, 0x01,
4009 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4010 /* rdata */ 0x00, 0x14,
4011 /* priority */ 0x00, 0x00,
4012 /* target */ 0x04, 's', 'o', 'c', 'k',
4013 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4014 0x03, 'c', 'o', 'm',
4015 0x00
4016 };
4017
4018 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4019
4020 ASSERT_OK(dns_packet_extract(packet));
4021 ASSERT_EQ(dns_question_size(packet->question), 0u);
4022 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
4023
4024 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SVCB, "sock.example.com");
4025 ASSERT_NOT_NULL(rr);
4026 rr->ttl = 3600;
4027 rr->svcb.priority = 0;
4028 rr->svcb.target_name = strdup("sock.example.com");
4029
4030 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ADDITIONAL);
4031 dns_resource_record_unref(rr);
4032 }
4033
4034 /* RFC 9460 says that recipients MUST ignore any params presented in alias mode RRs. We parse them out of the
4035 * message and their handling is down to further business logic, rather than rejecting such RRs in the
4036 * parser. */
4037
4038 TEST(packet_reply_svcb_alias_mode_with_param) {
4039 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4040 DnsResourceRecord *rr = NULL;
4041
4042 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4043 ASSERT_NOT_NULL(packet);
4044 dns_packet_truncate(packet, 0);
4045
4046 const uint8_t data[] = {
4047 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4048 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4049
4050 /* name */ 0x04, '_', '4', '4', '3',
4051 0x04, '_', 'w', 's', 's',
4052 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4053 0x03, 'c', 'o', 'm',
4054 0x00,
4055 /* SVCB */ 0x00, 0x40,
4056 /* IN */ 0x00, 0x01,
4057 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4058 /* rdata */ 0x00, 0x18,
4059 /* priority */ 0x00, 0x00,
4060 /* target */ 0x04, 's', 'o', 'c', 'k',
4061 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4062 0x03, 'c', 'o', 'm',
4063 0x00,
4064 /* no-deflt */ 0x00, 0x02,
4065 0x00, 0x00,
4066 };
4067
4068 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4069
4070 ASSERT_OK(dns_packet_extract(packet));
4071 ASSERT_EQ(dns_question_size(packet->question), 0u);
4072 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
4073
4074 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SVCB, "_443._wss.example.com");
4075 ASSERT_NOT_NULL(rr);
4076 rr->ttl = 3600;
4077 rr->svcb.priority = 0;
4078 rr->svcb.target_name = strdup("sock.example.com");
4079
4080 add_svcb_param(rr, DNS_SVC_PARAM_KEY_NO_DEFAULT_ALPN, NULL, 0);
4081
4082 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ADDITIONAL);
4083 dns_resource_record_unref(rr);
4084 }
4085
4086 TEST(packet_reply_svcb_service_mode) {
4087 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4088 DnsResourceRecord *rr = NULL;
4089 DnsSvcParam *param = NULL;
4090
4091 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4092 ASSERT_NOT_NULL(packet);
4093 dns_packet_truncate(packet, 0);
4094
4095 const uint8_t data[] = {
4096 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4097 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4098
4099 /* name */ 0x04, '_', '4', '4', '3',
4100 0x04, '_', 'w', 's', 's',
4101 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4102 0x03, 'c', 'o', 'm',
4103 0x00,
4104 /* SVCB */ 0x00, 0x40,
4105 /* IN */ 0x00, 0x01,
4106 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4107 /* rdata */ 0x00, 0x54,
4108 /* priority */ 0x00, 0x02,
4109 /* target */ 0x04, 's', 'o', 'c', 'k',
4110 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4111 0x03, 'c', 'o', 'm',
4112 0x00,
4113 /* mandatory */ 0x00, 0x00,
4114 0x00, 0x04,
4115 0x00, 0x01, 0x00, 0x03,
4116 /* alpn */ 0x00, 0x01,
4117 0x00, 0x0a,
4118 0x09, 'w', 'e', 'b', 's', 'o', 'c', 'k', 'e', 't',
4119 /* no-deflt */ 0x00, 0x02,
4120 0x00, 0x00,
4121 /* port */ 0x00, 0x03,
4122 0x00, 0x02,
4123 0x01, 0xbb,
4124 /* ipv4hint */ 0x00, 0x04,
4125 0x00, 0x08,
4126 0x72, 0x84, 0xfd, 0x3a,
4127 0x48, 0xbc, 0xc7, 0xc0,
4128 /* ipv6hint */ 0x00, 0x06,
4129 0x00, 0x10,
4130 0xf2, 0x34, 0x32, 0x2e, 0xb8, 0x25, 0x38, 0x35,
4131 0x2f, 0xd7, 0xdb, 0x7b, 0x28, 0x7e, 0x60, 0xbb
4132 };
4133
4134 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4135
4136 ASSERT_OK(dns_packet_extract(packet));
4137 ASSERT_EQ(dns_question_size(packet->question), 0u);
4138 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
4139
4140 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SVCB, "_443._wss.example.com");
4141 ASSERT_NOT_NULL(rr);
4142 rr->ttl = 3600;
4143 rr->svcb.priority = 2;
4144 rr->svcb.target_name = strdup("sock.example.com");
4145
4146 add_svcb_param(rr, DNS_SVC_PARAM_KEY_MANDATORY, "\x00\x01\x00\x03", 4);
4147 add_svcb_param(rr, DNS_SVC_PARAM_KEY_ALPN, "\x09websocket", 10);
4148 add_svcb_param(rr, DNS_SVC_PARAM_KEY_NO_DEFAULT_ALPN, "", 0);
4149 add_svcb_param(rr, DNS_SVC_PARAM_KEY_PORT, "\x01\xbb", 2);
4150
4151 param = add_svcb_param(rr, DNS_SVC_PARAM_KEY_IPV4HINT, NULL, 2 * sizeof(struct in_addr));
4152 param->value_in_addr[0].s_addr = htobe32(0x7284fd3a);
4153 param->value_in_addr[1].s_addr = htobe32(0x48bcc7c0);
4154
4155 param = add_svcb_param(rr, DNS_SVC_PARAM_KEY_IPV6HINT, NULL, sizeof(struct in6_addr));
4156 param->value_in6_addr[0] = (struct in6_addr) { .s6_addr = { 0xf2, 0x34, 0x32, 0x2e, 0xb8, 0x25, 0x38, 0x35, 0x2f, 0xd7, 0xdb, 0x7b, 0x28, 0x7e, 0x60, 0xbb } };
4157
4158 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ADDITIONAL);
4159 dns_resource_record_unref(rr);
4160 }
4161
4162 /* RFC 9460 says that clients MUST ignore any param keys that they do not recognise. We allow such keys to be
4163 * parsed; handling of them is down to later business logic. */
4164
4165 TEST(packet_reply_svcb_service_mode_unknown_param) {
4166 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4167 DnsResourceRecord *rr = NULL;
4168
4169 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4170 ASSERT_NOT_NULL(packet);
4171 dns_packet_truncate(packet, 0);
4172
4173 const uint8_t data[] = {
4174 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4175 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4176
4177 /* name */ 0x04, '_', '4', '4', '3',
4178 0x04, '_', 'w', 's', 's',
4179 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4180 0x03, 'c', 'o', 'm',
4181 0x00,
4182 /* HTTPS */ 0x00, 0x41,
4183 /* IN */ 0x00, 0x01,
4184 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4185 /* rdata */ 0x00, 0x18,
4186 /* priority */ 0x00, 0x02,
4187 /* target */ 0x04, 's', 'o', 'c', 'k',
4188 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4189 0x03, 'c', 'o', 'm',
4190 0x00,
4191 /* unknown */ 0x00, 0x99,
4192 0x00, 0x00
4193 };
4194
4195 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4196
4197 ASSERT_OK(dns_packet_extract(packet));
4198 ASSERT_EQ(dns_question_size(packet->question), 0u);
4199 ASSERT_EQ(dns_answer_size(packet->answer), 1u);
4200
4201 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_HTTPS, "_443._wss.example.com");
4202 ASSERT_NOT_NULL(rr);
4203 rr->ttl = 3600;
4204 rr->svcb.priority = 2;
4205 rr->svcb.target_name = strdup("sock.example.com");
4206
4207 add_svcb_param(rr, 153, NULL, 0);
4208
4209 check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ADDITIONAL);
4210 dns_resource_record_unref(rr);
4211 }
4212
4213 TEST(packet_reply_svcb_service_mode_duplicate_key) {
4214 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4215
4216 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4217 ASSERT_NOT_NULL(packet);
4218 dns_packet_truncate(packet, 0);
4219
4220 const uint8_t data[] = {
4221 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4222 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4223
4224 /* name */ 0x04, '_', '4', '4', '3',
4225 0x04, '_', 'w', 's', 's',
4226 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4227 0x03, 'c', 'o', 'm',
4228 0x00,
4229 /* SVCB */ 0x00, 0x40,
4230 /* IN */ 0x00, 0x01,
4231 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4232 /* rdata */ 0x00, 0x20,
4233 /* priority */ 0x00, 0x02,
4234 /* target */ 0x04, 's', 'o', 'c', 'k',
4235 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4236 0x03, 'c', 'o', 'm',
4237 0x00,
4238 /* port */ 0x00, 0x03,
4239 0x00, 0x02,
4240 0x01, 0xbb,
4241 /* port */ 0x00, 0x03,
4242 0x00, 0x02,
4243 0x01, 0xbc,
4244 };
4245
4246 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4247
4248 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
4249 ASSERT_EQ(dns_question_size(packet->question), 0u);
4250 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
4251 }
4252
4253 TEST(packet_reply_svcb_service_mode_key_bad_order) {
4254 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4255
4256 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4257 ASSERT_NOT_NULL(packet);
4258 dns_packet_truncate(packet, 0);
4259
4260 const uint8_t data[] = {
4261 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4262 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4263
4264 /* name */ 0x04, '_', '4', '4', '3',
4265 0x04, '_', 'w', 's', 's',
4266 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4267 0x03, 'c', 'o', 'm',
4268 0x00,
4269 /* SVCB */ 0x00, 0x40,
4270 /* IN */ 0x00, 0x01,
4271 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4272 /* rdata */ 0x00, 0x1e,
4273 /* priority */ 0x00, 0x02,
4274 /* target */ 0x04, 's', 'o', 'c', 'k',
4275 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4276 0x03, 'c', 'o', 'm',
4277 0x00,
4278 /* port */ 0x00, 0x03,
4279 0x00, 0x02,
4280 0x01, 0xbb,
4281 /* no-deflt */ 0x00, 0x02,
4282 0x00, 0x00
4283 };
4284
4285 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4286
4287 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
4288 ASSERT_EQ(dns_question_size(packet->question), 0u);
4289 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
4290 }
4291
4292 TEST(packet_reply_svcb_service_mode_alpn_too_long) {
4293 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4294
4295 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4296 ASSERT_NOT_NULL(packet);
4297 dns_packet_truncate(packet, 0);
4298
4299 const uint8_t data[] = {
4300 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4301 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4302
4303 /* name */ 0x04, '_', '4', '4', '3',
4304 0x04, '_', 'w', 's', 's',
4305 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4306 0x03, 'c', 'o', 'm',
4307 0x00,
4308 /* SVCB */ 0x00, 0x40,
4309 /* IN */ 0x00, 0x01,
4310 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4311 /* rdata */ 0x00, 0x20,
4312 /* priority */ 0x00, 0x02,
4313 /* target */ 0x04, 's', 'o', 'c', 'k',
4314 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4315 0x03, 'c', 'o', 'm',
4316 0x00,
4317 /* alpn */ 0x00, 0x01,
4318 0x00, 0x07,
4319 0x04, 'h', 't', 't', 'p',
4320 0x02, 'w', 's'
4321 };
4322
4323 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4324
4325 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
4326 ASSERT_EQ(dns_question_size(packet->question), 0u);
4327 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
4328 }
4329
4330 TEST(packet_reply_svcb_service_mode_alpn_too_short) {
4331 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4332
4333 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4334 ASSERT_NOT_NULL(packet);
4335 dns_packet_truncate(packet, 0);
4336
4337 const uint8_t data[] = {
4338 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4339 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4340
4341 /* name */ 0x04, '_', '4', '4', '3',
4342 0x04, '_', 'w', 's', 's',
4343 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4344 0x03, 'c', 'o', 'm',
4345 0x00,
4346 /* SVCB */ 0x00, 0x40,
4347 /* IN */ 0x00, 0x01,
4348 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4349 /* rdata */ 0x00, 0x20,
4350 /* priority */ 0x00, 0x02,
4351 /* target */ 0x04, 's', 'o', 'c', 'k',
4352 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4353 0x03, 'c', 'o', 'm',
4354 0x00,
4355 /* alpn */ 0x00, 0x01,
4356 0x00, 0x09,
4357 0x04, 'h', 't', 't', 'p',
4358 0x02, 'w', 's'
4359 };
4360
4361 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4362
4363 ASSERT_ERROR(dns_packet_extract(packet), EMSGSIZE);
4364 ASSERT_EQ(dns_question_size(packet->question), 0u);
4365 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
4366 }
4367
4368 TEST(packet_reply_svcb_service_mode_valid_alpn_overflows_rdata) {
4369 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4370
4371 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4372 ASSERT_NOT_NULL(packet);
4373 dns_packet_truncate(packet, 0);
4374
4375 const uint8_t data[] = {
4376 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4377 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4378
4379 /* name */ 0x04, '_', '4', '4', '3',
4380 0x04, '_', 'w', 's', 's',
4381 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4382 0x03, 'c', 'o', 'm',
4383 0x00,
4384 /* SVCB */ 0x00, 0x40,
4385 /* IN */ 0x00, 0x01,
4386 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4387 /* rdata */ 0x00, 0x1f,
4388 /* priority */ 0x00, 0x02,
4389 /* target */ 0x04, 's', 'o', 'c', 'k',
4390 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4391 0x03, 'c', 'o', 'm',
4392 0x00,
4393 /* alpn */ 0x00, 0x01,
4394 0x00, 0x08,
4395 0x04, 'h', 't', 't', 'p',
4396 0x02, 'w', 's'
4397 };
4398
4399 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4400
4401 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
4402 ASSERT_EQ(dns_question_size(packet->question), 0u);
4403 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
4404 }
4405
4406 TEST(packet_reply_svcb_service_mode_valid_alpn_and_port_overflows_rdata) {
4407 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4408
4409 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4410 ASSERT_NOT_NULL(packet);
4411 dns_packet_truncate(packet, 0);
4412
4413 const uint8_t data[] = {
4414 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4415 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4416
4417 /* name */ 0x04, '_', '4', '4', '3',
4418 0x04, '_', 'w', 's', 's',
4419 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4420 0x03, 'c', 'o', 'm',
4421 0x00,
4422 /* SVCB */ 0x00, 0x40,
4423 /* IN */ 0x00, 0x01,
4424 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4425 /* rdata */ 0x00, 0x25,
4426 /* priority */ 0x00, 0x02,
4427 /* target */ 0x04, 's', 'o', 'c', 'k',
4428 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4429 0x03, 'c', 'o', 'm',
4430 0x00,
4431 /* alpn */ 0x00, 0x01,
4432 0x00, 0x08,
4433 0x04, 'h', 't', 't', 'p',
4434 0x02, 'w', 's',
4435 /* port */ 0x00, 0x03,
4436 0x00, 0x02,
4437 0x01, 0xbb
4438 };
4439
4440 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4441
4442 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
4443 ASSERT_EQ(dns_question_size(packet->question), 0u);
4444 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
4445 }
4446
4447 TEST(packet_reply_svcb_service_mode_bad_no_default_alpn) {
4448 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4449
4450 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4451 ASSERT_NOT_NULL(packet);
4452 dns_packet_truncate(packet, 0);
4453
4454 const uint8_t data[] = {
4455 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4456 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4457
4458 /* name */ 0x04, '_', '4', '4', '3',
4459 0x04, '_', 'w', 's', 's',
4460 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4461 0x03, 'c', 'o', 'm',
4462 0x00,
4463 /* SVCB */ 0x00, 0x40,
4464 /* IN */ 0x00, 0x01,
4465 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4466 /* rdata */ 0x00, 0x19,
4467 /* priority */ 0x00, 0x02,
4468 /* target */ 0x04, 's', 'o', 'c', 'k',
4469 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4470 0x03, 'c', 'o', 'm',
4471 0x00,
4472 /* no-deflt */ 0x00, 0x02,
4473 0x00, 0x01,
4474 0x0a
4475 };
4476
4477 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4478
4479 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
4480 ASSERT_EQ(dns_question_size(packet->question), 0u);
4481 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
4482 }
4483
4484 TEST(packet_reply_svcb_service_mode_port_too_long) {
4485 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4486
4487 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4488 ASSERT_NOT_NULL(packet);
4489 dns_packet_truncate(packet, 0);
4490
4491 const uint8_t data[] = {
4492 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4493 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4494
4495 /* name */ 0x04, '_', '4', '4', '3',
4496 0x04, '_', 'w', 's', 's',
4497 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4498 0x03, 'c', 'o', 'm',
4499 0x00,
4500 /* SVCB */ 0x00, 0x40,
4501 /* IN */ 0x00, 0x01,
4502 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4503 /* rdata */ 0x00, 0x1b,
4504 /* priority */ 0x00, 0x02,
4505 /* target */ 0x04, 's', 'o', 'c', 'k',
4506 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4507 0x03, 'c', 'o', 'm',
4508 0x00,
4509 /* port */ 0x00, 0x03,
4510 0x00, 0x03,
4511 0x01, 0xbb, 0xff
4512 };
4513
4514 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4515
4516 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
4517 ASSERT_EQ(dns_question_size(packet->question), 0u);
4518 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
4519 }
4520
4521 TEST(packet_reply_svcb_service_mode_port_too_short) {
4522 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4523
4524 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4525 ASSERT_NOT_NULL(packet);
4526 dns_packet_truncate(packet, 0);
4527
4528 const uint8_t data[] = {
4529 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4530 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4531
4532 /* name */ 0x04, '_', '4', '4', '3',
4533 0x04, '_', 'w', 's', 's',
4534 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4535 0x03, 'c', 'o', 'm',
4536 0x00,
4537 /* SVCB */ 0x00, 0x40,
4538 /* IN */ 0x00, 0x01,
4539 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4540 /* rdata */ 0x00, 0x19,
4541 /* priority */ 0x00, 0x02,
4542 /* target */ 0x04, 's', 'o', 'c', 'k',
4543 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4544 0x03, 'c', 'o', 'm',
4545 0x00,
4546 /* port */ 0x00, 0x03,
4547 0x00, 0x01,
4548 0xbb
4549 };
4550
4551 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4552
4553 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
4554 ASSERT_EQ(dns_question_size(packet->question), 0u);
4555 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
4556 }
4557
4558 TEST(packet_reply_svcb_service_mode_bad_ipv4hint) {
4559 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4560
4561 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4562 ASSERT_NOT_NULL(packet);
4563 dns_packet_truncate(packet, 0);
4564
4565 const uint8_t data[] = {
4566 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4567 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4568
4569 /* name */ 0x04, '_', '4', '4', '3',
4570 0x04, '_', 'w', 's', 's',
4571 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4572 0x03, 'c', 'o', 'm',
4573 0x00,
4574 /* SVCB */ 0x00, 0x40,
4575 /* IN */ 0x00, 0x01,
4576 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4577 /* rdata */ 0x00, 0x1b,
4578 /* priority */ 0x00, 0x02,
4579 /* target */ 0x04, 's', 'o', 'c', 'k',
4580 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4581 0x03, 'c', 'o', 'm',
4582 0x00,
4583 /* ipv4hint */ 0x00, 0x04,
4584 0x00, 0x03,
4585 0x2f, 0x47, 0x34
4586 };
4587
4588 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4589
4590 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
4591 ASSERT_EQ(dns_question_size(packet->question), 0u);
4592 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
4593 }
4594
4595 TEST(packet_reply_svcb_service_mode_bad_ipv6hint) {
4596 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4597
4598 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4599 ASSERT_NOT_NULL(packet);
4600 dns_packet_truncate(packet, 0);
4601
4602 const uint8_t data[] = {
4603 0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4604 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
4605
4606 /* name */ 0x04, '_', '4', '4', '3',
4607 0x04, '_', 'w', 's', 's',
4608 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4609 0x03, 'c', 'o', 'm',
4610 0x00,
4611 /* SVCB */ 0x00, 0x40,
4612 /* IN */ 0x00, 0x01,
4613 /* ttl */ 0x00, 0x00, 0x0e, 0x10,
4614 /* rdata */ 0x00, 0x27,
4615 /* priority */ 0x00, 0x02,
4616 /* target */ 0x04, 's', 'o', 'c', 'k',
4617 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
4618 0x03, 'c', 'o', 'm',
4619 0x00,
4620 /* ipv6hint */ 0x00, 0x06,
4621 0x00, 0x0f,
4622 0x09, 0x36, 0xba, 0x5d, 0x17, 0x42, 0x47, 0xa2,
4623 0x14, 0xcc, 0x77, 0x67, 0x51, 0x68, 0xef
4624 };
4625
4626 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4627
4628 ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
4629 ASSERT_EQ(dns_question_size(packet->question), 0u);
4630 ASSERT_EQ(dns_answer_size(packet->answer), 0u);
4631 }
4632
4633 /* ================================================================
4634 * dns_packet_equal()
4635 * ================================================================ */
4636
4637 TEST(packet_equal_match) {
4638 _cleanup_(dns_packet_unrefp) DnsPacket *p1 = NULL, *p2 = NULL;
4639
4640 ASSERT_OK(dns_packet_new(&p1, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4641 ASSERT_NOT_NULL(p1);
4642 dns_packet_truncate(p1, 0);
4643
4644 ASSERT_OK(dns_packet_new(&p2, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4645 ASSERT_NOT_NULL(p2);
4646 dns_packet_truncate(p2, 0);
4647
4648 const uint8_t data[] = {
4649 0x00, 0x2a, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4650 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
4651 };
4652
4653 ASSERT_OK(dns_packet_append_blob(p1, data, sizeof(data), NULL));
4654 ASSERT_OK(dns_packet_append_blob(p2, data, sizeof(data), NULL));
4655 ASSERT_TRUE(dns_packet_equal(p1, p2));
4656 }
4657
4658 TEST(packet_equal_no_match) {
4659 _cleanup_(dns_packet_unrefp) DnsPacket *p1 = NULL, *p2 = NULL;
4660
4661 ASSERT_OK(dns_packet_new(&p1, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4662 ASSERT_NOT_NULL(p1);
4663 dns_packet_truncate(p1, 0);
4664
4665 const uint8_t data1[] = {
4666 0x00, 0x2a, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4667 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
4668 };
4669
4670 ASSERT_OK(dns_packet_append_blob(p1, data1, sizeof(data1), NULL));
4671
4672 ASSERT_OK(dns_packet_new(&p2, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4673 ASSERT_NOT_NULL(p2);
4674 dns_packet_truncate(p2, 0);
4675
4676 const uint8_t data2[] = {
4677 0x00, 0x2a, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
4678 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01
4679 };
4680
4681 ASSERT_OK(dns_packet_append_blob(p2, data2, sizeof(data2), NULL));
4682 ASSERT_FALSE(dns_packet_equal(p1, p2));
4683 }
4684
4685 /* ================================================================
4686 * dns_ede_rcode_is_dnssec()
4687 * ================================================================ */
4688
4689 TEST(dns_ede_rcode_is_dnssec) {
4690 ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_UNSUPPORTED_DNSKEY_ALG));
4691 ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_UNSUPPORTED_DS_DIGEST));
4692 ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_DNSSEC_INDETERMINATE));
4693 ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_DNSSEC_BOGUS));
4694 ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_SIG_EXPIRED));
4695 ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_SIG_NOT_YET_VALID));
4696 ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_DNSKEY_MISSING));
4697 ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_RRSIG_MISSING));
4698 ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_NO_ZONE_KEY_BIT));
4699 ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_NSEC_MISSING));
4700
4701 ASSERT_FALSE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_BLOCKED));
4702 ASSERT_FALSE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_CENSORED));
4703 ASSERT_FALSE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_OTHER));
4704 }
4705
4706 /* ================================================================
4707 * format_dns_rcode()
4708 * ================================================================ */
4709
4710 TEST(format_dns_rcode) {
4711 const char *str;
4712
4713 str = FORMAT_DNS_RCODE(DNS_RCODE_SUCCESS);
4714 ASSERT_STREQ(str, "SUCCESS");
4715
4716 str = FORMAT_DNS_RCODE(DNS_RCODE_NXDOMAIN);
4717 ASSERT_STREQ(str, "NXDOMAIN");
4718
4719 str = FORMAT_DNS_RCODE(DNS_RCODE_SERVFAIL);
4720 ASSERT_STREQ(str, "SERVFAIL");
4721
4722 str = FORMAT_DNS_RCODE(DNS_RCODE_REFUSED);
4723 ASSERT_STREQ(str, "REFUSED");
4724
4725 str = FORMAT_DNS_RCODE(DNS_RCODE_BADTIME);
4726 ASSERT_STREQ(str, "BADTIME");
4727 }
4728
4729 /* ================================================================
4730 * format_dns_ede_rcode()
4731 * ================================================================ */
4732
4733 TEST(format_dns_ede_rcode) {
4734 const char *str;
4735
4736 str = FORMAT_DNS_EDE_RCODE(DNS_EDE_RCODE_DNSSEC_BOGUS);
4737 ASSERT_STREQ(str, "DNSSEC Bogus");
4738
4739 str = FORMAT_DNS_EDE_RCODE(DNS_EDE_RCODE_SIG_EXPIRED);
4740 ASSERT_STREQ(str, "Signature Expired");
4741
4742 str = FORMAT_DNS_EDE_RCODE(DNS_EDE_RCODE_CENSORED);
4743 ASSERT_STREQ(str, "Censored");
4744
4745 str = FORMAT_DNS_EDE_RCODE(DNS_EDE_RCODE_OTHER);
4746 ASSERT_STREQ(str, "Other");
4747
4748 str = FORMAT_DNS_EDE_RCODE(DNS_EDE_RCODE_STALE_NXDOMAIN_ANSWER);
4749 ASSERT_STREQ(str, "Stale NXDOMAIN Answer");
4750 }
4751
4752 /* ================================================================
4753 * format_dns_svc_param_key()
4754 * ================================================================ */
4755
4756 TEST(format_dns_svc_param_key) {
4757 const char *str;
4758
4759 str = FORMAT_DNS_SVC_PARAM_KEY(DNS_SVC_PARAM_KEY_ALPN);
4760 ASSERT_STREQ(str, "alpn");
4761
4762 str = FORMAT_DNS_SVC_PARAM_KEY(DNS_SVC_PARAM_KEY_NO_DEFAULT_ALPN);
4763 ASSERT_STREQ(str, "no-default-alpn");
4764
4765 str = FORMAT_DNS_SVC_PARAM_KEY(DNS_SVC_PARAM_KEY_PORT);
4766 ASSERT_STREQ(str, "port");
4767
4768 str = FORMAT_DNS_SVC_PARAM_KEY(DNS_SVC_PARAM_KEY_IPV4HINT);
4769 ASSERT_STREQ(str, "ipv4hint");
4770
4771 str = FORMAT_DNS_SVC_PARAM_KEY(DNS_SVC_PARAM_KEY_OHTTP);
4772 ASSERT_STREQ(str, "ohttp");
4773 }
4774
4775 TEST(overlong_domain) {
4776 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
4777
4778 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4779 ASSERT_NOT_NULL(packet);
4780 dns_packet_truncate(packet, 0);
4781
4782 const uint8_t data[] = {
4783 0x00, 0x42, 0x00, 0x00,
4784 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4785
4786 63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
4787 63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
4788 63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
4789 63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
4790 0x00,
4791 0x00, DNS_TYPE_A,
4792 0x00, DNS_CLASS_IN,
4793 };
4794
4795 ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
4796 ASSERT_OK(dns_packet_validate_query(packet));
4797 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
4798 ASSERT_ERROR(dns_packet_read_key(packet, &key, NULL, NULL), EBADMSG);
4799
4800 const uint8_t data2[] = {
4801 0x00, 0x42, 0x00, 0x00,
4802 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4803
4804 63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
4805 63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
4806 63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
4807 62, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1',
4808 0x00,
4809 0x00, DNS_TYPE_A,
4810 0x00, DNS_CLASS_IN,
4811 };
4812
4813 packet = dns_packet_unref(packet);
4814 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4815 ASSERT_NOT_NULL(packet);
4816 dns_packet_truncate(packet, 0);
4817 ASSERT_OK(dns_packet_append_blob(packet, data2, sizeof(data2), NULL));
4818 ASSERT_OK(dns_packet_validate_query(packet));
4819 ASSERT_ERROR(dns_packet_read_key(packet, &key, NULL, NULL), EBADMSG);
4820
4821 const uint8_t data3[] = {
4822 0x00, 0x42, 0x00, 0x00,
4823 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4824
4825 63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
4826 63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
4827 63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
4828 61, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
4829 0x00,
4830 0x00, DNS_TYPE_A,
4831 0x00, DNS_CLASS_IN,
4832 };
4833
4834 packet = dns_packet_unref(packet);
4835 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
4836 ASSERT_NOT_NULL(packet);
4837 dns_packet_truncate(packet, 0);
4838 ASSERT_OK(dns_packet_append_blob(packet, data3, sizeof(data3), NULL));
4839 ASSERT_OK(dns_packet_validate_query(packet));
4840 ASSERT_OK(dns_packet_read_key(packet, &key, NULL, NULL));
4841
4842 ASSERT_STREQ(dns_resource_key_name(key),
4843 "012345678901234567890123456789012345678901234567890123456789012."
4844 "012345678901234567890123456789012345678901234567890123456789012."
4845 "012345678901234567890123456789012345678901234567890123456789012."
4846 "0123456789012345678901234567890123456789012345678901234567890");
4847 }
4848
4849 DEFINE_TEST_MAIN(LOG_DEBUG)