landlock: Add abstract unix socket connect restriction
Subsystems (5)
PATCH v4 1/1 landlock: Add abstract unix socket connect restriction
Abstract unix sockets are used for local inter-process communications without on a filesystem. Currently a sandboxed process can connect to a socket outside of the sandboxed environment, since landlock has no restriction for connecting to a unix socket in the abstract namespace. Access to such sockets for a sandboxed process should be scoped the same way ptrace is limited.
Because of compatibility reasons and since landlock should be flexible, we extend the user space interface by adding a new "scoped" field. This field optionally contains a "LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET" to specify that the ruleset will deny any connection from within the sandbox to its parents(i.e. any parent sandbox or non-sandbox processes)
-------
V3: Added "scoped" field to landlock_ruleset_attr
V2: Remove wrapper functions
-------
--- include/uapi/linux/landlock.h | 27 ++ security/landlock/limits.h | 3 + security/landlock/ruleset.c | 7 +- security/landlock/ruleset.h | 29 +- security/landlock/syscalls.c | 13 +- security/landlock/task.c | 58 ++++ .../testing/selftests/landlock/ptrace_test.c | 261 ++++++++++++++++++ 7 files changed, 392 insertions(+), 6 deletions(-)
include/uapi/linux/landlock.h +27 -0
@@ -37,6 +37,11 @@ struct landlock_ruleset_attr {* rule explicitly allow them. */ __u64 handled_access_net; +/** +* scoped: Bitmask of actions (cf. `Scope access flags`_) +* which are confined to only affect the current Landlock domain. +*/ +__u64 scoped; };/*
@@ -266,4 +271,26 @@ struct landlock_net_port_attr {#define LANDLOCK_ACCESS_NET_BIND_TCP (1ULL << 0)#define LANDLOCK_ACCESS_NET_CONNECT_TCP (1ULL << 1)/* clang-format on */ + +/** +* DOC: scope +* +* .scoped attribute handles a set of restrictions on kernel IPCs through +* the following flags. +* +* Scope access flags +* ~~~~~~~~~~~~~~~~~~~~ +* +* These flags enable to restrict a sandboxed process from a set of IPC +* actions. Setting a flag in a landlock domain will isolate the Landlock +* domain to forbid connections to resources outside the domain. +* +* IPCs with allowed actions: +* - %LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET: Restrict a sandbox process to +* connect to a process outside of the sandbox domain through abstract +* unix sockets. +*/ +/* clang-format off */ +#define LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET (1ULL << 0) +/* clang-format on*/ #endif /* _UAPI_LINUX_LANDLOCK_H */
security/landlock/limits.h +3 -0
@@ -26,6 +26,9 @@#define LANDLOCK_MASK_ACCESS_NET ((LANDLOCK_LAST_ACCESS_NET << 1) - 1)#define LANDLOCK_NUM_ACCESS_NET __const_hweight64(LANDLOCK_MASK_ACCESS_NET) +#define LANDLOCK_LAST_ACCESS_SCOPE LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET +#define LANDLOCK_MASK_ACCESS_SCOPE ((LANDLOCK_LAST_ACCESS_SCOPE << 1) - 1) +#define LANDLOCK_NUM_ACCESS_SCOPE __const_hweight64(LANDLOCK_MASK_ACCESS_SCOPE)/* clang-format on */ #endif /* _SECURITY_LANDLOCK_LIMITS_H */
security/landlock/ruleset.c +5 -2
@@ -52,12 +52,13 @@ static struct landlock_ruleset *create_ruleset(const u32 num_layers)struct landlock_ruleset *landlock_create_ruleset (const access_mask_t fs_access_mask, -const access_mask_t net_access_mask) +const access_mask_t net_access_mask, +const access_mask_t scope_mask) {struct landlock_ruleset *new_ruleset;/* Informs about useless ruleset. */ -if (!fs_access_mask && !net_access_mask) +if (!fs_access_mask && !net_access_mask && !scope_mask)return ERR_PTR (-ENOMSG ); new_ruleset =create_ruleset (1 );if (IS_ERR (new_ruleset))
@@ -66,6 +67,8 @@ landlock_create_ruleset(const access_mask_t fs_access_mask,landlock_add_fs_access_mask (new_ruleset, fs_access_mask,0 );if (net_access_mask)landlock_add_net_access_mask (new_ruleset, net_access_mask,0 ); +if (scope_mask) +landlock_add_scope_mask (new_ruleset, scope_mask,0 );return new_ruleset; }
security/landlock/ruleset.h +28 -1
@@ -35,6 +35,8 @@ typedef u16 access_mask_t;static_assert (BITS_PER_TYPE (access_mask_t) >=LANDLOCK_NUM_ACCESS_FS );/* Makes sure all network access rights can be stored. */ static_assert (BITS_PER_TYPE (access_mask_t) >=LANDLOCK_NUM_ACCESS_NET ); +/* Makes sure all scoped rights can be stored*/ +static_assert (BITS_PER_TYPE (access_mask_t) >=LANDLOCK_NUM_ACCESS_SCOPE );/* Makes sure for_each_set_bit() and for_each_clear_bit() calls are OK. */ static_assert (sizeof (unsigned long ) >=sizeof (access_mask_t));
@@ -42,8 +44,15 @@ static_assert(sizeof(unsigned long) >= sizeof(access_mask_t));struct access_masks {access_mask_t fs :LANDLOCK_NUM_ACCESS_FS ;access_mask_t net :LANDLOCK_NUM_ACCESS_NET ; +access_mask_t scoped :LANDLOCK_NUM_ACCESS_SCOPE ; }; +typedef u32 access_masks_t ; +/* Makes sure all ruleset access rights can be stored. */ +static_assert (BITS_PER_TYPE (access_masks_t) >= +LANDLOCK_NUM_ACCESS_FS +LANDLOCK_NUM_ACCESS_NET + +LANDLOCK_NUM_ACCESS_SCOPE ); +typedef u16 layer_mask_t ;/* Makes sure all layers can be checked. */ static_assert (BITS_PER_TYPE (layer_mask_t) >=LANDLOCK_MAX_NUM_LAYERS );
@@ -233,7 +242,8 @@ struct landlock_ruleset {struct landlock_ruleset *landlock_create_ruleset (const access_mask_t access_mask_fs, -const access_mask_t access_mask_net); +const access_mask_t access_mask_net, +const access_mask_t scope_mask);void landlock_put_ruleset (struct landlock_ruleset *const ruleset);void landlock_put_ruleset_deferred (struct landlock_ruleset *const ruleset);
@@ -280,6 +290,16 @@ landlock_add_net_access_mask(struct landlock_ruleset *const ruleset, ruleset->access_masks[layer_level].net |= net_mask; } +static inline void +landlock_add_scope_mask (struct landlock_ruleset *const ruleset, +const access_mask_t scope_mask,const u16 layer_level) +{ +access_mask_t scoped_mask = scope_mask &LANDLOCK_MASK_ACCESS_SCOPE ; + +WARN_ON_ONCE (scope_mask != scoped_mask); + ruleset->access_masks[layer_level].scoped |= scoped_mask; +} +static inline access_mask_t landlock_get_raw_fs_access_mask (const struct landlock_ruleset *const ruleset,const u16 layer_level)
@@ -303,6 +323,13 @@ landlock_get_net_access_mask(const struct landlock_ruleset *const ruleset,return ruleset->access_masks[layer_level].net; } +static inline access_mask_t +landlock_get_scope_mask (const struct landlock_ruleset *const ruleset, +const u16 layer_level) +{ +return ruleset->access_masks[layer_level].scoped; +} + bool landlock_unmask_layers(const struct landlock_rule *const rule, const access_mask_t access_request, layer_mask_t (*const layer_masks)[],
security/landlock/syscalls.c +10 -3
@@ -97,8 +97,9 @@ static void build_check_abi(void)*/ ruleset_size =sizeof (ruleset_attr.handled_access_fs); ruleset_size +=sizeof (ruleset_attr.handled_access_net); + ruleset_size +=sizeof (ruleset_attr.scoped);BUILD_BUG_ON (sizeof (ruleset_attr) != ruleset_size); -BUILD_BUG_ON (sizeof (ruleset_attr) !=16 ); +BUILD_BUG_ON (sizeof (ruleset_attr) !=24 ); path_beneath_size =sizeof (path_beneath_attr.allowed_access); path_beneath_size +=sizeof (path_beneath_attr.parent_fd);
@@ -170,7 +171,7 @@ static const struct file_operations ruleset_fops = {* Possible returned errors are: * * - %EOPNOTSUPP: Landlock is supported by the kernel but disabled at boot time; -* - %EINVAL: unknown @flags, or unknown access, or too small @size; +* - %EINVAL: unknown @flags, or unknown access, or uknown scope, or too small @size; * - %E2BIG or %EFAULT: @attr or @size inconsistencies; * - %ENOMSG: empty &landlock_ruleset_attr.handled_access_fs. */
@@ -212,10 +213,16 @@ SYSCALL_DEFINE3(landlock_create_ruleset,if ((ruleset_attr.handled_access_net |LANDLOCK_MASK_ACCESS_NET ) !=LANDLOCK_MASK_ACCESS_NET )return -EINVAL ; + +/* Checks IPC scoping content (and 32-bits cast). */ +if ((ruleset_attr.scoped |LANDLOCK_MASK_ACCESS_SCOPE ) != +LANDLOCK_MASK_ACCESS_SCOPE ) +return -EINVAL ;/* Checks arguments and transforms to kernel struct. */ ruleset =landlock_create_ruleset (ruleset_attr.handled_access_fs, - ruleset_attr.handled_access_net); + ruleset_attr.handled_access_net, + ruleset_attr.scoped);if (IS_ERR (ruleset))return PTR_ERR (ruleset);
security/landlock/task.c +58 -0
73 lines not on this page · raw message
tools/testing/selftests/landlock/ptrace_test.c +261 -0
271 lines not on this page · raw message
Signature · 1 line
2.34.1