kernel/bpf/token.c

   1 #include <linux/bpf.h>
   2 #include <linux/vmalloc.h>
   3 #include <linux/fdtable.h>
   4 #include <linux/file.h>
   5 #include <linux/fs.h>
   6 #include <linux/kernel.h>
   7 #include <linux/idr.h>
   8 #include <linux/namei.h>
   9 #include <linux/user_namespace.h>
  10 #include <linux/security.h>
  11
  12 static bool bpf_ns_capable(struct user_namespace *ns, int cap)
  13 {
  14         return ns_capable(ns, cap) || (cap != CAP_SYS_ADMIN && ns_capable(ns, CAP_SYS_ADMIN));
  15 }
  16
  17 bool bpf_token_capable(const struct bpf_token *token, int cap)
  18 {
  19         struct user_namespace *userns;
  20
  21         /* BPF token allows ns_capable() level of capabilities */
  22         userns = token ? token->userns : &init_user_ns;
  23         if (!bpf_ns_capable(userns, cap))
  24                 return false;
  25         if (token && security_bpf_token_capable(token, cap) < 0)
  26                 return false;
  27         return true;
  28 }
  29
  30 void bpf_token_inc(struct bpf_token *token)
  31 {
  32         atomic64_inc(&token->refcnt);
  33 }
  34
  35 static void bpf_token_free(struct bpf_token *token)
  36 {
  37         security_bpf_token_free(token);
  38         put_user_ns(token->userns);
  39         kfree(token);
  40 }
  41
  42 static void bpf_token_put_deferred(struct work_struct *work)
  43 {
  44         struct bpf_token *token = container_of(work, struct bpf_token, work);
  45
  46         bpf_token_free(token);
  47 }
  48
  49 void bpf_token_put(struct bpf_token *token)
  50 {
  51         if (!token)
  52                 return;
  53
  54         if (!atomic64_dec_and_test(&token->refcnt))
  55                 return;
  56
  57         INIT_WORK(&token->work, bpf_token_put_deferred);
  58         schedule_work(&token->work);
  59 }
  60
  61 static int bpf_token_release(struct inode *inode, struct file *filp)
  62 {
  63         struct bpf_token *token = filp->private_data;
  64
  65         bpf_token_put(token);
  66         return 0;
  67 }
  68
  69 static void bpf_token_show_fdinfo(struct seq_file *m, struct file *filp)
  70 {
  71         struct bpf_token *token = filp->private_data;
  72         u64 mask;
  73
  74         BUILD_BUG_ON(__MAX_BPF_CMD >= 64);
  75         mask = BIT_ULL(__MAX_BPF_CMD) - 1;
  76         if ((token->allowed_cmds & mask) == mask)
  77                 seq_printf(m, "allowed_cmds:\tany\n");
  78         else
  79                 seq_printf(m, "allowed_cmds:\t0x%llx\n", token->allowed_cmds);
  80
  81         BUILD_BUG_ON(__MAX_BPF_MAP_TYPE >= 64);
  82         mask = BIT_ULL(__MAX_BPF_MAP_TYPE) - 1;
  83         if ((token->allowed_maps & mask) == mask)
  84                 seq_printf(m, "allowed_maps:\tany\n");
  85         else
  86                 seq_printf(m, "allowed_maps:\t0x%llx\n", token->allowed_maps);
  87
  88         BUILD_BUG_ON(__MAX_BPF_PROG_TYPE >= 64);
  89         mask = BIT_ULL(__MAX_BPF_PROG_TYPE) - 1;
  90         if ((token->allowed_progs & mask) == mask)
  91                 seq_printf(m, "allowed_progs:\tany\n");
  92         else
  93                 seq_printf(m, "allowed_progs:\t0x%llx\n", token->allowed_progs);
  94
  95         BUILD_BUG_ON(__MAX_BPF_ATTACH_TYPE >= 64);
  96         mask = BIT_ULL(__MAX_BPF_ATTACH_TYPE) - 1;
  97         if ((token->allowed_attachs & mask) == mask)
  98                 seq_printf(m, "allowed_attachs:\tany\n");
  99         else
 100                 seq_printf(m, "allowed_attachs:\t0x%llx\n", token->allowed_attachs);
 101 }
 102
 103 #define BPF_TOKEN_INODE_NAME "bpf-token"
 104
 105 static const struct inode_operations bpf_token_iops = { };
 106
 107 static const struct file_operations bpf_token_fops = {
 108         .release        = bpf_token_release,
 109         .show_fdinfo    = bpf_token_show_fdinfo,
 110 };
 111
 112 int bpf_token_create(union bpf_attr *attr)
 113 {
 114         struct bpf_mount_opts *mnt_opts;
 115         struct bpf_token *token = NULL;
 116         struct user_namespace *userns;
 117         struct inode *inode;
 118         struct file *file;
 119         CLASS(fd, f)(attr->token_create.bpffs_fd);
 120         struct path path;
 121         struct super_block *sb;
 122         umode_t mode;
 123         int err, fd;
 124
 125         if (fd_empty(f))
 126                 return -EBADF;
 127
 128         path = fd_file(f)->f_path;
 129         sb = path.dentry->d_sb;
 130
 131         if (path.dentry != sb->s_root)
 132                 return -EINVAL;
 133         if (sb->s_op != &bpf_super_ops)
 134                 return -EINVAL;
 135         err = path_permission(&path, MAY_ACCESS);
 136         if (err)
 137                 return err;
 138
 139         userns = sb->s_user_ns;
 140         /*
 141          * Enforce that creators of BPF tokens are in the same user
 142          * namespace as the BPF FS instance. This makes reasoning about
 143          * permissions a lot easier and we can always relax this later.
 144          */
 145         if (current_user_ns() != userns)
 146                 return -EPERM;
 147         if (!ns_capable(userns, CAP_BPF))
 148                 return -EPERM;
 149
 150         /* Creating BPF token in init_user_ns doesn't make much sense. */
 151         if (current_user_ns() == &init_user_ns)
 152                 return -EOPNOTSUPP;
 153
 154         mnt_opts = sb->s_fs_info;
 155         if (mnt_opts->delegate_cmds == 0 &&
 156             mnt_opts->delegate_maps == 0 &&
 157             mnt_opts->delegate_progs == 0 &&
 158             mnt_opts->delegate_attachs == 0)
 159                 return -ENOENT; /* no BPF token delegation is set up */
 160
 161         mode = S_IFREG | ((S_IRUSR | S_IWUSR) & ~current_umask());
 162         inode = bpf_get_inode(sb, NULL, mode);
 163         if (IS_ERR(inode))
 164                 return PTR_ERR(inode);
 165
 166         inode->i_op = &bpf_token_iops;
 167         inode->i_fop = &bpf_token_fops;
 168         clear_nlink(inode); /* make sure it is unlinked */
 169
 170         file = alloc_file_pseudo(inode, path.mnt, BPF_TOKEN_INODE_NAME, O_RDWR, &bpf_token_fops);
 171         if (IS_ERR(file)) {
 172                 iput(inode);
 173                 return PTR_ERR(file);
 174         }
 175
 176         token = kzalloc(sizeof(*token), GFP_USER);
 177         if (!token) {
 178                 err = -ENOMEM;
 179                 goto out_file;
 180         }
 181
 182         atomic64_set(&token->refcnt, 1);
 183
 184         /* remember bpffs owning userns for future ns_capable() checks */
 185         token->userns = get_user_ns(userns);
 186
 187         token->allowed_cmds = mnt_opts->delegate_cmds;
 188         token->allowed_maps = mnt_opts->delegate_maps;
 189         token->allowed_progs = mnt_opts->delegate_progs;
 190         token->allowed_attachs = mnt_opts->delegate_attachs;
 191
 192         err = security_bpf_token_create(token, attr, &path);
 193         if (err)
 194                 goto out_token;
 195
 196         fd = get_unused_fd_flags(O_CLOEXEC);
 197         if (fd < 0) {
 198                 err = fd;
 199                 goto out_token;
 200         }
 201
 202         file->private_data = token;
 203         fd_install(fd, file);
 204
 205         return fd;
 206
 207 out_token:
 208         bpf_token_free(token);
 209 out_file:
 210         fput(file);
 211         return err;
 212 }
 213
 214 struct bpf_token *bpf_token_get_from_fd(u32 ufd)
 215 {
 216         CLASS(fd, f)(ufd);
 217         struct bpf_token *token;
 218
 219         if (fd_empty(f))
 220                 return ERR_PTR(-EBADF);
 221         if (fd_file(f)->f_op != &bpf_token_fops)
 222                 return ERR_PTR(-EINVAL);
 223
 224         token = fd_file(f)->private_data;
 225         bpf_token_inc(token);
 226
 227         return token;
 228 }
 229
 230 bool bpf_token_allow_cmd(const struct bpf_token *token, enum bpf_cmd cmd)
 231 {
 232         if (!token)
 233                 return false;
 234         if (!(token->allowed_cmds & BIT_ULL(cmd)))
 235                 return false;
 236         return security_bpf_token_cmd(token, cmd) == 0;
 237 }
 238
 239 bool bpf_token_allow_map_type(const struct bpf_token *token, enum bpf_map_type type)
 240 {
 241         if (!token || type >= __MAX_BPF_MAP_TYPE)
 242                 return false;
 243
 244         return token->allowed_maps & BIT_ULL(type);
 245 }
 246
 247 bool bpf_token_allow_prog_type(const struct bpf_token *token,
 248                                enum bpf_prog_type prog_type,
 249                                enum bpf_attach_type attach_type)
 250 {
 251         if (!token || prog_type >= __MAX_BPF_PROG_TYPE || attach_type >= __MAX_BPF_ATTACH_TYPE)
 252                 return false;
 253
 254         return (token->allowed_progs & BIT_ULL(prog_type)) &&
 255                (token->allowed_attachs & BIT_ULL(attach_type));
 256 }