[PATCH RFC v3 76/90] rtnetlink: use net_may() for requests that change state

From: Josef Bacik

Date: Thu Nov 05 2026 - 10:35:03 EST


rtnetlink_rcv_msg() has a single CAP_NET_ADMIN check for every request
that is not a GET. Pick the right from the message type instead:

NET_RIGHT_LINK SETLINK, NEWLINKPROP, DELLINKPROP
NET_RIGHT_LINK_NEW DELLINK
NET_RIGHT_ADDR NEWADDR, DELADDR
NET_RIGHT_ROUTE routes, rules, neighbours, nexthops
NET_RIGHT_TC qdiscs, classes, filters, actions, chains

All other message types keep the plain capability check.

RTM_NEWLINK either changes an existing device or creates a new one, and
that is only known after __rtnl_newlink() has looked the device up. So
rtnetlink_rcv_msg() accepts either NET_RIGHT_LINK or NET_RIGHT_LINK_NEW
for it, and __rtnl_newlink() then checks the one that applies.

rtnl_link_get_net_capable() checks the network namespace that the request
names as its target. That is the namespace of the sender if the request
names none. Convert it as well, and keep checking the target namespace.
All of its callers pass CAP_NET_ADMIN, so drop that argument.

No functional change. Every right used here maps to CAP_NET_ADMIN over the
owner of the same network namespace as before.

Signed-off-by: Josef Bacik <josef@xxxxxxxxxxxxxx>
---
net/core/rtnetlink.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++-----
1 file changed, 55 insertions(+), 5 deletions(-)

diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index e141340172ce..df97309a9622 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -2737,7 +2737,7 @@ static struct net *rtnl_link_get_net_by_nlattr(struct net *src_net,

static struct net *rtnl_link_get_net_capable(const struct sk_buff *skb,
struct net *src_net,
- struct nlattr *tb[], int cap)
+ struct nlattr *tb[])
{
struct net *net;

@@ -2745,7 +2745,9 @@ static struct net *rtnl_link_get_net_capable(const struct sk_buff *skb,
if (IS_ERR(net))
return net;

- if (!netlink_ns_capable(skb, net->user_ns, cap)) {
+ /* Where the device is, or where it is to go. */
+ if (!netlink_net_may(skb, net, NET_RIGHT_LINK) &&
+ !netlink_net_may(skb, net, NET_RIGHT_LINK_NEW)) {
put_net(net);
return ERR_PTR(-EPERM);
}
@@ -3610,7 +3612,7 @@ static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
if (err < 0)
goto errout;

- tgt_net = rtnl_link_get_net_capable(skb, net, tb, CAP_NET_ADMIN);
+ tgt_net = rtnl_link_get_net_capable(skb, net, tb);
if (IS_ERR(tgt_net)) {
err = PTR_ERR(tgt_net);
goto errout;
@@ -4109,6 +4111,11 @@ static int __rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
dev = NULL;
}

+ /* A device that is there is changed. One that is not is made. */
+ if (!netlink_net_may(skb, net, dev || !(nlh->nlmsg_flags & NLM_F_CREATE) ?
+ NET_RIGHT_LINK : NET_RIGHT_LINK_NEW))
+ return -EPERM;
+
if (dev)
return rtnl_changelink(skb, nlh, ops, dev, tgt_net, tbs, data, extack);

@@ -4220,7 +4227,7 @@ static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
}
}

- tgt_net = rtnl_link_get_net_capable(skb, sock_net(skb->sk), tb, CAP_NET_ADMIN);
+ tgt_net = rtnl_link_get_net_capable(skb, sock_net(skb->sk), tb);
if (IS_ERR(tgt_net)) {
ret = PTR_ERR(tgt_net);
goto put_net;
@@ -7067,6 +7074,49 @@ static int rtnetlink_dump_start(struct sock *ssk, struct sk_buff *skb,
return netlink_dump_start(ssk, skb, nlh, control);
}

+/* May whoever sent a request that changes something do so? */
+static bool rtnl_may(const struct sk_buff *skb, int msgtype)
+{
+ const struct net *net = sock_net(skb->sk);
+
+ switch (msgtype) {
+ case RTM_NEWLINK:
+ /* Which of the two it takes, __rtnl_newlink() finds out. */
+ return netlink_net_may(skb, net, NET_RIGHT_LINK) ||
+ netlink_net_may(skb, net, NET_RIGHT_LINK_NEW);
+ case RTM_SETLINK:
+ case RTM_NEWLINKPROP:
+ case RTM_DELLINKPROP:
+ return netlink_net_may(skb, net, NET_RIGHT_LINK);
+ case RTM_DELLINK:
+ return netlink_net_may(skb, net, NET_RIGHT_LINK_NEW);
+ case RTM_NEWADDR:
+ case RTM_DELADDR:
+ return netlink_net_may(skb, net, NET_RIGHT_ADDR);
+ case RTM_NEWROUTE:
+ case RTM_DELROUTE:
+ case RTM_NEWNEIGH:
+ case RTM_DELNEIGH:
+ case RTM_NEWRULE:
+ case RTM_DELRULE:
+ case RTM_NEWNEXTHOP:
+ case RTM_DELNEXTHOP:
+ return netlink_net_may(skb, net, NET_RIGHT_ROUTE);
+ case RTM_NEWQDISC:
+ case RTM_DELQDISC:
+ case RTM_NEWTCLASS:
+ case RTM_DELTCLASS:
+ case RTM_NEWTFILTER:
+ case RTM_DELTFILTER:
+ case RTM_NEWACTION:
+ case RTM_DELACTION:
+ case RTM_NEWCHAIN:
+ case RTM_DELCHAIN:
+ return netlink_net_may(skb, net, NET_RIGHT_TC);
+ }
+ return netlink_net_capable(skb, CAP_NET_ADMIN);
+}
+
static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
struct netlink_ext_ack *extack)
{
@@ -7093,7 +7143,7 @@ static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family;
kind = rtnl_msgtype_kind(type);

- if (kind != RTNL_KIND_GET && !netlink_net_capable(skb, CAP_NET_ADMIN))
+ if (kind != RTNL_KIND_GET && !rtnl_may(skb, nlh->nlmsg_type))
return -EPERM;

rcu_read_lock();

--
2.55.0