security/landlock/syscalls.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Landlock LSM - System call implementations and user space interfaces
   4  *
   5  * Copyright © 2016-2020 Mickaël Salaün <[email protected]>
   6  * Copyright © 2018-2020 ANSSI
   7  */
   8
   9 #include <asm/current.h>
  10 #include <linux/anon_inodes.h>
  11 #include <linux/build_bug.h>
  12 #include <linux/capability.h>
  13 #include <linux/cleanup.h>
  14 #include <linux/compiler_types.h>
  15 #include <linux/dcache.h>
  16 #include <linux/err.h>
  17 #include <linux/errno.h>
  18 #include <linux/fs.h>
  19 #include <linux/limits.h>
  20 #include <linux/mount.h>
  21 #include <linux/path.h>
  22 #include <linux/sched.h>
  23 #include <linux/security.h>
  24 #include <linux/stddef.h>
  25 #include <linux/syscalls.h>
  26 #include <linux/types.h>
  27 #include <linux/uaccess.h>
  28 #include <uapi/linux/landlock.h>
  29
  30 #include "cred.h"
  31 #include "fs.h"
  32 #include "limits.h"
  33 #include "net.h"
  34 #include "ruleset.h"
  35 #include "setup.h"
  36
  37 static bool is_initialized(void)
  38 {
  39         if (likely(landlock_initialized))
  40                 return true;
  41
  42         pr_warn_once(
  43                 "Disabled but requested by user space. "
  44                 "You should enable Landlock at boot time: "
  45                 "https://docs.kernel.org/userspace-api/landlock.html#boot-time-configuration\n");
  46         return false;
  47 }
  48
  49 /**
  50  * copy_min_struct_from_user - Safe future-proof argument copying
  51  *
  52  * Extend copy_struct_from_user() to check for consistent user buffer.
  53  *
  54  * @dst: Kernel space pointer or NULL.
  55  * @ksize: Actual size of the data pointed to by @dst.
  56  * @ksize_min: Minimal required size to be copied.
  57  * @src: User space pointer or NULL.
  58  * @usize: (Alleged) size of the data pointed to by @src.
  59  */
  60 static __always_inline int
  61 copy_min_struct_from_user(void *const dst, const size_t ksize,
  62                           const size_t ksize_min, const void __user *const src,
  63                           const size_t usize)
  64 {
  65         /* Checks buffer inconsistencies. */
  66         BUILD_BUG_ON(!dst);
  67         if (!src)
  68                 return -EFAULT;
  69
  70         /* Checks size ranges. */
  71         BUILD_BUG_ON(ksize <= 0);
  72         BUILD_BUG_ON(ksize < ksize_min);
  73         if (usize < ksize_min)
  74                 return -EINVAL;
  75         if (usize > PAGE_SIZE)
  76                 return -E2BIG;
  77
  78         /* Copies user buffer and fills with zeros. */
  79         return copy_struct_from_user(dst, ksize, src, usize);
  80 }
  81
  82 /*
  83  * This function only contains arithmetic operations with constants, leading to
  84  * BUILD_BUG_ON().  The related code is evaluated and checked at build time,
  85  * but it is then ignored thanks to compiler optimizations.
  86  */
  87 static void build_check_abi(void)
  88 {
  89         struct landlock_ruleset_attr ruleset_attr;
  90         struct landlock_path_beneath_attr path_beneath_attr;
  91         struct landlock_net_port_attr net_port_attr;
  92         size_t ruleset_size, path_beneath_size, net_port_size;
  93
  94         /*
  95          * For each user space ABI structures, first checks that there is no
  96          * hole in them, then checks that all architectures have the same
  97          * struct size.
  98          */
  99         ruleset_size = sizeof(ruleset_attr.handled_access_fs);
 100         ruleset_size += sizeof(ruleset_attr.handled_access_net);
 101         ruleset_size += sizeof(ruleset_attr.scoped);
 102         BUILD_BUG_ON(sizeof(ruleset_attr) != ruleset_size);
 103         BUILD_BUG_ON(sizeof(ruleset_attr) != 24);
 104
 105         path_beneath_size = sizeof(path_beneath_attr.allowed_access);
 106         path_beneath_size += sizeof(path_beneath_attr.parent_fd);
 107         BUILD_BUG_ON(sizeof(path_beneath_attr) != path_beneath_size);
 108         BUILD_BUG_ON(sizeof(path_beneath_attr) != 12);
 109
 110         net_port_size = sizeof(net_port_attr.allowed_access);
 111         net_port_size += sizeof(net_port_attr.port);
 112         BUILD_BUG_ON(sizeof(net_port_attr) != net_port_size);
 113         BUILD_BUG_ON(sizeof(net_port_attr) != 16);
 114 }
 115
 116 /* Ruleset handling */
 117
 118 static int fop_ruleset_release(struct inode *const inode,
 119                                struct file *const filp)
 120 {
 121         struct landlock_ruleset *ruleset = filp->private_data;
 122
 123         landlock_put_ruleset(ruleset);
 124         return 0;
 125 }
 126
 127 static ssize_t fop_dummy_read(struct file *const filp, char __user *const buf,
 128                               const size_t size, loff_t *const ppos)
 129 {
 130         /* Dummy handler to enable FMODE_CAN_READ. */
 131         return -EINVAL;
 132 }
 133
 134 static ssize_t fop_dummy_write(struct file *const filp,
 135                                const char __user *const buf, const size_t size,
 136                                loff_t *const ppos)
 137 {
 138         /* Dummy handler to enable FMODE_CAN_WRITE. */
 139         return -EINVAL;
 140 }
 141
 142 /*
 143  * A ruleset file descriptor enables to build a ruleset by adding (i.e.
 144  * writing) rule after rule, without relying on the task's context.  This
 145  * reentrant design is also used in a read way to enforce the ruleset on the
 146  * current task.
 147  */
 148 static const struct file_operations ruleset_fops = {
 149         .release = fop_ruleset_release,
 150         .read = fop_dummy_read,
 151         .write = fop_dummy_write,
 152 };
 153
 154 #define LANDLOCK_ABI_VERSION 6
 155
 156 /**
 157  * sys_landlock_create_ruleset - Create a new ruleset
 158  *
 159  * @attr: Pointer to a &struct landlock_ruleset_attr identifying the scope of
 160  *        the new ruleset.
 161  * @size: Size of the pointed &struct landlock_ruleset_attr (needed for
 162  *        backward and forward compatibility).
 163  * @flags: Supported value: %LANDLOCK_CREATE_RULESET_VERSION.
 164  *
 165  * This system call enables to create a new Landlock ruleset, and returns the
 166  * related file descriptor on success.
 167  *
 168  * If @flags is %LANDLOCK_CREATE_RULESET_VERSION and @attr is NULL and @size is
 169  * 0, then the returned value is the highest supported Landlock ABI version
 170  * (starting at 1).
 171  *
 172  * Possible returned errors are:
 173  *
 174  * - %EOPNOTSUPP: Landlock is supported by the kernel but disabled at boot time;
 175  * - %EINVAL: unknown @flags, or unknown access, or unknown scope, or too small @size;
 176  * - %E2BIG: @attr or @size inconsistencies;
 177  * - %EFAULT: @attr or @size inconsistencies;
 178  * - %ENOMSG: empty &landlock_ruleset_attr.handled_access_fs.
 179  */
 180 SYSCALL_DEFINE3(landlock_create_ruleset,
 181                 const struct landlock_ruleset_attr __user *const, attr,
 182                 const size_t, size, const __u32, flags)
 183 {
 184         struct landlock_ruleset_attr ruleset_attr;
 185         struct landlock_ruleset *ruleset;
 186         int err, ruleset_fd;
 187
 188         /* Build-time checks. */
 189         build_check_abi();
 190
 191         if (!is_initialized())
 192                 return -EOPNOTSUPP;
 193
 194         if (flags) {
 195                 if ((flags == LANDLOCK_CREATE_RULESET_VERSION) && !attr &&
 196                     !size)
 197                         return LANDLOCK_ABI_VERSION;
 198                 return -EINVAL;
 199         }
 200
 201         /* Copies raw user space buffer. */
 202         err = copy_min_struct_from_user(&ruleset_attr, sizeof(ruleset_attr),
 203                                         offsetofend(typeof(ruleset_attr),
 204                                                     handled_access_fs),
 205                                         attr, size);
 206         if (err)
 207                 return err;
 208
 209         /* Checks content (and 32-bits cast). */
 210         if ((ruleset_attr.handled_access_fs | LANDLOCK_MASK_ACCESS_FS) !=
 211             LANDLOCK_MASK_ACCESS_FS)
 212                 return -EINVAL;
 213
 214         /* Checks network content (and 32-bits cast). */
 215         if ((ruleset_attr.handled_access_net | LANDLOCK_MASK_ACCESS_NET) !=
 216             LANDLOCK_MASK_ACCESS_NET)
 217                 return -EINVAL;
 218
 219         /* Checks IPC scoping content (and 32-bits cast). */
 220         if ((ruleset_attr.scoped | LANDLOCK_MASK_SCOPE) != LANDLOCK_MASK_SCOPE)
 221                 return -EINVAL;
 222
 223         /* Checks arguments and transforms to kernel struct. */
 224         ruleset = landlock_create_ruleset(ruleset_attr.handled_access_fs,
 225                                           ruleset_attr.handled_access_net,
 226                                           ruleset_attr.scoped);
 227         if (IS_ERR(ruleset))
 228                 return PTR_ERR(ruleset);
 229
 230         /* Creates anonymous FD referring to the ruleset. */
 231         ruleset_fd = anon_inode_getfd("[landlock-ruleset]", &ruleset_fops,
 232                                       ruleset, O_RDWR | O_CLOEXEC);
 233         if (ruleset_fd < 0)
 234                 landlock_put_ruleset(ruleset);
 235         return ruleset_fd;
 236 }
 237
 238 /*
 239  * Returns an owned ruleset from a FD. It is thus needed to call
 240  * landlock_put_ruleset() on the return value.
 241  */
 242 static struct landlock_ruleset *get_ruleset_from_fd(const int fd,
 243                                                     const fmode_t mode)
 244 {
 245         CLASS(fd, ruleset_f)(fd);
 246         struct landlock_ruleset *ruleset;
 247
 248         if (fd_empty(ruleset_f))
 249                 return ERR_PTR(-EBADF);
 250
 251         /* Checks FD type and access right. */
 252         if (fd_file(ruleset_f)->f_op != &ruleset_fops)
 253                 return ERR_PTR(-EBADFD);
 254         if (!(fd_file(ruleset_f)->f_mode & mode))
 255                 return ERR_PTR(-EPERM);
 256         ruleset = fd_file(ruleset_f)->private_data;
 257         if (WARN_ON_ONCE(ruleset->num_layers != 1))
 258                 return ERR_PTR(-EINVAL);
 259         landlock_get_ruleset(ruleset);
 260         return ruleset;
 261 }
 262
 263 /* Path handling */
 264
 265 /*
 266  * @path: Must call put_path(@path) after the call if it succeeded.
 267  */
 268 static int get_path_from_fd(const s32 fd, struct path *const path)
 269 {
 270         CLASS(fd_raw, f)(fd);
 271
 272         BUILD_BUG_ON(!__same_type(
 273                 fd, ((struct landlock_path_beneath_attr *)NULL)->parent_fd));
 274
 275         if (fd_empty(f))
 276                 return -EBADF;
 277         /*
 278          * Forbids ruleset FDs, internal filesystems (e.g. nsfs), including
 279          * pseudo filesystems that will never be mountable (e.g. sockfs,
 280          * pipefs).
 281          */
 282         if ((fd_file(f)->f_op == &ruleset_fops) ||
 283             (fd_file(f)->f_path.mnt->mnt_flags & MNT_INTERNAL) ||
 284             (fd_file(f)->f_path.dentry->d_sb->s_flags & SB_NOUSER) ||
 285             d_is_negative(fd_file(f)->f_path.dentry) ||
 286             IS_PRIVATE(d_backing_inode(fd_file(f)->f_path.dentry)))
 287                 return -EBADFD;
 288
 289         *path = fd_file(f)->f_path;
 290         path_get(path);
 291         return 0;
 292 }
 293
 294 static int add_rule_path_beneath(struct landlock_ruleset *const ruleset,
 295                                  const void __user *const rule_attr)
 296 {
 297         struct landlock_path_beneath_attr path_beneath_attr;
 298         struct path path;
 299         int res, err;
 300         access_mask_t mask;
 301
 302         /* Copies raw user space buffer. */
 303         res = copy_from_user(&path_beneath_attr, rule_attr,
 304                              sizeof(path_beneath_attr));
 305         if (res)
 306                 return -EFAULT;
 307
 308         /*
 309          * Informs about useless rule: empty allowed_access (i.e. deny rules)
 310          * are ignored in path walks.
 311          */
 312         if (!path_beneath_attr.allowed_access)
 313                 return -ENOMSG;
 314
 315         /* Checks that allowed_access matches the @ruleset constraints. */
 316         mask = ruleset->access_masks[0].fs;
 317         if ((path_beneath_attr.allowed_access | mask) != mask)
 318                 return -EINVAL;
 319
 320         /* Gets and checks the new rule. */
 321         err = get_path_from_fd(path_beneath_attr.parent_fd, &path);
 322         if (err)
 323                 return err;
 324
 325         /* Imports the new rule. */
 326         err = landlock_append_fs_rule(ruleset, &path,
 327                                       path_beneath_attr.allowed_access);
 328         path_put(&path);
 329         return err;
 330 }
 331
 332 static int add_rule_net_port(struct landlock_ruleset *ruleset,
 333                              const void __user *const rule_attr)
 334 {
 335         struct landlock_net_port_attr net_port_attr;
 336         int res;
 337         access_mask_t mask;
 338
 339         /* Copies raw user space buffer. */
 340         res = copy_from_user(&net_port_attr, rule_attr, sizeof(net_port_attr));
 341         if (res)
 342                 return -EFAULT;
 343
 344         /*
 345          * Informs about useless rule: empty allowed_access (i.e. deny rules)
 346          * are ignored by network actions.
 347          */
 348         if (!net_port_attr.allowed_access)
 349                 return -ENOMSG;
 350
 351         /* Checks that allowed_access matches the @ruleset constraints. */
 352         mask = landlock_get_net_access_mask(ruleset, 0);
 353         if ((net_port_attr.allowed_access | mask) != mask)
 354                 return -EINVAL;
 355
 356         /* Denies inserting a rule with port greater than 65535. */
 357         if (net_port_attr.port > U16_MAX)
 358                 return -EINVAL;
 359
 360         /* Imports the new rule. */
 361         return landlock_append_net_rule(ruleset, net_port_attr.port,
 362                                         net_port_attr.allowed_access);
 363 }
 364
 365 /**
 366  * sys_landlock_add_rule - Add a new rule to a ruleset
 367  *
 368  * @ruleset_fd: File descriptor tied to the ruleset that should be extended
 369  *              with the new rule.
 370  * @rule_type: Identify the structure type pointed to by @rule_attr:
 371  *             %LANDLOCK_RULE_PATH_BENEATH or %LANDLOCK_RULE_NET_PORT.
 372  * @rule_attr: Pointer to a rule (matching the @rule_type).
 373  * @flags: Must be 0.
 374  *
 375  * This system call enables to define a new rule and add it to an existing
 376  * ruleset.
 377  *
 378  * Possible returned errors are:
 379  *
 380  * - %EOPNOTSUPP: Landlock is supported by the kernel but disabled at boot time;
 381  * - %EAFNOSUPPORT: @rule_type is %LANDLOCK_RULE_NET_PORT but TCP/IP is not
 382  *   supported by the running kernel;
 383  * - %EINVAL: @flags is not 0;
 384  * - %EINVAL: The rule accesses are inconsistent (i.e.
 385  *   &landlock_path_beneath_attr.allowed_access or
 386  *   &landlock_net_port_attr.allowed_access is not a subset of the ruleset
 387  *   handled accesses)
 388  * - %EINVAL: &landlock_net_port_attr.port is greater than 65535;
 389  * - %ENOMSG: Empty accesses (e.g. &landlock_path_beneath_attr.allowed_access is
 390  *   0);
 391  * - %EBADF: @ruleset_fd is not a file descriptor for the current thread, or a
 392  *   member of @rule_attr is not a file descriptor as expected;
 393  * - %EBADFD: @ruleset_fd is not a ruleset file descriptor, or a member of
 394  *   @rule_attr is not the expected file descriptor type;
 395  * - %EPERM: @ruleset_fd has no write access to the underlying ruleset;
 396  * - %EFAULT: @rule_attr was not a valid address.
 397  */
 398 SYSCALL_DEFINE4(landlock_add_rule, const int, ruleset_fd,
 399                 const enum landlock_rule_type, rule_type,
 400                 const void __user *const, rule_attr, const __u32, flags)
 401 {
 402         struct landlock_ruleset *ruleset __free(landlock_put_ruleset) = NULL;
 403
 404         if (!is_initialized())
 405                 return -EOPNOTSUPP;
 406
 407         /* No flag for now. */
 408         if (flags)
 409                 return -EINVAL;
 410
 411         /* Gets and checks the ruleset. */
 412         ruleset = get_ruleset_from_fd(ruleset_fd, FMODE_CAN_WRITE);
 413         if (IS_ERR(ruleset))
 414                 return PTR_ERR(ruleset);
 415
 416         switch (rule_type) {
 417         case LANDLOCK_RULE_PATH_BENEATH:
 418                 return add_rule_path_beneath(ruleset, rule_attr);
 419         case LANDLOCK_RULE_NET_PORT:
 420                 return add_rule_net_port(ruleset, rule_attr);
 421         default:
 422                 return -EINVAL;
 423         }
 424 }
 425
 426 /* Enforcement */
 427
 428 /**
 429  * sys_landlock_restrict_self - Enforce a ruleset on the calling thread
 430  *
 431  * @ruleset_fd: File descriptor tied to the ruleset to merge with the target.
 432  * @flags: Must be 0.
 433  *
 434  * This system call enables to enforce a Landlock ruleset on the current
 435  * thread.  Enforcing a ruleset requires that the task has %CAP_SYS_ADMIN in its
 436  * namespace or is running with no_new_privs.  This avoids scenarios where
 437  * unprivileged tasks can affect the behavior of privileged children.
 438  *
 439  * Possible returned errors are:
 440  *
 441  * - %EOPNOTSUPP: Landlock is supported by the kernel but disabled at boot time;
 442  * - %EINVAL: @flags is not 0.
 443  * - %EBADF: @ruleset_fd is not a file descriptor for the current thread;
 444  * - %EBADFD: @ruleset_fd is not a ruleset file descriptor;
 445  * - %EPERM: @ruleset_fd has no read access to the underlying ruleset, or the
 446  *   current thread is not running with no_new_privs, or it doesn't have
 447  *   %CAP_SYS_ADMIN in its namespace.
 448  * - %E2BIG: The maximum number of stacked rulesets is reached for the current
 449  *   thread.
 450  */
 451 SYSCALL_DEFINE2(landlock_restrict_self, const int, ruleset_fd, const __u32,
 452                 flags)
 453 {
 454         struct landlock_ruleset *new_dom,
 455                 *ruleset __free(landlock_put_ruleset) = NULL;
 456         struct cred *new_cred;
 457         struct landlock_cred_security *new_llcred;
 458
 459         if (!is_initialized())
 460                 return -EOPNOTSUPP;
 461
 462         /*
 463          * Similar checks as for seccomp(2), except that an -EPERM may be
 464          * returned.
 465          */
 466         if (!task_no_new_privs(current) &&
 467             !ns_capable_noaudit(current_user_ns(), CAP_SYS_ADMIN))
 468                 return -EPERM;
 469
 470         /* No flag for now. */
 471         if (flags)
 472                 return -EINVAL;
 473
 474         /* Gets and checks the ruleset. */
 475         ruleset = get_ruleset_from_fd(ruleset_fd, FMODE_CAN_READ);
 476         if (IS_ERR(ruleset))
 477                 return PTR_ERR(ruleset);
 478
 479         /* Prepares new credentials. */
 480         new_cred = prepare_creds();
 481         if (!new_cred)
 482                 return -ENOMEM;
 483
 484         new_llcred = landlock_cred(new_cred);
 485
 486         /*
 487          * There is no possible race condition while copying and manipulating
 488          * the current credentials because they are dedicated per thread.
 489          */
 490         new_dom = landlock_merge_ruleset(new_llcred->domain, ruleset);
 491         if (IS_ERR(new_dom)) {
 492                 abort_creds(new_cred);
 493                 return PTR_ERR(new_dom);
 494         }
 495
 496         /* Replaces the old (prepared) domain. */
 497         landlock_put_ruleset(new_llcred->domain);
 498         new_llcred->domain = new_dom;
 499         return commit_creds(new_cred);
 500 }