Landlock: Add abstract unix socket connect reastriction
Get series with b4
b4 am [email protected]Versions newest first
- v1 Latest0 of 2 patches 1 replyIn review
Patches in v1 No applies recorded yet
None of the 2 patches the cover letter announces are in this archive.
Reviews trailers per patch
No Reviewed-by, Acked-by or Tested-by trailers for v1 yet.
Cover letter [PATCH 0/2] Landlock: Add abstract unix socket connect reastriction
This patch series introduces the optional scoping of abstract unix sockets. This feature aims to scope the connection of an abstract socket from a sandbox process to other sockets outside of the sandbox domain. (see [1, 2])
The following changes are included in this series:
[PATCH 1/2]: Introduce the "scoped" field to the ruleset structure in
the user space interface, and add the restriction mechanism to Landlock.
[PATCH 2/2]: Add three comprehensive tests for the new feature.
Tahera Fahimi (2):
Landlock: Add abstract unix socket connect restriction
Landlock: Abstract unix socket restriction tests
include/uapi/linux/landlock.h | 29 + security/landlock/limits.h | 3 + security/landlock/ruleset.c | 7 +- security/landlock/ruleset.h | 23 +- security/landlock/syscalls.c | 12 +- security/landlock/task.c | 62 ++ .../testing/selftests/landlock/ptrace_test.c | 786 ++++++++++++++++++ 7 files changed, 916 insertions(+), 6 deletions(-)
[1]: https://lore.kernel.org/all/[email protected]/
[2]: https://lore.kernel.org/all/[email protected]/
Signature · 1 line
2.34.1
From 2901842a561ee3d205f93f9ba543741f82edf65d Mon Sep 17 00:00:00 2001
Message-Id: <2901842a561ee3d205f93f9ba543741f82edf65d.1720203255.git.fahimitahera@gmail.com>
In-Reply-To: <[email protected]>
References: <[email protected]>
From: Tahera Fahimi <[email protected]>
Date: Fri, 21 Jun 2024 15:23:17 -0600
Subject: [PATCH 1/2] Landlock: Add abstract unix socket connect restriction
Abstract unix sockets are used for local inter-process communications without a filesystem. Currently a sandboxed process can connect to a socket outside of the sandboxed environment, since Landlock has no restriction for connecting to an abstract socket address. 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 to the ruleset attribute structure. 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)
-------
v6: Removing tests. Removing curr_ruleset.
v5: Added curr_ruleset to hierarachy_ruleset structure for optional
scoping purpose.
V4: Added tests and changes in task.c to scope different sockets
differently.
V3: Added "scoped" field to landlock_ruleset_attr
V2: Remove wrapper functions
-------
--- include/uapi/linux/landlock.h | 29 ++++++++++++++++ security/landlock/limits.h | 3 ++ security/landlock/ruleset.c | 7 ++-- security/landlock/ruleset.h | 23 ++++++++++++- security/landlock/syscalls.c | 12 +++++-- security/landlock/task.c | 62 +++++++++++++++++++++++++++++++++++ 6 files changed, 130 insertions(+), 6 deletions(-)
include/uapi/linux/landlock.h +29 -0
@@ -37,6 +37,12 @@ struct landlock_ruleset_attr {* rule explicitly allow them. */ __u64 handled_access_net; +/** +* @scoped: Bitmask of scopes (cf. `Scope flags`_) +* restricting a Landlock domain from accessing outside +* resources(e.g. IPCs). +*/ +__u64 scoped; };/*
@@ -266,4 +272,27 @@ 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 flags +* ~~~~~~~~~~~ +* +* These flags enable to restrict a sandboxed process from a set of IPC +* actions. Setting a flag for a ruleset will isolate the Landlock domain +* to forbid connections to resources outside the domain. +* +* IPCs with scoped actions: +* - %LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET: Restrict a sandboxed process +* from connecting to an abstract unix socket created by a process +* outside the related Landlock domain (e.g. a parent domain or a process +* which is not sandboxed). +*/ +/* 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_SCOPE LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET +#define LANDLOCK_MASK_SCOPE ((LANDLOCK_LAST_SCOPE << 1) - 1) +#define LANDLOCK_NUM_SCOPE __const_hweight64(LANDLOCK_MASK_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 +22 -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_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,6 +44,7 @@ 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_SCOPE ; };typedef u16 layer_mask_t ;
@@ -233,7 +236,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 +284,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_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 +317,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 +9 -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. */
@@ -213,9 +214,14 @@ SYSCALL_DEFINE3(landlock_create_ruleset, LANDLOCK_MASK_ACCESS_NET)return -EINVAL ; +/* Checks IPC scoping content (and 32-bits cast). */ +if ((ruleset_attr.scoped |LANDLOCK_MASK_SCOPE ) !=LANDLOCK_MASK_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 +62 -0
77 lines not on this page · raw message
Signature · 1 line
2.34.1
From 314cc02a23cbf82bca140fe8a0f0ceb75c67ea77 Mon Sep 17 00:00:00 2001
Message-Id: <314cc02a23cbf82bca140fe8a0f0ceb75c67ea77.1720203255.git.fahimitahera@gmail.com>
In-Reply-To: <[email protected]>
References: <[email protected]>
From: Tahera Fahimi <[email protected]>
Date: Wed, 26 Jun 2024 15:54:25 -0600
Subject: [PATCH 2/2] Landlock: Abstract unix socket restriction tests
Tests for scoping abstract unix sockets. The patch has three types of tests:
i) unix_socket: base tests the scoping mechanism for a landlocked process, same as the ptrace test.
ii) optional_scoping: generates three processes with different domains and
tests if a process with a non-scoped domain can connect to other processes.
iii) unix_sock_special_cases: since the socket's creator credentials are used
for scoping datagram sockets, this test examines the cases where the socket's credentials are different from the process using it.
--- .../testing/selftests/landlock/ptrace_test.c | 786 ++++++++++++++++++ 1 file changed, 786 insertions(+)
tools/testing/selftests/landlock/ptrace_test.c +786 -0
796 lines not on this page · raw message
Signature · 1 line
2.34.1