mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 02:39:48 +00:00
![Jakub Kicinski](/assets/img/avatar_default.png)
We had historically not checked that genlmsghdr.reserved is 0 on input which prevents us from using those precious bytes in the future. One use case would be to extend the cmd field, which is currently just 8 bits wide and 256 is not a lot of commands for some core families. To make sure that new families do the right thing by default put the onus of opting out of validation on existing families. Signed-off-by: Jakub Kicinski <kuba@kernel.org> Acked-by: Paul Moore <paul@paul-moore.com> (NetLabel) Signed-off-by: David S. Miller <davem@davemloft.net>
1557 lines
42 KiB
C
1557 lines
42 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* NetLabel Unlabeled Support
|
|
*
|
|
* This file defines functions for dealing with unlabeled packets for the
|
|
* NetLabel system. The NetLabel system manages static and dynamic label
|
|
* mappings for network protocols such as CIPSO and RIPSO.
|
|
*
|
|
* Author: Paul Moore <paul@paul-moore.com>
|
|
*/
|
|
|
|
/*
|
|
* (c) Copyright Hewlett-Packard Development Company, L.P., 2006 - 2008
|
|
*/
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/rcupdate.h>
|
|
#include <linux/list.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/socket.h>
|
|
#include <linux/string.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/audit.h>
|
|
#include <linux/in.h>
|
|
#include <linux/in6.h>
|
|
#include <linux/ip.h>
|
|
#include <linux/ipv6.h>
|
|
#include <linux/notifier.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/security.h>
|
|
#include <linux/slab.h>
|
|
#include <net/sock.h>
|
|
#include <net/netlink.h>
|
|
#include <net/genetlink.h>
|
|
#include <net/ip.h>
|
|
#include <net/ipv6.h>
|
|
#include <net/net_namespace.h>
|
|
#include <net/netlabel.h>
|
|
#include <asm/bug.h>
|
|
#include <linux/atomic.h>
|
|
|
|
#include "netlabel_user.h"
|
|
#include "netlabel_addrlist.h"
|
|
#include "netlabel_domainhash.h"
|
|
#include "netlabel_unlabeled.h"
|
|
#include "netlabel_mgmt.h"
|
|
|
|
/* NOTE: at present we always use init's network namespace since we don't
|
|
* presently support different namespaces even though the majority of
|
|
* the functions in this file are "namespace safe" */
|
|
|
|
/* The unlabeled connection hash table which we use to map network interfaces
|
|
* and addresses of unlabeled packets to a user specified secid value for the
|
|
* LSM. The hash table is used to lookup the network interface entry
|
|
* (struct netlbl_unlhsh_iface) and then the interface entry is used to
|
|
* lookup an IP address match from an ordered list. If a network interface
|
|
* match can not be found in the hash table then the default entry
|
|
* (netlbl_unlhsh_def) is used. The IP address entry list
|
|
* (struct netlbl_unlhsh_addr) is ordered such that the entries with a
|
|
* larger netmask come first.
|
|
*/
|
|
struct netlbl_unlhsh_tbl {
|
|
struct list_head *tbl;
|
|
u32 size;
|
|
};
|
|
#define netlbl_unlhsh_addr4_entry(iter) \
|
|
container_of(iter, struct netlbl_unlhsh_addr4, list)
|
|
struct netlbl_unlhsh_addr4 {
|
|
u32 secid;
|
|
|
|
struct netlbl_af4list list;
|
|
struct rcu_head rcu;
|
|
};
|
|
#define netlbl_unlhsh_addr6_entry(iter) \
|
|
container_of(iter, struct netlbl_unlhsh_addr6, list)
|
|
struct netlbl_unlhsh_addr6 {
|
|
u32 secid;
|
|
|
|
struct netlbl_af6list list;
|
|
struct rcu_head rcu;
|
|
};
|
|
struct netlbl_unlhsh_iface {
|
|
int ifindex;
|
|
struct list_head addr4_list;
|
|
struct list_head addr6_list;
|
|
|
|
u32 valid;
|
|
struct list_head list;
|
|
struct rcu_head rcu;
|
|
};
|
|
|
|
/* Argument struct for netlbl_unlhsh_walk() */
|
|
struct netlbl_unlhsh_walk_arg {
|
|
struct netlink_callback *nl_cb;
|
|
struct sk_buff *skb;
|
|
u32 seq;
|
|
};
|
|
|
|
/* Unlabeled connection hash table */
|
|
/* updates should be so rare that having one spinlock for the entire
|
|
* hash table should be okay */
|
|
static DEFINE_SPINLOCK(netlbl_unlhsh_lock);
|
|
#define netlbl_unlhsh_rcu_deref(p) \
|
|
rcu_dereference_check(p, lockdep_is_held(&netlbl_unlhsh_lock))
|
|
static struct netlbl_unlhsh_tbl __rcu *netlbl_unlhsh;
|
|
static struct netlbl_unlhsh_iface __rcu *netlbl_unlhsh_def;
|
|
|
|
/* Accept unlabeled packets flag */
|
|
static u8 netlabel_unlabel_acceptflg;
|
|
|
|
/* NetLabel Generic NETLINK unlabeled family */
|
|
static struct genl_family netlbl_unlabel_gnl_family;
|
|
|
|
/* NetLabel Netlink attribute policy */
|
|
static const struct nla_policy netlbl_unlabel_genl_policy[NLBL_UNLABEL_A_MAX + 1] = {
|
|
[NLBL_UNLABEL_A_ACPTFLG] = { .type = NLA_U8 },
|
|
[NLBL_UNLABEL_A_IPV6ADDR] = { .type = NLA_BINARY,
|
|
.len = sizeof(struct in6_addr) },
|
|
[NLBL_UNLABEL_A_IPV6MASK] = { .type = NLA_BINARY,
|
|
.len = sizeof(struct in6_addr) },
|
|
[NLBL_UNLABEL_A_IPV4ADDR] = { .type = NLA_BINARY,
|
|
.len = sizeof(struct in_addr) },
|
|
[NLBL_UNLABEL_A_IPV4MASK] = { .type = NLA_BINARY,
|
|
.len = sizeof(struct in_addr) },
|
|
[NLBL_UNLABEL_A_IFACE] = { .type = NLA_NUL_STRING,
|
|
.len = IFNAMSIZ - 1 },
|
|
[NLBL_UNLABEL_A_SECCTX] = { .type = NLA_BINARY }
|
|
};
|
|
|
|
/*
|
|
* Unlabeled Connection Hash Table Functions
|
|
*/
|
|
|
|
/**
|
|
* netlbl_unlhsh_free_iface - Frees an interface entry from the hash table
|
|
* @entry: the entry's RCU field
|
|
*
|
|
* Description:
|
|
* This function is designed to be used as a callback to the call_rcu()
|
|
* function so that memory allocated to a hash table interface entry can be
|
|
* released safely. It is important to note that this function does not free
|
|
* the IPv4 and IPv6 address lists contained as part of an interface entry. It
|
|
* is up to the rest of the code to make sure an interface entry is only freed
|
|
* once it's address lists are empty.
|
|
*
|
|
*/
|
|
static void netlbl_unlhsh_free_iface(struct rcu_head *entry)
|
|
{
|
|
struct netlbl_unlhsh_iface *iface;
|
|
struct netlbl_af4list *iter4;
|
|
struct netlbl_af4list *tmp4;
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
struct netlbl_af6list *iter6;
|
|
struct netlbl_af6list *tmp6;
|
|
#endif /* IPv6 */
|
|
|
|
iface = container_of(entry, struct netlbl_unlhsh_iface, rcu);
|
|
|
|
/* no need for locks here since we are the only one with access to this
|
|
* structure */
|
|
|
|
netlbl_af4list_foreach_safe(iter4, tmp4, &iface->addr4_list) {
|
|
netlbl_af4list_remove_entry(iter4);
|
|
kfree(netlbl_unlhsh_addr4_entry(iter4));
|
|
}
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
netlbl_af6list_foreach_safe(iter6, tmp6, &iface->addr6_list) {
|
|
netlbl_af6list_remove_entry(iter6);
|
|
kfree(netlbl_unlhsh_addr6_entry(iter6));
|
|
}
|
|
#endif /* IPv6 */
|
|
kfree(iface);
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlhsh_hash - Hashing function for the hash table
|
|
* @ifindex: the network interface/device to hash
|
|
*
|
|
* Description:
|
|
* This is the hashing function for the unlabeled hash table, it returns the
|
|
* bucket number for the given device/interface. The caller is responsible for
|
|
* ensuring that the hash table is protected with either a RCU read lock or
|
|
* the hash table lock.
|
|
*
|
|
*/
|
|
static u32 netlbl_unlhsh_hash(int ifindex)
|
|
{
|
|
return ifindex & (netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->size - 1);
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlhsh_search_iface - Search for a matching interface entry
|
|
* @ifindex: the network interface
|
|
*
|
|
* Description:
|
|
* Searches the unlabeled connection hash table and returns a pointer to the
|
|
* interface entry which matches @ifindex, otherwise NULL is returned. The
|
|
* caller is responsible for ensuring that the hash table is protected with
|
|
* either a RCU read lock or the hash table lock.
|
|
*
|
|
*/
|
|
static struct netlbl_unlhsh_iface *netlbl_unlhsh_search_iface(int ifindex)
|
|
{
|
|
u32 bkt;
|
|
struct list_head *bkt_list;
|
|
struct netlbl_unlhsh_iface *iter;
|
|
|
|
bkt = netlbl_unlhsh_hash(ifindex);
|
|
bkt_list = &netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt];
|
|
list_for_each_entry_rcu(iter, bkt_list, list,
|
|
lockdep_is_held(&netlbl_unlhsh_lock))
|
|
if (iter->valid && iter->ifindex == ifindex)
|
|
return iter;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlhsh_add_addr4 - Add a new IPv4 address entry to the hash table
|
|
* @iface: the associated interface entry
|
|
* @addr: IPv4 address in network byte order
|
|
* @mask: IPv4 address mask in network byte order
|
|
* @secid: LSM secid value for entry
|
|
*
|
|
* Description:
|
|
* Add a new address entry into the unlabeled connection hash table using the
|
|
* interface entry specified by @iface. On success zero is returned, otherwise
|
|
* a negative value is returned.
|
|
*
|
|
*/
|
|
static int netlbl_unlhsh_add_addr4(struct netlbl_unlhsh_iface *iface,
|
|
const struct in_addr *addr,
|
|
const struct in_addr *mask,
|
|
u32 secid)
|
|
{
|
|
int ret_val;
|
|
struct netlbl_unlhsh_addr4 *entry;
|
|
|
|
entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
|
|
if (entry == NULL)
|
|
return -ENOMEM;
|
|
|
|
entry->list.addr = addr->s_addr & mask->s_addr;
|
|
entry->list.mask = mask->s_addr;
|
|
entry->list.valid = 1;
|
|
entry->secid = secid;
|
|
|
|
spin_lock(&netlbl_unlhsh_lock);
|
|
ret_val = netlbl_af4list_add(&entry->list, &iface->addr4_list);
|
|
spin_unlock(&netlbl_unlhsh_lock);
|
|
|
|
if (ret_val != 0)
|
|
kfree(entry);
|
|
return ret_val;
|
|
}
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
/**
|
|
* netlbl_unlhsh_add_addr6 - Add a new IPv6 address entry to the hash table
|
|
* @iface: the associated interface entry
|
|
* @addr: IPv6 address in network byte order
|
|
* @mask: IPv6 address mask in network byte order
|
|
* @secid: LSM secid value for entry
|
|
*
|
|
* Description:
|
|
* Add a new address entry into the unlabeled connection hash table using the
|
|
* interface entry specified by @iface. On success zero is returned, otherwise
|
|
* a negative value is returned.
|
|
*
|
|
*/
|
|
static int netlbl_unlhsh_add_addr6(struct netlbl_unlhsh_iface *iface,
|
|
const struct in6_addr *addr,
|
|
const struct in6_addr *mask,
|
|
u32 secid)
|
|
{
|
|
int ret_val;
|
|
struct netlbl_unlhsh_addr6 *entry;
|
|
|
|
entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
|
|
if (entry == NULL)
|
|
return -ENOMEM;
|
|
|
|
entry->list.addr = *addr;
|
|
entry->list.addr.s6_addr32[0] &= mask->s6_addr32[0];
|
|
entry->list.addr.s6_addr32[1] &= mask->s6_addr32[1];
|
|
entry->list.addr.s6_addr32[2] &= mask->s6_addr32[2];
|
|
entry->list.addr.s6_addr32[3] &= mask->s6_addr32[3];
|
|
entry->list.mask = *mask;
|
|
entry->list.valid = 1;
|
|
entry->secid = secid;
|
|
|
|
spin_lock(&netlbl_unlhsh_lock);
|
|
ret_val = netlbl_af6list_add(&entry->list, &iface->addr6_list);
|
|
spin_unlock(&netlbl_unlhsh_lock);
|
|
|
|
if (ret_val != 0)
|
|
kfree(entry);
|
|
return 0;
|
|
}
|
|
#endif /* IPv6 */
|
|
|
|
/**
|
|
* netlbl_unlhsh_add_iface - Adds a new interface entry to the hash table
|
|
* @ifindex: network interface
|
|
*
|
|
* Description:
|
|
* Add a new, empty, interface entry into the unlabeled connection hash table.
|
|
* On success a pointer to the new interface entry is returned, on failure NULL
|
|
* is returned.
|
|
*
|
|
*/
|
|
static struct netlbl_unlhsh_iface *netlbl_unlhsh_add_iface(int ifindex)
|
|
{
|
|
u32 bkt;
|
|
struct netlbl_unlhsh_iface *iface;
|
|
|
|
iface = kzalloc(sizeof(*iface), GFP_ATOMIC);
|
|
if (iface == NULL)
|
|
return NULL;
|
|
|
|
iface->ifindex = ifindex;
|
|
INIT_LIST_HEAD(&iface->addr4_list);
|
|
INIT_LIST_HEAD(&iface->addr6_list);
|
|
iface->valid = 1;
|
|
|
|
spin_lock(&netlbl_unlhsh_lock);
|
|
if (ifindex > 0) {
|
|
bkt = netlbl_unlhsh_hash(ifindex);
|
|
if (netlbl_unlhsh_search_iface(ifindex) != NULL)
|
|
goto add_iface_failure;
|
|
list_add_tail_rcu(&iface->list,
|
|
&netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt]);
|
|
} else {
|
|
INIT_LIST_HEAD(&iface->list);
|
|
if (netlbl_unlhsh_rcu_deref(netlbl_unlhsh_def) != NULL)
|
|
goto add_iface_failure;
|
|
rcu_assign_pointer(netlbl_unlhsh_def, iface);
|
|
}
|
|
spin_unlock(&netlbl_unlhsh_lock);
|
|
|
|
return iface;
|
|
|
|
add_iface_failure:
|
|
spin_unlock(&netlbl_unlhsh_lock);
|
|
kfree(iface);
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlhsh_add - Adds a new entry to the unlabeled connection hash table
|
|
* @net: network namespace
|
|
* @dev_name: interface name
|
|
* @addr: IP address in network byte order
|
|
* @mask: address mask in network byte order
|
|
* @addr_len: length of address/mask (4 for IPv4, 16 for IPv6)
|
|
* @secid: LSM secid value for the entry
|
|
* @audit_info: NetLabel audit information
|
|
*
|
|
* Description:
|
|
* Adds a new entry to the unlabeled connection hash table. Returns zero on
|
|
* success, negative values on failure.
|
|
*
|
|
*/
|
|
int netlbl_unlhsh_add(struct net *net,
|
|
const char *dev_name,
|
|
const void *addr,
|
|
const void *mask,
|
|
u32 addr_len,
|
|
u32 secid,
|
|
struct netlbl_audit *audit_info)
|
|
{
|
|
int ret_val;
|
|
int ifindex;
|
|
struct net_device *dev;
|
|
struct netlbl_unlhsh_iface *iface;
|
|
struct audit_buffer *audit_buf = NULL;
|
|
char *secctx = NULL;
|
|
u32 secctx_len;
|
|
|
|
if (addr_len != sizeof(struct in_addr) &&
|
|
addr_len != sizeof(struct in6_addr))
|
|
return -EINVAL;
|
|
|
|
rcu_read_lock();
|
|
if (dev_name != NULL) {
|
|
dev = dev_get_by_name_rcu(net, dev_name);
|
|
if (dev == NULL) {
|
|
ret_val = -ENODEV;
|
|
goto unlhsh_add_return;
|
|
}
|
|
ifindex = dev->ifindex;
|
|
iface = netlbl_unlhsh_search_iface(ifindex);
|
|
} else {
|
|
ifindex = 0;
|
|
iface = rcu_dereference(netlbl_unlhsh_def);
|
|
}
|
|
if (iface == NULL) {
|
|
iface = netlbl_unlhsh_add_iface(ifindex);
|
|
if (iface == NULL) {
|
|
ret_val = -ENOMEM;
|
|
goto unlhsh_add_return;
|
|
}
|
|
}
|
|
audit_buf = netlbl_audit_start_common(AUDIT_MAC_UNLBL_STCADD,
|
|
audit_info);
|
|
switch (addr_len) {
|
|
case sizeof(struct in_addr): {
|
|
const struct in_addr *addr4 = addr;
|
|
const struct in_addr *mask4 = mask;
|
|
|
|
ret_val = netlbl_unlhsh_add_addr4(iface, addr4, mask4, secid);
|
|
if (audit_buf != NULL)
|
|
netlbl_af4list_audit_addr(audit_buf, 1,
|
|
dev_name,
|
|
addr4->s_addr,
|
|
mask4->s_addr);
|
|
break;
|
|
}
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
case sizeof(struct in6_addr): {
|
|
const struct in6_addr *addr6 = addr;
|
|
const struct in6_addr *mask6 = mask;
|
|
|
|
ret_val = netlbl_unlhsh_add_addr6(iface, addr6, mask6, secid);
|
|
if (audit_buf != NULL)
|
|
netlbl_af6list_audit_addr(audit_buf, 1,
|
|
dev_name,
|
|
addr6, mask6);
|
|
break;
|
|
}
|
|
#endif /* IPv6 */
|
|
default:
|
|
ret_val = -EINVAL;
|
|
}
|
|
if (ret_val == 0)
|
|
atomic_inc(&netlabel_mgmt_protocount);
|
|
|
|
unlhsh_add_return:
|
|
rcu_read_unlock();
|
|
if (audit_buf != NULL) {
|
|
if (security_secid_to_secctx(secid,
|
|
&secctx,
|
|
&secctx_len) == 0) {
|
|
audit_log_format(audit_buf, " sec_obj=%s", secctx);
|
|
security_release_secctx(secctx, secctx_len);
|
|
}
|
|
audit_log_format(audit_buf, " res=%u", ret_val == 0 ? 1 : 0);
|
|
audit_log_end(audit_buf);
|
|
}
|
|
return ret_val;
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlhsh_remove_addr4 - Remove an IPv4 address entry
|
|
* @net: network namespace
|
|
* @iface: interface entry
|
|
* @addr: IP address
|
|
* @mask: IP address mask
|
|
* @audit_info: NetLabel audit information
|
|
*
|
|
* Description:
|
|
* Remove an IP address entry from the unlabeled connection hash table.
|
|
* Returns zero on success, negative values on failure.
|
|
*
|
|
*/
|
|
static int netlbl_unlhsh_remove_addr4(struct net *net,
|
|
struct netlbl_unlhsh_iface *iface,
|
|
const struct in_addr *addr,
|
|
const struct in_addr *mask,
|
|
struct netlbl_audit *audit_info)
|
|
{
|
|
struct netlbl_af4list *list_entry;
|
|
struct netlbl_unlhsh_addr4 *entry;
|
|
struct audit_buffer *audit_buf;
|
|
struct net_device *dev;
|
|
char *secctx;
|
|
u32 secctx_len;
|
|
|
|
spin_lock(&netlbl_unlhsh_lock);
|
|
list_entry = netlbl_af4list_remove(addr->s_addr, mask->s_addr,
|
|
&iface->addr4_list);
|
|
spin_unlock(&netlbl_unlhsh_lock);
|
|
if (list_entry != NULL)
|
|
entry = netlbl_unlhsh_addr4_entry(list_entry);
|
|
else
|
|
entry = NULL;
|
|
|
|
audit_buf = netlbl_audit_start_common(AUDIT_MAC_UNLBL_STCDEL,
|
|
audit_info);
|
|
if (audit_buf != NULL) {
|
|
dev = dev_get_by_index(net, iface->ifindex);
|
|
netlbl_af4list_audit_addr(audit_buf, 1,
|
|
(dev != NULL ? dev->name : NULL),
|
|
addr->s_addr, mask->s_addr);
|
|
dev_put(dev);
|
|
if (entry != NULL &&
|
|
security_secid_to_secctx(entry->secid,
|
|
&secctx, &secctx_len) == 0) {
|
|
audit_log_format(audit_buf, " sec_obj=%s", secctx);
|
|
security_release_secctx(secctx, secctx_len);
|
|
}
|
|
audit_log_format(audit_buf, " res=%u", entry != NULL ? 1 : 0);
|
|
audit_log_end(audit_buf);
|
|
}
|
|
|
|
if (entry == NULL)
|
|
return -ENOENT;
|
|
|
|
kfree_rcu(entry, rcu);
|
|
return 0;
|
|
}
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
/**
|
|
* netlbl_unlhsh_remove_addr6 - Remove an IPv6 address entry
|
|
* @net: network namespace
|
|
* @iface: interface entry
|
|
* @addr: IP address
|
|
* @mask: IP address mask
|
|
* @audit_info: NetLabel audit information
|
|
*
|
|
* Description:
|
|
* Remove an IP address entry from the unlabeled connection hash table.
|
|
* Returns zero on success, negative values on failure.
|
|
*
|
|
*/
|
|
static int netlbl_unlhsh_remove_addr6(struct net *net,
|
|
struct netlbl_unlhsh_iface *iface,
|
|
const struct in6_addr *addr,
|
|
const struct in6_addr *mask,
|
|
struct netlbl_audit *audit_info)
|
|
{
|
|
struct netlbl_af6list *list_entry;
|
|
struct netlbl_unlhsh_addr6 *entry;
|
|
struct audit_buffer *audit_buf;
|
|
struct net_device *dev;
|
|
char *secctx;
|
|
u32 secctx_len;
|
|
|
|
spin_lock(&netlbl_unlhsh_lock);
|
|
list_entry = netlbl_af6list_remove(addr, mask, &iface->addr6_list);
|
|
spin_unlock(&netlbl_unlhsh_lock);
|
|
if (list_entry != NULL)
|
|
entry = netlbl_unlhsh_addr6_entry(list_entry);
|
|
else
|
|
entry = NULL;
|
|
|
|
audit_buf = netlbl_audit_start_common(AUDIT_MAC_UNLBL_STCDEL,
|
|
audit_info);
|
|
if (audit_buf != NULL) {
|
|
dev = dev_get_by_index(net, iface->ifindex);
|
|
netlbl_af6list_audit_addr(audit_buf, 1,
|
|
(dev != NULL ? dev->name : NULL),
|
|
addr, mask);
|
|
dev_put(dev);
|
|
if (entry != NULL &&
|
|
security_secid_to_secctx(entry->secid,
|
|
&secctx, &secctx_len) == 0) {
|
|
audit_log_format(audit_buf, " sec_obj=%s", secctx);
|
|
security_release_secctx(secctx, secctx_len);
|
|
}
|
|
audit_log_format(audit_buf, " res=%u", entry != NULL ? 1 : 0);
|
|
audit_log_end(audit_buf);
|
|
}
|
|
|
|
if (entry == NULL)
|
|
return -ENOENT;
|
|
|
|
kfree_rcu(entry, rcu);
|
|
return 0;
|
|
}
|
|
#endif /* IPv6 */
|
|
|
|
/**
|
|
* netlbl_unlhsh_condremove_iface - Remove an interface entry
|
|
* @iface: the interface entry
|
|
*
|
|
* Description:
|
|
* Remove an interface entry from the unlabeled connection hash table if it is
|
|
* empty. An interface entry is considered to be empty if there are no
|
|
* address entries assigned to it.
|
|
*
|
|
*/
|
|
static void netlbl_unlhsh_condremove_iface(struct netlbl_unlhsh_iface *iface)
|
|
{
|
|
struct netlbl_af4list *iter4;
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
struct netlbl_af6list *iter6;
|
|
#endif /* IPv6 */
|
|
|
|
spin_lock(&netlbl_unlhsh_lock);
|
|
netlbl_af4list_foreach_rcu(iter4, &iface->addr4_list)
|
|
goto unlhsh_condremove_failure;
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
netlbl_af6list_foreach_rcu(iter6, &iface->addr6_list)
|
|
goto unlhsh_condremove_failure;
|
|
#endif /* IPv6 */
|
|
iface->valid = 0;
|
|
if (iface->ifindex > 0)
|
|
list_del_rcu(&iface->list);
|
|
else
|
|
RCU_INIT_POINTER(netlbl_unlhsh_def, NULL);
|
|
spin_unlock(&netlbl_unlhsh_lock);
|
|
|
|
call_rcu(&iface->rcu, netlbl_unlhsh_free_iface);
|
|
return;
|
|
|
|
unlhsh_condremove_failure:
|
|
spin_unlock(&netlbl_unlhsh_lock);
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlhsh_remove - Remove an entry from the unlabeled hash table
|
|
* @net: network namespace
|
|
* @dev_name: interface name
|
|
* @addr: IP address in network byte order
|
|
* @mask: address mask in network byte order
|
|
* @addr_len: length of address/mask (4 for IPv4, 16 for IPv6)
|
|
* @audit_info: NetLabel audit information
|
|
*
|
|
* Description:
|
|
* Removes and existing entry from the unlabeled connection hash table.
|
|
* Returns zero on success, negative values on failure.
|
|
*
|
|
*/
|
|
int netlbl_unlhsh_remove(struct net *net,
|
|
const char *dev_name,
|
|
const void *addr,
|
|
const void *mask,
|
|
u32 addr_len,
|
|
struct netlbl_audit *audit_info)
|
|
{
|
|
int ret_val;
|
|
struct net_device *dev;
|
|
struct netlbl_unlhsh_iface *iface;
|
|
|
|
if (addr_len != sizeof(struct in_addr) &&
|
|
addr_len != sizeof(struct in6_addr))
|
|
return -EINVAL;
|
|
|
|
rcu_read_lock();
|
|
if (dev_name != NULL) {
|
|
dev = dev_get_by_name_rcu(net, dev_name);
|
|
if (dev == NULL) {
|
|
ret_val = -ENODEV;
|
|
goto unlhsh_remove_return;
|
|
}
|
|
iface = netlbl_unlhsh_search_iface(dev->ifindex);
|
|
} else
|
|
iface = rcu_dereference(netlbl_unlhsh_def);
|
|
if (iface == NULL) {
|
|
ret_val = -ENOENT;
|
|
goto unlhsh_remove_return;
|
|
}
|
|
switch (addr_len) {
|
|
case sizeof(struct in_addr):
|
|
ret_val = netlbl_unlhsh_remove_addr4(net,
|
|
iface, addr, mask,
|
|
audit_info);
|
|
break;
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
case sizeof(struct in6_addr):
|
|
ret_val = netlbl_unlhsh_remove_addr6(net,
|
|
iface, addr, mask,
|
|
audit_info);
|
|
break;
|
|
#endif /* IPv6 */
|
|
default:
|
|
ret_val = -EINVAL;
|
|
}
|
|
if (ret_val == 0) {
|
|
netlbl_unlhsh_condremove_iface(iface);
|
|
atomic_dec(&netlabel_mgmt_protocount);
|
|
}
|
|
|
|
unlhsh_remove_return:
|
|
rcu_read_unlock();
|
|
return ret_val;
|
|
}
|
|
|
|
/*
|
|
* General Helper Functions
|
|
*/
|
|
|
|
/**
|
|
* netlbl_unlhsh_netdev_handler - Network device notification handler
|
|
* @this: notifier block
|
|
* @event: the event
|
|
* @ptr: the netdevice notifier info (cast to void)
|
|
*
|
|
* Description:
|
|
* Handle network device events, although at present all we care about is a
|
|
* network device going away. In the case of a device going away we clear any
|
|
* related entries from the unlabeled connection hash table.
|
|
*
|
|
*/
|
|
static int netlbl_unlhsh_netdev_handler(struct notifier_block *this,
|
|
unsigned long event, void *ptr)
|
|
{
|
|
struct net_device *dev = netdev_notifier_info_to_dev(ptr);
|
|
struct netlbl_unlhsh_iface *iface = NULL;
|
|
|
|
if (!net_eq(dev_net(dev), &init_net))
|
|
return NOTIFY_DONE;
|
|
|
|
/* XXX - should this be a check for NETDEV_DOWN or _UNREGISTER? */
|
|
if (event == NETDEV_DOWN) {
|
|
spin_lock(&netlbl_unlhsh_lock);
|
|
iface = netlbl_unlhsh_search_iface(dev->ifindex);
|
|
if (iface != NULL && iface->valid) {
|
|
iface->valid = 0;
|
|
list_del_rcu(&iface->list);
|
|
} else
|
|
iface = NULL;
|
|
spin_unlock(&netlbl_unlhsh_lock);
|
|
}
|
|
|
|
if (iface != NULL)
|
|
call_rcu(&iface->rcu, netlbl_unlhsh_free_iface);
|
|
|
|
return NOTIFY_DONE;
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlabel_acceptflg_set - Set the unlabeled accept flag
|
|
* @value: desired value
|
|
* @audit_info: NetLabel audit information
|
|
*
|
|
* Description:
|
|
* Set the value of the unlabeled accept flag to @value.
|
|
*
|
|
*/
|
|
static void netlbl_unlabel_acceptflg_set(u8 value,
|
|
struct netlbl_audit *audit_info)
|
|
{
|
|
struct audit_buffer *audit_buf;
|
|
u8 old_val;
|
|
|
|
old_val = netlabel_unlabel_acceptflg;
|
|
netlabel_unlabel_acceptflg = value;
|
|
audit_buf = netlbl_audit_start_common(AUDIT_MAC_UNLBL_ALLOW,
|
|
audit_info);
|
|
if (audit_buf != NULL) {
|
|
audit_log_format(audit_buf,
|
|
" unlbl_accept=%u old=%u", value, old_val);
|
|
audit_log_end(audit_buf);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlabel_addrinfo_get - Get the IPv4/6 address information
|
|
* @info: the Generic NETLINK info block
|
|
* @addr: the IP address
|
|
* @mask: the IP address mask
|
|
* @len: the address length
|
|
*
|
|
* Description:
|
|
* Examine the Generic NETLINK message and extract the IP address information.
|
|
* Returns zero on success, negative values on failure.
|
|
*
|
|
*/
|
|
static int netlbl_unlabel_addrinfo_get(struct genl_info *info,
|
|
void **addr,
|
|
void **mask,
|
|
u32 *len)
|
|
{
|
|
u32 addr_len;
|
|
|
|
if (info->attrs[NLBL_UNLABEL_A_IPV4ADDR] &&
|
|
info->attrs[NLBL_UNLABEL_A_IPV4MASK]) {
|
|
addr_len = nla_len(info->attrs[NLBL_UNLABEL_A_IPV4ADDR]);
|
|
if (addr_len != sizeof(struct in_addr) &&
|
|
addr_len != nla_len(info->attrs[NLBL_UNLABEL_A_IPV4MASK]))
|
|
return -EINVAL;
|
|
*len = addr_len;
|
|
*addr = nla_data(info->attrs[NLBL_UNLABEL_A_IPV4ADDR]);
|
|
*mask = nla_data(info->attrs[NLBL_UNLABEL_A_IPV4MASK]);
|
|
return 0;
|
|
} else if (info->attrs[NLBL_UNLABEL_A_IPV6ADDR]) {
|
|
addr_len = nla_len(info->attrs[NLBL_UNLABEL_A_IPV6ADDR]);
|
|
if (addr_len != sizeof(struct in6_addr) &&
|
|
addr_len != nla_len(info->attrs[NLBL_UNLABEL_A_IPV6MASK]))
|
|
return -EINVAL;
|
|
*len = addr_len;
|
|
*addr = nla_data(info->attrs[NLBL_UNLABEL_A_IPV6ADDR]);
|
|
*mask = nla_data(info->attrs[NLBL_UNLABEL_A_IPV6MASK]);
|
|
return 0;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
/*
|
|
* NetLabel Command Handlers
|
|
*/
|
|
|
|
/**
|
|
* netlbl_unlabel_accept - Handle an ACCEPT message
|
|
* @skb: the NETLINK buffer
|
|
* @info: the Generic NETLINK info block
|
|
*
|
|
* Description:
|
|
* Process a user generated ACCEPT message and set the accept flag accordingly.
|
|
* Returns zero on success, negative values on failure.
|
|
*
|
|
*/
|
|
static int netlbl_unlabel_accept(struct sk_buff *skb, struct genl_info *info)
|
|
{
|
|
u8 value;
|
|
struct netlbl_audit audit_info;
|
|
|
|
if (info->attrs[NLBL_UNLABEL_A_ACPTFLG]) {
|
|
value = nla_get_u8(info->attrs[NLBL_UNLABEL_A_ACPTFLG]);
|
|
if (value == 1 || value == 0) {
|
|
netlbl_netlink_auditinfo(&audit_info);
|
|
netlbl_unlabel_acceptflg_set(value, &audit_info);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlabel_list - Handle a LIST message
|
|
* @skb: the NETLINK buffer
|
|
* @info: the Generic NETLINK info block
|
|
*
|
|
* Description:
|
|
* Process a user generated LIST message and respond with the current status.
|
|
* Returns zero on success, negative values on failure.
|
|
*
|
|
*/
|
|
static int netlbl_unlabel_list(struct sk_buff *skb, struct genl_info *info)
|
|
{
|
|
int ret_val = -EINVAL;
|
|
struct sk_buff *ans_skb;
|
|
void *data;
|
|
|
|
ans_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
|
|
if (ans_skb == NULL)
|
|
goto list_failure;
|
|
data = genlmsg_put_reply(ans_skb, info, &netlbl_unlabel_gnl_family,
|
|
0, NLBL_UNLABEL_C_LIST);
|
|
if (data == NULL) {
|
|
ret_val = -ENOMEM;
|
|
goto list_failure;
|
|
}
|
|
|
|
ret_val = nla_put_u8(ans_skb,
|
|
NLBL_UNLABEL_A_ACPTFLG,
|
|
netlabel_unlabel_acceptflg);
|
|
if (ret_val != 0)
|
|
goto list_failure;
|
|
|
|
genlmsg_end(ans_skb, data);
|
|
return genlmsg_reply(ans_skb, info);
|
|
|
|
list_failure:
|
|
kfree_skb(ans_skb);
|
|
return ret_val;
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlabel_staticadd - Handle a STATICADD message
|
|
* @skb: the NETLINK buffer
|
|
* @info: the Generic NETLINK info block
|
|
*
|
|
* Description:
|
|
* Process a user generated STATICADD message and add a new unlabeled
|
|
* connection entry to the hash table. Returns zero on success, negative
|
|
* values on failure.
|
|
*
|
|
*/
|
|
static int netlbl_unlabel_staticadd(struct sk_buff *skb,
|
|
struct genl_info *info)
|
|
{
|
|
int ret_val;
|
|
char *dev_name;
|
|
void *addr;
|
|
void *mask;
|
|
u32 addr_len;
|
|
u32 secid;
|
|
struct netlbl_audit audit_info;
|
|
|
|
/* Don't allow users to add both IPv4 and IPv6 addresses for a
|
|
* single entry. However, allow users to create two entries, one each
|
|
* for IPv4 and IPv6, with the same LSM security context which should
|
|
* achieve the same result. */
|
|
if (!info->attrs[NLBL_UNLABEL_A_SECCTX] ||
|
|
!info->attrs[NLBL_UNLABEL_A_IFACE] ||
|
|
!((!info->attrs[NLBL_UNLABEL_A_IPV4ADDR] ||
|
|
!info->attrs[NLBL_UNLABEL_A_IPV4MASK]) ^
|
|
(!info->attrs[NLBL_UNLABEL_A_IPV6ADDR] ||
|
|
!info->attrs[NLBL_UNLABEL_A_IPV6MASK])))
|
|
return -EINVAL;
|
|
|
|
netlbl_netlink_auditinfo(&audit_info);
|
|
|
|
ret_val = netlbl_unlabel_addrinfo_get(info, &addr, &mask, &addr_len);
|
|
if (ret_val != 0)
|
|
return ret_val;
|
|
dev_name = nla_data(info->attrs[NLBL_UNLABEL_A_IFACE]);
|
|
ret_val = security_secctx_to_secid(
|
|
nla_data(info->attrs[NLBL_UNLABEL_A_SECCTX]),
|
|
nla_len(info->attrs[NLBL_UNLABEL_A_SECCTX]),
|
|
&secid);
|
|
if (ret_val != 0)
|
|
return ret_val;
|
|
|
|
return netlbl_unlhsh_add(&init_net,
|
|
dev_name, addr, mask, addr_len, secid,
|
|
&audit_info);
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlabel_staticadddef - Handle a STATICADDDEF message
|
|
* @skb: the NETLINK buffer
|
|
* @info: the Generic NETLINK info block
|
|
*
|
|
* Description:
|
|
* Process a user generated STATICADDDEF message and add a new default
|
|
* unlabeled connection entry. Returns zero on success, negative values on
|
|
* failure.
|
|
*
|
|
*/
|
|
static int netlbl_unlabel_staticadddef(struct sk_buff *skb,
|
|
struct genl_info *info)
|
|
{
|
|
int ret_val;
|
|
void *addr;
|
|
void *mask;
|
|
u32 addr_len;
|
|
u32 secid;
|
|
struct netlbl_audit audit_info;
|
|
|
|
/* Don't allow users to add both IPv4 and IPv6 addresses for a
|
|
* single entry. However, allow users to create two entries, one each
|
|
* for IPv4 and IPv6, with the same LSM security context which should
|
|
* achieve the same result. */
|
|
if (!info->attrs[NLBL_UNLABEL_A_SECCTX] ||
|
|
!((!info->attrs[NLBL_UNLABEL_A_IPV4ADDR] ||
|
|
!info->attrs[NLBL_UNLABEL_A_IPV4MASK]) ^
|
|
(!info->attrs[NLBL_UNLABEL_A_IPV6ADDR] ||
|
|
!info->attrs[NLBL_UNLABEL_A_IPV6MASK])))
|
|
return -EINVAL;
|
|
|
|
netlbl_netlink_auditinfo(&audit_info);
|
|
|
|
ret_val = netlbl_unlabel_addrinfo_get(info, &addr, &mask, &addr_len);
|
|
if (ret_val != 0)
|
|
return ret_val;
|
|
ret_val = security_secctx_to_secid(
|
|
nla_data(info->attrs[NLBL_UNLABEL_A_SECCTX]),
|
|
nla_len(info->attrs[NLBL_UNLABEL_A_SECCTX]),
|
|
&secid);
|
|
if (ret_val != 0)
|
|
return ret_val;
|
|
|
|
return netlbl_unlhsh_add(&init_net,
|
|
NULL, addr, mask, addr_len, secid,
|
|
&audit_info);
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlabel_staticremove - Handle a STATICREMOVE message
|
|
* @skb: the NETLINK buffer
|
|
* @info: the Generic NETLINK info block
|
|
*
|
|
* Description:
|
|
* Process a user generated STATICREMOVE message and remove the specified
|
|
* unlabeled connection entry. Returns zero on success, negative values on
|
|
* failure.
|
|
*
|
|
*/
|
|
static int netlbl_unlabel_staticremove(struct sk_buff *skb,
|
|
struct genl_info *info)
|
|
{
|
|
int ret_val;
|
|
char *dev_name;
|
|
void *addr;
|
|
void *mask;
|
|
u32 addr_len;
|
|
struct netlbl_audit audit_info;
|
|
|
|
/* See the note in netlbl_unlabel_staticadd() about not allowing both
|
|
* IPv4 and IPv6 in the same entry. */
|
|
if (!info->attrs[NLBL_UNLABEL_A_IFACE] ||
|
|
!((!info->attrs[NLBL_UNLABEL_A_IPV4ADDR] ||
|
|
!info->attrs[NLBL_UNLABEL_A_IPV4MASK]) ^
|
|
(!info->attrs[NLBL_UNLABEL_A_IPV6ADDR] ||
|
|
!info->attrs[NLBL_UNLABEL_A_IPV6MASK])))
|
|
return -EINVAL;
|
|
|
|
netlbl_netlink_auditinfo(&audit_info);
|
|
|
|
ret_val = netlbl_unlabel_addrinfo_get(info, &addr, &mask, &addr_len);
|
|
if (ret_val != 0)
|
|
return ret_val;
|
|
dev_name = nla_data(info->attrs[NLBL_UNLABEL_A_IFACE]);
|
|
|
|
return netlbl_unlhsh_remove(&init_net,
|
|
dev_name, addr, mask, addr_len,
|
|
&audit_info);
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlabel_staticremovedef - Handle a STATICREMOVEDEF message
|
|
* @skb: the NETLINK buffer
|
|
* @info: the Generic NETLINK info block
|
|
*
|
|
* Description:
|
|
* Process a user generated STATICREMOVEDEF message and remove the default
|
|
* unlabeled connection entry. Returns zero on success, negative values on
|
|
* failure.
|
|
*
|
|
*/
|
|
static int netlbl_unlabel_staticremovedef(struct sk_buff *skb,
|
|
struct genl_info *info)
|
|
{
|
|
int ret_val;
|
|
void *addr;
|
|
void *mask;
|
|
u32 addr_len;
|
|
struct netlbl_audit audit_info;
|
|
|
|
/* See the note in netlbl_unlabel_staticadd() about not allowing both
|
|
* IPv4 and IPv6 in the same entry. */
|
|
if (!((!info->attrs[NLBL_UNLABEL_A_IPV4ADDR] ||
|
|
!info->attrs[NLBL_UNLABEL_A_IPV4MASK]) ^
|
|
(!info->attrs[NLBL_UNLABEL_A_IPV6ADDR] ||
|
|
!info->attrs[NLBL_UNLABEL_A_IPV6MASK])))
|
|
return -EINVAL;
|
|
|
|
netlbl_netlink_auditinfo(&audit_info);
|
|
|
|
ret_val = netlbl_unlabel_addrinfo_get(info, &addr, &mask, &addr_len);
|
|
if (ret_val != 0)
|
|
return ret_val;
|
|
|
|
return netlbl_unlhsh_remove(&init_net,
|
|
NULL, addr, mask, addr_len,
|
|
&audit_info);
|
|
}
|
|
|
|
|
|
/**
|
|
* netlbl_unlabel_staticlist_gen - Generate messages for STATICLIST[DEF]
|
|
* @cmd: command/message
|
|
* @iface: the interface entry
|
|
* @addr4: the IPv4 address entry
|
|
* @addr6: the IPv6 address entry
|
|
* @arg: the netlbl_unlhsh_walk_arg structure
|
|
*
|
|
* Description:
|
|
* This function is designed to be used to generate a response for a
|
|
* STATICLIST or STATICLISTDEF message. When called either @addr4 or @addr6
|
|
* can be specified, not both, the other unspecified entry should be set to
|
|
* NULL by the caller. Returns the size of the message on success, negative
|
|
* values on failure.
|
|
*
|
|
*/
|
|
static int netlbl_unlabel_staticlist_gen(u32 cmd,
|
|
const struct netlbl_unlhsh_iface *iface,
|
|
const struct netlbl_unlhsh_addr4 *addr4,
|
|
const struct netlbl_unlhsh_addr6 *addr6,
|
|
void *arg)
|
|
{
|
|
int ret_val = -ENOMEM;
|
|
struct netlbl_unlhsh_walk_arg *cb_arg = arg;
|
|
struct net_device *dev;
|
|
void *data;
|
|
u32 secid;
|
|
char *secctx;
|
|
u32 secctx_len;
|
|
|
|
data = genlmsg_put(cb_arg->skb, NETLINK_CB(cb_arg->nl_cb->skb).portid,
|
|
cb_arg->seq, &netlbl_unlabel_gnl_family,
|
|
NLM_F_MULTI, cmd);
|
|
if (data == NULL)
|
|
goto list_cb_failure;
|
|
|
|
if (iface->ifindex > 0) {
|
|
dev = dev_get_by_index(&init_net, iface->ifindex);
|
|
if (!dev) {
|
|
ret_val = -ENODEV;
|
|
goto list_cb_failure;
|
|
}
|
|
ret_val = nla_put_string(cb_arg->skb,
|
|
NLBL_UNLABEL_A_IFACE, dev->name);
|
|
dev_put(dev);
|
|
if (ret_val != 0)
|
|
goto list_cb_failure;
|
|
}
|
|
|
|
if (addr4) {
|
|
struct in_addr addr_struct;
|
|
|
|
addr_struct.s_addr = addr4->list.addr;
|
|
ret_val = nla_put_in_addr(cb_arg->skb,
|
|
NLBL_UNLABEL_A_IPV4ADDR,
|
|
addr_struct.s_addr);
|
|
if (ret_val != 0)
|
|
goto list_cb_failure;
|
|
|
|
addr_struct.s_addr = addr4->list.mask;
|
|
ret_val = nla_put_in_addr(cb_arg->skb,
|
|
NLBL_UNLABEL_A_IPV4MASK,
|
|
addr_struct.s_addr);
|
|
if (ret_val != 0)
|
|
goto list_cb_failure;
|
|
|
|
secid = addr4->secid;
|
|
} else {
|
|
ret_val = nla_put_in6_addr(cb_arg->skb,
|
|
NLBL_UNLABEL_A_IPV6ADDR,
|
|
&addr6->list.addr);
|
|
if (ret_val != 0)
|
|
goto list_cb_failure;
|
|
|
|
ret_val = nla_put_in6_addr(cb_arg->skb,
|
|
NLBL_UNLABEL_A_IPV6MASK,
|
|
&addr6->list.mask);
|
|
if (ret_val != 0)
|
|
goto list_cb_failure;
|
|
|
|
secid = addr6->secid;
|
|
}
|
|
|
|
ret_val = security_secid_to_secctx(secid, &secctx, &secctx_len);
|
|
if (ret_val != 0)
|
|
goto list_cb_failure;
|
|
ret_val = nla_put(cb_arg->skb,
|
|
NLBL_UNLABEL_A_SECCTX,
|
|
secctx_len,
|
|
secctx);
|
|
security_release_secctx(secctx, secctx_len);
|
|
if (ret_val != 0)
|
|
goto list_cb_failure;
|
|
|
|
cb_arg->seq++;
|
|
genlmsg_end(cb_arg->skb, data);
|
|
return 0;
|
|
|
|
list_cb_failure:
|
|
genlmsg_cancel(cb_arg->skb, data);
|
|
return ret_val;
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlabel_staticlist - Handle a STATICLIST message
|
|
* @skb: the NETLINK buffer
|
|
* @cb: the NETLINK callback
|
|
*
|
|
* Description:
|
|
* Process a user generated STATICLIST message and dump the unlabeled
|
|
* connection hash table in a form suitable for use in a kernel generated
|
|
* STATICLIST message. Returns the length of @skb.
|
|
*
|
|
*/
|
|
static int netlbl_unlabel_staticlist(struct sk_buff *skb,
|
|
struct netlink_callback *cb)
|
|
{
|
|
struct netlbl_unlhsh_walk_arg cb_arg;
|
|
u32 skip_bkt = cb->args[0];
|
|
u32 skip_chain = cb->args[1];
|
|
u32 skip_addr4 = cb->args[2];
|
|
u32 iter_bkt, iter_chain = 0, iter_addr4 = 0, iter_addr6 = 0;
|
|
struct netlbl_unlhsh_iface *iface;
|
|
struct list_head *iter_list;
|
|
struct netlbl_af4list *addr4;
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
u32 skip_addr6 = cb->args[3];
|
|
struct netlbl_af6list *addr6;
|
|
#endif
|
|
|
|
cb_arg.nl_cb = cb;
|
|
cb_arg.skb = skb;
|
|
cb_arg.seq = cb->nlh->nlmsg_seq;
|
|
|
|
rcu_read_lock();
|
|
for (iter_bkt = skip_bkt;
|
|
iter_bkt < rcu_dereference(netlbl_unlhsh)->size;
|
|
iter_bkt++) {
|
|
iter_list = &rcu_dereference(netlbl_unlhsh)->tbl[iter_bkt];
|
|
list_for_each_entry_rcu(iface, iter_list, list) {
|
|
if (!iface->valid ||
|
|
iter_chain++ < skip_chain)
|
|
continue;
|
|
netlbl_af4list_foreach_rcu(addr4,
|
|
&iface->addr4_list) {
|
|
if (iter_addr4++ < skip_addr4)
|
|
continue;
|
|
if (netlbl_unlabel_staticlist_gen(
|
|
NLBL_UNLABEL_C_STATICLIST,
|
|
iface,
|
|
netlbl_unlhsh_addr4_entry(addr4),
|
|
NULL,
|
|
&cb_arg) < 0) {
|
|
iter_addr4--;
|
|
iter_chain--;
|
|
goto unlabel_staticlist_return;
|
|
}
|
|
}
|
|
iter_addr4 = 0;
|
|
skip_addr4 = 0;
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
netlbl_af6list_foreach_rcu(addr6,
|
|
&iface->addr6_list) {
|
|
if (iter_addr6++ < skip_addr6)
|
|
continue;
|
|
if (netlbl_unlabel_staticlist_gen(
|
|
NLBL_UNLABEL_C_STATICLIST,
|
|
iface,
|
|
NULL,
|
|
netlbl_unlhsh_addr6_entry(addr6),
|
|
&cb_arg) < 0) {
|
|
iter_addr6--;
|
|
iter_chain--;
|
|
goto unlabel_staticlist_return;
|
|
}
|
|
}
|
|
iter_addr6 = 0;
|
|
skip_addr6 = 0;
|
|
#endif /* IPv6 */
|
|
}
|
|
iter_chain = 0;
|
|
skip_chain = 0;
|
|
}
|
|
|
|
unlabel_staticlist_return:
|
|
rcu_read_unlock();
|
|
cb->args[0] = iter_bkt;
|
|
cb->args[1] = iter_chain;
|
|
cb->args[2] = iter_addr4;
|
|
cb->args[3] = iter_addr6;
|
|
return skb->len;
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlabel_staticlistdef - Handle a STATICLISTDEF message
|
|
* @skb: the NETLINK buffer
|
|
* @cb: the NETLINK callback
|
|
*
|
|
* Description:
|
|
* Process a user generated STATICLISTDEF message and dump the default
|
|
* unlabeled connection entry in a form suitable for use in a kernel generated
|
|
* STATICLISTDEF message. Returns the length of @skb.
|
|
*
|
|
*/
|
|
static int netlbl_unlabel_staticlistdef(struct sk_buff *skb,
|
|
struct netlink_callback *cb)
|
|
{
|
|
struct netlbl_unlhsh_walk_arg cb_arg;
|
|
struct netlbl_unlhsh_iface *iface;
|
|
u32 iter_addr4 = 0, iter_addr6 = 0;
|
|
struct netlbl_af4list *addr4;
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
struct netlbl_af6list *addr6;
|
|
#endif
|
|
|
|
cb_arg.nl_cb = cb;
|
|
cb_arg.skb = skb;
|
|
cb_arg.seq = cb->nlh->nlmsg_seq;
|
|
|
|
rcu_read_lock();
|
|
iface = rcu_dereference(netlbl_unlhsh_def);
|
|
if (iface == NULL || !iface->valid)
|
|
goto unlabel_staticlistdef_return;
|
|
|
|
netlbl_af4list_foreach_rcu(addr4, &iface->addr4_list) {
|
|
if (iter_addr4++ < cb->args[0])
|
|
continue;
|
|
if (netlbl_unlabel_staticlist_gen(NLBL_UNLABEL_C_STATICLISTDEF,
|
|
iface,
|
|
netlbl_unlhsh_addr4_entry(addr4),
|
|
NULL,
|
|
&cb_arg) < 0) {
|
|
iter_addr4--;
|
|
goto unlabel_staticlistdef_return;
|
|
}
|
|
}
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
netlbl_af6list_foreach_rcu(addr6, &iface->addr6_list) {
|
|
if (iter_addr6++ < cb->args[1])
|
|
continue;
|
|
if (netlbl_unlabel_staticlist_gen(NLBL_UNLABEL_C_STATICLISTDEF,
|
|
iface,
|
|
NULL,
|
|
netlbl_unlhsh_addr6_entry(addr6),
|
|
&cb_arg) < 0) {
|
|
iter_addr6--;
|
|
goto unlabel_staticlistdef_return;
|
|
}
|
|
}
|
|
#endif /* IPv6 */
|
|
|
|
unlabel_staticlistdef_return:
|
|
rcu_read_unlock();
|
|
cb->args[0] = iter_addr4;
|
|
cb->args[1] = iter_addr6;
|
|
return skb->len;
|
|
}
|
|
|
|
/*
|
|
* NetLabel Generic NETLINK Command Definitions
|
|
*/
|
|
|
|
static const struct genl_small_ops netlbl_unlabel_genl_ops[] = {
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_STATICADD,
|
|
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
|
|
.flags = GENL_ADMIN_PERM,
|
|
.doit = netlbl_unlabel_staticadd,
|
|
.dumpit = NULL,
|
|
},
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_STATICREMOVE,
|
|
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
|
|
.flags = GENL_ADMIN_PERM,
|
|
.doit = netlbl_unlabel_staticremove,
|
|
.dumpit = NULL,
|
|
},
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_STATICLIST,
|
|
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
|
|
.flags = 0,
|
|
.doit = NULL,
|
|
.dumpit = netlbl_unlabel_staticlist,
|
|
},
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_STATICADDDEF,
|
|
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
|
|
.flags = GENL_ADMIN_PERM,
|
|
.doit = netlbl_unlabel_staticadddef,
|
|
.dumpit = NULL,
|
|
},
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_STATICREMOVEDEF,
|
|
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
|
|
.flags = GENL_ADMIN_PERM,
|
|
.doit = netlbl_unlabel_staticremovedef,
|
|
.dumpit = NULL,
|
|
},
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_STATICLISTDEF,
|
|
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
|
|
.flags = 0,
|
|
.doit = NULL,
|
|
.dumpit = netlbl_unlabel_staticlistdef,
|
|
},
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_ACCEPT,
|
|
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
|
|
.flags = GENL_ADMIN_PERM,
|
|
.doit = netlbl_unlabel_accept,
|
|
.dumpit = NULL,
|
|
},
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_LIST,
|
|
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
|
|
.flags = 0,
|
|
.doit = netlbl_unlabel_list,
|
|
.dumpit = NULL,
|
|
},
|
|
};
|
|
|
|
static struct genl_family netlbl_unlabel_gnl_family __ro_after_init = {
|
|
.hdrsize = 0,
|
|
.name = NETLBL_NLTYPE_UNLABELED_NAME,
|
|
.version = NETLBL_PROTO_VERSION,
|
|
.maxattr = NLBL_UNLABEL_A_MAX,
|
|
.policy = netlbl_unlabel_genl_policy,
|
|
.module = THIS_MODULE,
|
|
.small_ops = netlbl_unlabel_genl_ops,
|
|
.n_small_ops = ARRAY_SIZE(netlbl_unlabel_genl_ops),
|
|
.resv_start_op = NLBL_UNLABEL_C_STATICLISTDEF + 1,
|
|
};
|
|
|
|
/*
|
|
* NetLabel Generic NETLINK Protocol Functions
|
|
*/
|
|
|
|
/**
|
|
* netlbl_unlabel_genl_init - Register the Unlabeled NetLabel component
|
|
*
|
|
* Description:
|
|
* Register the unlabeled packet NetLabel component with the Generic NETLINK
|
|
* mechanism. Returns zero on success, negative values on failure.
|
|
*
|
|
*/
|
|
int __init netlbl_unlabel_genl_init(void)
|
|
{
|
|
return genl_register_family(&netlbl_unlabel_gnl_family);
|
|
}
|
|
|
|
/*
|
|
* NetLabel KAPI Hooks
|
|
*/
|
|
|
|
static struct notifier_block netlbl_unlhsh_netdev_notifier = {
|
|
.notifier_call = netlbl_unlhsh_netdev_handler,
|
|
};
|
|
|
|
/**
|
|
* netlbl_unlabel_init - Initialize the unlabeled connection hash table
|
|
* @size: the number of bits to use for the hash buckets
|
|
*
|
|
* Description:
|
|
* Initializes the unlabeled connection hash table and registers a network
|
|
* device notification handler. This function should only be called by the
|
|
* NetLabel subsystem itself during initialization. Returns zero on success,
|
|
* non-zero values on error.
|
|
*
|
|
*/
|
|
int __init netlbl_unlabel_init(u32 size)
|
|
{
|
|
u32 iter;
|
|
struct netlbl_unlhsh_tbl *hsh_tbl;
|
|
|
|
if (size == 0)
|
|
return -EINVAL;
|
|
|
|
hsh_tbl = kmalloc(sizeof(*hsh_tbl), GFP_KERNEL);
|
|
if (hsh_tbl == NULL)
|
|
return -ENOMEM;
|
|
hsh_tbl->size = 1 << size;
|
|
hsh_tbl->tbl = kcalloc(hsh_tbl->size,
|
|
sizeof(struct list_head),
|
|
GFP_KERNEL);
|
|
if (hsh_tbl->tbl == NULL) {
|
|
kfree(hsh_tbl);
|
|
return -ENOMEM;
|
|
}
|
|
for (iter = 0; iter < hsh_tbl->size; iter++)
|
|
INIT_LIST_HEAD(&hsh_tbl->tbl[iter]);
|
|
|
|
spin_lock(&netlbl_unlhsh_lock);
|
|
rcu_assign_pointer(netlbl_unlhsh, hsh_tbl);
|
|
spin_unlock(&netlbl_unlhsh_lock);
|
|
|
|
register_netdevice_notifier(&netlbl_unlhsh_netdev_notifier);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlabel_getattr - Get the security attributes for an unlabled packet
|
|
* @skb: the packet
|
|
* @family: protocol family
|
|
* @secattr: the security attributes
|
|
*
|
|
* Description:
|
|
* Determine the security attributes, if any, for an unlabled packet and return
|
|
* them in @secattr. Returns zero on success and negative values on failure.
|
|
*
|
|
*/
|
|
int netlbl_unlabel_getattr(const struct sk_buff *skb,
|
|
u16 family,
|
|
struct netlbl_lsm_secattr *secattr)
|
|
{
|
|
struct netlbl_unlhsh_iface *iface;
|
|
|
|
rcu_read_lock();
|
|
iface = netlbl_unlhsh_search_iface(skb->skb_iif);
|
|
if (iface == NULL)
|
|
iface = rcu_dereference(netlbl_unlhsh_def);
|
|
if (iface == NULL || !iface->valid)
|
|
goto unlabel_getattr_nolabel;
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
/* When resolving a fallback label, check the sk_buff version as
|
|
* it is possible (e.g. SCTP) to have family = PF_INET6 while
|
|
* receiving ip_hdr(skb)->version = 4.
|
|
*/
|
|
if (family == PF_INET6 && ip_hdr(skb)->version == 4)
|
|
family = PF_INET;
|
|
#endif /* IPv6 */
|
|
|
|
switch (family) {
|
|
case PF_INET: {
|
|
struct iphdr *hdr4;
|
|
struct netlbl_af4list *addr4;
|
|
|
|
hdr4 = ip_hdr(skb);
|
|
addr4 = netlbl_af4list_search(hdr4->saddr,
|
|
&iface->addr4_list);
|
|
if (addr4 == NULL)
|
|
goto unlabel_getattr_nolabel;
|
|
secattr->attr.secid = netlbl_unlhsh_addr4_entry(addr4)->secid;
|
|
break;
|
|
}
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
case PF_INET6: {
|
|
struct ipv6hdr *hdr6;
|
|
struct netlbl_af6list *addr6;
|
|
|
|
hdr6 = ipv6_hdr(skb);
|
|
addr6 = netlbl_af6list_search(&hdr6->saddr,
|
|
&iface->addr6_list);
|
|
if (addr6 == NULL)
|
|
goto unlabel_getattr_nolabel;
|
|
secattr->attr.secid = netlbl_unlhsh_addr6_entry(addr6)->secid;
|
|
break;
|
|
}
|
|
#endif /* IPv6 */
|
|
default:
|
|
goto unlabel_getattr_nolabel;
|
|
}
|
|
rcu_read_unlock();
|
|
|
|
secattr->flags |= NETLBL_SECATTR_SECID;
|
|
secattr->type = NETLBL_NLTYPE_UNLABELED;
|
|
return 0;
|
|
|
|
unlabel_getattr_nolabel:
|
|
rcu_read_unlock();
|
|
if (netlabel_unlabel_acceptflg == 0)
|
|
return -ENOMSG;
|
|
secattr->type = NETLBL_NLTYPE_UNLABELED;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* netlbl_unlabel_defconf - Set the default config to allow unlabeled packets
|
|
*
|
|
* Description:
|
|
* Set the default NetLabel configuration to allow incoming unlabeled packets
|
|
* and to send unlabeled network traffic by default.
|
|
*
|
|
*/
|
|
int __init netlbl_unlabel_defconf(void)
|
|
{
|
|
int ret_val;
|
|
struct netlbl_dom_map *entry;
|
|
struct netlbl_audit audit_info;
|
|
|
|
/* Only the kernel is allowed to call this function and the only time
|
|
* it is called is at bootup before the audit subsystem is reporting
|
|
* messages so don't worry to much about these values. */
|
|
security_current_getsecid_subj(&audit_info.secid);
|
|
audit_info.loginuid = GLOBAL_ROOT_UID;
|
|
audit_info.sessionid = 0;
|
|
|
|
entry = kzalloc(sizeof(*entry), GFP_KERNEL);
|
|
if (entry == NULL)
|
|
return -ENOMEM;
|
|
entry->family = AF_UNSPEC;
|
|
entry->def.type = NETLBL_NLTYPE_UNLABELED;
|
|
ret_val = netlbl_domhsh_add_default(entry, &audit_info);
|
|
if (ret_val != 0)
|
|
return ret_val;
|
|
|
|
netlbl_unlabel_acceptflg_set(1, &audit_info);
|
|
|
|
return 0;
|
|
}
|