HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/network/netdev/wireguard.c

44,285 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: daf4ff458f2ea4af27d4a1daac96421a70b529da

Lines 1001–1274 of 1,274

                void *data,
                void *userdata) {
 
        uint32_t *priority = ASSERT_PTR(data);
        int r;
 
        assert(filename);
        assert(lvalue);
        assert(rvalue);
 
        if (isempty(rvalue)) {
                *priority = 0;
                return 0;
        }
 
        r = safe_atou32(rvalue, priority);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Could not parse route priority \"%s\", ignoring assignment: %m", rvalue);
                return 0;
        }
 
        return 0;
}
 
int config_parse_wireguard_peer_route_priority(
                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) {
 
        _cleanup_(wireguard_peer_free_or_set_invalidp) WireguardPeer *peer = NULL;
        Wireguard *w;
        int r;
 
        assert(filename);
        assert(lvalue);
        assert(rvalue);
        assert(userdata);
 
        w = WIREGUARD(userdata);
        assert(w);
 
        r = wireguard_peer_new_static(w, filename, section_line, &peer);
        if (r < 0)
                return log_oom();
 
        if (isempty(rvalue)) {
                peer->route_priority_set = false; /* Use the priority specified in [WireGuard] section. */
                TAKE_PTR(peer);
                return 0;
        }
 
        r = safe_atou32(rvalue, &peer->route_priority);
        if (r < 0) {
                log_syntax(unit, LOG_WARNING, filename, line, r,
                           "Could not parse route priority \"%s\", ignoring assignment: %m", rvalue);
                return 0;
        }
 
        peer->route_priority_set = true;
        TAKE_PTR(peer);
        return 0;
}
 
static void wireguard_init(NetDev *netdev) {
        Wireguard *w = WIREGUARD(netdev);
 
        w->flags = WGDEVICE_F_REPLACE_PEERS;
}
 
static void wireguard_done(NetDev *netdev) {
        Wireguard *w = WIREGUARD(netdev);
 
        explicit_bzero_safe(w->private_key, WG_KEY_LEN);
        free(w->private_key_file);
 
        hashmap_free(w->peers_by_section);
 
        set_free(w->routes);
}
 
static int wireguard_read_key_file(const char *filename, uint8_t dest[static WG_KEY_LEN]) {
        _cleanup_(erase_and_freep) char *key = NULL;
        size_t key_len;
        int r;
 
        if (!filename)
                return 0;
 
        assert(dest);
 
        r = read_full_file_full(
                        AT_FDCWD, filename, UINT64_MAX, WG_KEY_LEN,
                        READ_FULL_FILE_SECURE |
                        READ_FULL_FILE_UNBASE64 |
                        READ_FULL_FILE_WARN_WORLD_READABLE |
                        READ_FULL_FILE_CONNECT_SOCKET |
                        READ_FULL_FILE_FAIL_WHEN_LARGER,
                        NULL, &key, &key_len);
        if (r < 0)
                return r;
 
        if (key_len != WG_KEY_LEN)
                return -EINVAL;
 
        memcpy(dest, key, WG_KEY_LEN);
        return 0;
}
 
static int wireguard_peer_verify(WireguardPeer *peer) {
        NetDev *netdev = NETDEV(peer->wireguard);
        int r;
 
        if (section_is_invalid(peer->section))
                return -EINVAL;
 
        r = wireguard_read_key_file(peer->public_key_file, peer->public_key);
        if (r < 0)
                return log_netdev_error_errno(netdev, r,
                                              "%s: Failed to read public key from '%s'. "
                                              "Ignoring [WireGuardPeer] section from line %u.",
                                              peer->section->filename, peer->public_key_file,
                                              peer->section->line);
 
        if (eqzero(peer->public_key))
                return log_netdev_error_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
                                              "%s: WireGuardPeer section without PublicKey= configured. "
                                              "Ignoring [WireGuardPeer] section from line %u.",
                                              peer->section->filename, peer->section->line);
 
        r = wireguard_read_key_file(peer->preshared_key_file, peer->preshared_key);
        if (r < 0)
                return log_netdev_error_errno(netdev, r,
                                              "%s: Failed to read preshared key from '%s'. "
                                              "Ignoring [WireGuardPeer] section from line %u.",
                                              peer->section->filename, peer->preshared_key_file,
                                              peer->section->line);
 
        return 0;
}
 
static int wireguard_read_default_key_cred(NetDev *netdev, const char *filename) {
        Wireguard *w = WIREGUARD(netdev);
        _cleanup_free_ char *config_name = NULL;
        int r;
 
        assert(filename);
 
        r = path_extract_filename(filename, &config_name);
        if (r < 0)
                return log_netdev_error_errno(netdev, r,
                                              "%s: Failed to extract config name, ignoring network device: %m",
                                              filename);
 
        char *p = endswith(config_name, ".netdev");
        if (!p)
                /* Fuzzer run? Then we just ignore this device. */
                return log_netdev_error_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
                                              "%s: Invalid netdev config name, refusing default key lookup.",
                                              filename);
        *p = '\0';
 
        _cleanup_(erase_and_freep) char *cred = NULL;
 
        r = read_credential(strjoina("network.wireguard.private.", config_name), (void**) &cred, /* ret_size= */ NULL);
        if (r < 0)
                return log_netdev_error_errno(netdev, r,
                                              "%s: No private key specified and default key isn't available, "
                                              "ignoring network device: %m",
                                              filename);
 
        _cleanup_(erase_and_freep) void *key = NULL;
        size_t len;
 
        r = unbase64mem_full(cred, SIZE_MAX, /* secure= */ true, &key, &len);
        if (r < 0)
                return log_netdev_error_errno(netdev, r,
                                              "%s: No private key specified and default key cannot be parsed, "
                                              "ignoring network device: %m",
                                              filename);
        if (len != WG_KEY_LEN || memeqzero(key, len))
                return log_netdev_error_errno(netdev, SYNTHETIC_ERRNO(EINVAL),
                                              "%s: No private key specified and default key is invalid. "
                                              "Ignoring network device.",
                                              filename);
 
        memcpy(w->private_key, key, WG_KEY_LEN);
        return 0;
}
 
static int wireguard_verify(NetDev *netdev, const char *filename) {
        Wireguard *w = WIREGUARD(netdev);
        int r;
 
        r = wireguard_read_key_file(w->private_key_file, w->private_key);
        if (r < 0)
                return log_netdev_error_errno(netdev, r,
                                              "Failed to read private key from '%s', ignoring network device: %m",
                                              w->private_key_file);
 
        if (eqzero(w->private_key)) {
                r = wireguard_read_default_key_cred(netdev, filename);
                if (r < 0)
                        return r;
        }
 
        LIST_FOREACH(peers, peer, w->peers) {
                if (wireguard_peer_verify(peer) < 0) {
                        wireguard_peer_free(peer);
                        continue;
                }
 
                if ((peer->route_table_set ? peer->route_table : w->route_table) == 0)
                        continue;
 
                LIST_FOREACH(ipmasks, ipmask, peer->ipmasks) {
                        _cleanup_(route_unrefp) Route *route = NULL;
 
                        r = route_new(&route);
                        if (r < 0)
                                return log_oom();
 
                        /* For route_section_verify() below. */
                        r = config_section_new(peer->section->filename, peer->section->line, &route->section);
                        if (r < 0)
                                return log_oom();
 
                        route->source = NETWORK_CONFIG_SOURCE_STATIC;
                        route->family = ipmask->family;
                        route->dst = ipmask->ip;
                        route->dst_prefixlen = ipmask->cidr;
                        route->protocol = RTPROT_STATIC;
                        route->protocol_set = true;
                        route->table = peer->route_table_set ? peer->route_table : w->route_table;
                        route->table_set = true;
                        route->priority = peer->route_priority_set ? peer->route_priority : w->route_priority;
                        route->priority_set = true;
 
                        if (route_section_verify(route) < 0)
                                continue;
 
                        r = set_ensure_put(&w->routes, &route_hash_ops, route);
                        if (r < 0)
                                return log_oom();
                        if (r == 0)
                                continue;
 
                        route->wireguard = w;
                        TAKE_PTR(route);
                }
        }
 
        return 0;
}
 
const NetDevVTable wireguard_vtable = {
        .object_size = sizeof(Wireguard),
        .sections = NETDEV_COMMON_SECTIONS "WireGuard\0WireGuardPeer\0",
        .post_create = netdev_wireguard_post_create,
        .init = wireguard_init,
        .done = wireguard_done,
        .create_type = NETDEV_CREATE_INDEPENDENT,
        .config_verify = wireguard_verify,
        .iftype = ARPHRD_NONE,
        .keep_existing = true,
};