Landlock: Add abstract UNIX socket restriction
Subsystems (7)
v11 cover Landlock: Add abstract UNIX socket restriction
This patch series adds scoping mechanism for abstract UNIX sockets.
Problem
=======
Abstract UNIX sockets are used for local inter-process communications independent of the 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(see more details in [1,2]). Access to such sockets for a sandboxed process should be scoped the same way ptrace is limited.
[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/[email protected]/
Solution
========
To solve this issue, we extend the user space interface by adding a new "scoped" field to Landlock ruleset attribute structure. This field can contains different rights to restrict different functionalities. For abstract UNIX sockets, we introduce "LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET" field to specify that a ruleset will deny any connection from within the sandbox domain to its parent (i.e. any parent sandbox or non-sandbox processes).
Example
=======
Starting a listening socket with socat(1):
socat abstract-listen:mysocket -
Starting a sandboxed shell from $HOME with samples/landlock/sandboxer:
LL_FS_RO=/ LL_FS_RW=. LL_SCOPED="a" ./sandboxer /bin/bash
If we try to connect to the listening socket, the connection gets refused.
socat - abstract-connect:mysocket --> fails
Notes of Implementation
=======================
* Using the "scoped" field provides enough compatibility and flexibility to extend the scoping mechanism for other IPCs(e.g. signals).
* To access the domain of a socket, we use its credentials of the file's FD which point to the credentials of the process that created the socket (see more details in [3]). Cases where the process using the socket has a different domain than the process created it are covered in the "outside_socket" test.
[3]https://lore.kernel.org/all/[email protected]/
Previous Versions
=================
v10:https://lore.kernel.org/all/[email protected]/
v9: https://lore.kernel.org/all/[email protected]/
v8: https://lore.kernel.org/all/[email protected]/
v7: https://lore.kernel.org/all/[email protected]/
v6: https://lore.kernel.org/all/Zn32CYZiu7pY+rdI@tahera-OptiPlex-5000/
and https://lore.kernel.org/all/Zn32KKIJrY7Zi51K@tahera-OptiPlex-5000/
v5: https://lore.kernel.org/all/ZnSZnhGBiprI6FRk@tahera-OptiPlex-5000/
v4: https://lore.kernel.org/all/ZnNcE3ph2SWi1qmd@tahera-OptiPlex-5000/
v3: https://lore.kernel.org/all/ZmJJ7lZdQuQop7e5@tahera-OptiPlex-5000/
v2: https://lore.kernel.org/all/ZgX5TRTrSDPrJFfF@tahera-OptiPlex-5000/
v1: https://lore.kernel.org/all/ZgXN5fi6A1YQKiAQ@tahera-OptiPlex-5000/
Tahera Fahimi (8):
Landlock: Add abstract UNIX socket restriction selftests/landlock: Add test for handling unknown scope selftests/landlock: Add abstract UNIX socket restriction tests selftests/landlock: Add tests for UNIX sockets with any address
formats
selftests/landlock: Test connected vs non-connected datagram UNIX
socket
selftests/landlock: Restrict inherited datagram UNIX socket to connect sample/landlock: Add support abstract UNIX socket restriction
Landlock: Document LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET and ABI
version
Documentation/userspace-api/landlock.rst | 45 +- include/uapi/linux/landlock.h | 28 + samples/landlock/sandboxer.c | 61 +- security/landlock/limits.h | 3 + security/landlock/ruleset.c | 7 +- security/landlock/ruleset.h | 24 +- security/landlock/syscalls.c | 17 +- security/landlock/task.c | 136 +++ tools/testing/selftests/landlock/base_test.c | 2 +- tools/testing/selftests/landlock/common.h | 38 + tools/testing/selftests/landlock/net_test.c | 31 +- .../landlock/scoped_abstract_unix_test.c | 993 ++++++++++++++++++ .../selftests/landlock/scoped_base_variants.h | 154 +++ .../selftests/landlock/scoped_common.h | 28 + .../scoped_multiple_domain_variants.h | 154 +++ .../testing/selftests/landlock/scoped_test.c | 33 + 16 files changed, 1709 insertions(+), 45 deletions(-) create mode 100644 tools/testing/selftests/landlock/scoped_abstract_unix_test.c create mode 100644 tools/testing/selftests/landlock/scoped_base_variants.h create mode 100644 tools/testing/selftests/landlock/scoped_common.h create mode 100644 tools/testing/selftests/landlock/scoped_multiple_domain_variants.h create mode 100644 tools/testing/selftests/landlock/scoped_test.c
Signature · 1 line
2.34.1
PATCH v11 1/8 Landlock: Add abstract UNIX socket restriction
This patch introduces a new "scoped" attribute to the landlock_ruleset_attr that can specify "LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET" to scope abstract UNIX sockets from connecting to a process outside of the same Landlock domain. It implements two hooks, unix_stream_connect and unix_may_send to enforce this restriction.
---
v11:
- For a connected abstract datagram socket, the hook_unix_may_send allows the socket to send a data. (it is treated as a connected stream socket)
- Minor comment revision.
v10:
- Minor code improvement based on reviews on v9.
v9:
- Editting inline comments.
- Major refactoring in domain_is_scoped() and is_abstract_socket v8:
- Code refactoring (improve code readability, renaming variable, etc.) based on reviews by Mickaël Salaün on version 7.
- Adding warn_on_once to check (impossible) inconsistencies.
- Adding inline comments.
- Adding check_unix_address_format to check if the scoping socket is an abstract UNIX sockets.
v7:
- Using socket's file credentials for both connected(STREAM) and non-connected(DGRAM) sockets.
- Adding "domain_sock_scope" instead of the domain scoping mechanism used in ptrace ensures that if a server's domain is accessible from the client's domain (where the client is more privileged than the server), the client can connect to the server in all edge cases.
- Removing debug codes.
v6:
- Removing curr_ruleset from landlock_hierarchy, and switching back to use the same domain scoping as ptrace.
- code clean up.
v5:
- Renaming "LANDLOCK_*_ACCESS_SCOPE" to "LANDLOCK_*_SCOPE"
- Adding curr_ruleset to hierarachy_ruleset structure to have access from landlock_hierarchy to its respective landlock_ruleset.
- Using curr_ruleset to check if a domain is scoped while walking in the hierarchy of domains.
- Modifying inline comments.
v4:
- Rebased on Günther's Patch:
https://lore.kernel.org/all/[email protected]/
so there is no need for "LANDLOCK_SHIFT_ACCESS_SCOPE", then it is removed.
- Adding get_scope_accesses function to check all scoped access masks in a ruleset.
- Using socket's file credentials instead of credentials stored in peer_cred for datagram sockets. (see discussion in [1])
- Modifying inline comments.
V3:
- Improving commit description.
- Introducing "scoped" attribute to landlock_ruleset_attr for IPC scoping purpose, and adding related functions.
- Changing structure of ruleset based on "scoped".
- Removing rcu lock and using unix_sk lock instead.
- Introducing scoping for datagram sockets in unix_may_send. V2:
- Removing wrapper functions
[1]https://lore.kernel.org/all/[email protected]/
--- include/uapi/linux/landlock.h | 28 ++++ security/landlock/limits.h | 3 + security/landlock/ruleset.c | 7 +- security/landlock/ruleset.h | 24 +++- security/landlock/syscalls.c | 17 ++- security/landlock/task.c | 136 +++++++++++++++++++ tools/testing/selftests/landlock/base_test.c | 2 +- 7 files changed, 208 insertions(+), 9 deletions(-)
include/uapi/linux/landlock.h +28 -0
@@ -44,6 +44,12 @@ struct landlock_ruleset_attr {* flags`_). */ __u64 handled_access_net; +/** +* @scoped: Bitmask of scopes (cf. `Scope flags`_) +* restricting a Landlock domain from accessing outside +* resources(e.g. IPCs). +*/ +__u64 scoped; };/*
@@ -274,4 +280,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 +* +* 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 +* non-sandboxed process). +*/ +/* 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 +23 -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,17 @@ 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 ; + +/* Should already be checked in sys_landlock_create_ruleset(). */ +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 +318,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 +12 -5
@@ -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);
@@ -149,7 +150,7 @@ static const struct file_operations ruleset_fops = { .write = fop_dummy_write, }; -#define LANDLOCK_ABI_VERSION 5 +#define LANDLOCK_ABI_VERSION 6/** * sys_landlock_create_ruleset - Create a new ruleset
@@ -170,8 +171,9 @@ 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; -* - %E2BIG or %EFAULT: @attr or @size inconsistencies; +* - %EINVAL: unknown @flags, or unknown access, or unknown scope, or too small @size; +* - %E2BIG: @attr or @size inconsistencies; +* - %EFAULT: @attr or @size inconsistencies; * - %ENOMSG: empty &landlock_ruleset_attr.handled_access_fs. */ SYSCALL_DEFINE3(landlock_create_ruleset,
@@ -213,9 +215,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 +136 -0
151 lines not on this page · raw message
tools/testing/selftests/landlock/base_test.c +1 -1
@@ -76,7 +76,7 @@ TEST(abi_version)const struct landlock_ruleset_attr ruleset_attr = { .handled_access_fs =LANDLOCK_ACCESS_FS_READ_FILE , }; -ASSERT_EQ (5 ,landlock_create_ruleset (NULL ,0 , +ASSERT_EQ (6 ,landlock_create_ruleset (NULL ,0 ,LANDLOCK_CREATE_RULESET_VERSION )); ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr, 0,
Signature · 1 line
2.34.1
PATCH v11 2/8 selftests/landlock: Add test for handling unknown scope
In reply to Tahera FahimiThe test function, "ruleset_with_unknown_scope", is designed to validate the behaviour of the "landlock_create_ruleset" function when it is provided with an unsupported or unknown scope mask.
---
Changes in versions:
v11:
* Change commit subject and apply coding style
--- .../testing/selftests/landlock/scoped_test.c | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 tools/testing/selftests/landlock/scoped_test.c
tools/testing/selftests/landlock/scoped_test.c new file +33 -0
@@ -0,0 +1,33 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Landlock tests - Common scope restriction +* +* Copyright © 2024 Tahera Fahimi <[email protected]> +*/ + +#define _GNU_SOURCE +#include <errno.h> +#include <linux/landlock.h> +#include <sys/prctl.h> + +#include "common.h" + +#define ACCESS_LAST LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET + +TEST (ruleset_with_unknown_scope) +{ +__u64 scoped_mask; + +for (scoped_mask =1ULL <<63 ; scoped_mask !=ACCESS_LAST ; + scoped_mask >>=1 ) { +struct landlock_ruleset_attr ruleset_attr = { + .scoped = scoped_mask, + }; + +ASSERT_EQ (-1 ,landlock_create_ruleset (&ruleset_attr, +sizeof (ruleset_attr),0 )); +ASSERT_EQ (EINVAL , errno); + } +} + +TEST_HARNESS_MAIN
Signature · 1 line
2.34.1
PATCH v11 3/8 selftests/landlock: Add abstract UNIX socket restriction tests
In reply to Tahera FahimiThe patch introduces Landlock ABI version 6 and adds three tests that examines different scenarios for abstract UNIX socket:
1) unix_socket: base tests of the abstract socket scoping mechanism for a landlocked process, same as the ptrace test.
2) scoped_vs_unscoped_sockets: generates three processes with different domains and tests if a process with a non-scoped domain can connect to other processes.
3) outside_socket: since the socket's creator credentials are used for scoping sockets, this test examines the cases where the socket's credentials are different from the process using it.
---
Changes in versions:
v11:
- Adding a generalized domain creation function, "create_scoped_domain", for different types of scoped domains in "scoped_common.h" file.
- Rename "unix_socket" to "scoped_domain" and moving its variants to "scoped_base_variants.h" file (for future use in other IPC tests).
- Minor code improvement, and renaming variables.
- Rename "optional_scoping" to "scoped_vs_unscoped_sockets", and add support for datagram and stream sockets. Moving its variants to "scoped_multiple_domain_variants.h" file.
v10:
- Code improvements by changing fixture variables to local ones.
- Rename "unix_sock_special_cases" to "outside_socket"
v9:
- Move pathname_address_sockets to a different patch.
- Extend optional_scoping test scenarios.
- Removing hardcoded numbers and using "backlog" instead. V8:
- Move tests to scoped_abstract_unix_test.c file.
- To avoid potential conflicts among Unix socket names in different tests, set_unix_address is added to common.h to set different sun_path for Unix sockets.
- protocol_variant and service_fixture structures are also moved to common.h
- Adding pathname_address_sockets to cover all types of address formats for unix sockets, and moving remove_path() to common.h to reuse in this test.
V7:
- Introducing landlock ABI version 6.
- Adding some edge test cases to optional_scoping test.
- Using enum for different domains in optional_scoping tests.
- Extend unix_sock_special_cases test cases for connected(SOCK_STREAM) sockets.
- Modifying inline comments.
V6:
- Introducing optional_scoping test which ensures a sandboxed process with a non-scoped domain can still connect to another abstract unix socket(either sandboxed or non-sandboxed).
- Introducing unix_sock_special_cases test which tests examines scenarios where the connecting sockets have different domain than the process using them.
V4:
- Introducing unix_socket to evaluate the basic scoping mechanism for abstract unix sockets.
--- tools/testing/selftests/landlock/common.h | 38 ++ tools/testing/selftests/landlock/net_test.c | 31 +- .../landlock/scoped_abstract_unix_test.c | 620 ++++++++++++++++++ .../selftests/landlock/scoped_base_variants.h | 154 +++++ .../selftests/landlock/scoped_common.h | 28 + .../scoped_multiple_domain_variants.h | 154 +++++ 6 files changed, 995 insertions(+), 30 deletions(-) create mode 100644 tools/testing/selftests/landlock/scoped_abstract_unix_test.c create mode 100644 tools/testing/selftests/landlock/scoped_base_variants.h create mode 100644 tools/testing/selftests/landlock/scoped_common.h create mode 100644 tools/testing/selftests/landlock/scoped_multiple_domain_variants.h
tools/testing/selftests/landlock/common.h +38 -0
@@ -7,6 +7,7 @@* Copyright © 2021 Microsoft Corporation */ +#include <arpa/inet.h> #include <errno.h> #include <linux/landlock.h> #include <linux/securebits.h>
@@ -14,10 +15,12 @@#include <sys/socket.h> #include <sys/syscall.h> #include <sys/types.h> +#include <sys/un.h> #include <sys/wait.h> #include <unistd.h> #include "../kselftest_harness.h" +#define TMP_DIR "tmp"#ifndef __maybe_unused#define __maybe_unused __attribute__((__unused__))
@@ -226,3 +229,38 @@ enforce_ruleset(struct __test_metadata *const _metadata, const int ruleset_fd)TH_LOG ("Failed to enforce ruleset: %s" ,strerror (errno)); } } + +struct protocol_variant { +int domain; +int type; +}; + +struct service_fixture { +struct protocol_variant protocol; +/* port is also stored in ipv4_addr.sin_port or ipv6_addr.sin6_port */ +unsigned short port; +union { +struct sockaddr_in ipv4_addr; +struct sockaddr_in6 ipv6_addr; +struct { +struct sockaddr_un unix_addr; +socklen_t unix_addr_len; + }; + }; +}; + +static pid_t __maybe_unused sys_gettid (void ) +{ +return syscall (__NR_gettid); +} + +static void __maybe_unused set_unix_address (struct service_fixture *const srv, +const unsigned short index) +{ + srv->unix_addr.sun_family =AF_UNIX ; +sprintf (srv->unix_addr.sun_path, +"_selftests-landlock-abstract-unix-tid%d-index%d" ,sys_gettid (), + index); + srv->unix_addr_len =SUN_LEN (&srv->unix_addr); + srv->unix_addr.sun_path[0 ] ='\0' ; +}
tools/testing/selftests/landlock/net_test.c +1 -30
@@ -36,30 +36,6 @@ enum sandbox_type { TCP_SANDBOX, }; -struct protocol_variant { -int domain; -int type; -}; - -struct service_fixture { -struct protocol_variant protocol; -/* port is also stored in ipv4_addr.sin_port or ipv6_addr.sin6_port */ -unsigned short port; -union { -struct sockaddr_in ipv4_addr; -struct sockaddr_in6 ipv6_addr; -struct { -struct sockaddr_un unix_addr; -socklen_t unix_addr_len; - }; - }; -}; - -static pid_t sys_gettid (void ) -{ -return syscall (__NR_gettid); -} -static int set_service (struct service_fixture *const srv,const struct protocol_variant prot,const unsigned short index)
@@ -92,12 +68,7 @@ static int set_service(struct service_fixture *const srv,return 0 ;case AF_UNIX : - srv->unix_addr.sun_family = prot.domain; -sprintf (srv->unix_addr.sun_path, -"_selftests-landlock-net-tid%d-index%d" ,sys_gettid (), - index); - srv->unix_addr_len =SUN_LEN (&srv->unix_addr); - srv->unix_addr.sun_path[0 ] ='\0' ; +set_unix_address (srv, index);return 0 ; }return 1 ;
tools/testing/selftests/landlock/scoped_abstract_unix_test.c new file +620 -0
620 lines not on this page · raw message
tools/testing/selftests/landlock/scoped_base_variants.h new file +154 -0
154 lines not on this page · raw message
tools/testing/selftests/landlock/scoped_common.h new file +28 -0
@@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Landlock scope test helpers +* +* Copyright © 2024 Tahera Fahimi <[email protected]> +*/ + +#define _GNU_SOURCE + +#include <sys/types.h> + +static void create_scoped_domain (struct __test_metadata *const _metadata, +const __u16 scope) +{ +int ruleset_fd; +const struct landlock_ruleset_attr ruleset_attr = { + .scoped = scope, + }; + + ruleset_fd = +landlock_create_ruleset (&ruleset_attr,sizeof (ruleset_attr),0 ); + ASSERT_LE(0, ruleset_fd) + { +TH_LOG ("Failed to create a ruleset: %s" ,strerror (errno)); + } +enforce_ruleset (_metadata, ruleset_fd); +EXPECT_EQ (0 ,close (ruleset_fd)); +}
tools/testing/selftests/landlock/scoped_multiple_domain_variants.h new file +154 -0
154 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v11 4/8 selftests/landlock: Add tests for UNIX sockets with any address formats
In reply to Tahera FahimiThis patch expands abstract UNIX socket restriction tests by examining different scenarios for UNIX sockets with pathname or unnamed address formats connection with scoped domain.
The test "various_address_sockets" ensures that UNIX sockets bound to a filesystem pathname and unnamed sockets created by socketpair can still connect to a socket outside of their scoped domain, meaning that even if the domain is scoped with LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET, the socket can connect to a socket outside the scoped domain.
---
changes in versions:
v11:
- Using generalized scoped domain creation, "create_scoped_domain"
- Rename pathname_address_sockets to various_address_sockets
- Using local variables.
- Commit improvement.
- Support test for unnamed datagram sockets(via socketpair(2)). v10:
- Code improvements by changing fixture variables to local ones.
- Commit improvement.
v9:
- Moving remove_path() back to fs_test.c, and using unlink(2) and rmdir(2) instead.
- Removing hard-coded numbers and using "backlog" instead. V8:
- Adding pathname_address_sockets to cover all types of address formats for unix sockets, and moving remove_path() to common.h to reuse in this test.
--- .../landlock/scoped_abstract_unix_test.c | 202 ++++++++++++++++++ 1 file changed, 202 insertions(+)
tools/testing/selftests/landlock/scoped_abstract_unix_test.c +202 -0
@@ -617,4 +617,206 @@ TEST_F(outside_socket, socket_with_different_domain) _metadata->exit_code =KSFT_FAIL ; } +static const char path1[] =TMP_DIR "/s1_variant1" ; +static const char path2[] =TMP_DIR "/s2_variant1" ; + +/* clang-format off */ +FIXTURE (various_address_sockets) +{ +struct service_fixture stream_address, dgram_address; +}; +/* clang-format on */ + +FIXTURE_VARIANT (various_address_sockets) +{ +const int domain; +}; + +/* clang-format off */ +FIXTURE_VARIANT_ADD(various_address_sockets, pathname_socket_scoped_domain) { +/* clang-format on */ + .domain =SCOPE_SANDBOX , +}; + +/* clang-format off */ +FIXTURE_VARIANT_ADD(various_address_sockets, pathname_socket_other_domain) { +/* clang-format on */ + .domain =OTHER_SANDBOX , +}; + +/* clang-format off */ +FIXTURE_VARIANT_ADD(various_address_sockets, pathname_socket_no_domain) { +/* clang-format on */ + .domain = NO_SANDBOX, +}; + +FIXTURE_SETUP (various_address_sockets) +{ +disable_caps (_metadata); +umask (0077 ); +ASSERT_EQ (0 ,mkdir (TMP_DIR ,0700 )); + + ASSERT_EQ(0, mknod(path1, S_IFREG | 0700, 0)) + { +TH_LOG ("Failed to create file \"%s\": %s" , path1, +strerror (errno)); +ASSERT_EQ (0 ,unlink (TMP_DIR ) &rmdir (TMP_DIR )); + } + ASSERT_EQ(0, mknod(path2, S_IFREG | 0700, 0)) + { +TH_LOG ("Failed to create file \"%s\": %s" , path2, +strerror (errno)); +ASSERT_EQ (0 ,unlink (TMP_DIR ) &rmdir (TMP_DIR )); + } +memset (&self->stream_address,0 ,sizeof (self->stream_address)); +set_unix_address (&self->stream_address,0 ); +memset (&self->dgram_address,0 ,sizeof (self->dgram_address)); +set_unix_address (&self->dgram_address,1 ); +} + +FIXTURE_TEARDOWN (various_address_sockets) +{ +ASSERT_EQ (0 ,unlink (path1) &rmdir (path1)); +ASSERT_EQ (0 ,unlink (path2) &rmdir (path2)); +ASSERT_EQ (0 ,unlink (TMP_DIR ) &rmdir (TMP_DIR )); +} + +TEST_F(various_address_sockets, scoped_pathname_sockets) +{ +const char *const stream_path = path1; +const char *const dgram_path = path2; +socklen_t size, size_dg; +struct sockaddr_un stream_pathname_addr, dgram_pathname_addr; +int unnamed_sockets[2 ]; +int stream_pathname_socket, dgram_pathname_socket, + stream_abstract_socket, dgram_abstract_socket; +int pipe_parent[2 ]; +pid_t child; +int status; +char buf_child; +char data ='S' ; +char buf[5 ]; +int nbyte; + +ASSERT_EQ (0 ,socketpair (AF_UNIX ,SOCK_DGRAM ,0 , unnamed_sockets)); + + stream_pathname_addr.sun_family =AF_UNIX ; +snprintf (stream_pathname_addr.sun_path, +sizeof (stream_pathname_addr.sun_path),"%s" , stream_path); + size = offsetof(struct sockaddr_un , sun_path) + +strlen (stream_pathname_addr.sun_path); + + dgram_pathname_addr.sun_family =AF_UNIX ; +snprintf (dgram_pathname_addr.sun_path, +sizeof (dgram_pathname_addr.sun_path),"%s" , dgram_path); + size_dg = offsetof(struct sockaddr_un , sun_path) + +strlen (dgram_pathname_addr.sun_path); + +ASSERT_EQ (0 ,pipe2 (pipe_parent,O_CLOEXEC )); + + child =fork (); +ASSERT_LE (0 , child); +if (child ==0 ) { +int err, err_dg; + +ASSERT_EQ (0 ,close (pipe_parent[1 ])); + +if (variant->domain ==SCOPE_SANDBOX ) +create_scoped_domain ( + _metadata, +LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET ); +else if (variant->domain ==OTHER_SANDBOX ) +create_fs_domain (_metadata); + +ASSERT_EQ (0 ,close (unnamed_sockets[1 ])); +ASSERT_NE (-1 ,write (unnamed_sockets[0 ], &data,sizeof (data))); +ASSERT_EQ (0 ,close (unnamed_sockets[0 ])); + +ASSERT_EQ (1 ,read (pipe_parent[0 ], &buf_child,1 )); + +/* Connect with pathname sockets. */ + stream_pathname_socket =socket (AF_UNIX ,SOCK_STREAM ,0 ); +ASSERT_LE (0 , stream_pathname_socket); +ASSERT_EQ (0 ,connect (stream_pathname_socket, + &stream_pathname_addr, size)); + dgram_pathname_socket =socket (AF_UNIX ,SOCK_DGRAM ,0 ); +ASSERT_LE (0 , dgram_pathname_socket); +ASSERT_EQ (0 ,connect (dgram_pathname_socket, + &dgram_pathname_addr, size_dg)); + +/* Connect with abstract sockets. */ + stream_abstract_socket =socket (AF_UNIX ,SOCK_STREAM ,0 ); + dgram_abstract_socket =socket (AF_UNIX ,SOCK_DGRAM ,0 ); + +ASSERT_NE (-1 , stream_abstract_socket); +ASSERT_NE (-1 , dgram_abstract_socket); + + err =connect (stream_abstract_socket, + &self->stream_address.unix_addr, + self->stream_address.unix_addr_len); + err_dg =connect (dgram_abstract_socket, + &self->dgram_address.unix_addr, + self->dgram_address.unix_addr_len); +if (variant->domain ==SCOPE_SANDBOX ) { +EXPECT_EQ (-1 , err); +EXPECT_EQ (-1 , err_dg); +EXPECT_EQ (EPERM , errno); + }else { +EXPECT_EQ (0 , err); +EXPECT_EQ (0 , err_dg); + } +ASSERT_EQ (0 ,close (stream_abstract_socket)); +ASSERT_EQ (0 ,close (dgram_abstract_socket)); +ASSERT_EQ (0 ,close (stream_pathname_socket)); +ASSERT_EQ (0 ,close (dgram_pathname_socket)); +_exit (_metadata->exit_code); +return ; + } +ASSERT_EQ (0 ,close (pipe_parent[0 ])); + +ASSERT_EQ (0 ,close (unnamed_sockets[0 ])); + nbyte =read (unnamed_sockets[1 ], buf,sizeof (buf)); +ASSERT_EQ (sizeof (data), nbyte); + buf[nbyte] ='\0' ; +ASSERT_EQ (0 ,strcmp (&data, buf)); +ASSERT_LE (0 ,close (unnamed_sockets[1 ])); + +/* Sets up pathname servers */ + stream_pathname_socket =socket (AF_UNIX ,SOCK_STREAM ,0 ); +ASSERT_LE (0 , stream_pathname_socket); +ASSERT_EQ (0 ,unlink (stream_path)); +ASSERT_EQ (0 ,bind (stream_pathname_socket, &stream_pathname_addr, size)); +ASSERT_EQ (0 ,listen (stream_pathname_socket, backlog)); + +ASSERT_EQ (0 ,unlink (dgram_path)); + dgram_pathname_socket =socket (AF_UNIX ,SOCK_DGRAM ,0 ); +ASSERT_LE (0 , dgram_pathname_socket); +ASSERT_EQ (0 , +bind (dgram_pathname_socket, &dgram_pathname_addr, size_dg)); + +/* Set up abstract servers */ + stream_abstract_socket =socket (AF_UNIX ,SOCK_STREAM ,0 ); + dgram_abstract_socket =socket (AF_UNIX ,SOCK_DGRAM ,0 ); +ASSERT_NE (-1 , stream_abstract_socket); +ASSERT_NE (-1 , dgram_abstract_socket); +ASSERT_EQ (0 , +bind (stream_abstract_socket, &self->stream_address.unix_addr, + self->stream_address.unix_addr_len)); +ASSERT_EQ (0 ,bind (dgram_abstract_socket, &self->dgram_address.unix_addr, + self->dgram_address.unix_addr_len)); +ASSERT_EQ (0 ,listen (stream_abstract_socket, backlog)); + +ASSERT_EQ (1 ,write (pipe_parent[1 ],"." ,1 )); +ASSERT_EQ (child,waitpid (child, &status,0 )); + +ASSERT_EQ (0 ,close (stream_abstract_socket)); +ASSERT_EQ (0 ,close (dgram_abstract_socket)); +ASSERT_EQ (0 ,close (stream_pathname_socket)); +ASSERT_EQ (0 ,close (dgram_pathname_socket)); + +if (WIFSIGNALED (status) || !WIFEXITED (status) || +WEXITSTATUS (status) !=EXIT_SUCCESS ) + _metadata->exit_code =KSFT_FAIL ; +} +TEST_HARNESS_MAIN
Signature · 1 line
2.34.1
PATCH v11 5/8 selftests/landlock: Test connected vs non-connected datagram UNIX socket
In reply to Tahera FahimiThis patch checks the specific case where a scoped datagram socket is connected and send(2) works, whereas sendto(2) is denied if the datagram socket is not connected.
--- .../landlock/scoped_abstract_unix_test.c | 105 ++++++++++++++++++ 1 file changed, 105 insertions(+)
tools/testing/selftests/landlock/scoped_abstract_unix_test.c +105 -0
@@ -819,4 +819,109 @@ TEST_F(various_address_sockets, scoped_pathname_sockets) _metadata->exit_code =KSFT_FAIL ; } +TEST (datagram_sockets) +{ +struct service_fixture connected_addr, non_connected_addr; +int conn_sock, non_conn_sock; +int pipe_parent[2 ], pipe_child[2 ]; +int status; +char buf; +pid_t child; +int num_bytes; +char data[64 ]; + +drop_caps (_metadata); +memset (&connected_addr,0 ,sizeof (connected_addr)); +set_unix_address (&connected_addr,0 ); +memset (&non_connected_addr,0 ,sizeof (non_connected_addr)); +set_unix_address (&non_connected_addr,1 ); + +ASSERT_EQ (0 ,pipe2 (pipe_parent,O_CLOEXEC )); +ASSERT_EQ (0 ,pipe2 (pipe_child,O_CLOEXEC )); + + child =fork (); +ASSERT_LE (0 , child); +if (child ==0 ) { +char buf_data[64 ]; + +ASSERT_EQ (0 ,close (pipe_parent[1 ])); +ASSERT_EQ (0 ,close (pipe_child[0 ])); + + conn_sock =socket (AF_UNIX ,SOCK_DGRAM ,0 ); + non_conn_sock =socket (AF_UNIX ,SOCK_DGRAM ,0 ); +ASSERT_NE (-1 , conn_sock); +ASSERT_NE (-1 , non_conn_sock); + +ASSERT_EQ (1 ,read (pipe_parent[0 ], &buf,1 )); + +ASSERT_EQ (0 ,connect (conn_sock, &connected_addr.unix_addr, + connected_addr.unix_addr_len)); + +/* Both connected and non-connected sockets can send +* data when the domain is not scoped. +*/ +memset (buf_data,'x' ,sizeof (buf_data)); +ASSERT_NE (-1 ,send (conn_sock, buf_data,sizeof (buf_data),0 )); +ASSERT_NE (-1 ,sendto (non_conn_sock, buf_data,sizeof (buf_data), +0 , &non_connected_addr.unix_addr, + non_connected_addr.unix_addr_len)); +ASSERT_EQ (1 ,write (pipe_child[1 ],"." ,1 )); + +/* Scopes the domain. */ +create_scoped_domain (_metadata, +LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET ); + +/* +* Connected socket sends data to the receiver, but the +* non-connected socket must fail to send data. +*/ +ASSERT_NE (-1 ,send (conn_sock, buf_data,sizeof (buf_data),0 )); +ASSERT_EQ (-1 ,sendto (non_conn_sock, buf_data,sizeof (buf_data), +0 , &non_connected_addr.unix_addr, + non_connected_addr.unix_addr_len)); +ASSERT_EQ (EPERM , errno); +ASSERT_EQ (1 ,write (pipe_child[1 ],"." ,1 )); + +EXPECT_EQ (0 ,close (conn_sock)); +EXPECT_EQ (0 ,close (non_conn_sock)); +_exit (_metadata->exit_code); +return ; + } +ASSERT_EQ (0 ,close (pipe_parent[0 ])); +ASSERT_EQ (0 ,close (pipe_child[1 ])); + + conn_sock =socket (AF_UNIX ,SOCK_DGRAM ,0 ); + non_conn_sock =socket (AF_UNIX ,SOCK_DGRAM ,0 ); +ASSERT_NE (-1 , conn_sock); +ASSERT_NE (-1 , non_conn_sock); + +ASSERT_EQ (0 ,bind (conn_sock, &connected_addr.unix_addr, + connected_addr.unix_addr_len)); +ASSERT_EQ (0 ,bind (non_conn_sock, &non_connected_addr.unix_addr, + non_connected_addr.unix_addr_len)); + +ASSERT_EQ (1 ,write (pipe_parent[1 ],"." ,1 )); + +ASSERT_EQ (1 ,read (pipe_child[0 ], &buf,1 )); + num_bytes =recv (conn_sock, data,sizeof (data) -1 ,0 ); +ASSERT_NE (-1 , num_bytes); + num_bytes =recv (non_conn_sock, data,sizeof (data) -1 ,0 ); +ASSERT_NE (-1 , num_bytes); + +/* +* Connected datagram socket will receive data, but +* non-connected datagram socket does not receive data. +*/ +ASSERT_EQ (1 ,read (pipe_child[0 ], &buf,1 )); + num_bytes =recv (conn_sock, data,sizeof (data) -1 ,0 ); +ASSERT_NE (-1 , num_bytes); + +EXPECT_EQ (0 ,close (conn_sock)); +EXPECT_EQ (0 ,close (non_conn_sock)); +ASSERT_EQ (child,waitpid (child, &status,0 )); +if (WIFSIGNALED (status) || !WIFEXITED (status) || +WEXITSTATUS (status) !=EXIT_SUCCESS ) + _metadata->exit_code =KSFT_FAIL ; +} +TEST_HARNESS_MAIN
Signature · 1 line
2.34.1
PATCH v11 6/8 selftests/landlock: Restrict inherited datagram UNIX socket to connect
In reply to Tahera FahimiA socket can be shared between multiple processes, so it can connect and send data to them. This patch provides a test scenario where a sandboxed process inherits a socket's file descriptor. The process cannot connect or send data to the inherited socket since the process is scoped.
--- .../landlock/scoped_abstract_unix_test.c | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+)
tools/testing/selftests/landlock/scoped_abstract_unix_test.c +66 -0
@@ -924,4 +924,70 @@ TEST(datagram_sockets) _metadata->exit_code =KSFT_FAIL ; } +TEST (self_connect) +{ +struct service_fixture connected_addr, non_connected_addr; +int connected_socket, non_connected_socket, status; +pid_t child; + +drop_caps (_metadata); +memset (&connected_addr,0 ,sizeof (connected_addr)); +set_unix_address (&connected_addr,0 ); +memset (&non_connected_addr,0 ,sizeof (non_connected_addr)); +set_unix_address (&non_connected_addr,1 ); + + connected_socket =socket (AF_UNIX ,SOCK_DGRAM ,0 ); + non_connected_socket =socket (AF_UNIX ,SOCK_DGRAM ,0 ); +ASSERT_NE (-1 , connected_socket); +ASSERT_NE (-1 , non_connected_socket); + +ASSERT_EQ (0 ,bind (connected_socket, &connected_addr.unix_addr, + connected_addr.unix_addr_len)); +ASSERT_EQ (0 ,bind (non_connected_socket, &non_connected_addr.unix_addr, + non_connected_addr.unix_addr_len)); + + child =fork (); +ASSERT_LE (0 , child); +if (child ==0 ) { +char buf_data[64 ]; + +memset (buf_data,'x' ,sizeof (buf_data)); +/* Child's domain is scoped. */ +create_scoped_domain (_metadata, +LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET ); + +/* +* The child inherits the sockets, and cannot connect or +* send data to them. +*/ +ASSERT_NE (0 , +connect (connected_socket, &connected_addr.unix_addr, + connected_addr.unix_addr_len)); +ASSERT_EQ (EPERM , errno); + +ASSERT_EQ (-1 , +sendto (connected_socket, buf_data,sizeof (buf_data), +0 , &connected_addr.unix_addr, + connected_addr.unix_addr_len)); +ASSERT_EQ (EPERM , errno); + +ASSERT_EQ (-1 ,sendto (non_connected_socket, buf_data, +sizeof (buf_data),0 , + &non_connected_addr.unix_addr, + non_connected_addr.unix_addr_len)); +ASSERT_EQ (EPERM , errno); + +EXPECT_EQ (0 ,close (connected_socket)); +EXPECT_EQ (0 ,close (non_connected_socket)); +_exit (_metadata->exit_code); +return ; + } +EXPECT_EQ (0 ,close (connected_socket)); +EXPECT_EQ (0 ,close (non_connected_socket)); +ASSERT_EQ (child,waitpid (child, &status,0 )); +if (WIFSIGNALED (status) || !WIFEXITED (status) || +WEXITSTATUS (status) !=EXIT_SUCCESS ) + _metadata->exit_code =KSFT_FAIL ; +} +TEST_HARNESS_MAIN
Signature · 1 line
2.34.1
PATCH v11 7/8 sample/landlock: Add support abstract UNIX socket restriction
In reply to Tahera FahimiA sandboxer can receive the character "a" as input from the environment variable LL_SCOPE to restrict the abstract UNIX sockets from connecting to a process outside its scoped domain.
Example
=======
Create an abstract UNIX socket to listen with socat(1):
socat abstract-listen:mysocket -
Create a sandboxed shell and pass the character "a" to LL_SCOPED:
LL_FS_RO=/ LL_FS_RW=. LL_SCOPED="a" ./sandboxer /bin/bash
Note that any other form of input(e.g. "a:a", "aa", etc) is not acceptable.
If the sandboxed process tries to connect to the listening socket with command "socat - abstract-connect:mysocket", the connection will fail.
---
v11:
- Change implementation of check_ruleset_scope function to make it less bug prone.
- Imptovement on the commit description.
v10:
- Minor improvement in code based on v9.
v9:
- Add a restrict approach on input of LL_SCOPED, so it only allows zero or one "a" to be the input.
v8:
- Adding check_ruleset_scope function to parse the scope environment variable and update the landlock attribute based on the restriction provided by the user.
- Adding Mickaël Salaün reviews on version 7.
v7:
- Adding IPC scoping to the sandbox demo by defining a new "LL_SCOPED" environment variable. "LL_SCOPED" gets value "a" to restrict abstract unix sockets.
- Change LANDLOCK_ABI_LAST to 6.
--- samples/landlock/sandboxer.c | 61 +++++++++++++++++++++++++++++++++--- 1 file changed, 57 insertions(+), 4 deletions(-)
samples/landlock/sandboxer.c +57 -4
@@ -14,6 +14,7 @@#include <fcntl.h> #include <linux/landlock.h> #include <linux/prctl.h> +#include <linux/socket.h> #include <stddef.h> #include <stdio.h> #include <stdlib.h>
@@ -22,6 +23,7 @@#include <sys/stat.h> #include <sys/syscall.h> #include <unistd.h> +#include <stdbool.h> #ifndef landlock_create_ruleset static inline int
@@ -55,6 +57,7 @@ static inline int landlock_restrict_self(const int ruleset_fd,#define ENV_FS_RW_NAME "LL_FS_RW"#define ENV_TCP_BIND_NAME "LL_TCP_BIND"#define ENV_TCP_CONNECT_NAME "LL_TCP_CONNECT" +#define ENV_SCOPED_NAME "LL_SCOPED"#define ENV_DELIMITER ":"static int parse_path (char *env_path,const char ***const path_list)
@@ -184,6 +187,45 @@ static int populate_ruleset_net(const char *const env_var, const int ruleset_fd,return ret; } +static bool check_ruleset_scope (const char *const env_var, +struct landlock_ruleset_attr *ruleset_attr) +{ +bool abstract_scoping = false; +bool ret = true; +char *env_type_scope, *env_type_scope_next, *ipc_scoping_name; + +/* scoping is not supported by Landlock ABI */ +if (!(ruleset_attr->scoped &LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET )) +return ret; + + env_type_scope =getenv (env_var); +/* scoping is not supported by the user */ +if (!env_type_scope ||strcmp ("" , env_type_scope) ==0 ) { + ruleset_attr->scoped &= ~LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET ; +return ret; + } + + env_type_scope =strdup (env_type_scope); +unsetenv (env_var); + env_type_scope_next = env_type_scope; +while ((ipc_scoping_name = +strsep (&env_type_scope_next,ENV_DELIMITER ))) { +if (strcmp ("a" , ipc_scoping_name) ==0 && !abstract_scoping) { + abstract_scoping = true; + }else { +fprintf (stderr,"Unsupported scoping \"%s\"\n" , + ipc_scoping_name); + ret = false; + goto out_free_name; + } + } +if (!abstract_scoping) + ruleset_attr->scoped &= ~LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET ; +out_free_name: +free (env_type_scope); +return ret; +} +/* clang-format off */ #define ACCESS_FS_ROUGHLY_READ ( \
@@ -208,7 +250,7 @@ static int populate_ruleset_net(const char *const env_var, const int ruleset_fd,/* clang-format on */ -#define LANDLOCK_ABI_LAST 5 +#define LANDLOCK_ABI_LAST 6int main (const int argc,char *const argv[],char *const *const envp) {
@@ -223,14 +265,15 @@ int main(const int argc, char *const argv[], char *const *const envp) .handled_access_fs = access_fs_rw, .handled_access_net = LANDLOCK_ACCESS_NET_BIND_TCP | LANDLOCK_ACCESS_NET_CONNECT_TCP, + .scoped = LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET, };if (argc <2 ) {fprintf (stderr, -"usage: %s=\"...\" %s=\"...\" %s=\"...\" %s=\"...\"%s " +"usage: %s=\"...\" %s=\"...\" %s=\"...\" %s=\"...\" %s=\"...\" %s " "<cmd> [args]...\n\n" ,ENV_FS_RO_NAME ,ENV_FS_RW_NAME ,ENV_TCP_BIND_NAME , -ENV_TCP_CONNECT_NAME , argv[0 ]); +ENV_TCP_CONNECT_NAME ,ENV_SCOPED_NAME , argv[0 ]);fprintf (stderr,"Execute a command in a restricted environment.\n\n" ); fprintf(stderr,
@@ -251,15 +294,18 @@ int main(const int argc, char *const argv[], char *const *const envp)fprintf (stderr,"* %s: list of ports allowed to connect (client).\n" ,ENV_TCP_CONNECT_NAME ); +fprintf (stderr,"* %s: list of restrictions on IPCs.\n" , +ENV_SCOPED_NAME );fprintf (stderr,"\nexample:\n" "%s=\"${PATH}:/lib:/usr:/proc:/etc:/dev/urandom\" " "%s=\"/dev/null:/dev/full:/dev/zero:/dev/pts:/tmp\" " "%s=\"9418\" " "%s=\"80:443\" " +"%s=\"a\" " "%s bash -i\n\n" ,ENV_FS_RO_NAME ,ENV_FS_RW_NAME ,ENV_TCP_BIND_NAME , -ENV_TCP_CONNECT_NAME , argv[0 ]); +ENV_TCP_CONNECT_NAME ,ENV_SCOPED_NAME , argv[0 ]); fprintf(stderr, "This sandboxer can use Landlock features " "up to ABI version %d.\n",
@@ -327,6 +373,10 @@ int main(const int argc, char *const argv[], char *const *const envp)/* Removes LANDLOCK_ACCESS_FS_IOCTL_DEV for ABI < 5 */ ruleset_attr.handled_access_fs &= ~LANDLOCK_ACCESS_FS_IOCTL_DEV ; + __attribute__((fallthrough)); +case 5 : +/* Removes LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET for ABI < 6 */ + ruleset_attr.scoped &= ~LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET ;fprintf (stderr,"Hint: You should update the running kernel " "to leverage Landlock features "
@@ -358,6 +408,9 @@ int main(const int argc, char *const argv[], char *const *const envp) ~LANDLOCK_ACCESS_NET_CONNECT_TCP ; } +if (!check_ruleset_scope (ENV_SCOPED_NAME , &ruleset_attr)) +return 1 ; + ruleset_fd =landlock_create_ruleset (&ruleset_attr,sizeof (ruleset_attr),0 );if (ruleset_fd <0 ) {
Signature · 1 line
2.34.1
PATCH v11 8/8 Landlock: Document LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET and ABI version
In reply to Tahera FahimiIntroducing LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET as an IPC scoping mechanism in Landlock ABI version 6, and updating ruleset_attr, Landlock ABI version, and access rights code blocks based on that.
---
v11:
- Documentation cases where i) a connected datagram UNIX socket send(2)/ sendto(2) data, but it is denied when the socket is not connected, and ii) a scoped process cannot connect by an inherited socket's file descriptor.
v10:
- Update date.
v8:
- Improving documentation by specifying differences between scoped and non-scoped domains.
- Adding review notes of version 7.
- Update date.
v7:
- Add "LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET" explanation to IPC scoping section and updating ABI to version 6.
- Adding "scoped" attribute to the Access rights section.
- In current limitation, unnamed sockets are specified as sockets that are not restricted.
- Update date.
--- Documentation/userspace-api/landlock.rst | 45 ++++++++++++++++++++++-- 1 file changed, 43 insertions(+), 2 deletions(-)
Documentation/userspace-api/landlock.rst +43 -2
@@ -8,7 +8,7 @@ Landlock: unprivileged access control ===================================== :Author: Mickaël Salaün -:Date: July 2024 +:Date: August 2024 The goal of Landlock is to enable to restrict ambient rights (e.g. global filesystem or network access) for a set of processes. Because Landlock
@@ -81,6 +81,8 @@ to be explicit about the denied-by-default access rights. .handled_access_net = LANDLOCK_ACCESS_NET_BIND_TCP | LANDLOCK_ACCESS_NET_CONNECT_TCP, + .scoped = + LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET, }; Because we may not know on which kernel version an application will be
@@ -119,6 +121,9 @@ version, and only use the available subset of access rights: case 4: /* Removes LANDLOCK_ACCESS_FS_IOCTL_DEV for ABI < 5 */ ruleset_attr.handled_access_fs &= ~LANDLOCK_ACCESS_FS_IOCTL_DEV; + case 5: + /* Removes LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET for ABI < 6 */ + ruleset_attr.scoped &= ~LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET; } This enables to create an inclusive ruleset that will contain our rules.
@@ -306,6 +311,35 @@ To be allowed to use :manpage:`ptrace(2)` and related syscalls on a target process, a sandboxed process should have a subset of the target process rules, which means the tracee must be in a sub-domain of the tracer. +IPC Scoping +----------- + +Similar to the implicit `Ptrace restrictions`_, we may want to further +restrict interactions between sandboxes. Each Landlock domain can be +explicitly scoped for a set of actions by specifying it on a ruleset. +For example, if a sandboxed process should not be able to +:manpage:`connect(2)` to a non-sandboxed process through abstract +:manpage:`unix(7)` sockets, we can specify such restriction with +``LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET``. + +A sandboxed process can connect to a non-sandboxed process when its +domain is not scoped. If a process's domain is scoped, it can only +connect to sockets created by processes in the same scoped domain. + +A connected datagram socket behaves like a stream socket when its domain +is scoped, meaning if the domain is scoped after the socket is connected +, it can still :manpage:`send(2)` data just like a stream socket. +However, in the same scenario, a non-connected datagram socket cannot +send data (with :manpage:`sendto(2)`) outside its scoped domain. + +A process with a scoped domain can inherit a socket created by a +non-scoped process. The process cannot connect to this socket since it +has a scoped domain. + +IPC scoping does not support Landlock rules, so if a domain is scoped, +no rules can be added to allow access to a resource outside of the +scoped domain. + Truncating files ----------------
@@ -404,7 +438,7 @@ Access rights ------------- .. kernel-doc:: include/uapi/linux/landlock.h - :identifiers: fs_access net_access + :identifiers: fs_access net_access scope Creating a new ruleset ----------------------
@@ -541,6 +575,13 @@ earlier ABI. Starting with the Landlock ABI version 5, it is possible to restrict the use of :manpage:`ioctl(2)` using the new ``LANDLOCK_ACCESS_FS_IOCTL_DEV`` right. +Abstract UNIX sockets Restriction (ABI < 6) +-------------------------------------------- + +With ABI version 6, it is possible to restrict connection to an abstract +Unix socket through ``LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET``, thanks to +the ``scoped`` ruleset attribute. + .. _kernel_support: Kernel support
Signature · 1 line
2.34.1
Mickaël Salaün
maintainerQuoted 18 lines · Tahera Fahimi
This patch introduces a new "scoped" attribute to the
landlock_ruleset_attrthat can specify "LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET" to scope abstract UNIX sockets from connecting to a process outside of the same Landlock domain. It implements two hooks,unix_stream_connectandunix_may_sendto enforce this restriction.Signed-off-by Tahera Fahimi <[email protected]>security/landlock/task.c +3
-0+static int hook_unix_stream_connect (struct sock *const sock, +struct sock *const other, +struct sock *const newsk)
security/landlock/task.c static int hook_ptrace_traceme(struct task_struct *const parent) · line 217
Quoted 10 lines
security/landlock/task.c +10
-0+{ +const struct landlock_ruleset *const dom = +landlock_get_current_domain (); + +/* quick return for non-sandboxed processes */ +if (!dom) +return 0 ; + +if (is_abstract_socket (other) &&sock_is_scoped (other, dom)) +return -EPERM ;
I was wondering if it would make more sense to return -EACCES here. EACCES is usually related to file permission, but send(2)/sendto(2) don't return EPERM according to man pages. Well, according to the kernel code they can return EPERM so I think we are good with EPERM.
It looks like other LSMs always use EACCES though...
Quoted 13 lines
security/landlock/task.c +13
-0+ +return 0 ; +} + +static int hook_unix_may_send (struct socket *const sock, +struct socket *const other) +{ +const struct landlock_ruleset *const dom = +landlock_get_current_domain (); + +if (!dom) +return 0 ; +
security/landlock/task.c static int hook_ptrace_traceme(struct task_struct *const parent) · line 240
Quoted 10 lines
security/landlock/task.c +10
-0+if (is_abstract_socket (other->sk)) { +/* +* Checks if this datagram socket was already allowed to +* be connected to other. +*/ +if (unix_peer (sock->sk) == other->sk) +return 0 ; + +if (sock_is_scoped (other->sk, dom)) +return -EPERM ;
ditto
Mickaël Salaün
maintainerQuoted 109 lines · Tahera Fahimi
This patch introduces a new "scoped" attribute to the
landlock_ruleset_attrthat can specify "LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET" to scope abstract UNIX sockets from connecting to a process outside of the same Landlock domain. It implements two hooks,unix_stream_connectandunix_may_sendto enforce this restriction.Signed-off-by Tahera Fahimi <[email protected]>---
v11:
- For a connected abstract datagram socket, thehook_unix_may_sendallows the socket to send a data. (it is treated as a connected stream socket)
- Minor comment revision.
v10:
- Minor code improvement based on reviews on v9.
v9:
- Editting inline comments.
- Major refactoring indomain_is_scoped()andis_abstract_socketv8:
- Code refactoring (improve code readability, renaming variable, etc.) based on reviews by Mickaël Salaün on version 7.
- Addingwarn_on_onceto check (impossible) inconsistencies.
- Adding inline comments.
- Addingcheck_unix_address_formatto check if the scoping socket is an abstract UNIX sockets.
v7:
- Using socket's file credentials for both connected(STREAM) and non-connected(DGRAM) sockets.
- Adding "domain_sock_scope" instead of the domain scoping mechanism used in ptrace ensures that if a server's domain is accessible from the client's domain (where the client is more privileged than the server), the client can connect to the server in all edge cases.
- Removing debug codes.
v6:
- Removingcurr_rulesetfromlandlock_hierarchy, and switching back to use the same domain scoping as ptrace.
- code clean up.
v5:
- Renaming "LANDLOCK_*_ACCESS_SCOPE" to "LANDLOCK_*_SCOPE"
- Addingcurr_rulesettohierarachy_rulesetstructure to have access fromlandlock_hierarchyto its respectivelandlock_ruleset.
- Usingcurr_rulesetto check if a domain is scoped while walking in the hierarchy of domains.
- Modifying inline comments.
v4:
- Rebased on Günther's Patch:
https://lore.kernel.org/all/[email protected]/
so there is no need for "LANDLOCK_SHIFT_ACCESS_SCOPE", then it is removed.
- Addingget_scope_accessesfunction to check all scoped access masks in a ruleset.
- Using socket's file credentials instead of credentials stored inpeer_credfor datagram sockets. (see discussion in [1])
- Modifying inline comments.
V3:
- Improving commit description.
- Introducing "scoped" attribute tolandlock_ruleset_attrfor IPC scoping purpose, and adding related functions.
- Changing structure of ruleset based on "scoped".
- Removing rcu lock and usingunix_sklock instead.
- Introducing scoping for datagram sockets inunix_may_send. V2:
- Removing wrapper functions[1]https://lore.kernel.org/all/[email protected]/
--- include/uapi/linux/landlock.h | 28 ++++ security/landlock/limits.h | 3 + security/landlock/ruleset.c | 7 +- security/landlock/ruleset.h | 24 +++- security/landlock/syscalls.c | 17 ++- security/landlock/task.c | 136 +++++++++++++++++++ tools/testing/selftests/landlock/base_test.c | 2 +- 7 files changed, 208 insertions(+), 9 deletions(-)include/uapi/linux/landlock.h +16
-0@@ -44,6 +44,12 @@ struct landlock_ruleset_attr {* flags`_). */ __u64 handled_access_net; +/** +* @scoped: Bitmask of scopes (cf. `Scope flags`_) +* restricting a Landlock domain from accessing outside +* resources(e.g. IPCs). +*/ +__u64 scoped; };/* @@ -274,4 +280,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 +* +* 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.
include/uapi/linux/landlock.h struct landlock_net_port_attr { · line 302
Quoted 10 lines
include/uapi/linux/landlock.h +10
-0+* +* 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 +* non-sandboxed process). +*/ +/* clang-format off */ +#define LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET (1ULL << 0)
Thinking more about it, it makes more sense to rename it to LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET (s/SCOPED/SCOPE/) because it express a scope (not a "scoped") and it allign with the current LANDLOCK_ACCESS_* and other internal variables such as LANDLOCK_LAST_SCOPE...
However, it still makes sense to keep the "scoped" ruleset's field, which is pretty similar to the "handled_*" semantic: it describes what will be *scoped* by the ruleset.
Quoted 15 lines
include/uapi/linux/landlock.h +2
-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 */
Mickaël Salaün
maintainerI have reworked a bit the patches, including the signal scoping ones, and they are here:
https://git.kernel.org/pub/scm/linux/kernel/git/mic/linux.git/log/?h=next
This is based on a manual merge of some VFS changes and LSM changes required for this patch series:
https://git.kernel.org/pub/scm/linux/kernel/git/mic/linux.git/commit/?h=next&id=24dfe95e493086a99acf7df1ef23d9f21f8cdec7
My changes are explained in the "[mic: ...]" part of the commit messages. Please send two last patch series, with this changes and reply to it with your comments if any.
Quoted 108 lines · Tahera Fahimi
This patch series adds scoping mechanism for abstract UNIX sockets.
Problem
=======Abstract UNIX sockets are used for local inter-process communications independent of the 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(see more details in [1,2]). Access to such sockets for a sandboxed process should be scoped the same way ptrace is limited.[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/[email protected]/Solution
========To solve this issue, we extend the user space interface by adding a new "scoped" field to Landlock ruleset attribute structure. This field can contains different rights to restrict different functionalities. For abstract UNIX sockets, we introduce "
LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET" field to specify that a ruleset will deny any connection from within the sandbox domain to its parent (i.e. any parent sandbox or non-sandbox processes).Example
=======Starting a listening socket with socat(1):
socat abstract-listen:mysocket -Starting a sandboxed shell from $HOME with
samples/landlock/sandboxer:LL_FS_RO=/ LL_FS_RW=. LL_SCOPED="a" ./sandboxer /bin/bashIf we try to connect to the listening socket, the connection gets refused.
socat - abstract-connect:mysocket --> failsNotes of Implementation
=======================* Using the "scoped" field provides enough compatibility and flexibility to extend the scoping mechanism for other IPCs(e.g. signals).
* To access the domain of a socket, we use its credentials of the file's FD which point to the credentials of the process that created the socket (see more details in [3]). Cases where the process using the socket has a different domain than the process created it are covered in the "
outside_socket" test.[3]https://lore.kernel.org/all/[email protected]/
Previous Versions
=================
v10:https://lore.kernel.org/all/[email protected]/
v9: https://lore.kernel.org/all/[email protected]/
v8: https://lore.kernel.org/all/[email protected]/
v7: https://lore.kernel.org/all/[email protected]/
v6: https://lore.kernel.org/all/Zn32CYZiu7pY+rdI@tahera-OptiPlex-5000/
and https://lore.kernel.org/all/Zn32KKIJrY7Zi51K@tahera-OptiPlex-5000/
v5: https://lore.kernel.org/all/ZnSZnhGBiprI6FRk@tahera-OptiPlex-5000/
v4: https://lore.kernel.org/all/ZnNcE3ph2SWi1qmd@tahera-OptiPlex-5000/
v3: https://lore.kernel.org/all/ZmJJ7lZdQuQop7e5@tahera-OptiPlex-5000/
v2: https://lore.kernel.org/all/ZgX5TRTrSDPrJFfF@tahera-OptiPlex-5000/
v1: https://lore.kernel.org/all/ZgXN5fi6A1YQKiAQ@tahera-OptiPlex-5000/Tahera Fahimi (8):
Landlock: Add abstract UNIX socket restriction selftests/landlock: Add test for handling unknown scope selftests/landlock: Add abstract UNIX socket restriction tests selftests/landlock: Add tests for UNIX sockets with any address
formats
selftests/landlock: Test connected vs non-connected datagram UNIX
socket
selftests/landlock: Restrict inherited datagram UNIX socket to connect sample/landlock: Add support abstract UNIX socket restriction
Landlock: DocumentLANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKETand ABI
versionDocumentation/userspace-api/landlock.rst | 45 +- include/uapi/linux/landlock.h | 28 + samples/landlock/sandboxer.c | 61 +- security/landlock/limits.h | 3 + security/landlock/ruleset.c | 7 +- security/landlock/ruleset.h | 24 +- security/landlock/syscalls.c | 17 +- security/landlock/task.c | 136 +++ tools/testing/selftests/landlock/base_test.c | 2 +- tools/testing/selftests/landlock/common.h | 38 + tools/testing/selftests/landlock/net_test.c | 31 +- .../landlock/scoped_abstract_unix_test.c | 993 ++++++++++++++++++ .../selftests/landlock/scoped_base_variants.h | 154 +++ .../selftests/landlock/scoped_common.h | 28 + .../scoped_multiple_domain_variants.h | 154 +++ .../testing/selftests/landlock/scoped_test.c | 33 + 16 files changed, 1709 insertions(+), 45 deletions(-) create mode 100644 tools/testing/selftests/landlock/scoped_abstract_unix_test.c create mode 100644 tools/testing/selftests/landlock/scoped_base_variants.h create mode 100644 tools/testing/selftests/landlock/scoped_common.h create mode 100644 tools/testing/selftests/landlock/scoped_multiple_domain_variants.h create mode 100644 tools/testing/selftests/landlock/scoped_test.cSignature · 1 line
2.34.1
Mickaël Salaün
maintainerQuoted 3 lines · Mickaël Salaün
I have reworked a bit the patches, including the signal scoping ones, and they are here:
https://git.kernel.org/pub/scm/linux/kernel/git/mic/linux.git/log/?h=next
I pushed a last few changes to add drop_caps() calls to all the signal tests. The top commit is b530ec46a0dbe8889b35909ae51f2dacbd18f0f5
Quoted 118 lines
This is based on a manual merge of some VFS changes and LSM changes required for this patch series:
https://git.kernel.org/pub/scm/linux/kernel/git/mic/linux.git/commit/?h=next&id=24dfe95e493086a99acf7df1ef23d9f21f8cdec7My changes are explained in the "[mic: ...]" part of the commit messages. Please send two last patch series, with this changes and reply to it with your comments if any.
Quoted 108 lines · Tahera Fahimi
This patch series adds scoping mechanism for abstract UNIX sockets.
Problem
=======Abstract UNIX sockets are used for local inter-process communications independent of the 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(see more details in [1,2]). Access to such sockets for a sandboxed process should be scoped the same way ptrace is limited.[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/[email protected]/Solution
========To solve this issue, we extend the user space interface by adding a new "scoped" field to Landlock ruleset attribute structure. This field can contains different rights to restrict different functionalities. For abstract UNIX sockets, we introduce "
LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET" field to specify that a ruleset will deny any connection from within the sandbox domain to its parent (i.e. any parent sandbox or non-sandbox processes).Example
=======Starting a listening socket with socat(1):
socat abstract-listen:mysocket -Starting a sandboxed shell from $HOME with
samples/landlock/sandboxer:LL_FS_RO=/ LL_FS_RW=. LL_SCOPED="a" ./sandboxer /bin/bashIf we try to connect to the listening socket, the connection gets refused.
socat - abstract-connect:mysocket --> failsNotes of Implementation
=======================* Using the "scoped" field provides enough compatibility and flexibility to extend the scoping mechanism for other IPCs(e.g. signals).
* To access the domain of a socket, we use its credentials of the file's FD which point to the credentials of the process that created the socket (see more details in [3]). Cases where the process using the socket has a different domain than the process created it are covered in the "
outside_socket" test.[3]https://lore.kernel.org/all/[email protected]/
Previous Versions
=================
v10:https://lore.kernel.org/all/[email protected]/
v9: https://lore.kernel.org/all/[email protected]/
v8: https://lore.kernel.org/all/[email protected]/
v7: https://lore.kernel.org/all/[email protected]/
v6: https://lore.kernel.org/all/Zn32CYZiu7pY+rdI@tahera-OptiPlex-5000/
and https://lore.kernel.org/all/Zn32KKIJrY7Zi51K@tahera-OptiPlex-5000/
v5: https://lore.kernel.org/all/ZnSZnhGBiprI6FRk@tahera-OptiPlex-5000/
v4: https://lore.kernel.org/all/ZnNcE3ph2SWi1qmd@tahera-OptiPlex-5000/
v3: https://lore.kernel.org/all/ZmJJ7lZdQuQop7e5@tahera-OptiPlex-5000/
v2: https://lore.kernel.org/all/ZgX5TRTrSDPrJFfF@tahera-OptiPlex-5000/
v1: https://lore.kernel.org/all/ZgXN5fi6A1YQKiAQ@tahera-OptiPlex-5000/Tahera Fahimi (8):
Landlock: Add abstract UNIX socket restriction selftests/landlock: Add test for handling unknown scope selftests/landlock: Add abstract UNIX socket restriction tests selftests/landlock: Add tests for UNIX sockets with any address
formats
selftests/landlock: Test connected vs non-connected datagram UNIX
socket
selftests/landlock: Restrict inherited datagram UNIX socket to connect sample/landlock: Add support abstract UNIX socket restriction
Landlock: DocumentLANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKETand ABI
versionDocumentation/userspace-api/landlock.rst | 45 +- include/uapi/linux/landlock.h | 28 + samples/landlock/sandboxer.c | 61 +- security/landlock/limits.h | 3 + security/landlock/ruleset.c | 7 +- security/landlock/ruleset.h | 24 +- security/landlock/syscalls.c | 17 +- security/landlock/task.c | 136 +++ tools/testing/selftests/landlock/base_test.c | 2 +- tools/testing/selftests/landlock/common.h | 38 + tools/testing/selftests/landlock/net_test.c | 31 +- .../landlock/scoped_abstract_unix_test.c | 993 ++++++++++++++++++ .../selftests/landlock/scoped_base_variants.h | 154 +++ .../selftests/landlock/scoped_common.h | 28 + .../scoped_multiple_domain_variants.h | 154 +++ .../testing/selftests/landlock/scoped_test.c | 33 + 16 files changed, 1709 insertions(+), 45 deletions(-) create mode 100644 tools/testing/selftests/landlock/scoped_abstract_unix_test.c create mode 100644 tools/testing/selftests/landlock/scoped_base_variants.h create mode 100644 tools/testing/selftests/landlock/scoped_common.h create mode 100644 tools/testing/selftests/landlock/scoped_multiple_domain_variants.h create mode 100644 tools/testing/selftests/landlock/scoped_test.cSignature · 1 line
2.34.1
Quoted 127 lines · Mickaël Salaün
Quoted 109 lines · Tahera Fahimi
This patch introduces a new "scoped" attribute to the
landlock_ruleset_attrthat can specify "LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET" to scope abstract UNIX sockets from connecting to a process outside of the same Landlock domain. It implements two hooks,unix_stream_connectandunix_may_sendto enforce this restriction.Signed-off-by Tahera Fahimi <[email protected]>---
v11:
- For a connected abstract datagram socket, thehook_unix_may_sendallows the socket to send a data. (it is treated as a connected stream socket)
- Minor comment revision.
v10:
- Minor code improvement based on reviews on v9.
v9:
- Editting inline comments.
- Major refactoring indomain_is_scoped()andis_abstract_socketv8:
- Code refactoring (improve code readability, renaming variable, etc.) based on reviews by Mickaël Salaün on version 7.
- Addingwarn_on_onceto check (impossible) inconsistencies.
- Adding inline comments.
- Addingcheck_unix_address_formatto check if the scoping socket is an abstract UNIX sockets.
v7:
- Using socket's file credentials for both connected(STREAM) and non-connected(DGRAM) sockets.
- Adding "domain_sock_scope" instead of the domain scoping mechanism used in ptrace ensures that if a server's domain is accessible from the client's domain (where the client is more privileged than the server), the client can connect to the server in all edge cases.
- Removing debug codes.
v6:
- Removingcurr_rulesetfromlandlock_hierarchy, and switching back to use the same domain scoping as ptrace.
- code clean up.
v5:
- Renaming "LANDLOCK_*_ACCESS_SCOPE" to "LANDLOCK_*_SCOPE"
- Addingcurr_rulesettohierarachy_rulesetstructure to have access fromlandlock_hierarchyto its respectivelandlock_ruleset.
- Usingcurr_rulesetto check if a domain is scoped while walking in the hierarchy of domains.
- Modifying inline comments.
v4:
- Rebased on Günther's Patch:
https://lore.kernel.org/all/[email protected]/
so there is no need for "LANDLOCK_SHIFT_ACCESS_SCOPE", then it is removed.
- Addingget_scope_accessesfunction to check all scoped access masks in a ruleset.
- Using socket's file credentials instead of credentials stored inpeer_credfor datagram sockets. (see discussion in [1])
- Modifying inline comments.
V3:
- Improving commit description.
- Introducing "scoped" attribute tolandlock_ruleset_attrfor IPC scoping purpose, and adding related functions.
- Changing structure of ruleset based on "scoped".
- Removing rcu lock and usingunix_sklock instead.
- Introducing scoping for datagram sockets inunix_may_send. V2:
- Removing wrapper functions[1]https://lore.kernel.org/all/[email protected]/
--- include/uapi/linux/landlock.h | 28 ++++ security/landlock/limits.h | 3 + security/landlock/ruleset.c | 7 +- security/landlock/ruleset.h | 24 +++- security/landlock/syscalls.c | 17 ++- security/landlock/task.c | 136 +++++++++++++++++++ tools/testing/selftests/landlock/base_test.c | 2 +- 7 files changed, 208 insertions(+), 9 deletions(-)include/uapi/linux/landlock.h +16
-0@@ -44,6 +44,12 @@ struct landlock_ruleset_attr {* flags`_). */ __u64 handled_access_net; +/** +* @scoped: Bitmask of scopes (cf. `Scope flags`_) +* restricting a Landlock domain from accessing outside +* resources(e.g. IPCs). +*/ +__u64 scoped; };/* @@ -274,4 +280,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 +* +* 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. include/uapi/linux/landlock.h struct landlock_net_port_attr { · line 302
Quoted 10 lines
include/uapi/linux/landlock.h +10
-0+* +* 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 +* non-sandboxed process). +*/ +/* clang-format off */ +#define LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET (1ULL << 0)Thinking more about it, it makes more sense to rename it to
LANDLOCK_SCOPED_ABSTRACT_UNIX_SOCKET(s/SCOPED/SCOPE/) because it express a scope (not a "scoped") and it allign with the current LANDLOCK_ACCESS_* and other internal variables such asLANDLOCK_LAST_SCOPE...
Quoted 3 lines
However, it still makes sense to keep the "scoped" ruleset's field, which is pretty similar to the "handled_*" semantic: it describes what will be *scoped* by the ruleset.
The proposed changes make sense. They are applied in commit [0b365024c726277eb73e461849709605d1819977]/next branch, and look good to me.
Quoted 15 lines
Quoted 15 lines
include/uapi/linux/landlock.h +2
-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 */