HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/resolve/test-dns-stub.c

14,754 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: d7b3ee01b497bb4258ab365136d4378495551c36

Lines 1–333 of 333

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include "dns-answer.h"
#include "dns-packet.h"
#include "dns-rr.h"
#include "memory-util.h"
#include "resolved-dns-stub.h"
#include "string-util.h"
#include "tests.h"
 
#define ADVERTISE_DATAGRAM_SIZE_MAX (65536U-14U-20U-8U)
 
#define DNSKEY_KEY_SIZE 200U
 
static void make_request(DnsResourceKey *key, uint16_t max_udp_size, DnsPacket **ret) {
        _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
 
        assert(ret);
 
        ASSERT_OK(dns_packet_new_query(&p, DNS_PROTOCOL_DNS, /* min_alloc_dsize= */ 0,
                                       /* dnssec_checking_disabled= */ false));
        DNS_PACKET_HEADER(p)->id = htobe16(42);
 
        ASSERT_OK(dns_packet_append_key(p, key, 0, NULL));
        DNS_PACKET_HEADER(p)->qdcount = htobe16(1);
 
        /* Without max_udp_size the client doesn't use EDNS0 */
        if (max_udp_size > 0)
                ASSERT_OK(dns_packet_append_opt(p, max_udp_size,
                                                /* edns0_do= */ false,
                                                /* include_rfc6975= */ false,
                                                /* nsid= */ NULL,
                                                DNS_RCODE_SUCCESS,
                                                /* ret_start= */ NULL));
 
        ASSERT_OK(dns_packet_extract(p));
        ASSERT_EQ(dns_packet_payload_size_max(p), MAX(max_udp_size, DNS_PACKET_UNICAST_SIZE_MAX));
 
        *ret = TAKE_PTR(p);
}
 
static void append_dnskey(DnsPacket *p, DnsResourceKey *key, char fill) {
        _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
 
        ASSERT_NOT_NULL(rr = dns_resource_record_new(key));
        rr->ttl = 3600;
        rr->dnskey.flags = 257;
        rr->dnskey.protocol = 3;
        rr->dnskey.algorithm = DNSSEC_ALGORITHM_RSASHA256;
        rr->dnskey.key_size = DNSKEY_KEY_SIZE;
        ASSERT_NOT_NULL(rr->dnskey.key = malloc(DNSKEY_KEY_SIZE));
        memset(rr->dnskey.key, fill, DNSKEY_KEY_SIZE);
 
        ASSERT_OK(dns_packet_append_rr(p, rr, 0, NULL, NULL));
}
 
static void make_upstream_reply(DnsResourceKey *key, const char *layout, DnsPacket **ret) {
        _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
        unsigned n[3] = {}, section = 0;
 
        assert(ret);
 
        /* 'layout' lists the RRs of the answer, authority and additional sections, separated by '|'. 'O' is
         * the OPT RR, any other character a DNSKEY RR whose key is filled with it, so that all RRs are
         * distinct. Header and question take 21 bytes, each DNSKEY RR 216 bytes, the OPT RR 11 bytes. */
 
        ASSERT_OK(dns_packet_new(&p, DNS_PROTOCOL_DNS, /* min_alloc_dsize= */ 0, DNS_PACKET_SIZE_MAX));
        DNS_PACKET_HEADER(p)->id = htobe16(4711);
        DNS_PACKET_HEADER(p)->flags = htobe16(
                        DNS_PACKET_MAKE_FLAGS(1, 0, 0, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
 
        ASSERT_OK(dns_packet_append_key(p, key, 0, NULL));
        DNS_PACKET_HEADER(p)->qdcount = htobe16(1);
 
        for (const char *c = layout; *c; c++) {
                if (*c == '|') {
                        section++;
                        ASSERT_LT(section, ELEMENTSOF(n));
                        continue;
                }
 
                if (*c == 'O')
                        ASSERT_OK(dns_packet_append_opt(p, 1232,
                                                        /* edns0_do= */ false,
                                                        /* include_rfc6975= */ false,
                                                        /* nsid= */ NULL,
                                                        DNS_RCODE_SUCCESS,
                                                        /* ret_start= */ NULL));
                else
                        append_dnskey(p, key, *c);
 
                n[section]++;
        }
 
        DNS_PACKET_HEADER(p)->ancount = htobe16(n[0]);
        DNS_PACKET_HEADER(p)->nscount = htobe16(n[1]);
        DNS_PACKET_HEADER(p)->arcount = htobe16(n[2]);
 
        *ret = TAKE_PTR(p);
}
 
static void parse_reply(DnsPacket *reply, DnsPacket **ret_parsed, char **ret_layout) {
        _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
        _cleanup_free_ char *layout = NULL;
 
        assert(ret_parsed);
        assert(ret_layout);
 
        /* The extracted data of 'reply' describes the packet from before it was patched, hence verify a
         * fresh, not yet extracted copy of what is actually sent to the client: every RR the header
         * announces must be present in full, and nothing may follow the last one. The RRs are returned in
         * the notation of make_upstream_reply(). */
        ASSERT_OK(dns_packet_dup(&p, reply));
 
        dns_packet_rewind(p, DNS_PACKET_HEADER_SIZE);
        for (unsigned i = 0; i < DNS_PACKET_QDCOUNT(p); i++)
                ASSERT_OK(dns_packet_read_key(p, NULL, NULL, NULL));
 
        unsigned n[] = { DNS_PACKET_ANCOUNT(p), DNS_PACKET_NSCOUNT(p), DNS_PACKET_ARCOUNT(p) };
        FOREACH_ELEMENT(count, n) {
                if (count != n)
                        ASSERT_NOT_NULL(strextend(&layout, "|"));
 
                for (unsigned i = 0; i < *count; i++) {
                        _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
                        uint8_t fill;
 
                        log_debug("Reading RR at offset %zu of %zu", p->rindex, p->size);
                        ASSERT_OK(dns_packet_read_rr(p, &rr, NULL, NULL));
 
                        if (rr->key->type == DNS_TYPE_OPT) {
                                ASSERT_NOT_NULL(strextend(&layout, "O"));
                                continue;
                        }
 
                        ASSERT_EQ(rr->key->type, DNS_TYPE_DNSKEY);
                        ASSERT_EQ(rr->dnskey.key_size, DNSKEY_KEY_SIZE);
                        fill = *(uint8_t*) rr->dnskey.key;
                        ASSERT_TRUE(memeqbyte(fill, rr->dnskey.key, rr->dnskey.key_size));
                        ASSERT_OK(strextendf(&layout, "%c", fill));
                }
        }
        ASSERT_EQ(p->rindex, p->size);
 
        ASSERT_OK(dns_packet_extract(p));
        ASSERT_EQ(DNS_PACKET_RRCOUNT(p), dns_answer_size(p->answer) + !!p->opt);
 
        *ret_parsed = TAKE_PTR(p);
        *ret_layout = TAKE_PTR(layout);
}
 
static void assert_only_tc_added(DnsPacket *reply, DnsPacket *original) {
        ASSERT_EQ(be16toh(DNS_PACKET_HEADER(reply)->flags),
                  be16toh(DNS_PACKET_HEADER(original)->flags) | DNS_PACKET_FLAG_TC);
}
 
TEST(patch_bypass_reply_packet_truncated) {
        _cleanup_(dns_packet_unrefp) DnsPacket *request = NULL, *original = NULL, *reply = NULL,
                *parsed = NULL;
        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
        _cleanup_free_ char *layout = NULL;
 
        /* An oversized upstream reply (e.g. received via TCP or from the cache) is proxied back to a UDP
         * client that advertised a 512-byte EDNS0 payload size. */
 
        ASSERT_NOT_NULL(key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_DNSKEY, "org"));
 
        make_request(key, 512, &request);
        make_upstream_reply(key, "abcde||O", &original);
        ASSERT_EQ(original->size, 1112U);
 
        ASSERT_OK(dns_stub_patch_bypass_reply_packet(&reply, original, request,
                                                     /* validated= */ true,
                                                     /* authenticated= */ false));
 
        ASSERT_EQ(DNS_PACKET_ID(reply), DNS_PACKET_ID(request));
        assert_only_tc_added(reply, original);
 
        /* Two DNSKEY RRs fit, with the OPT RR moved behind them */
        ASSERT_EQ(reply->size, 464U);
        parse_reply(reply, &parsed, &layout);
        ASSERT_EQ(DNS_PACKET_QDCOUNT(parsed), 1U);
        ASSERT_STREQ(layout, "ab||O");
        ASSERT_EQ(parsed->opt->key->class, ADVERTISE_DATAGRAM_SIZE_MAX);
}
 
TEST(patch_bypass_reply_packet_truncated_large_opt) {
        _cleanup_(dns_packet_unrefp) DnsPacket *request = NULL, *original = NULL, *reply = NULL,
                *parsed = NULL;
        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
        _cleanup_free_ char *nsid = NULL, *layout = NULL;
 
        /* The upstream OPT RR doesn't even fit right behind the question. The reply must still carry an OPT
         * RR with the UDP payload size, extended RCODE and flags. Only the options may be dropped. */
 
        ASSERT_NOT_NULL(key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_DNSKEY, "org"));
 
        make_request(key, 512, &request);
 
        /* Replace the OPT RR by one with DO, an extended RCODE and a large NSID option, making it 495 bytes,
         * which doesn't fit behind the 21 bytes of header and question. */
        make_upstream_reply(key, "abcde||O", &original);
        ASSERT_OK_POSITIVE(dns_packet_truncate_opt(original));
        DNS_PACKET_HEADER(original)->flags = htobe16(be16toh(DNS_PACKET_HEADER(original)->flags) |
                                                     (DNS_RCODE_BADCOOKIE & 0xF));
        ASSERT_NOT_NULL(nsid = strrep("x", 480));
        ASSERT_OK(dns_packet_append_opt(original, 1232,
                                        /* edns0_do= */ true,
                                        /* include_rfc6975= */ false,
                                        nsid,
                                        DNS_RCODE_BADCOOKIE,
                                        /* ret_start= */ NULL));
        ASSERT_EQ(original->size, 1596U);
 
        ASSERT_OK(dns_stub_patch_bypass_reply_packet(&reply, original, request,
                                                     /* validated= */ true,
                                                     /* authenticated= */ false));
 
        assert_only_tc_added(reply, original);
 
        /* Only the 11 byte fixed part of the OPT RR is retained, which leaves room for two DNSKEY RRs */
        ASSERT_EQ(reply->size, 464U);
        parse_reply(reply, &parsed, &layout);
        ASSERT_STREQ(layout, "ab||O");
        ASSERT_EQ(parsed->opt->opt.data_size, 0U);
        ASSERT_EQ(parsed->opt->key->class, ADVERTISE_DATAGRAM_SIZE_MAX);
        ASSERT_TRUE(dns_packet_do(parsed));
        ASSERT_EQ(dns_packet_rcode(parsed), DNS_RCODE_BADCOOKIE);
}
 
TEST(patch_bypass_reply_packet_truncated_no_edns) {
        _cleanup_(dns_packet_unrefp) DnsPacket *request = NULL, *original = NULL, *reply = NULL,
                *parsed = NULL;
        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
        _cleanup_free_ char *layout = NULL;
 
        /* A client that didn't use EDNS0 might still get an upstream packet with an OPT RR, e.g. one cached
         * from an earlier lookup with DO. Its truncated reply must not gain an OPT RR. */
 
        ASSERT_NOT_NULL(key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_DNSKEY, "org"));
 
        make_request(key, /* max_udp_size= */ 0, &request);
        make_upstream_reply(key, "abcde||O", &original);
 
        ASSERT_OK(dns_stub_patch_bypass_reply_packet(&reply, original, request,
                                                     /* validated= */ true,
                                                     /* authenticated= */ false));
 
        assert_only_tc_added(reply, original);
 
        ASSERT_EQ(reply->size, 453U);
        parse_reply(reply, &parsed, &layout);
        ASSERT_STREQ(layout, "ab||");
        ASSERT_NULL(parsed->opt);
}
 
TEST(patch_bypass_reply_packet_truncated_sections) {
        static const struct {
                unsigned max_udp_size;
                size_t size;
                const char *layout;
        } table[] = {
                /* Cut in the answer section */
                {  512U,  464U, "ab||O"     },
                /* Cut in the authority section */
                {  900U,  896U, "abc|n|O"   },
                /* Cut in front of the first additional RR, the OPT RR is moved up to the cut */
                { 1200U, 1112U, "abc|no|O"  },
                /* Cut behind the OPT RR, which stays in place */
                { 1400U, 1328U, "abc|no|xO" },
        };
        _cleanup_(dns_packet_unrefp) DnsPacket *original = NULL;
        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
 
        /* All three sections, with the OPT RR in the middle of the additional section */
 
        ASSERT_NOT_NULL(key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_DNSKEY, "org"));
 
        make_upstream_reply(key, "abc|no|xOy", &original);
        ASSERT_EQ(original->size, 1544U);
 
        FOREACH_ELEMENT(t, table) {
                _cleanup_(dns_packet_unrefp) DnsPacket *request = NULL, *reply = NULL, *parsed = NULL;
                _cleanup_free_ char *layout = NULL;
 
                log_debug("Client payload size %u", t->max_udp_size);
 
                make_request(key, t->max_udp_size, &request);
 
                ASSERT_OK(dns_stub_patch_bypass_reply_packet(&reply, original, request,
                                                             /* validated= */ true,
                                                             /* authenticated= */ false));
 
                assert_only_tc_added(reply, original);
 
                ASSERT_EQ(reply->size, t->size);
                parse_reply(reply, &parsed, &layout);
                ASSERT_STREQ(layout, t->layout);
                ASSERT_EQ(parsed->opt->key->class, ADVERTISE_DATAGRAM_SIZE_MAX);
        }
}
 
TEST(patch_bypass_reply_packet_trailing_garbage) {
        static const uint8_t garbage[64] = {};
        _cleanup_(dns_packet_unrefp) DnsPacket *request = NULL, *original = NULL, *reply = NULL,
                *parsed = NULL;
        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
        _cleanup_free_ char *layout = NULL;
 
        /* All RRs fit, but trailing garbage pushes the upstream packet over the limit. The garbage must not
         * end up in the reply. As dns_packet_extract() ignores the OPT RR of such a packet, it is retained
         * like any other RR. */
 
        ASSERT_NOT_NULL(key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_DNSKEY, "org"));
 
        make_request(key, 512, &request);
        make_upstream_reply(key, "ab||O", &original);
        ASSERT_OK(dns_packet_append_blob(original, garbage, sizeof(garbage), NULL));
        ASSERT_EQ(original->size, 528U);
 
        ASSERT_OK(dns_stub_patch_bypass_reply_packet(&reply, original, request,
                                                     /* validated= */ true,
                                                     /* authenticated= */ false));
 
        assert_only_tc_added(reply, original);
 
        ASSERT_EQ(reply->size, 464U);
        parse_reply(reply, &parsed, &layout);
        ASSERT_STREQ(layout, "ab||O");
}
 
DEFINE_TEST_MAIN(LOG_DEBUG);