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: Andrey Ignatov <rdna@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>

3 files changed, 65 insertions, 8 deletions

diff --git a/kernel/bpf/cgroup.c b/kernel/bpf/cgroup.c
index 8730b24ed540..43171a0bb02b 100644
--- a/kernel/bpf/cgroup.c
+++ b/kernel/bpf/cgroup.c
@@ -495,6 +495,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
  * @sock_ops: bpf_sock_ops_kern struct to pass to program. Contains
diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index 9d3b572d4dec..2cad66a4cacb 100644
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -1175,19 +1175,29 @@ static int
 bpf_prog_load_check_attach_type(enum bpf_prog_type prog_type,
                                 enum bpf_attach_type expected_attach_type)
 {
-        /* There are currently no prog types that require specifying
-         * attach_type at load time.
-         */
-        return 0;
+        switch (prog_type) {
+        case BPF_PROG_TYPE_CGROUP_SOCK_ADDR:
+                switch (expected_attach_type) {
+                case BPF_CGROUP_INET4_BIND:
+                case BPF_CGROUP_INET6_BIND:
+                        return 0;
+                default:
+                        return -EINVAL;
+                }
+        default:
+                return 0;
+        }
 }
 
 static int bpf_prog_attach_check_attach_type(const struct bpf_prog *prog,
                                              enum bpf_attach_type attach_type)
 {
-        /* There are currently no prog types that require specifying
-         * attach_type at load time.
-         */
-        return 0;
+        switch (prog->type) {
+        case BPF_PROG_TYPE_CGROUP_SOCK_ADDR:
+                return attach_type == prog->expected_attach_type ? 0 : -EINVAL;
+        default:
+                return 0;
+        }
 }
 
 /* last field in 'union bpf_attr' used by this command */
@@ -1479,6 +1489,10 @@ static int bpf_prog_attach(const union bpf_attr *attr)
         case BPF_CGROUP_INET_SOCK_CREATE:
                 ptype = BPF_PROG_TYPE_CGROUP_SOCK;
                 break;
+        case BPF_CGROUP_INET4_BIND:
+        case BPF_CGROUP_INET6_BIND:
+                ptype = BPF_PROG_TYPE_CGROUP_SOCK_ADDR;
+                break;
         case BPF_CGROUP_SOCK_OPS:
                 ptype = BPF_PROG_TYPE_SOCK_OPS;
                 break;
@@ -1541,6 +1555,10 @@ static int bpf_prog_detach(const union bpf_attr *attr)
         case BPF_CGROUP_INET_SOCK_CREATE:
                 ptype = BPF_PROG_TYPE_CGROUP_SOCK;
                 break;
+        case BPF_CGROUP_INET4_BIND:
+        case BPF_CGROUP_INET6_BIND:
+                ptype = BPF_PROG_TYPE_CGROUP_SOCK_ADDR;
+                break;
         case BPF_CGROUP_SOCK_OPS:
                 ptype = BPF_PROG_TYPE_SOCK_OPS;
                 break;
@@ -1590,6 +1608,8 @@ static int bpf_prog_query(const union bpf_attr *attr,
         case BPF_CGROUP_INET_INGRESS:
         case BPF_CGROUP_INET_EGRESS:
         case BPF_CGROUP_INET_SOCK_CREATE:
+        case BPF_CGROUP_INET4_BIND:
+        case BPF_CGROUP_INET6_BIND:
         case BPF_CGROUP_SOCK_OPS:
         case BPF_CGROUP_DEVICE:
                 break;
diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 10024323031d..5dd1dcb902bf 100644
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -3887,6 +3887,7 @@ static int check_return_code(struct bpf_verifier_env *env)
         switch (env->prog->type) {
         case BPF_PROG_TYPE_CGROUP_SKB:
         case BPF_PROG_TYPE_CGROUP_SOCK:
+        case BPF_PROG_TYPE_CGROUP_SOCK_ADDR:
         case BPF_PROG_TYPE_SOCK_OPS:
         case BPF_PROG_TYPE_CGROUP_DEVICE:
                 break;