| 1 |
/* SPDX-License-Identifier: LGPL-2.1-or-later */ |
| 2 |
|
| 3 |
#include "sd-daemon.h" |
| 4 |
#include "sd-event.h" |
| 5 |
|
| 6 |
#include "dns-packet.h" |
| 7 |
#include "dns-question.h" |
| 8 |
#include "dns-type.h" |
| 9 |
#include "errno-util.h" |
| 10 |
#include "fd-util.h" |
| 11 |
#include "iovec-util.h" |
| 12 |
#include "log.h" |
| 13 |
#include "main-func.h" |
| 14 |
#include "resolved-manager.h" |
| 15 |
#include "socket-netlink.h" |
| 16 |
#include "socket-util.h" |
| 17 |
#include "string-util.h" |
| 18 |
#include "time-util.h" |
| 19 |
|
| 20 |
/* Taken from resolved-dns-stub.c */ |
| 21 |
#define ADVERTISE_DATAGRAM_SIZE_MAX (65536U-14U-20U-8U) |
| 22 |
|
| 23 |
/* This is more or less verbatim manager_recv() from resolved-manager.c, sans the manager stuff */ |
| 24 |
static int server_recv(int fd, DnsPacket **ret) { |
| 25 |
_cleanup_(dns_packet_unrefp) DnsPacket *p = NULL; |
| 26 |
CMSG_BUFFER_TYPE(CMSG_SPACE(MAXSIZE(struct in_pktinfo, struct in6_pktinfo)) |
| 27 |
+ CMSG_SPACE(int) /* ttl/hoplimit */ |
| 28 |
+ EXTRA_CMSG_SPACE /* kernel appears to require extra buffer space */) control; |
| 29 |
union sockaddr_union sa; |
| 30 |
struct iovec iov; |
| 31 |
struct msghdr mh = { |
| 32 |
.msg_name = &sa.sa, |
| 33 |
.msg_namelen = sizeof(sa), |
| 34 |
.msg_iov = &iov, |
| 35 |
.msg_iovlen = 1, |
| 36 |
.msg_control = &control, |
| 37 |
.msg_controllen = sizeof(control), |
| 38 |
}; |
| 39 |
struct cmsghdr *cmsg; |
| 40 |
ssize_t ms, l; |
| 41 |
int r; |
| 42 |
|
| 43 |
assert(fd >= 0); |
| 44 |
assert(ret); |
| 45 |
|
| 46 |
ms = next_datagram_size_fd(fd); |
| 47 |
if (ms < 0) |
| 48 |
return ms; |
| 49 |
|
| 50 |
r = dns_packet_new(&p, DNS_PROTOCOL_DNS, ms, DNS_PACKET_SIZE_MAX); |
| 51 |
if (r < 0) |
| 52 |
return r; |
| 53 |
|
| 54 |
iov = IOVEC_MAKE(DNS_PACKET_DATA(p), p->allocated); |
| 55 |
|
| 56 |
l = recvmsg_safe(fd, &mh, 0); |
| 57 |
if (ERRNO_IS_NEG_TRANSIENT(l)) |
| 58 |
return 0; |
| 59 |
if (l <= 0) |
| 60 |
return l; |
| 61 |
|
| 62 |
p->size = (size_t) l; |
| 63 |
|
| 64 |
p->family = sa.sa.sa_family; |
| 65 |
p->ipproto = IPPROTO_UDP; |
| 66 |
if (p->family == AF_INET) { |
| 67 |
p->sender.in = sa.in.sin_addr; |
| 68 |
p->sender_port = be16toh(sa.in.sin_port); |
| 69 |
} else if (p->family == AF_INET6) { |
| 70 |
p->sender.in6 = sa.in6.sin6_addr; |
| 71 |
p->sender_port = be16toh(sa.in6.sin6_port); |
| 72 |
p->ifindex = sa.in6.sin6_scope_id; |
| 73 |
} else |
| 74 |
return -EAFNOSUPPORT; |
| 75 |
|
| 76 |
p->timestamp = now(CLOCK_BOOTTIME); |
| 77 |
|
| 78 |
CMSG_FOREACH(cmsg, &mh) { |
| 79 |
|
| 80 |
if (cmsg->cmsg_level == IPPROTO_IPV6) { |
| 81 |
assert(p->family == AF_INET6); |
| 82 |
|
| 83 |
switch (cmsg->cmsg_type) { |
| 84 |
|
| 85 |
case IPV6_PKTINFO: { |
| 86 |
struct in6_pktinfo *i = CMSG_TYPED_DATA(cmsg, struct in6_pktinfo); |
| 87 |
|
| 88 |
if (p->ifindex <= 0) |
| 89 |
p->ifindex = i->ipi6_ifindex; |
| 90 |
|
| 91 |
p->destination.in6 = i->ipi6_addr; |
| 92 |
break; |
| 93 |
} |
| 94 |
|
| 95 |
case IPV6_HOPLIMIT: |
| 96 |
p->ttl = *CMSG_TYPED_DATA(cmsg, int); |
| 97 |
break; |
| 98 |
|
| 99 |
case IPV6_RECVFRAGSIZE: |
| 100 |
p->fragsize = *CMSG_TYPED_DATA(cmsg, int); |
| 101 |
break; |
| 102 |
} |
| 103 |
} else if (cmsg->cmsg_level == IPPROTO_IP) { |
| 104 |
assert(p->family == AF_INET); |
| 105 |
|
| 106 |
switch (cmsg->cmsg_type) { |
| 107 |
|
| 108 |
case IP_PKTINFO: { |
| 109 |
struct in_pktinfo *i = CMSG_TYPED_DATA(cmsg, struct in_pktinfo); |
| 110 |
|
| 111 |
if (p->ifindex <= 0) |
| 112 |
p->ifindex = i->ipi_ifindex; |
| 113 |
|
| 114 |
p->destination.in = i->ipi_addr; |
| 115 |
break; |
| 116 |
} |
| 117 |
|
| 118 |
case IP_TTL: |
| 119 |
p->ttl = *CMSG_TYPED_DATA(cmsg, int); |
| 120 |
break; |
| 121 |
|
| 122 |
case IP_RECVFRAGSIZE: |
| 123 |
p->fragsize = *CMSG_TYPED_DATA(cmsg, int); |
| 124 |
break; |
| 125 |
} |
| 126 |
} |
| 127 |
} |
| 128 |
|
| 129 |
/* The Linux kernel sets the interface index to the loopback |
| 130 |
* device if the packet came from the local host since it |
| 131 |
* avoids the routing table in such a case. Let's unset the |
| 132 |
* interface index in such a case. */ |
| 133 |
if (p->ifindex == LOOPBACK_IFINDEX) |
| 134 |
p->ifindex = 0; |
| 135 |
|
| 136 |
log_debug("Received DNS UDP packet of size %zu, ifindex=%i, ttl=%u, fragsize=%zu, sender=%s, destination=%s", |
| 137 |
p->size, p->ifindex, p->ttl, p->fragsize, |
| 138 |
IN_ADDR_TO_STRING(p->family, &p->sender), |
| 139 |
IN_ADDR_TO_STRING(p->family, &p->destination)); |
| 140 |
|
| 141 |
*ret = TAKE_PTR(p); |
| 142 |
return 1; |
| 143 |
} |
| 144 |
|
| 145 |
/* Same as above, see manager_ipv4_send() in resolved-manager.c */ |
| 146 |
static int server_ipv4_send( |
| 147 |
int fd, |
| 148 |
const struct in_addr *destination, |
| 149 |
uint16_t port, |
| 150 |
const struct in_addr *source, |
| 151 |
DnsPacket *packet) { |
| 152 |
|
| 153 |
union sockaddr_union sa; |
| 154 |
struct iovec iov; |
| 155 |
struct msghdr mh = { |
| 156 |
.msg_iov = &iov, |
| 157 |
.msg_iovlen = 1, |
| 158 |
.msg_name = &sa.sa, |
| 159 |
.msg_namelen = sizeof(sa.in), |
| 160 |
}; |
| 161 |
|
| 162 |
assert(fd >= 0); |
| 163 |
assert(destination); |
| 164 |
assert(port > 0); |
| 165 |
assert(packet); |
| 166 |
|
| 167 |
iov = IOVEC_MAKE(DNS_PACKET_DATA(packet), packet->size); |
| 168 |
|
| 169 |
sa = (union sockaddr_union) { |
| 170 |
.in.sin_family = AF_INET, |
| 171 |
.in.sin_addr = *destination, |
| 172 |
.in.sin_port = htobe16(port), |
| 173 |
}; |
| 174 |
|
| 175 |
return sendmsg_loop(fd, &mh, 0); |
| 176 |
} |
| 177 |
|
| 178 |
static int make_reply_packet(DnsPacket *packet, DnsPacket **ret) { |
| 179 |
_cleanup_(dns_packet_unrefp) DnsPacket *p = NULL; |
| 180 |
int r; |
| 181 |
|
| 182 |
assert(packet); |
| 183 |
assert(ret); |
| 184 |
|
| 185 |
r = dns_packet_new(&p, DNS_PROTOCOL_DNS, 0, dns_packet_payload_size_max(packet)); |
| 186 |
if (r < 0) |
| 187 |
return r; |
| 188 |
|
| 189 |
r = dns_packet_append_question(p, packet->question); |
| 190 |
if (r < 0) |
| 191 |
return r; |
| 192 |
|
| 193 |
DNS_PACKET_HEADER(p)->id = DNS_PACKET_ID(packet); |
| 194 |
DNS_PACKET_HEADER(p)->qdcount = htobe16(dns_question_size(packet->question)); |
| 195 |
|
| 196 |
*ret = TAKE_PTR(p); |
| 197 |
return 0; |
| 198 |
} |
| 199 |
|
| 200 |
static int reply_append_edns(DnsPacket *packet, DnsPacket *reply, const char *extra_text, size_t rcode, uint16_t ede_code) { |
| 201 |
size_t saved_size; |
| 202 |
int r; |
| 203 |
|
| 204 |
assert(packet); |
| 205 |
assert(reply); |
| 206 |
|
| 207 |
/* Append EDNS0 stuff (inspired by dns_packet_append_opt() from resolved-dns-packet.c). |
| 208 |
* |
| 209 |
* Relevant headers from RFC 6891: |
| 210 |
* |
| 211 |
* +------------+--------------+------------------------------+ |
| 212 |
* | Field Name | Field Type | Description | |
| 213 |
* +------------+--------------+------------------------------+ |
| 214 |
* | NAME | domain name | MUST be 0 (root domain) | |
| 215 |
* | TYPE | u_int16_t | OPT (41) | |
| 216 |
* | CLASS | u_int16_t | requestor's UDP payload size | |
| 217 |
* | TTL | u_int32_t | extended RCODE and flags | |
| 218 |
* | RDLEN | u_int16_t | length of all RDATA | |
| 219 |
* | RDATA | octet stream | {attribute,value} pairs | |
| 220 |
* +------------+--------------+------------------------------+ |
| 221 |
* |
| 222 |
* +0 (MSB) +1 (LSB) |
| 223 |
* +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ |
| 224 |
* 0: | OPTION-CODE | |
| 225 |
* +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ |
| 226 |
* 2: | OPTION-LENGTH | |
| 227 |
* +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ |
| 228 |
* 4: | | |
| 229 |
* / OPTION-DATA / |
| 230 |
* / / |
| 231 |
* +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ |
| 232 |
* |
| 233 |
* And from RFC 8914: |
| 234 |
* |
| 235 |
* 1 1 1 1 1 1 |
| 236 |
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 |
| 237 |
* +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ |
| 238 |
* 0: | OPTION-CODE | |
| 239 |
* +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ |
| 240 |
* 2: | OPTION-LENGTH | |
| 241 |
* +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ |
| 242 |
* 4: | INFO-CODE | |
| 243 |
* +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ |
| 244 |
* 6: / EXTRA-TEXT ... / |
| 245 |
* +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ |
| 246 |
*/ |
| 247 |
|
| 248 |
saved_size = reply->size; |
| 249 |
|
| 250 |
/* empty name */ |
| 251 |
r = dns_packet_append_uint8(reply, 0, NULL); |
| 252 |
if (r < 0) |
| 253 |
return r; |
| 254 |
|
| 255 |
/* type */ |
| 256 |
r = dns_packet_append_uint16(reply, DNS_TYPE_OPT, NULL); |
| 257 |
if (r < 0) |
| 258 |
return r; |
| 259 |
|
| 260 |
/* class: maximum udp packet that can be received */ |
| 261 |
r = dns_packet_append_uint16(reply, ADVERTISE_DATAGRAM_SIZE_MAX, NULL); |
| 262 |
if (r < 0) |
| 263 |
return r; |
| 264 |
|
| 265 |
/* extended RCODE and VERSION */ |
| 266 |
r = dns_packet_append_uint16(reply, ((uint16_t) rcode & 0x0FF0) << 4, NULL); |
| 267 |
if (r < 0) |
| 268 |
return r; |
| 269 |
|
| 270 |
/* flags: DNSSEC OK (DO), see RFC3225 */ |
| 271 |
r = dns_packet_append_uint16(reply, 0, NULL); |
| 272 |
if (r < 0) |
| 273 |
return r; |
| 274 |
|
| 275 |
/* RDATA */ |
| 276 |
|
| 277 |
size_t extra_text_len = isempty(extra_text) ? 0 : strlen(extra_text); |
| 278 |
/* RDLENGTH (OPTION CODE + OPTION LENGTH + INFO-CODE + EXTRA-TEXT) */ |
| 279 |
r = dns_packet_append_uint16(reply, 2 + 2 + 2 + extra_text_len, NULL); |
| 280 |
if (r < 0) |
| 281 |
return 0; |
| 282 |
|
| 283 |
/* OPTION-CODE: 15 for EDE */ |
| 284 |
r = dns_packet_append_uint16(reply, 15, NULL); |
| 285 |
if (r < 0) |
| 286 |
return r; |
| 287 |
|
| 288 |
/* OPTION-LENGTH: INFO-CODE + EXTRA-TEXT */ |
| 289 |
r = dns_packet_append_uint16(reply, 2 + extra_text_len, NULL); |
| 290 |
if (r < 0) |
| 291 |
return r; |
| 292 |
|
| 293 |
/* INFO-CODE: EDE code */ |
| 294 |
r = dns_packet_append_uint16(reply, ede_code, NULL); |
| 295 |
if (r < 0) |
| 296 |
return r; |
| 297 |
|
| 298 |
/* EXTRA-TEXT */ |
| 299 |
if (extra_text_len > 0) { |
| 300 |
/* From RFC 8914: |
| 301 |
* EDE text may be null terminated but MUST NOT be assumed to be; the length MUST be derived |
| 302 |
* from the OPTION-LENGTH field |
| 303 |
* |
| 304 |
* Let's exercise our code on the receiving side and not NUL-terminate the EXTRA-TEXT field |
| 305 |
*/ |
| 306 |
r = dns_packet_append_blob(reply, extra_text, extra_text_len, NULL); |
| 307 |
if (r < 0) |
| 308 |
return r; |
| 309 |
} |
| 310 |
|
| 311 |
DNS_PACKET_HEADER(reply)->arcount = htobe16(DNS_PACKET_ARCOUNT(reply) + 1); |
| 312 |
reply->opt_start = saved_size; |
| 313 |
reply->opt_size = reply->size - saved_size; |
| 314 |
|
| 315 |
/* Order: qr, opcode, aa, tc, rd, ra, ad, cd, rcode */ |
| 316 |
DNS_PACKET_HEADER(reply)->flags = htobe16(DNS_PACKET_MAKE_FLAGS( |
| 317 |
1, 0, 0, 0, DNS_PACKET_RD(packet), 1, 0, 1, rcode)); |
| 318 |
return 0; |
| 319 |
} |
| 320 |
|
| 321 |
static void server_fail(DnsPacket *packet, DnsPacket *reply, int rcode) { |
| 322 |
assert(reply); |
| 323 |
|
| 324 |
/* Order: qr, opcode, aa, tc, rd, ra, ad, cd, rcode */ |
| 325 |
DNS_PACKET_HEADER(reply)->flags = htobe16(DNS_PACKET_MAKE_FLAGS( |
| 326 |
1, 0, 0, 0, DNS_PACKET_RD(packet), 1, 0, 1, rcode)); |
| 327 |
} |
| 328 |
|
| 329 |
static int server_handle_edns_bogus_dnssec(DnsPacket *packet, DnsPacket *reply) { |
| 330 |
assert(packet); |
| 331 |
assert(reply); |
| 332 |
|
| 333 |
return reply_append_edns(packet, reply, NULL, DNS_RCODE_SERVFAIL, DNS_EDE_RCODE_DNSSEC_BOGUS); |
| 334 |
} |
| 335 |
|
| 336 |
static int server_handle_edns_extra_text(DnsPacket *packet, DnsPacket *reply) { |
| 337 |
assert(packet); |
| 338 |
assert(reply); |
| 339 |
|
| 340 |
return reply_append_edns(packet, reply, "Nothing to see here!", DNS_RCODE_SERVFAIL, DNS_EDE_RCODE_CENSORED); |
| 341 |
} |
| 342 |
|
| 343 |
static int server_handle_edns_invalid_code(DnsPacket *packet, DnsPacket *reply, const char *extra_text) { |
| 344 |
assert(packet); |
| 345 |
assert(reply); |
| 346 |
assert_cc(_DNS_EDE_RCODE_MAX_DEFINED < UINT16_MAX); |
| 347 |
|
| 348 |
return reply_append_edns(packet, reply, extra_text, DNS_RCODE_SERVFAIL, _DNS_EDE_RCODE_MAX_DEFINED + 1); |
| 349 |
} |
| 350 |
|
| 351 |
static int server_handle_edns_code_zero(DnsPacket *packet, DnsPacket *reply) { |
| 352 |
assert(packet); |
| 353 |
assert(reply); |
| 354 |
assert_cc(DNS_EDE_RCODE_OTHER == 0); |
| 355 |
|
| 356 |
return reply_append_edns(packet, reply, "\xF0\x9F\x90\xB1", DNS_RCODE_SERVFAIL, DNS_EDE_RCODE_OTHER); |
| 357 |
} |
| 358 |
|
| 359 |
static int on_dns_packet(sd_event_source *s, int fd, uint32_t revents, void *userdata) { |
| 360 |
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL; |
| 361 |
_cleanup_(dns_packet_unrefp) DnsPacket *reply = NULL; |
| 362 |
const char *name; |
| 363 |
int r; |
| 364 |
|
| 365 |
assert(fd >= 0); |
| 366 |
|
| 367 |
r = server_recv(fd, &packet); |
| 368 |
if (r < 0) { |
| 369 |
log_debug_errno(r, "Failed to receive packet, ignoring: %m"); |
| 370 |
return 0; |
| 371 |
} |
| 372 |
|
| 373 |
r = dns_packet_validate_query(packet); |
| 374 |
if (r < 0) { |
| 375 |
log_debug_errno(r, "Invalid DNS UDP packet, ignoring."); |
| 376 |
return 0; |
| 377 |
} |
| 378 |
|
| 379 |
r = dns_packet_extract(packet); |
| 380 |
if (r < 0) { |
| 381 |
log_debug_errno(r, "Failed to extract DNS packet, ignoring: %m"); |
| 382 |
return 0; |
| 383 |
} |
| 384 |
|
| 385 |
name = dns_question_first_name(packet->question); |
| 386 |
log_info("Processing question for name '%s'", name); |
| 387 |
|
| 388 |
dns_question_dump(packet->question, stdout); |
| 389 |
|
| 390 |
r = make_reply_packet(packet, &reply); |
| 391 |
if (r < 0) { |
| 392 |
log_debug_errno(r, "Failed to make reply packet, ignoring: %m"); |
| 393 |
return 0; |
| 394 |
} |
| 395 |
|
| 396 |
if (streq_ptr(name, "edns-bogus-dnssec.forwarded.test")) |
| 397 |
r = server_handle_edns_bogus_dnssec(packet, reply); |
| 398 |
else if (streq_ptr(name, "edns-extra-text.forwarded.test")) |
| 399 |
r = server_handle_edns_extra_text(packet, reply); |
| 400 |
else if (streq_ptr(name, "edns-invalid-code.forwarded.test")) |
| 401 |
r = server_handle_edns_invalid_code(packet, reply, NULL); |
| 402 |
else if (streq_ptr(name, "edns-invalid-code-with-extra-text.forwarded.test")) |
| 403 |
r = server_handle_edns_invalid_code(packet, reply, "Hello [#]$%~ World"); |
| 404 |
else if (streq_ptr(name, "edns-code-zero.forwarded.test")) |
| 405 |
r = server_handle_edns_code_zero(packet, reply); |
| 406 |
else |
| 407 |
r = log_debug_errno(SYNTHETIC_ERRNO(EFAULT), "Unhandled name '%s', ignoring.", name); |
| 408 |
if (r < 0) |
| 409 |
server_fail(packet, reply, DNS_RCODE_NXDOMAIN); |
| 410 |
|
| 411 |
r = server_ipv4_send(fd, &packet->sender.in, packet->sender_port, &packet->destination.in, reply); |
| 412 |
if (r < 0) |
| 413 |
log_debug_errno(r, "Failed to send reply, ignoring: %m"); |
| 414 |
|
| 415 |
return 0; |
| 416 |
} |
| 417 |
|
| 418 |
static int run(int argc, char *argv[]) { |
| 419 |
_cleanup_(sd_event_unrefp) sd_event *event = NULL; |
| 420 |
_cleanup_close_ int fd = -EBADF; |
| 421 |
int r; |
| 422 |
|
| 423 |
log_setup(); |
| 424 |
|
| 425 |
if (argc != 2) |
| 426 |
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), |
| 427 |
"This program takes one argument in format ip_address:port"); |
| 428 |
|
| 429 |
fd = make_socket_fd(LOG_DEBUG, argv[1], SOCK_DGRAM, SOCK_CLOEXEC); |
| 430 |
if (fd < 0) |
| 431 |
return log_error_errno(fd, "Failed to listen on address '%s': %m", argv[1]); |
| 432 |
|
| 433 |
r = sd_event_default(&event); |
| 434 |
if (r < 0) |
| 435 |
return log_error_errno(r, "Failed to allocate event: %m"); |
| 436 |
|
| 437 |
r = sd_event_add_io(event, NULL, fd, EPOLLIN, on_dns_packet, NULL); |
| 438 |
if (r < 0) |
| 439 |
return log_error_errno(r, "Failed to add IO event source: %m"); |
| 440 |
|
| 441 |
r = sd_event_set_signal_exit(event, true); |
| 442 |
if (r < 0) |
| 443 |
return log_error_errno(r, "Failed to install SIGINT/SIGTERM handlers: %m"); |
| 444 |
|
| 445 |
(void) sd_notify(/* unset_environment=false */ false, "READY=1"); |
| 446 |
|
| 447 |
r = sd_event_loop(event); |
| 448 |
if (r < 0) |
| 449 |
return log_error_errno(r, "Failed to run event loop: %m"); |
| 450 |
|
| 451 |
return 0; |
| 452 |
} |
| 453 |
|
| 454 |
DEFINE_MAIN_FUNCTION(run); |