On Mon, Oct 9, 2023 at 11:37 AM Mickaël Salaün [off-list ref] wrote:

On Thu, Oct 05, 2023 at 09:04:34PM -0400, Paul Moore wrote:

quoted

On Tue, Oct 3, 2023 at 10:09 AM Mickaël Salaün [off-list ref] wrote:

quoted

On Tue, Sep 12, 2023 at 01:56:49PM -0700, Casey Schaufler wrote:

quoted

Create a system call lsm_get_self_attr() to provide the security
module maintained attributes of the current process.
Create a system call lsm_set_self_attr() to set a security
module maintained attribute of the current process.
Historically these attributes have been exposed to user space via
entries in procfs under /proc/self/attr.

The attribute value is provided in a lsm_ctx structure. The structure
identifies the size of the attribute, and the attribute value. The format
of the attribute value is defined by the security module. A flags field
is included for LSM specific information. It is currently unused and must
be 0. The total size of the data, including the lsm_ctx structure and any
padding, is maintained as well.

struct lsm_ctx {
        __u64 id;
        __u64 flags;
        __u64 len;
        __u64 ctx_len;
        __u8 ctx[];
};

Two new LSM hooks are used to interface with the LSMs.
security_getselfattr() collects the lsm_ctx values from the
LSMs that support the hook, accounting for space requirements.
security_setselfattr() identifies which LSM the attribute is
intended for and passes it along.

Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
Reviewed-by: Kees Cook <redacted>
Reviewed-by: Serge Hallyn <serge@hallyn.com>
Reviewed-by: John Johansen <john.johansen@canonical.com>
---
 Documentation/userspace-api/lsm.rst |  70 +++++++++++++
 include/linux/lsm_hook_defs.h       |   4 +
 include/linux/lsm_hooks.h           |   1 +
 include/linux/security.h            |  19 ++++
 include/linux/syscalls.h            |   5 +
 include/uapi/linux/lsm.h            |  36 +++++++
 kernel/sys_ni.c                     |   2 +
 security/Makefile                   |   1 +
 security/lsm_syscalls.c             |  57 +++++++++++
 security/security.c                 | 152 ++++++++++++++++++++++++++++
 10 files changed, 347 insertions(+)
 create mode 100644 Documentation/userspace-api/lsm.rst
 create mode 100644 security/lsm_syscalls.c

...

quoted

quoted

diff --git a/security/security.c b/security/security.c
index a3489c04b783..0d179750d964 100644
--- a/security/security.c
+++ b/security/security.c

@@ -3837,6 +3837,158 @@ void security_d_instantiate(struct dentry *dentry, struct inode *inode)
 }
 EXPORT_SYMBOL(security_d_instantiate);

+/*
+ * Please keep this in sync with it's counterpart in security/lsm_syscalls.c
+ */
+
+/**
+ * security_getselfattr - Read an LSM attribute of the current process.
+ * @attr: which attribute to return
+ * @uctx: the user-space destination for the information, or NULL
+ * @size: pointer to the size of space available to receive the data
+ * @flags: special handling options. LSM_FLAG_SINGLE indicates that only
+ * attributes associated with the LSM identified in the passed @ctx be
+ * reported.
+ *
+ * A NULL value for @uctx can be used to get both the number of attributes
+ * and the size of the data.
+ *
+ * Returns the number of attributes found on success, negative value
+ * on error. @size is reset to the total size of the data.
+ * If @size is insufficient to contain the data -E2BIG is returned.
+ */
+int security_getselfattr(unsigned int attr, struct lsm_ctx __user *uctx,
+                      size_t __user *size, u32 flags)
+{
+     struct security_hook_list *hp;
+     struct lsm_ctx lctx = { .id = LSM_ID_UNDEF, };
+     u8 __user *base = (u8 __user *)uctx;
+     size_t total = 0;
+     size_t entrysize;
+     size_t left;
+     bool toobig = false;
+     bool single = false;
+     int count = 0;
+     int rc;
+
+     if (attr == LSM_ATTR_UNDEF)
+             return -EINVAL;
+     if (size == NULL)
+             return -EINVAL;
+     if (get_user(left, size))
+             return -EFAULT;
+
+     if (flags) {
+             /*
+              * Only flag supported is LSM_FLAG_SINGLE
+              */
+             if (flags != LSM_FLAG_SINGLE)
+                     return -EINVAL;
+             if (uctx && copy_from_user(&lctx, uctx, sizeof(lctx)))

I'm not sure if we should return -EINVAL or -EFAULT when uctx == NULL.
Because uctx is optional (when LSM_FLAG_SINGLE is not set), I guess
-EINVAL is OK.

That's a good point, we should probably the error codes here: if uctx
is NULL in the LSM_FLAG_SINGLE case we should return -EINVAL, if the
copy_from_user() fails we should return -EFAULT.

quoted

quoted

+                     return -EFAULT;
+             /*
+              * If the LSM ID isn't specified it is an error.
+              */
+             if (lctx.id == LSM_ID_UNDEF)
+                     return -EINVAL;
+             single = true;
+     }
+
+     /*
+      * In the usual case gather all the data from the LSMs.
+      * In the single case only get the data from the LSM specified.
+      */
+     hlist_for_each_entry(hp, &security_hook_heads.getselfattr, list) {
+             if (single && lctx.id != hp->lsmid->id)
+                     continue;
+             entrysize = left;
+             if (base)
+                     uctx = (struct lsm_ctx __user *)(base + total);
+             rc = hp->hook.getselfattr(attr, uctx, &entrysize, flags);
+             if (rc == -EOPNOTSUPP) {
+                     rc = 0;
+                     continue;
+             }
+             if (rc == -E2BIG) {
+                     toobig = true;
+                     left = 0;
+             } else if (rc < 0)
+                     return rc;
+             else
+                     left -= entrysize;
+
+             total += entrysize;
+             count += rc;

There is a bug if rc == -E2BIG

Can you elaborate a bit more on this? Nothing is jumping out at me as
obviously broken... are you talking about @count becoming garbage due
to @rc being equal to -E2BIG?  If that is the case it should be okay
since we explicitly return -E2BIG, not @count, if @toobig is true.

Indeed, in this case count will not be returned thanks to toobig. I'd
suggest to "continue" if rc == -E2BIG (like for -EOPNOTSUPP) to avoid an
inconsistent count value, which could bite us one day.

Okay, how about we reset @rc to zero in the -E2BIG case?  We don't
want to bypass the lower part of the loop in this case as we still
need to update @total.

  if (rc == -E2BIG) {
    rc = 0;
    left = 0;
    toobig = true;
  }

-- 
paul-moore.com