netns: send uevent messages

This patch adds a receive method to NETLINK_KOBJECT_UEVENT netlink sockets
to allow sending uevent messages into the network namespace the socket
belongs to.

Currently non-initial network namespaces are already isolated and don't
receive uevents. There are a number of cases where it is beneficial for a
sufficiently privileged userspace process to send a uevent into a network
namespace.

One such use case would be debugging and fuzzing of a piece of software
which listens and reacts to uevents. By running a copy of that software
inside a network namespace, specific uevents could then be presented to it.
More concretely, this would allow for easy testing of udevd/ueventd.

This will also allow some piece of software to run components inside a
separate network namespace and then effectively filter what that software
can receive. Some examples of software that do directly listen to uevents
and that we have in the past attempted to run inside a network namespace
are rbd (CEPH client) or the X server.

Implementation:
The implementation has been kept as simple as possible from the kernel's
perspective. Specifically, a simple input method uevent_net_rcv() is added
to NETLINK_KOBJECT_UEVENT sockets which completely reuses existing
af_netlink infrastructure and does neither add an additional netlink family
nor requires any user-visible changes.

For example, by using netlink_rcv_skb() we can make use of existing netlink
infrastructure to report back informative error messages to userspace.

Furthermore, this implementation does not introduce any overhead for
existing uevent generating codepaths. The struct netns got a new uevent
socket member that records the uevent socket associated with that network
namespace including its position in the uevent socket list. Since we record
the uevent socket for each network namespace in struct net we don't have to
walk the whole uevent socket list. Instead we can directly retrieve the
relevant uevent socket and send the message. At exit time we can now also
trivially remove the uevent socket from the uevent socket list. This keeps
the codepath very performant without introducing needless overhead and even
makes older codepaths faster.

Uevent sequence numbers are kept global. When a uevent message is sent to
another network namespace the implementation will simply increment the
global uevent sequence number and append it to the received uevent. This
has the advantage that the kernel will never need to parse the received
uevent message to replace any existing uevent sequence numbers. Instead it
is up to the userspace process to remove any existing uevent sequence
numbers in case the uevent message to be sent contains any.

Security:
In order for a caller to send uevent messages to a target network namespace
the caller must have CAP_SYS_ADMIN in the owning user namespace of the
target network namespace. Additionally, any received uevent message is
verified to not exceed size UEVENT_BUFFER_SIZE. This includes the space
needed to append the uevent sequence number.

Testing:
This patch has been tested and verified to work with the following udev
implementations:
1. CentOS 6 with udevd version 147
2. Debian Sid with systemd-udevd version 237
3. Android 7.1.1 with ueventd

Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/lib/kobject_uevent.c b/lib/kobject_uevent.c
index 54cfbaeb3a4ebdc3bc304441a934435453ef4b1e..fa10ad8e9b17494814b976eaf9689b16a8c561bd 100644 (file)
--- a/lib/kobject_uevent.c
+++ b/lib/kobject_uevent.c
@@ -25,6 +25,7 @@
 #include <linux/uuid.h>
 #include <linux/ctype.h>
 #include <net/sock.h>
+#include <net/netlink.h>
 #include <net/net_namespace.h>
 
 
@@ -604,12 +605,88 @@ int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
 EXPORT_SYMBOL_GPL(add_uevent_var);
 
 #if defined(CONFIG_NET)
+static int uevent_net_broadcast(struct sock *usk, struct sk_buff *skb,
+                               struct netlink_ext_ack *extack)
+{
+       /* u64 to chars: 2^64 - 1 = 21 chars */
+       char buf[sizeof("SEQNUM=") + 21];
+       struct sk_buff *skbc;
+       int ret;
+
+       /* bump and prepare sequence number */
+       ret = snprintf(buf, sizeof(buf), "SEQNUM=%llu", ++uevent_seqnum);
+       if (ret < 0 || (size_t)ret >= sizeof(buf))
+               return -ENOMEM;
+       ret++;
+
+       /* verify message does not overflow */
+       if ((skb->len + ret) > UEVENT_BUFFER_SIZE) {
+               NL_SET_ERR_MSG(extack, "uevent message too big");
+               return -EINVAL;
+       }
+
+       /* copy skb and extend to accommodate sequence number */
+       skbc = skb_copy_expand(skb, 0, ret, GFP_KERNEL);
+       if (!skbc)
+               return -ENOMEM;
+
+       /* append sequence number */
+       skb_put_data(skbc, buf, ret);
+
+       /* remove msg header */
+       skb_pull(skbc, NLMSG_HDRLEN);
+
+       /* set portid 0 to inform userspace message comes from kernel */
+       NETLINK_CB(skbc).portid = 0;
+       NETLINK_CB(skbc).dst_group = 1;
+
+       ret = netlink_broadcast(usk, skbc, 0, 1, GFP_KERNEL);
+       /* ENOBUFS should be handled in userspace */
+       if (ret == -ENOBUFS || ret == -ESRCH)
+               ret = 0;
+
+       return ret;
+}
+
+static int uevent_net_rcv_skb(struct sk_buff *skb, struct nlmsghdr *nlh,
+                             struct netlink_ext_ack *extack)
+{
+       struct net *net;
+       int ret;
+
+       if (!nlmsg_data(nlh))
+               return -EINVAL;
+
+       /*
+        * Verify that we are allowed to send messages to the target
+        * network namespace. The caller must have CAP_SYS_ADMIN in the
+        * owning user namespace of the target network namespace.
+        */
+       net = sock_net(NETLINK_CB(skb).sk);
+       if (!netlink_ns_capable(skb, net->user_ns, CAP_SYS_ADMIN)) {
+               NL_SET_ERR_MSG(extack, "missing CAP_SYS_ADMIN capability");
+               return -EPERM;
+       }
+
+       mutex_lock(&uevent_sock_mutex);
+       ret = uevent_net_broadcast(net->uevent_sock->sk, skb, extack);
+       mutex_unlock(&uevent_sock_mutex);
+
+       return ret;
+}
+
+static void uevent_net_rcv(struct sk_buff *skb)
+{
+       netlink_rcv_skb(skb, &uevent_net_rcv_skb);
+}
+
 static int uevent_net_init(struct net *net)
 {
        struct uevent_sock *ue_sk;
        struct netlink_kernel_cfg cfg = {
                .groups = 1,
-               .flags  = NL_CFG_F_NONROOT_RECV,
+               .input = uevent_net_rcv,
+               .flags  = NL_CFG_F_NONROOT_RECV
        };
 
        ue_sk = kzalloc(sizeof(*ue_sk), GFP_KERNEL);