![Jiri Pirko](/assets/img/avatar_default.png)
So far, only net_device * could be passed along with netdevice notifier event. This patch provides a possibility to pass custom structure able to provide info that event listener needs to know. Signed-off-by: Jiri Pirko <jiri@resnulli.us> v2->v3: fix typo on simeth shortened dev_getter shortened notifier_info struct name v1->v2: fix notifier_call parameter in call_netdevice_notifier() Signed-off-by: David S. Miller <davem@davemloft.net>
1553 lines
42 KiB
C
1553 lines
42 KiB
C
/*
|
|
* 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
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
|
|
* the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
|
|
#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 *netlbl_unlhsh = NULL;
|
|
static struct netlbl_unlhsh_iface *netlbl_unlhsh_def = NULL;
|
|
|
|
/* Accept unlabeled packets flag */
|
|
static u8 netlabel_unlabel_acceptflg = 0;
|
|
|
|
/* NetLabel Generic NETLINK unlabeled family */
|
|
static struct genl_family netlbl_unlabel_gnl_family = {
|
|
.id = GENL_ID_GENERATE,
|
|
.hdrsize = 0,
|
|
.name = NETLBL_NLTYPE_UNLABELED_NAME,
|
|
.version = NETLBL_PROTO_VERSION,
|
|
.maxattr = NLBL_UNLABEL_A_MAX,
|
|
};
|
|
|
|
/* 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)
|
|
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);
|
|
if (dev != NULL)
|
|
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);
|
|
if (dev != NULL)
|
|
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]) {
|
|
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(skb, &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 IPv4, 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(skb, &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(skb, &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(skb, &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(skb, &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(cb_arg->skb,
|
|
NLBL_UNLABEL_A_IPV4ADDR,
|
|
sizeof(struct in_addr),
|
|
&addr_struct);
|
|
if (ret_val != 0)
|
|
goto list_cb_failure;
|
|
|
|
addr_struct.s_addr = addr4->list.mask;
|
|
ret_val = nla_put(cb_arg->skb,
|
|
NLBL_UNLABEL_A_IPV4MASK,
|
|
sizeof(struct in_addr),
|
|
&addr_struct);
|
|
if (ret_val != 0)
|
|
goto list_cb_failure;
|
|
|
|
secid = addr4->secid;
|
|
} else {
|
|
ret_val = nla_put(cb_arg->skb,
|
|
NLBL_UNLABEL_A_IPV6ADDR,
|
|
sizeof(struct in6_addr),
|
|
&addr6->list.addr);
|
|
if (ret_val != 0)
|
|
goto list_cb_failure;
|
|
|
|
ret_val = nla_put(cb_arg->skb,
|
|
NLBL_UNLABEL_A_IPV6MASK,
|
|
sizeof(struct in6_addr),
|
|
&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++;
|
|
return genlmsg_end(cb_arg->skb, data);
|
|
|
|
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 iter_bkt;
|
|
u32 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)
|
|
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_chain = 0, iter_addr4 = 0, iter_addr6 = 0) {
|
|
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++ < cb->args[2])
|
|
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;
|
|
}
|
|
}
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
netlbl_af6list_foreach_rcu(addr6,
|
|
&iface->addr6_list) {
|
|
if (iter_addr6++ < cb->args[3])
|
|
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;
|
|
}
|
|
}
|
|
#endif /* IPv6 */
|
|
}
|
|
}
|
|
|
|
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 struct genl_ops netlbl_unlabel_genl_ops[] = {
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_STATICADD,
|
|
.flags = GENL_ADMIN_PERM,
|
|
.policy = netlbl_unlabel_genl_policy,
|
|
.doit = netlbl_unlabel_staticadd,
|
|
.dumpit = NULL,
|
|
},
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_STATICREMOVE,
|
|
.flags = GENL_ADMIN_PERM,
|
|
.policy = netlbl_unlabel_genl_policy,
|
|
.doit = netlbl_unlabel_staticremove,
|
|
.dumpit = NULL,
|
|
},
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_STATICLIST,
|
|
.flags = 0,
|
|
.policy = netlbl_unlabel_genl_policy,
|
|
.doit = NULL,
|
|
.dumpit = netlbl_unlabel_staticlist,
|
|
},
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_STATICADDDEF,
|
|
.flags = GENL_ADMIN_PERM,
|
|
.policy = netlbl_unlabel_genl_policy,
|
|
.doit = netlbl_unlabel_staticadddef,
|
|
.dumpit = NULL,
|
|
},
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_STATICREMOVEDEF,
|
|
.flags = GENL_ADMIN_PERM,
|
|
.policy = netlbl_unlabel_genl_policy,
|
|
.doit = netlbl_unlabel_staticremovedef,
|
|
.dumpit = NULL,
|
|
},
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_STATICLISTDEF,
|
|
.flags = 0,
|
|
.policy = netlbl_unlabel_genl_policy,
|
|
.doit = NULL,
|
|
.dumpit = netlbl_unlabel_staticlistdef,
|
|
},
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_ACCEPT,
|
|
.flags = GENL_ADMIN_PERM,
|
|
.policy = netlbl_unlabel_genl_policy,
|
|
.doit = netlbl_unlabel_accept,
|
|
.dumpit = NULL,
|
|
},
|
|
{
|
|
.cmd = NLBL_UNLABEL_C_LIST,
|
|
.flags = 0,
|
|
.policy = netlbl_unlabel_genl_policy,
|
|
.doit = netlbl_unlabel_list,
|
|
.dumpit = NULL,
|
|
},
|
|
};
|
|
|
|
/*
|
|
* 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_with_ops(&netlbl_unlabel_gnl_family,
|
|
netlbl_unlabel_genl_ops, ARRAY_SIZE(netlbl_unlabel_genl_ops));
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
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_task_getsecid(current, &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->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;
|
|
}
|