HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/resolve/resolved-dns-dnssec.c

84,182 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 0e234111d3499f3d3425030135d88ba1f15c70fb

Lines 1–1000 of 2,284

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include "alloc-util.h"
#include "bitmap.h"
#include "crypto-util.h"
#include "dns-answer.h"
#include "dns-domain.h"
#include "dns-rr.h"
#include "dns-type.h"
#include "hexdecoct.h"
#include "log.h"
#include "memory-util.h"
#include "memstream-util.h"
#include "resolved-dns-dnssec.h"
#include "resolved-dns-dnssec-crypto.h"
#include "sort-util.h"
#include "string-table.h"
#include "string-util.h"
#include "time-util.h"
 
#define VERIFY_RRS_MAX 256
#define MAX_KEY_SIZE (32*1024)
 
/* Permit a maximum clock skew of 1h 10min. This should be enough to deal with DST confusion */
#define SKEW_MAX (1*USEC_PER_HOUR + 10*USEC_PER_MINUTE)
 
/* Maximum number of NSEC3 iterations we'll do. RFC5155 says 2500 shall be the maximum useful value, but
 * RFC9276 § 3.2 says that we should reduce the acceptable iteration count */
#define NSEC3_ITERATIONS_MAX 100
 
/*
 * The DNSSEC Chain of trust:
 *
 *            Normal RRs are protected via RRSIG RRs in combination with DNSKEY RRs, all in the same zone
 *            DNSKEY RRs are either protected like normal RRs, or via a DS from a zone "higher" up the tree
 *            DS RRs are protected like normal RRs
 *
 * Example chain:
 *            Normal RR → RRSIG/DNSKEY+ → DS → RRSIG/DNSKEY+ → DS → ... → DS → RRSIG/DNSKEY+ → DS
 */
 
#if HAVE_OPENSSL
 
static int rr_compare(DnsResourceRecord * const *a, DnsResourceRecord * const *b) {
        const DnsResourceRecord *x = *ASSERT_PTR(a), *y = *ASSERT_PTR(b);
        size_t m;
        int r;
 
        /* Let's order the RRs according to RFC 4034, Section 6.3 */
 
        assert(x);
        assert(x->wire_format);
        assert(y);
        assert(y->wire_format);
 
        m = MIN(DNS_RESOURCE_RECORD_RDATA_SIZE(x), DNS_RESOURCE_RECORD_RDATA_SIZE(y));
 
        r = memcmp(DNS_RESOURCE_RECORD_RDATA(x), DNS_RESOURCE_RECORD_RDATA(y), m);
        if (r != 0)
                return r;
 
        return CMP(DNS_RESOURCE_RECORD_RDATA_SIZE(x), DNS_RESOURCE_RECORD_RDATA_SIZE(y));
}
 
/* The DNSSEC verification and digest helpers below reserve -EOPNOTSUPP to mean "this algorithm or digest
 * is not supported (or is disabled by host policy)" — a condition their callers deliberately treat as an
 * insecure-but-accepted result (DNSSEC_UNSUPPORTED_ALGORITHM and friends). Once an algorithm has been
 * established as supported, a low-level OpenSSL failure during the actual computation can nonetheless
 * translate to -EOPNOTSUPP (e.g. an OpenSSL provider pushing ERR_R_UNSUPPORTED, ERR_R_FETCH_FAILED, or
 * ERR_R_DISABLED under FIPS or similar). Such a failure must fail closed, so collapse it onto -EIO and
 * keep -EOPNOTSUPP exclusively for the genuine unsupported-algorithm signal. */
static int dnssec_verify_errno(int r) {
        return r == -EOPNOTSUPP ? -EIO : r;
}
 
int dnssec_rsa_verify_raw(
                const EVP_MD *hash_algorithm,
                const struct iovec *signature,
                const struct iovec *hash,
                const struct iovec *exponent,
                const struct iovec *modulus) {
 
        int r;
 
        assert(hash_algorithm);
        assert(iovec_is_set(signature));
        assert(iovec_is_set(hash));
        assert(iovec_is_set(exponent));
        assert(iovec_is_set(modulus));
 
        _cleanup_(BN_freep) BIGNUM *e = sym_BN_bin2bn(exponent->iov_base, exponent->iov_len, NULL);
        if (!e)
                return log_openssl_errors(LOG_DEBUG, "Failed to convert RSA exponent to BIGNUM");
 
        _cleanup_(BN_freep) BIGNUM *m = sym_BN_bin2bn(modulus->iov_base, modulus->iov_len, NULL);
        if (!m)
                return log_openssl_errors(LOG_DEBUG, "Failed to convert RSA modulus to BIGNUM");
 
        _cleanup_(OSSL_PARAM_BLD_freep) OSSL_PARAM_BLD *bld = sym_OSSL_PARAM_BLD_new();
        if (!bld)
                return -ENOMEM;
 
        if (sym_OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, e) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to push RSA exponent to OSSL_PARAM_BLD");
 
        if (sym_OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, m) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to push RSA modulus to OSSL_PARAM_BLD");
 
        _cleanup_(OSSL_PARAM_freep) OSSL_PARAM *params = sym_OSSL_PARAM_BLD_to_param(bld);
        if (!params)
                return log_openssl_errors(LOG_DEBUG, "Failed to generate OSSL param");
 
        _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *kctx = sym_EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
        if (!kctx)
                return -ENOMEM;
 
        if (sym_EVP_PKEY_fromdata_init(kctx) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to initialize key creation");
 
        _cleanup_(EVP_PKEY_freep) EVP_PKEY *epubkey = NULL;
        if (sym_EVP_PKEY_fromdata(kctx, &epubkey, EVP_PKEY_PUBLIC_KEY, params) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to load RSA public key from raw data");
 
        if ((size_t) sym_EVP_PKEY_get_size(epubkey) != signature->iov_len)
                return -EINVAL;
 
        _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *ctx = sym_EVP_PKEY_CTX_new(epubkey, NULL);
        if (!ctx)
                return -ENOMEM;
 
        if (sym_EVP_PKEY_verify_init(ctx) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to initialize RSA signature verification");
 
        if (sym_EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to set RSA padding");
 
        if (sym_EVP_PKEY_CTX_set_signature_md(ctx, hash_algorithm) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to set RSA signature digest");
 
        r = sym_EVP_PKEY_verify(ctx, signature->iov_base, signature->iov_len, hash->iov_base, hash->iov_len);
        if (r < 0)
                return log_openssl_errors(LOG_DEBUG, "Signature verification failed");
 
        return r;
}
 
static int dnssec_rsa_verify(
                const EVP_MD *hash_algorithm,
                const struct iovec *hash,
                DnsResourceRecord *rrsig,
                DnsResourceRecord *dnskey) {
 
        size_t exponent_size, modulus_size;
        void *exponent, *modulus;
 
        assert(hash_algorithm);
        assert(iovec_is_set(hash));
        assert(rrsig);
        assert(dnskey);
 
        if (dnskey->dnskey.key_size < 1)
                return -EINVAL;
 
        if (*(uint8_t*) dnskey->dnskey.key == 0) {
                /* exponent is > 255 bytes long */
 
                if (dnskey->dnskey.key_size < 3)
                        return -EINVAL;
 
                exponent_size =
                        ((size_t) (((uint8_t*) dnskey->dnskey.key)[1]) << 8) |
                        ((size_t) ((uint8_t*) dnskey->dnskey.key)[2]);
 
                if (exponent_size < 256)
                        return -EINVAL;
 
                if (3 + exponent_size >= dnskey->dnskey.key_size)
                        return -EINVAL;
 
                exponent = (uint8_t*) dnskey->dnskey.key + 3;
                modulus = (uint8_t*) dnskey->dnskey.key + 3 + exponent_size;
                modulus_size = dnskey->dnskey.key_size - 3 - exponent_size;
 
        } else {
                /* exponent is <= 255 bytes long */
                exponent_size = (size_t) ((uint8_t*) dnskey->dnskey.key)[0];
 
                if (exponent_size <= 0)
                        return -EINVAL;
 
                if (1 + exponent_size >= dnskey->dnskey.key_size)
                        return -EINVAL;
 
                exponent = (uint8_t*) dnskey->dnskey.key + 1;
                modulus = (uint8_t*) dnskey->dnskey.key + 1 + exponent_size;
                modulus_size = dnskey->dnskey.key_size - 1 - exponent_size;
        }
 
        return dnssec_rsa_verify_raw(
                        hash_algorithm,
                        &IOVEC_MAKE(rrsig->rrsig.signature, rrsig->rrsig.signature_size),
                        hash,
                        &IOVEC_MAKE(exponent, exponent_size),
                        &IOVEC_MAKE(modulus, modulus_size));
}
 
int dnssec_ecdsa_verify_raw(
                const EVP_MD *hash_algorithm,
                int curve,
                const struct iovec *signature_r,
                const struct iovec *signature_s,
                const struct iovec *hash,
                const struct iovec *key) {
 
        int r;
 
        assert(hash_algorithm);
        assert(iovec_is_set(signature_r));
        assert(iovec_is_set(signature_s));
        assert(iovec_is_set(hash));
        assert(iovec_is_set(key));
 
        const char *curve_name = sym_OBJ_nid2sn(curve);
        if (!curve_name)
                return log_openssl_errors(LOG_DEBUG, "Unknown curve NID");
 
        OSSL_PARAM params[] = {
                sym_OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME, (char*) curve_name, 0),
                sym_OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_PUB_KEY, key->iov_base, key->iov_len),
                sym_OSSL_PARAM_construct_end(),
        };
 
        _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *kctx = sym_EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
        if (!kctx)
                return -ENOMEM;
 
        if (sym_EVP_PKEY_fromdata_init(kctx) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to initialize EC key creation");
 
        _cleanup_(EVP_PKEY_freep) EVP_PKEY *epubkey = NULL;
        if (sym_EVP_PKEY_fromdata(kctx, &epubkey, EVP_PKEY_PUBLIC_KEY, params) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to load EC public key from raw data");
 
        _cleanup_(BN_freep) BIGNUM *bn_r = sym_BN_bin2bn(signature_r->iov_base, signature_r->iov_len, NULL);
        if (!bn_r)
                return log_openssl_errors(LOG_DEBUG, "Failed to convert ECDSA signature r to BIGNUM");
 
        _cleanup_(BN_freep) BIGNUM *bn_s = sym_BN_bin2bn(signature_s->iov_base, signature_s->iov_len, NULL);
        if (!bn_s)
                return log_openssl_errors(LOG_DEBUG, "Failed to convert ECDSA signature s to BIGNUM");
 
        _cleanup_(ECDSA_SIG_freep) ECDSA_SIG *sig = sym_ECDSA_SIG_new();
        if (!sig)
                return -ENOMEM;
 
        if (sym_ECDSA_SIG_set0(sig, bn_r, bn_s) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to set ECDSA signature");
        TAKE_PTR(bn_r);
        TAKE_PTR(bn_s);
 
        _cleanup_(OPENSSL_freep) void *buf = NULL;
        r = sym_i2d_ECDSA_SIG(sig, (unsigned char**) &buf);
        if (r <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to DER encode ECDSA signature");
        struct iovec der_sig = IOVEC_MAKE(buf, r);
 
        _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *vctx = sym_EVP_PKEY_CTX_new(epubkey, NULL);
        if (!vctx)
                return -ENOMEM;
 
        if (sym_EVP_PKEY_public_check(vctx) <= 0)
                return log_openssl_errors(LOG_DEBUG, "EC public key validation failed");
 
        if (sym_EVP_PKEY_verify_init(vctx) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to initialize ECDSA signature verification");
 
        if (sym_EVP_PKEY_CTX_set_signature_md(vctx, hash_algorithm) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to set ECDSA signature digest");
 
        r = sym_EVP_PKEY_verify(vctx, der_sig.iov_base, der_sig.iov_len, hash->iov_base, hash->iov_len);
        if (r < 0)
                return log_openssl_errors(LOG_DEBUG, "Signature verification failed");
 
        return r;
}
 
static int dnssec_ecdsa_verify(
                const EVP_MD *hash_algorithm,
                int algorithm,
                const struct iovec *hash,
                DnsResourceRecord *rrsig,
                DnsResourceRecord *dnskey) {
 
        int curve;
        size_t key_size;
        uint8_t *q;
 
        assert(hash_algorithm);
        assert(iovec_is_set(hash));
        assert(rrsig);
        assert(dnskey);
 
        if (algorithm == DNSSEC_ALGORITHM_ECDSAP256SHA256) {
                curve = NID_X9_62_prime256v1;  /* NIST P-256 */
                key_size = 32;
        } else if (algorithm == DNSSEC_ALGORITHM_ECDSAP384SHA384) {
                curve = NID_secp384r1;         /* NIST P-384 */
                key_size = 48;
        } else
                return -EOPNOTSUPP;
 
        if (dnskey->dnskey.key_size != key_size * 2)
                return -EINVAL;
 
        if (rrsig->rrsig.signature_size != key_size * 2)
                return -EINVAL;
 
        q = newa(uint8_t, key_size*2 + 1);
        q[0] = 0x04; /* Prepend 0x04 to indicate an uncompressed key */
        memcpy(q+1, dnskey->dnskey.key, key_size*2);
 
        return dnssec_ecdsa_verify_raw(
                        hash_algorithm,
                        curve,
                        &IOVEC_MAKE(rrsig->rrsig.signature, key_size),
                        &IOVEC_MAKE((uint8_t*) rrsig->rrsig.signature + key_size, key_size),
                        hash,
                        &IOVEC_MAKE(q, key_size * 2 + 1));
}
 
static int dnssec_eddsa_verify_raw(
                int curve,
                const uint8_t *signature, size_t signature_size,
                const uint8_t *data, size_t data_size,
                const uint8_t *key, size_t key_size) {
 
        _cleanup_(EVP_PKEY_freep) EVP_PKEY *evkey = NULL;
        _cleanup_(EVP_PKEY_CTX_freep) EVP_PKEY_CTX *pctx = NULL;
        _cleanup_(EVP_MD_CTX_freep) EVP_MD_CTX *ctx = NULL;
        int r;
 
        assert(curve == NID_ED25519);
        assert(signature_size == key_size * 2);
 
        uint8_t *q = newa(uint8_t, signature_size + 1);
        q[0] = 0x04; /* Prepend 0x04 to indicate an uncompressed key */
        memcpy(q+1, signature, signature_size);
 
        evkey = sym_EVP_PKEY_new_raw_public_key(EVP_PKEY_ED25519, NULL, key, key_size);
        if (!evkey)
                return log_openssl_errors(LOG_DEBUG, "EVP_PKEY_new_raw_public_key failed");
 
        pctx = sym_EVP_PKEY_CTX_new(evkey, NULL);
        if (!pctx)
                return -ENOMEM;
 
        ctx = sym_EVP_MD_CTX_new();
        if (!ctx)
                return -ENOMEM;
 
        /* This prevents EVP_DigestVerifyInit from managing pctx and complicating our free logic. */
        sym_EVP_MD_CTX_set_pkey_ctx(ctx, pctx);
 
        /* One might be tempted to use EVP_PKEY_verify_init, but see Ed25519(7ssl). */
        if (sym_EVP_DigestVerifyInit(ctx, &pctx, NULL, NULL, evkey) <= 0)
                return log_openssl_errors(LOG_DEBUG, "Failed to initialize EdDSA verification");
 
        r = sym_EVP_DigestVerify(ctx, signature, signature_size, data, data_size);
        if (r < 0)
                return log_openssl_errors(LOG_DEBUG, "Signature verification failed");
 
        return r;
}
 
static int dnssec_eddsa_verify(
                int algorithm,
                const void *data, size_t data_size,
                DnsResourceRecord *rrsig,
                DnsResourceRecord *dnskey) {
        int curve;
        size_t key_size;
 
        if (algorithm == DNSSEC_ALGORITHM_ED25519) {
                curve = NID_ED25519;
                key_size = 32;
        } else
                return -EOPNOTSUPP;
 
        if (dnskey->dnskey.key_size != key_size)
                return -EINVAL;
 
        if (rrsig->rrsig.signature_size != key_size * 2)
                return -EINVAL;
 
        return dnssec_eddsa_verify_raw(
                        curve,
                        rrsig->rrsig.signature, rrsig->rrsig.signature_size,
                        data, data_size,
                        dnskey->dnskey.key, key_size);
}
 
static int md_add_uint8(EVP_MD_CTX *ctx, uint8_t v) {
        return sym_EVP_DigestUpdate(ctx, &v, sizeof(v));
}
 
static int md_add_uint16(EVP_MD_CTX *ctx, uint16_t v) {
        v = htobe16(v);
        return sym_EVP_DigestUpdate(ctx, &v, sizeof(v));
}
 
static void fwrite_uint8(FILE *fp, uint8_t v) {
        fwrite(&v, sizeof(v), 1, fp);
}
 
static void fwrite_uint16(FILE *fp, uint16_t v) {
        v = htobe16(v);
        fwrite(&v, sizeof(v), 1, fp);
}
 
static void fwrite_uint32(FILE *fp, uint32_t v) {
        v = htobe32(v);
        fwrite(&v, sizeof(v), 1, fp);
}
 
static int dnssec_rrsig_prepare(DnsResourceRecord *rrsig) {
        int n_key_labels, n_signer_labels;
        const char *name;
        int r;
 
        /* Checks whether the specified RRSIG RR is somewhat valid, and initializes the .n_skip_labels_source
         * and .n_skip_labels_signer fields so that we can use them later on. */
 
        assert(rrsig);
        assert(rrsig->key->type == DNS_TYPE_RRSIG);
 
        /* Check if this RRSIG RR is already prepared */
        if (rrsig->n_skip_labels_source != UINT8_MAX)
                return 0;
 
        if (rrsig->rrsig.inception > rrsig->rrsig.expiration)
                return -EINVAL;
 
        name = dns_resource_key_name(rrsig->key);
 
        n_key_labels = dns_name_count_labels(name);
        if (n_key_labels < 0)
                return n_key_labels;
        if (rrsig->rrsig.labels > n_key_labels)
                return -EINVAL;
 
        n_signer_labels = dns_name_count_labels(rrsig->rrsig.signer);
        if (n_signer_labels < 0)
                return n_signer_labels;
        if (n_signer_labels > rrsig->rrsig.labels)
                return -EINVAL;
 
        r = dns_name_skip(name, n_key_labels - n_signer_labels, &name);
        if (r < 0)
                return r;
        if (r == 0)
                return -EINVAL;
 
        /* Check if the signer is really a suffix of us */
        r = dns_name_equal(name, rrsig->rrsig.signer);
        if (r < 0)
                return r;
        if (r == 0)
                return -EINVAL;
 
        assert(n_key_labels < UINT8_MAX); /* UINT8_MAX/-1 means unsigned. */
        rrsig->n_skip_labels_source = n_key_labels - rrsig->rrsig.labels;
        rrsig->n_skip_labels_signer = n_key_labels - n_signer_labels;
 
        return 0;
}
 
static int dnssec_rrsig_expired(DnsResourceRecord *rrsig, usec_t realtime) {
        usec_t expiration, inception, skew;
 
        assert(rrsig);
        assert(rrsig->key->type == DNS_TYPE_RRSIG);
 
        if (realtime == USEC_INFINITY)
                realtime = now(CLOCK_REALTIME);
 
        expiration = rrsig->rrsig.expiration * USEC_PER_SEC;
        inception = rrsig->rrsig.inception * USEC_PER_SEC;
 
        /* Consider inverted validity intervals as expired */
        if (inception > expiration)
                return true;
 
        /* Permit a certain amount of clock skew of 10% of the valid
         * time range. This takes inspiration from unbound's
         * resolver. */
        skew = (expiration - inception) / 10;
        if (skew > SKEW_MAX)
                skew = SKEW_MAX;
 
        if (inception < skew)
                inception = 0;
        else
                inception -= skew;
 
        if (expiration + skew < expiration)
                expiration = USEC_INFINITY;
        else
                expiration += skew;
 
        return realtime < inception || realtime > expiration;
}
 
static const EVP_MD* algorithm_to_implementation_id(uint8_t algorithm) {
 
        /* Translates a DNSSEC signature algorithm into an openssl digest identifier.
         *
         * Note that we implement all algorithms listed as "Must implement" and "Recommended to Implement" in
         * RFC6944. We don't implement any algorithms that are listed as "Optional" or "Must Not Implement".
         * Specifically, we do not implement RSAMD5, DSASHA1, DH, DSA-NSEC3-SHA1, and GOST-ECC. */
 
        switch (algorithm) {
 
        case DNSSEC_ALGORITHM_RSASHA1:
        case DNSSEC_ALGORITHM_RSASHA1_NSEC3_SHA1:
                return sym_EVP_sha1();
 
        case DNSSEC_ALGORITHM_RSASHA256:
        case DNSSEC_ALGORITHM_ECDSAP256SHA256:
                return sym_EVP_sha256();
 
        case DNSSEC_ALGORITHM_ECDSAP384SHA384:
                return sym_EVP_sha384();
 
        case DNSSEC_ALGORITHM_RSASHA512:
                return sym_EVP_sha512();
 
        default:
                return NULL;
        }
}
 
static void dnssec_fix_rrset_ttl(
                DnsResourceRecord *list[],
                unsigned n,
                DnsResourceRecord *rrsig) {
 
        assert(list);
        assert(n > 0);
        assert(rrsig);
 
        for (unsigned k = 0; k < n; k++) {
                DnsResourceRecord *rr = list[k];
 
                /* Pick the TTL as the minimum of the RR's TTL, the
                 * RR's original TTL according to the RRSIG and the
                 * RRSIG's own TTL, see RFC 4035, Section 5.3.3 */
                uint32_t ttl = MIN3(rr->ttl, rrsig->rrsig.original_ttl, rrsig->ttl);
                if (ttl != rr->ttl) {
                        rr->ttl = ttl;
                        dns_resource_record_clear_wire_format(rr);
                }
 
                rr->expiry = rrsig->rrsig.expiration * USEC_PER_SEC;
 
                /* Copy over information about the signer and wildcard source of synthesis */
                rr->n_skip_labels_source = rrsig->n_skip_labels_source;
                rr->n_skip_labels_signer = rrsig->n_skip_labels_signer;
        }
 
        rrsig->expiry = rrsig->rrsig.expiration * USEC_PER_SEC;
}
 
static int dnssec_rrset_serialize_sig(
                DnsResourceRecord *rrsig,
                const char *source,
                DnsResourceRecord **list,
                size_t list_len,
                bool wildcard,
                char **ret_sig_data,
                size_t *ret_sig_size) {
 
        _cleanup_(memstream_done) MemStream m = {};
        uint8_t wire_format_name[DNS_WIRE_FORMAT_HOSTNAME_MAX];
        DnsResourceRecord *rr;
        FILE *f;
        int r;
 
        assert(rrsig);
        assert(source);
        assert(list || list_len == 0);
        assert(ret_sig_data);
        assert(ret_sig_size);
 
        f = memstream_init(&m);
        if (!f)
                return -ENOMEM;
 
        fwrite_uint16(f, rrsig->rrsig.type_covered);
        fwrite_uint8(f, rrsig->rrsig.algorithm);
        fwrite_uint8(f, rrsig->rrsig.labels);
        fwrite_uint32(f, rrsig->rrsig.original_ttl);
        fwrite_uint32(f, rrsig->rrsig.expiration);
        fwrite_uint32(f, rrsig->rrsig.inception);
        fwrite_uint16(f, rrsig->rrsig.key_tag);
 
        r = dns_name_to_wire_format(rrsig->rrsig.signer, wire_format_name, sizeof(wire_format_name), true);
        if (r < 0)
                return r;
        fwrite(wire_format_name, 1, r, f);
 
        /* Convert the source of synthesis into wire format */
        r = dns_name_to_wire_format(source, wire_format_name, sizeof(wire_format_name), true);
        if (r < 0)
                return r;
 
        for (size_t k = 0; k < list_len; k++) {
                size_t l;
 
                rr = list[k];
 
                /* Hash the source of synthesis. If this is a wildcard, then prefix it with the *. label */
                if (wildcard)
                        fwrite((uint8_t[]) { 1, '*'}, sizeof(uint8_t), 2, f);
                fwrite(wire_format_name, 1, r, f);
 
                fwrite_uint16(f, rr->key->type);
                fwrite_uint16(f, rr->key->class);
                fwrite_uint32(f, rrsig->rrsig.original_ttl);
 
                l = DNS_RESOURCE_RECORD_RDATA_SIZE(rr);
                assert(l <= 0xFFFF);
 
                fwrite_uint16(f, (uint16_t) l);
                fwrite(DNS_RESOURCE_RECORD_RDATA(rr), 1, l, f);
        }
 
        return memstream_finalize(&m, ret_sig_data, ret_sig_size);
}
 
static int dnssec_rrset_verify_sig(
                DnsResourceRecord *rrsig,
                DnsResourceRecord *dnskey,
                const char *sig_data,
                size_t sig_size) {
 
        assert(rrsig);
        assert(dnskey);
        assert(sig_data);
        assert(sig_size > 0);
 
        const EVP_MD *md_algorithm;
 
        uint8_t hash[EVP_MAX_MD_SIZE];
        unsigned hash_size;
 
        switch (rrsig->rrsig.algorithm) {
        case DNSSEC_ALGORITHM_ED25519:
                /* The algorithm is supported, so a -EOPNOTSUPP from the actual verification is a hard
                 * crypto failure, not an unsupported-algorithm condition: fail closed. */
                return dnssec_verify_errno(dnssec_eddsa_verify(
                                rrsig->rrsig.algorithm,
                                sig_data, sig_size,
                                rrsig,
                                dnskey));
        case DNSSEC_ALGORITHM_ED448:
                return -EOPNOTSUPP;
        default:
                /* OK, the RRs are now in canonical order. Let's calculate the digest */
                md_algorithm = algorithm_to_implementation_id(rrsig->rrsig.algorithm);
                if (!md_algorithm)
                        return -EOPNOTSUPP;
 
                _cleanup_(EVP_MD_CTX_freep) EVP_MD_CTX *ctx = sym_EVP_MD_CTX_new();
                if (!ctx)
                        return -ENOMEM;
 
                /* If the signature algorithm is supported by systemd-resolved but disabled by host policy,
                 * also return -EOPNOTSUPP. */
                if (sym_EVP_DigestInit_ex(ctx, md_algorithm, NULL) <= 0)
                        return -EOPNOTSUPP;
 
                if (sym_EVP_DigestUpdate(ctx, sig_data, sig_size) <= 0)
                        return dnssec_verify_errno(log_openssl_errors(LOG_DEBUG, "Failed to update digest"));
 
                if (sym_EVP_DigestFinal_ex(ctx, hash, &hash_size) <= 0)
                        return dnssec_verify_errno(log_openssl_errors(LOG_DEBUG, "Failed to finalize digest"));
 
                assert(hash_size > 0);
        }
 
        switch (rrsig->rrsig.algorithm) {
 
        case DNSSEC_ALGORITHM_RSASHA1:
        case DNSSEC_ALGORITHM_RSASHA1_NSEC3_SHA1:
        case DNSSEC_ALGORITHM_RSASHA256:
        case DNSSEC_ALGORITHM_RSASHA512:
                return dnssec_verify_errno(dnssec_rsa_verify(
                                md_algorithm,
                                &IOVEC_MAKE(hash, hash_size),
                                rrsig,
                                dnskey));
 
        case DNSSEC_ALGORITHM_ECDSAP256SHA256:
        case DNSSEC_ALGORITHM_ECDSAP384SHA384:
                return dnssec_verify_errno(dnssec_ecdsa_verify(
                                md_algorithm,
                                rrsig->rrsig.algorithm,
                                &IOVEC_MAKE(hash, hash_size),
                                rrsig,
                                dnskey));
 
        default:
                assert_not_reached();
        }
}
 
int dnssec_verify_rrset(
                DnsAnswer *a,
                const DnsResourceKey *key,
                DnsResourceRecord *rrsig,
                DnsResourceRecord *dnskey,
                usec_t realtime,
                DnssecResult *result) {
 
        DnsResourceRecord **list, *rr;
        const char *source, *name;
        _cleanup_free_ char *sig_data = NULL;
        size_t sig_size = 0; /* avoid false maybe-uninitialized warning */
        size_t n = 0;
        bool wildcard;
        int r;
 
        assert(key);
        assert(rrsig);
        assert(dnskey);
        assert(result);
 
        r = dlopen_libcrypto(LOG_WARNING);
        if (r < 0)
                return r;
 
        assert(rrsig->key->type == DNS_TYPE_RRSIG);
        assert(dnskey->key->type == DNS_TYPE_DNSKEY);
 
        /* Verifies that the RRSet matches the specified "key" in "a",
         * using the signature "rrsig" and the key "dnskey". It's
         * assumed that RRSIG and DNSKEY match. */
 
        r = dnssec_rrsig_prepare(rrsig);
        if (r == -EINVAL) {
                *result = DNSSEC_INVALID;
                return r;
        }
        if (r < 0)
                return r;
 
        r = dnssec_rrsig_expired(rrsig, realtime);
        if (r < 0)
                return r;
        if (r > 0) {
                *result = DNSSEC_SIGNATURE_EXPIRED;
                return 0;
        }
 
        name = dns_resource_key_name(key);
 
        /* Some keys may only appear signed in the zone apex, and are invalid anywhere else. (SOA, NS...) */
        if (dns_type_apex_only(rrsig->rrsig.type_covered)) {
                r = dns_name_equal(rrsig->rrsig.signer, name);
                if (r < 0)
                        return r;
                if (r == 0) {
                        *result = DNSSEC_INVALID;
                        return 0;
                }
        }
 
        /* OTOH DS RRs may not appear in the zone apex, but are valid everywhere else. */
        if (rrsig->rrsig.type_covered == DNS_TYPE_DS) {
                r = dns_name_equal(rrsig->rrsig.signer, name);
                if (r < 0)
                        return r;
                if (r > 0) {
                        *result = DNSSEC_INVALID;
                        return 0;
                }
        }
 
        /* Determine the "Source of Synthesis" and whether this is a wildcard RRSIG */
        r = dns_name_suffix(name, rrsig->rrsig.labels, &source);
        if (r < 0)
                return r;
        if (r > 0 && !dns_type_may_wildcard(rrsig->rrsig.type_covered)) {
                /* We refuse to validate NSEC3 or SOA RRs that are synthesized from wildcards */
                *result = DNSSEC_INVALID;
                return 0;
        }
        if (r == 1) {
                /* If we stripped a single label, then let's see if that maybe was "*". If so, we are not really
                 * synthesized from a wildcard, we are the wildcard itself. Treat that like a normal name. */
                r = dns_name_startswith(name, "*");
                if (r < 0)
                        return r;
                if (r > 0)
                        source = name;
 
                wildcard = r == 0;
        } else
                wildcard = r > 0;
 
        /* Collect all relevant RRs in a single array, so that we can look at the RRset */
        list = newa(DnsResourceRecord *, dns_answer_size(a));
 
        DNS_ANSWER_FOREACH(rr, a) {
                r = dns_resource_key_equal(key, rr->key);
                if (r < 0)
                        return r;
                if (r == 0)
                        continue;
 
                /* We need the wire format for ordering, and digest calculation */
                r = dns_resource_record_to_wire_format(rr, true);
                if (r < 0)
                        return r;
 
                list[n++] = rr;
 
                if (n > VERIFY_RRS_MAX)
                        return -E2BIG;
        }
 
        if (n <= 0)
                return -ENODATA;
 
        /* Bring the RRs into canonical order */
        typesafe_qsort(list, n, rr_compare);
 
        r = dnssec_rrset_serialize_sig(rrsig, source, list, n, wildcard,
                                       &sig_data, &sig_size);
        if (r < 0)
                return r;
 
        r = dnssec_rrset_verify_sig(rrsig, dnskey, sig_data, sig_size);
        if (r == -EOPNOTSUPP) {
                *result = DNSSEC_UNSUPPORTED_ALGORITHM;
                return 0;
        }
        if (r < 0)
                return r;
 
        /* Now, fix the ttl, expiry, and remember the synthesizing source and the signer */
        if (r > 0)
                dnssec_fix_rrset_ttl(list, n, rrsig);
 
        if (r == 0)
                *result = DNSSEC_INVALID;
        else if (wildcard)
                *result = DNSSEC_VALIDATED_WILDCARD;
        else
                *result = DNSSEC_VALIDATED;
 
        return 0;
}
 
int dnssec_rrsig_match_dnskey(DnsResourceRecord *rrsig, DnsResourceRecord *dnskey, bool revoked_ok) {
 
        assert(rrsig);
        assert(dnskey);
 
        /* Checks if the specified DNSKEY RR matches the key used for
         * the signature in the specified RRSIG RR */
 
        if (rrsig->key->type != DNS_TYPE_RRSIG)
                return -EINVAL;
 
        if (dnskey->key->type != DNS_TYPE_DNSKEY)
                return 0;
        if (dnskey->key->class != rrsig->key->class)
                return 0;
        if ((dnskey->dnskey.flags & DNSKEY_FLAG_ZONE_KEY) == 0)
                return 0;
        if (!revoked_ok && (dnskey->dnskey.flags & DNSKEY_FLAG_REVOKE))
                return 0;
        if (dnskey->dnskey.protocol != 3)
                return 0;
        if (dnskey->dnskey.algorithm != rrsig->rrsig.algorithm)
                return 0;
 
        if (dnssec_keytag(dnskey, false) != rrsig->rrsig.key_tag)
                return 0;
 
        return dns_name_equal(dns_resource_key_name(dnskey->key), rrsig->rrsig.signer);
}
 
int dnssec_key_match_rrsig(const DnsResourceKey *key, DnsResourceRecord *rrsig) {
        assert(key);
        assert(rrsig);
 
        /* Checks if the specified RRSIG RR protects the RRSet of the specified RR key. */
 
        if (rrsig->key->type != DNS_TYPE_RRSIG)
                return 0;
        if (rrsig->key->class != key->class)
                return 0;
        if (rrsig->rrsig.type_covered != key->type)
                return 0;
 
        return dns_name_equal(dns_resource_key_name(rrsig->key), dns_resource_key_name(key));
}
 
int dnssec_verify_rrset_search(
                DnsAnswer *a,
                const DnsResourceKey *key,
                DnsAnswer *validated_dnskeys,
                usec_t realtime,
                DnssecResult *result,
                DnsResourceRecord **ret_rrsig) {
 
        bool found_rrsig = false, found_invalid = false, found_expired_rrsig = false, found_unsupported_algorithm = false;
        unsigned nvalidations = 0;
        DnsResourceRecord *rrsig;
        int r;
 
        assert(key);
        assert(result);
 
        /* Verifies all RRs from "a" that match the key "key" against DNSKEYs in "validated_dnskeys" */
 
        if (dns_answer_isempty(a))
                return -ENODATA;
 
        /* Iterate through each RRSIG RR. */
        DNS_ANSWER_FOREACH(rrsig, a) {
                DnsResourceRecord *dnskey;
                DnsAnswerFlags flags;
 
                /* Is this an RRSIG RR that applies to RRs matching our key? */
                r = dnssec_key_match_rrsig(key, rrsig);
                if (r < 0)
                        return r;
                if (r == 0)
                        continue;
 
                found_rrsig = true;
 
                /* Look for a matching key */
                DNS_ANSWER_FOREACH_FLAGS(dnskey, flags, validated_dnskeys) {
                        DnssecResult one_result;
 
                        /* Is this a DNSKEY RR that matches they key of our RRSIG? */
                        r = dnssec_rrsig_match_dnskey(rrsig, dnskey, false);
                        if (r < 0)
                                return r;
                        if (r == 0)
                                continue;
 
                        if ((flags & DNS_ANSWER_AUTHENTICATED) == 0) {
                                /* An unauthenticated DNSKEY in validated_dnskeys is a key we are not able to
                                 * authenticate, but might still be valid. Record this as an unsupported
                                 * algorithm so we can still at least report an insecure answer. */
                                found_unsupported_algorithm = true;
                                continue;
                        }
 
                        /* Take the time here, if it isn't set yet, so
                         * that we do all validations with the same
                         * time. */
                        if (realtime == USEC_INFINITY)
                                realtime = now(CLOCK_REALTIME);
 
                        /* Have we seen an unreasonable number of invalid signatures? */
                        if (nvalidations > DNSSEC_INVALID_MAX) {
                                if (ret_rrsig)
                                        *ret_rrsig = NULL;
                                *result = DNSSEC_TOO_MANY_VALIDATIONS;
                                return (int) nvalidations;
                        }
 
                        /* Yay, we found a matching RRSIG with a matching
                         * DNSKEY, awesome. Now let's verify all entries of
                         * the RRSet against the RRSIG and DNSKEY
                         * combination. */
 
                        r = dnssec_verify_rrset(a, key, rrsig, dnskey, realtime, &one_result);
                        if (r < 0)
                                return r;
 
                        nvalidations++;
 
                        switch (one_result) {
 
                        case DNSSEC_VALIDATED:
                        case DNSSEC_VALIDATED_WILDCARD:
                                /* Yay, the RR has been validated,
                                 * return immediately, but fix up the expiry */
                                if (ret_rrsig)
                                        *ret_rrsig = rrsig;
 
                                *result = one_result;
                                return (int) nvalidations;