Commit 4fbac77d authored by Andrey Ignatov's avatar Andrey Ignatov Committed by Daniel Borkmann
Browse files

bpf: Hooks for sys_bind 



== The problem ==

There is a use-case when all processes inside a cgroup should use one
single IP address on a host that has multiple IP configured.  Those
processes should use the IP for both ingress and egress, for TCP and UDP
traffic. So TCP/UDP servers should be bound to that IP to accept
incoming connections on it, and TCP/UDP clients should make outgoing
connections from that IP. It should not require changing application
code since it's often not possible.

Currently it's solved by intercepting glibc wrappers around syscalls
such as `bind(2)` and `connect(2)`. It's done by a shared library that
is preloaded for every process in a cgroup so that whenever TCP/UDP
server calls `bind(2)`, the library replaces IP in sockaddr before
passing arguments to syscall. When application calls `connect(2)` the
library transparently binds the local end of connection to that IP
(`bind(2)` with `IP_BIND_ADDRESS_NO_PORT` to avoid performance penalty).

Shared library approach is fragile though, e.g.:
* some applications clear env vars (incl. `LD_PRELOAD`);
* `/etc/ld.so.preload` doesn't help since some applications are linked
  with option `-z nodefaultlib`;
* other applications don't use glibc and there is nothing to intercept.

== The solution ==

The patch provides much more reliable in-kernel solution for the 1st
part of the problem: binding TCP/UDP servers on desired IP. It does not
depend on application environment and implementation details (whether
glibc is used or not).

It adds new eBPF program type `BPF_PROG_TYPE_CGROUP_SOCK_ADDR` and
attach types `BPF_CGROUP_INET4_BIND` and `BPF_CGROUP_INET6_BIND`
(similar to already existing `BPF_CGROUP_INET_SOCK_CREATE`).

The new program type is intended to be used with sockets (`struct sock`)
in a cgroup and provided by user `struct sockaddr`. Pointers to both of
them are parts of the context passed to programs of newly added types.

The new attach types provides hooks in `bind(2)` system call for both
IPv4 and IPv6 so that one can write a program to override IP addresses
and ports user program tries to bind to and apply such a program for
whole cgroup.

== Implementation notes ==

[1]
Separate attach types for `AF_INET` and `AF_INET6` are added
intentionally to prevent reading/writing to offsets that don't make
sense for corresponding socket family. E.g. if user passes `sockaddr_in`
it doesn't make sense to read from / write to `user_ip6[]` context
fields.

[2]
The write access to `struct bpf_sock_addr_kern` is implemented using
special field as an additional "register".

There are just two registers in `sock_addr_convert_ctx_access`: `src`
with value to write and `dst` with pointer to context that can't be
changed not to break later instructions. But the fields, allowed to
write to, are not available directly and to access them address of
corresponding pointer has to be loaded first. To get additional register
the 1st not used by `src` and `dst` one is taken, its content is saved
to `bpf_sock_addr_kern.tmp_reg`, then the register is used to load
address of pointer field, and finally the register's content is restored
from the temporary field after writing `src` value.

Signed-off-by: default avatarAndrey Ignatov <rdna@fb.com>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
Signed-off-by: default avatarDaniel Borkmann <daniel@iogearbox.net>
parent d7be143b

include/linux/bpf-cgroup.h

+21 −0
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ 
#include <uapi/linux/bpf.h>



struct sock;

struct sockaddr;

struct cgroup;

struct sk_buff;

struct bpf_sock_ops_kern;
@@ -63,6 +64,10 @@ int __cgroup_bpf_run_filter_skb(struct sock *sk, 
int __cgroup_bpf_run_filter_sk(struct sock *sk,

			       enum bpf_attach_type type);



int __cgroup_bpf_run_filter_sock_addr(struct sock *sk,

				      struct sockaddr *uaddr,

				      enum bpf_attach_type type);



int __cgroup_bpf_run_filter_sock_ops(struct sock *sk,

				     struct bpf_sock_ops_kern *sock_ops,

				     enum bpf_attach_type type);
@@ -103,6 +108,20 @@ int __cgroup_bpf_check_dev_permission(short dev_type, u32 major, u32 minor, 
	__ret;								       \

})



#define BPF_CGROUP_RUN_SA_PROG(sk, uaddr, type)				       \

({									       \

	int __ret = 0;							       \

	if (cgroup_bpf_enabled)						       \

		__ret = __cgroup_bpf_run_filter_sock_addr(sk, uaddr, type);    \

	__ret;								       \

})



#define BPF_CGROUP_RUN_PROG_INET4_BIND(sk, uaddr)			       \

	BPF_CGROUP_RUN_SA_PROG(sk, uaddr, BPF_CGROUP_INET4_BIND)



#define BPF_CGROUP_RUN_PROG_INET6_BIND(sk, uaddr)			       \

	BPF_CGROUP_RUN_SA_PROG(sk, uaddr, BPF_CGROUP_INET6_BIND)



#define BPF_CGROUP_RUN_PROG_SOCK_OPS(sock_ops)				       \

({									       \

	int __ret = 0;							       \
@@ -135,6 +154,8 @@ static inline int cgroup_bpf_inherit(struct cgroup *cgrp) { return 0; } 
#define BPF_CGROUP_RUN_PROG_INET_INGRESS(sk,skb) ({ 0; })

#define BPF_CGROUP_RUN_PROG_INET_EGRESS(sk,skb) ({ 0; })

#define BPF_CGROUP_RUN_PROG_INET_SOCK(sk) ({ 0; })

#define BPF_CGROUP_RUN_PROG_INET4_BIND(sk, uaddr) ({ 0; })

#define BPF_CGROUP_RUN_PROG_INET6_BIND(sk, uaddr) ({ 0; })

#define BPF_CGROUP_RUN_PROG_SOCK_OPS(sock_ops) ({ 0; })

#define BPF_CGROUP_RUN_PROG_DEVICE_CGROUP(type,major,minor,access) ({ 0; })

include/linux/bpf_types.h

+1 −0
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ BPF_PROG_TYPE(BPF_PROG_TYPE_SCHED_ACT, tc_cls_act) 
BPF_PROG_TYPE(BPF_PROG_TYPE_XDP, xdp)

BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SKB, cg_skb)

BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SOCK, cg_sock)

BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SOCK_ADDR, cg_sock_addr)

BPF_PROG_TYPE(BPF_PROG_TYPE_LWT_IN, lwt_inout)

BPF_PROG_TYPE(BPF_PROG_TYPE_LWT_OUT, lwt_inout)

BPF_PROG_TYPE(BPF_PROG_TYPE_LWT_XMIT, lwt_xmit)

include/linux/filter.h

+10 −0
Original line number Diff line number Diff line
@@ -1021,6 +1021,16 @@ static inline int bpf_tell_extensions(void) 
	return SKF_AD_MAX;

}



struct bpf_sock_addr_kern {

	struct sock *sk;

	struct sockaddr *uaddr;

	/* Temporary "register" to make indirect stores to nested structures

	 * defined above. We need three registers to make such a store, but

	 * only two (src and dst) are available at convert_ctx_access time

	 */

	u64 tmp_reg;

};



struct bpf_sock_ops_kern {

	struct	sock *sk;

	u32	op;

include/uapi/linux/bpf.h

+23 −0
Original line number Diff line number Diff line
@@ -136,6 +136,7 @@ enum bpf_prog_type { 
	BPF_PROG_TYPE_CGROUP_DEVICE,

	BPF_PROG_TYPE_SK_MSG,

	BPF_PROG_TYPE_RAW_TRACEPOINT,

	BPF_PROG_TYPE_CGROUP_SOCK_ADDR,

};



enum bpf_attach_type {
@@ -147,6 +148,8 @@ enum bpf_attach_type { 
	BPF_SK_SKB_STREAM_VERDICT,

	BPF_CGROUP_DEVICE,

	BPF_SK_MSG_VERDICT,

	BPF_CGROUP_INET4_BIND,

	BPF_CGROUP_INET6_BIND,

	__MAX_BPF_ATTACH_TYPE

};
@@ -1010,6 +1013,26 @@ struct bpf_map_info { 
	__u64 netns_ino;

} __attribute__((aligned(8)));



/* User bpf_sock_addr struct to access socket fields and sockaddr struct passed

 * by user and intended to be used by socket (e.g. to bind to, depends on

 * attach attach type).

 */

struct bpf_sock_addr {

	__u32 user_family;	/* Allows 4-byte read, but no write. */

	__u32 user_ip4;		/* Allows 1,2,4-byte read and 4-byte write.

				 * Stored in network byte order.

				 */

	__u32 user_ip6[4];	/* Allows 1,2,4-byte read an 4-byte write.

				 * Stored in network byte order.

				 */

	__u32 user_port;	/* Allows 4-byte read and write.

				 * Stored in network byte order

				 */

	__u32 family;		/* Allows 4-byte read, but no write */

	__u32 type;		/* Allows 4-byte read, but no write */

	__u32 protocol;		/* Allows 4-byte read, but no write */

};



/* User bpf_sock_ops struct to access socket values and specify request ops

 * and their replies.

 * Some of this fields are in network (bigendian) byte order and may need

kernel/bpf/cgroup.c

+36 −0
Original line number Diff line number Diff line
@@ -494,6 +494,42 @@ int __cgroup_bpf_run_filter_sk(struct sock *sk, 
}

EXPORT_SYMBOL(__cgroup_bpf_run_filter_sk);



/**

 * __cgroup_bpf_run_filter_sock_addr() - Run a program on a sock and

 *                                       provided by user sockaddr

 * @sk: sock struct that will use sockaddr

 * @uaddr: sockaddr struct provided by user

 * @type: The type of program to be exectuted

 *

 * socket is expected to be of type INET or INET6.

 *

 * This function will return %-EPERM if an attached program is found and

 * returned value != 1 during execution. In all other cases, 0 is returned.

 */

int __cgroup_bpf_run_filter_sock_addr(struct sock *sk,

				      struct sockaddr *uaddr,

				      enum bpf_attach_type type)

{

	struct bpf_sock_addr_kern ctx = {

		.sk = sk,

		.uaddr = uaddr,

	};

	struct cgroup *cgrp;

	int ret;



	/* Check socket family since not all sockets represent network

	 * endpoint (e.g. AF_UNIX).

	 */

	if (sk->sk_family != AF_INET && sk->sk_family != AF_INET6)

		return 0;



	cgrp = sock_cgroup_ptr(&sk->sk_cgrp_data);

	ret = BPF_PROG_RUN_ARRAY(cgrp->bpf.effective[type], &ctx, BPF_PROG_RUN);



	return ret == 1 ? 0 : -EPERM;

}

EXPORT_SYMBOL(__cgroup_bpf_run_filter_sock_addr);



/**

 * __cgroup_bpf_run_filter_sock_ops() - Run a program on a sock

 * @sk: socket to get cgroup from

CRA Git | Maintained and supported by SUSTech CRA and CCSE