HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/firewall-util.c

42,967 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 239ccd4e8f6acf535eff5b3429bc8b8754afc9c7

Lines 1001–1338 of 1,338

 
        switch (af) {
        case AF_INET:
                return NFPROTO_IPV4;
        case AF_INET6:
                return NFPROTO_IPV6;
        default:
                assert_not_reached();
        }
}
 
int fw_nftables_add_masquerade(
                sd_netlink *nfnl,
                bool add,
                int af,
                const union in_addr_union *source,
                unsigned source_prefixlen) {
 
        int r;
 
        assert(nfnl);
        assert(IN_SET(af, AF_INET, AF_INET6));
 
        if (!socket_ipv6_is_supported() && af == AF_INET6)
                return -EOPNOTSUPP;
 
        r = nft_set_element_modify_iprange(nfnl, add, af_to_nfproto(af), af, nft_table_name(), NFT_SYSTEMD_MASQ_SET_NAME,
                                           source, source_prefixlen);
        if (r != -ENOENT)
                return r;
 
        /* When someone runs 'nft flush ruleset' in the same net namespace this will also tear down the
         * systemd nat table.
         *
         * Unlike iptables -t nat -F (which will remove all rules added by the systemd iptables
         * backend, iptables has builtin chains that cannot be deleted -- the next add operation will
         * 'just work'.
         *
         * In the nftables case, everything gets removed. The next add operation will yield -ENOENT.
         *
         * If we see -ENOENT on add, replay the initial table setup. If that works, re-do the add
         * operation.
         *
         * Note that this doesn't protect against external sabotage such as a
         * 'while true; nft flush ruleset; done'. There is nothing that could be done about that short
         * of extending the kernel to allow tables to be owned by stystemd-networkd and making them
         * non-deletable except by the 'owning process'. */
 
        r = fw_nftables_init_family(nfnl, af);
        if (r < 0)
                return r;
 
        return nft_set_element_modify_iprange(nfnl, add, af_to_nfproto(af), af, nft_table_name(), NFT_SYSTEMD_MASQ_SET_NAME,
                                              source, source_prefixlen);
}
 
static int fw_nftables_add_local_dnat_internal(
                sd_netlink *nfnl,
                bool add,
                int af,
                int protocol,
                uint16_t local_port,
                const union in_addr_union *remote,
                uint16_t remote_port,
                const union in_addr_union *previous_remote) {
 
        sd_netlink_message *messages[3] = {};
        CLEANUP_ELEMENTS(messages, sd_netlink_message_unref_array_clear);
        uint32_t data[5], key[2], dlen;
        size_t msgcnt = 0;
        int r;
 
        assert(nfnl);
        assert(add || !previous_remote);
        assert(IN_SET(af, AF_INET, AF_INET6));
 
        if (!IN_SET(protocol, IPPROTO_TCP, IPPROTO_UDP))
                return -EPROTONOSUPPORT;
 
        if (local_port <= 0)
                return -EINVAL;
 
        key[0] = protocol;
        key[1] = htobe16(local_port);
 
        if (!remote)
                return -EOPNOTSUPP;
 
        if (remote_port <= 0)
                return -EINVAL;
 
        if (af == AF_INET) {
                dlen = 8;
                data[1] = htobe16(remote_port);
        } else {
                assert(af == AF_INET6);
                dlen = sizeof(data);
                data[4] = htobe16(remote_port);
        }
 
        /* If a previous remote is set, remove its entry */
        if (add && previous_remote && !in_addr_equal(af, previous_remote, remote)) {
                if (af == AF_INET)
                        data[0] = previous_remote->in.s_addr;
                else
                        memcpy(data, &previous_remote->in6, sizeof(previous_remote->in6));
 
                r = nft_del_element(nfnl, &messages[msgcnt++], af, nft_table_name(), dnat_map_name(),
                                    key, sizeof(key), data, dlen);
                if (r < 0)
                        return r;
        }
 
        if (af == AF_INET)
                data[0] = remote->in.s_addr;
        else
                memcpy(data, &remote->in6, sizeof(remote->in6));
 
        if (add)
                r = nft_add_element(nfnl, &messages[msgcnt++], af_to_nfproto(af), nft_table_name(), dnat_map_name(),
                                    key, sizeof(key), data, dlen);
        else
                r = nft_del_element(nfnl, &messages[msgcnt++], af_to_nfproto(af), nft_table_name(), dnat_map_name(),
                                    key, sizeof(key), data, dlen);
        if (r < 0)
                return r;
 
        assert(msgcnt < ELEMENTSOF(messages));
        r = sd_nfnl_call_batch(nfnl, messages, msgcnt, NFNL_DEFAULT_TIMEOUT_USECS);
        if (r < 0)
                return r;
 
        return 0;
}
 
int fw_nftables_add_local_dnat(
                sd_netlink *nfnl,
                bool add,
                int af,
                int protocol,
                uint16_t local_port,
                const union in_addr_union *remote,
                uint16_t remote_port,
                const union in_addr_union *previous_remote) {
 
        int r;
 
        assert(nfnl);
        assert(IN_SET(af, AF_INET, AF_INET6));
 
        if (!socket_ipv6_is_supported() && af == AF_INET6)
                return -EOPNOTSUPP;
 
        r = fw_nftables_add_local_dnat_internal(nfnl, add, af, protocol, local_port, remote, remote_port, previous_remote);
        if (r != -ENOENT)
                return r;
 
        /* See comment in fw_nftables_add_masquerade(). */
        r = fw_nftables_init_family(nfnl, af);
        if (r < 0)
                return r;
 
        /* table created anew; previous address already gone */
        return fw_nftables_add_local_dnat_internal(nfnl, add, af, protocol, local_port, remote, remote_port, NULL);
}
 
static const char *const nfproto_table[] = {
        [NFPROTO_ARP]    = "arp",
        [NFPROTO_BRIDGE] = "bridge",
        [NFPROTO_INET]   = "inet",
        [NFPROTO_IPV4]   = "ip",
        [NFPROTO_IPV6]   = "ip6",
        [NFPROTO_NETDEV] = "netdev",
};
 
DEFINE_STRING_TABLE_LOOKUP(nfproto, int);
 
static const char *const nft_set_source_table[] = {
        [NFT_SET_SOURCE_ADDRESS] = "address",
        [NFT_SET_SOURCE_PREFIX]  = "prefix",
        [NFT_SET_SOURCE_IFINDEX] = "ifindex",
        [NFT_SET_SOURCE_CGROUP]  = "cgroup",
        [NFT_SET_SOURCE_USER]    = "user",
        [NFT_SET_SOURCE_GROUP]   = "group",
};
 
DEFINE_STRING_TABLE_LOOKUP(nft_set_source, int);
 
void nft_set_context_clear(NFTSetContext *s) {
        assert(s);
 
        FOREACH_ARRAY(nft_set, s->sets, s->n_sets) {
                free(nft_set->table);
                free(nft_set->set);
        }
 
        s->n_sets = 0;
        s->sets = mfree(s->sets);
}
 
int nft_set_add(NFTSetContext *s, NFTSetSource source, int nfproto, const char *table, const char *set) {
        _cleanup_free_ char *table_dup = NULL, *set_dup = NULL;
 
        assert(s);
        assert(IN_SET(source, NFT_SET_SOURCE_ADDRESS, NFT_SET_SOURCE_PREFIX, NFT_SET_SOURCE_IFINDEX, NFT_SET_SOURCE_CGROUP, NFT_SET_SOURCE_USER, NFT_SET_SOURCE_GROUP));
        assert(nfproto_is_valid(nfproto));
        assert(table);
        assert(set);
 
        table_dup = strdup(table);
        if (!table_dup)
                return -ENOMEM;
 
        set_dup = strdup(set);
        if (!set_dup)
                return -ENOMEM;
 
        if (!GREEDY_REALLOC(s->sets, s->n_sets + 1))
                return -ENOMEM;
 
        s->sets[s->n_sets++] = (NFTSet) {
                .source = source,
                .nfproto = nfproto,
                .table = TAKE_PTR(table_dup),
                .set = TAKE_PTR(set_dup),
        };
 
        return 0;
}
 
int nft_set_context_dup(const NFTSetContext *src, NFTSetContext *dst) {
        int r;
        _cleanup_(nft_set_context_clear) NFTSetContext d = (NFTSetContext) {};
 
        assert(src);
        assert(dst);
 
        FOREACH_ARRAY(nft_set, src->sets, src->n_sets) {
                r = nft_set_add(&d, nft_set->source, nft_set->nfproto, nft_set->table, nft_set->set);
                if (r < 0)
                        return r;
        }
 
        *dst = TAKE_STRUCT(d);
 
        return 0;
}
 
int config_parse_nft_set(
                const char *unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {
 
        NFTSetContext *nft_set_context = ASSERT_PTR(data);
        int r;
 
        assert(IN_SET(ltype, NFT_SET_PARSE_NETWORK, NFT_SET_PARSE_CGROUP));
 
        if (isempty(rvalue)) {
                nft_set_context_clear(nft_set_context);
                return 1;
        }
 
        for (const char *p = rvalue;;) {
                _cleanup_free_ char *tuple = NULL, *source_str = NULL, *family_str = NULL, *table = NULL, *set = NULL;
                const char *q = NULL;
                int nfproto;
                NFTSetSource source;
 
                r = extract_first_word(&p, &tuple, NULL, EXTRACT_UNQUOTE|EXTRACT_RETAIN_ESCAPE);
                if (r < 0)
                        return log_syntax_parse_error(unit, filename, line, r, lvalue, rvalue);
                if (r == 0)
                        return 1;
 
                q = tuple;
                r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE, &source_str, &family_str, &table, &set);
                if (r == -ENOMEM)
                        return log_oom();
                if (r != 4 || !isempty(q)) {
                        _cleanup_free_ char *esc = NULL;
 
                        esc = cescape(tuple);
                        return log_syntax(unit, LOG_WARNING, filename, line, 0, "Failed to parse NFT set %s, ignoring", strna(esc));
                }
 
                assert(source_str);
                assert(family_str);
                assert(table);
                assert(set);
 
                source = nft_set_source_from_string(source_str);
                if (source < 0 ||
                    (ltype == NFT_SET_PARSE_NETWORK && !IN_SET(source, NFT_SET_SOURCE_ADDRESS, NFT_SET_SOURCE_PREFIX, NFT_SET_SOURCE_IFINDEX)) ||
                    (ltype == NFT_SET_PARSE_CGROUP && !IN_SET(source, NFT_SET_SOURCE_CGROUP, NFT_SET_SOURCE_USER, NFT_SET_SOURCE_GROUP))) {
                        _cleanup_free_ char *esc = NULL;
 
                        esc = cescape(source_str);
                        return log_syntax(unit, LOG_WARNING, filename, line, 0, "Unknown NFT source %s, ignoring", strna(esc));
                }
 
                nfproto = nfproto_from_string(family_str);
                if (nfproto < 0) {
                        _cleanup_free_ char *esc = NULL;
 
                        esc = cescape(family_str);
                        return log_syntax(unit, LOG_WARNING, filename, line, 0, "Unknown NFT protocol family %s, ignoring", strna(esc));
                }
 
                if (!nft_identifier_valid(table)) {
                        _cleanup_free_ char *esc = NULL;
 
                        esc = cescape(table);
                        return log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid table name %s, ignoring", strna(esc));
                }
 
                if (!nft_identifier_valid(set)) {
                        _cleanup_free_ char *esc = NULL;
 
                        esc = cescape(set);
                        return log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid set name %s, ignoring", strna(esc));
                }
 
                r = nft_set_add(nft_set_context, source, nfproto, table, set);
                if (r < 0)
                        return log_oom();
        }
 
        assert_not_reached();
}