From patchwork Wed Aug 17 20:30:03 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?q?G=C3=BCnther_Noack?= X-Patchwork-Id: 12946431 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id B409AC32772 for ; Wed, 17 Aug 2022 20:30:35 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241546AbiHQUae (ORCPT ); Wed, 17 Aug 2022 16:30:34 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50408 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241943AbiHQUaV (ORCPT ); Wed, 17 Aug 2022 16:30:21 -0400 Received: from mail-ej1-x62b.google.com (mail-ej1-x62b.google.com [IPv6:2a00:1450:4864:20::62b]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4CCE4A98F3; Wed, 17 Aug 2022 13:30:19 -0700 (PDT) Received: by mail-ej1-x62b.google.com with SMTP id i14so26478115ejg.6; Wed, 17 Aug 2022 13:30:19 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc; bh=/Vvzr+OTnuwQXrGOY+/lEBQwn9fiaqN6qenxPjftdtA=; b=OWg8AKmmBdBR81D7+pa0uu/X/Dn1NbnjLKPKaafykls/r91xnJ7jHUDqkt8cV2cssA xb83kFZ+AcTxezyww4vhEFYEegm+cBOQDUdx3DoFvR2RbRZkeBuqGxuBPw4Y3wtPGDEz +zvnWyrHaGueTCHi+VcVHsiNd/a6Igc9akHZeH7mw28mKoknuJ81kByACMcaD2jbcr+0 fTtLkAJoy8K4G08z7ARuR9PTQk6HkYhJgrJXns9x++zEkFbha1vpenvfiovBAk2hrxXU ZlDGrYx/4tnguKDqA4/KatBAxwqdOsEXWJAH8FpR56r3qMa+4+AO+rVNl6uBoVMR27Ty xj+Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc; bh=/Vvzr+OTnuwQXrGOY+/lEBQwn9fiaqN6qenxPjftdtA=; b=uDpWOL8JBqdJaw1eErUSjU9xEXaRbQZD/uJOMT5jWKfZEsv8ZbMA3cmmEIKn6KdGFN FQLwyQpUN+2zoU6kccAXMeaKnnqxbXP5m0xKjbyEFzdHIIBAUbUdXHjmXLU5JbfZgyH/ l2vP40AcSqRzeTS4raPT2nAkRjZUTQJLLJuUCB71AWf5aEI3Bo5+Nddlh8N4L+LyJTtl UyXAXAGoCA0b+XknhZAlK9fyt6tnZXnwGwh3cS2WqlI8hQEbs7V0zr/W+o0eb5UgfL8U Q6pNqutulgEmqIXJy/3xTm2IpL3pEldi3fmMnlmETHvyD784vvxjf4PbZsdwkQ9683dN Smmw== X-Gm-Message-State: ACgBeo0l4JJe6CcVvVJgMRut/9HK0NhU2y633uf+nxeuOHsvOS5Bg482 IINRr+NcwiKGLrenFKfrIS2tgdZJaiA= X-Google-Smtp-Source: AA6agR7BDddie+aAYCAxA4jJ5qGAEpU+Fsi3V2tSRTc7yjYbOcgZ9SfdYLlW+Dz9RZ6DTKvjiQgsKw== X-Received: by 2002:a17:906:216:b0:711:f623:8bb0 with SMTP id 22-20020a170906021600b00711f6238bb0mr18237094ejd.174.1660768217881; Wed, 17 Aug 2022 13:30:17 -0700 (PDT) Received: from nuc.i.gnoack.org ([2a02:168:633b:1:1e69:7aff:fe05:97e6]) by smtp.gmail.com with ESMTPSA id p7-20020a17090653c700b0073b0c2d420dsm512042ejo.217.2022.08.17.13.30.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Aug 2022 13:30:17 -0700 (PDT) From: =?utf-8?q?G=C3=BCnther_Noack?= To: linux-security-module@vger.kernel.org Cc: =?utf-8?q?Micka=C3=ABl_Sala=C3=BCn?= , James Morris , Paul Moore , "Serge E . Hallyn" , linux-fsdevel@vger.kernel.org, Konstantin Meskhidze , =?utf-8?q?G=C3=BCnt?= =?utf-8?q?her_Noack?= Subject: [PATCH v5 1/4] landlock: Support file truncation Date: Wed, 17 Aug 2022 22:30:03 +0200 Message-Id: <20220817203006.21769-2-gnoack3000@gmail.com> X-Mailer: git-send-email 2.37.2 In-Reply-To: <20220817203006.21769-1-gnoack3000@gmail.com> References: <20220817203006.21769-1-gnoack3000@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: Introduce the LANDLOCK_ACCESS_FS_TRUNCATE flag for file truncation. This flag hooks into the path_truncate LSM hook and covers file truncation using truncate(2), ftruncate(2), open(2) with O_TRUNC, as well as creat(). This change also increments the Landlock ABI version, updates corresponding selftests, and updates code documentation to document the flag. Signed-off-by: Günther Noack --- include/uapi/linux/landlock.h | 17 ++++++++++++----- security/landlock/fs.c | 9 ++++++++- security/landlock/limits.h | 2 +- security/landlock/syscalls.c | 2 +- tools/testing/selftests/landlock/base_test.c | 2 +- tools/testing/selftests/landlock/fs_test.c | 7 ++++--- 6 files changed, 27 insertions(+), 12 deletions(-) diff --git a/include/uapi/linux/landlock.h b/include/uapi/linux/landlock.h index 23df4e0e8ace..50c35404c4d3 100644 --- a/include/uapi/linux/landlock.h +++ b/include/uapi/linux/landlock.h @@ -95,8 +95,15 @@ struct landlock_path_beneath_attr { * A file can only receive these access rights: * * - %LANDLOCK_ACCESS_FS_EXECUTE: Execute a file. - * - %LANDLOCK_ACCESS_FS_WRITE_FILE: Open a file with write access. + * - %LANDLOCK_ACCESS_FS_WRITE_FILE: Open a file with write access. Note that + * you might additionally need the `LANDLOCK_ACCESS_FS_TRUNCATE` right in + * order to overwrite files with :manpage:`open(2)` using `O_TRUNC` or + * :manpage:`creat(2)`. * - %LANDLOCK_ACCESS_FS_READ_FILE: Open a file with read access. + * - %LANDLOCK_ACCESS_FS_TRUNCATE: Truncate a file with :manpage:`truncate(2)`, + * :manpage:`ftruncate(2)`, :manpage:`open(2)` with `O_TRUNC` or + * :manpage:`creat(2)`. This access right is available since the third version + * of the Landlock ABI. * * A directory can receive access rights related to files or directories. The * following access right is applied to the directory itself, and the @@ -139,10 +146,9 @@ struct landlock_path_beneath_attr { * * It is currently not possible to restrict some file-related actions * accessible through these syscall families: :manpage:`chdir(2)`, - * :manpage:`truncate(2)`, :manpage:`stat(2)`, :manpage:`flock(2)`, - * :manpage:`chmod(2)`, :manpage:`chown(2)`, :manpage:`setxattr(2)`, - * :manpage:`utime(2)`, :manpage:`ioctl(2)`, :manpage:`fcntl(2)`, - * :manpage:`access(2)`. + * :manpage:`stat(2)`, :manpage:`flock(2)`, :manpage:`chmod(2)`, + * :manpage:`chown(2)`, :manpage:`setxattr(2)`, :manpage:`utime(2)`, + * :manpage:`ioctl(2)`, :manpage:`fcntl(2)`, :manpage:`access(2)`. * Future Landlock evolutions will enable to restrict them. */ /* clang-format off */ @@ -160,6 +166,7 @@ struct landlock_path_beneath_attr { #define LANDLOCK_ACCESS_FS_MAKE_BLOCK (1ULL << 11) #define LANDLOCK_ACCESS_FS_MAKE_SYM (1ULL << 12) #define LANDLOCK_ACCESS_FS_REFER (1ULL << 13) +#define LANDLOCK_ACCESS_FS_TRUNCATE (1ULL << 14) /* clang-format on */ #endif /* _UAPI_LINUX_LANDLOCK_H */ diff --git a/security/landlock/fs.c b/security/landlock/fs.c index ec5a6247cd3e..c57f581a9cd5 100644 --- a/security/landlock/fs.c +++ b/security/landlock/fs.c @@ -146,7 +146,8 @@ static struct landlock_object *get_inode_object(struct inode *const inode) #define ACCESS_FILE ( \ LANDLOCK_ACCESS_FS_EXECUTE | \ LANDLOCK_ACCESS_FS_WRITE_FILE | \ - LANDLOCK_ACCESS_FS_READ_FILE) + LANDLOCK_ACCESS_FS_READ_FILE | \ + LANDLOCK_ACCESS_FS_TRUNCATE) /* clang-format on */ /* @@ -1140,6 +1141,11 @@ static int hook_path_rmdir(const struct path *const dir, return current_check_access_path(dir, LANDLOCK_ACCESS_FS_REMOVE_DIR); } +static int hook_path_truncate(const struct path *const path) +{ + return current_check_access_path(path, LANDLOCK_ACCESS_FS_TRUNCATE); +} + /* File hooks */ static inline access_mask_t get_file_access(const struct file *const file) @@ -1192,6 +1198,7 @@ static struct security_hook_list landlock_hooks[] __lsm_ro_after_init = { LSM_HOOK_INIT(path_symlink, hook_path_symlink), LSM_HOOK_INIT(path_unlink, hook_path_unlink), LSM_HOOK_INIT(path_rmdir, hook_path_rmdir), + LSM_HOOK_INIT(path_truncate, hook_path_truncate), LSM_HOOK_INIT(file_open, hook_file_open), }; diff --git a/security/landlock/limits.h b/security/landlock/limits.h index b54184ab9439..82288f0e9e5e 100644 --- a/security/landlock/limits.h +++ b/security/landlock/limits.h @@ -18,7 +18,7 @@ #define LANDLOCK_MAX_NUM_LAYERS 16 #define LANDLOCK_MAX_NUM_RULES U32_MAX -#define LANDLOCK_LAST_ACCESS_FS LANDLOCK_ACCESS_FS_REFER +#define LANDLOCK_LAST_ACCESS_FS LANDLOCK_ACCESS_FS_TRUNCATE #define LANDLOCK_MASK_ACCESS_FS ((LANDLOCK_LAST_ACCESS_FS << 1) - 1) #define LANDLOCK_NUM_ACCESS_FS __const_hweight64(LANDLOCK_MASK_ACCESS_FS) diff --git a/security/landlock/syscalls.c b/security/landlock/syscalls.c index 735a0865ea11..f4d6fc7ed17f 100644 --- a/security/landlock/syscalls.c +++ b/security/landlock/syscalls.c @@ -129,7 +129,7 @@ static const struct file_operations ruleset_fops = { .write = fop_dummy_write, }; -#define LANDLOCK_ABI_VERSION 2 +#define LANDLOCK_ABI_VERSION 3 /** * sys_landlock_create_ruleset - Create a new ruleset diff --git a/tools/testing/selftests/landlock/base_test.c b/tools/testing/selftests/landlock/base_test.c index da9290817866..72cdae277b02 100644 --- a/tools/testing/selftests/landlock/base_test.c +++ b/tools/testing/selftests/landlock/base_test.c @@ -75,7 +75,7 @@ TEST(abi_version) const struct landlock_ruleset_attr ruleset_attr = { .handled_access_fs = LANDLOCK_ACCESS_FS_READ_FILE, }; - ASSERT_EQ(2, landlock_create_ruleset(NULL, 0, + ASSERT_EQ(3, landlock_create_ruleset(NULL, 0, LANDLOCK_CREATE_RULESET_VERSION)); ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr, 0, diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c index 21a2ce8fa739..cb77eaa01c91 100644 --- a/tools/testing/selftests/landlock/fs_test.c +++ b/tools/testing/selftests/landlock/fs_test.c @@ -399,9 +399,10 @@ TEST_F_FORK(layout1, inval) #define ACCESS_FILE ( \ LANDLOCK_ACCESS_FS_EXECUTE | \ LANDLOCK_ACCESS_FS_WRITE_FILE | \ - LANDLOCK_ACCESS_FS_READ_FILE) + LANDLOCK_ACCESS_FS_READ_FILE | \ + LANDLOCK_ACCESS_FS_TRUNCATE) -#define ACCESS_LAST LANDLOCK_ACCESS_FS_REFER +#define ACCESS_LAST LANDLOCK_ACCESS_FS_TRUNCATE #define ACCESS_ALL ( \ ACCESS_FILE | \ @@ -415,7 +416,7 @@ TEST_F_FORK(layout1, inval) LANDLOCK_ACCESS_FS_MAKE_FIFO | \ LANDLOCK_ACCESS_FS_MAKE_BLOCK | \ LANDLOCK_ACCESS_FS_MAKE_SYM | \ - ACCESS_LAST) + LANDLOCK_ACCESS_FS_REFER) /* clang-format on */ From patchwork Wed Aug 17 20:30:04 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?q?G=C3=BCnther_Noack?= X-Patchwork-Id: 12946432 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 42720C25B08 for ; Wed, 17 Aug 2022 20:30:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241517AbiHQUaf (ORCPT ); Wed, 17 Aug 2022 16:30:35 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50426 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241966AbiHQUaY (ORCPT ); Wed, 17 Aug 2022 16:30:24 -0400 Received: from mail-ed1-x52c.google.com (mail-ed1-x52c.google.com [IPv6:2a00:1450:4864:20::52c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 9671DA98D3; Wed, 17 Aug 2022 13:30:22 -0700 (PDT) Received: by mail-ed1-x52c.google.com with SMTP id o22so18962563edc.10; Wed, 17 Aug 2022 13:30:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc; bh=CU7UfL6wEL0y5Oi4r0g+oADsGvcV7i1sDoIV91jwnLs=; b=PEWURrXXCLkgFJ3pkzJ3Srt7LI+5ZeJbeD3eSLjEYdk06WlkEqBEPTVkjMNtvoR065 Kcvi3oPMl9eSeQmSwQKtGp8Z5GZXVZCQNhuVrndvkOUhomKCcclfyM9vM4OcPfZYh6NO eijY78QeEsz/4itqsZP0PnP0e3qISobB3cRqCSVPOestWyNzrk3nB+vnTEv1Wp+vSAIJ GjVqtmDR87P8gydoVCZz9Un8CAb2k275geZNULv4b2fQxn17ULeUde9UGnwhmAc9v/3+ R7eUi8wrcRF7/h3oogBxUnJn+NuSEA0/PPE4G3HRBnceZxN7mYoNjgivDhC5vIqI45kp f21w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc; bh=CU7UfL6wEL0y5Oi4r0g+oADsGvcV7i1sDoIV91jwnLs=; b=yamFvWzpKOMW1Z5CTFeEjX3pCaLR5i0EbYJpzlmd6VNflFQdUJqANWgIemFnUUqZ7j Nkt7ngZHXfXbdQ30VlpgmZUeEJLwhJMn5t6cJ200NSG/bKsmTaJHAiUebcWXj5+blySs MxP0hqtnu1Cilk0klVRsxtA9cmJW1zUvdkkSsw+BtT8kyI7TahpGU3x9SYWd6S8vZoBF o+SnDUNZRPa3J7N0L+dX/2EjgpfmvQ1B/veHXHvF+TqmbsxeteiiNQAx2cxVaYMtfyse ZnpaCt4doxNhWRzwi8I2wPzXNqQl5P4Z4unChUsdKQiEWxuuaHzc9kgIrmmvf/735fP6 oCew== X-Gm-Message-State: ACgBeo3HJwQPQ+rkUafj7Q8jluNm2AFMZq43a1+Wky/7mFT35lW0l2w8 ypatW3pNPFsqYvZzCwsZzTJDaTc60QQ= X-Google-Smtp-Source: AA6agR5mk7L2cu2kL3cjj1YR8oNJBXUAjAjfHL3pl7YtjhQva2sdWaKc+9lfRcjWjsQsHujhOBtrQA== X-Received: by 2002:a05:6402:500d:b0:440:9bc5:d0c1 with SMTP id p13-20020a056402500d00b004409bc5d0c1mr24733908eda.202.1660768221088; Wed, 17 Aug 2022 13:30:21 -0700 (PDT) Received: from nuc.i.gnoack.org ([2a02:168:633b:1:1e69:7aff:fe05:97e6]) by smtp.gmail.com with ESMTPSA id p7-20020a17090653c700b0073b0c2d420dsm512042ejo.217.2022.08.17.13.30.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Aug 2022 13:30:20 -0700 (PDT) From: =?utf-8?q?G=C3=BCnther_Noack?= To: linux-security-module@vger.kernel.org Cc: =?utf-8?q?Micka=C3=ABl_Sala=C3=BCn?= , James Morris , Paul Moore , "Serge E . Hallyn" , linux-fsdevel@vger.kernel.org, Konstantin Meskhidze , =?utf-8?q?G=C3=BCnt?= =?utf-8?q?her_Noack?= Subject: [PATCH v5 2/4] selftests/landlock: Selftests for file truncation support Date: Wed, 17 Aug 2022 22:30:04 +0200 Message-Id: <20220817203006.21769-3-gnoack3000@gmail.com> X-Mailer: git-send-email 2.37.2 In-Reply-To: <20220817203006.21769-1-gnoack3000@gmail.com> References: <20220817203006.21769-1-gnoack3000@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: These tests exercise the following truncation operations: * truncate() (truncate by path) * ftruncate() (truncate by file descriptor) * open with the O_TRUNC flag * special case: creat(), which is open with O_CREAT|O_WRONLY|O_TRUNC. in the following scenarios: * Files with read, write and truncate rights. * Files with read and truncate rights. * Files with the truncate right. * Files without the truncate right. In particular, the following scenarios are enforced with the test: * ftruncate() requires the truncate right, even when the thread already has the right to write to the file. * open() with O_TRUNC requires the truncate right, if it truncates a file. open() already checks security_path_truncate() in this case, and it required no additional check in the Landlock LSM's file_open hook. * creat() requires the truncate right when called with an existing filename. * creat() does *not* require the truncate right when it's creating a new file. Signed-off-by: Günther Noack --- tools/testing/selftests/landlock/fs_test.c | 250 +++++++++++++++++++++ 1 file changed, 250 insertions(+) diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c index cb77eaa01c91..010d4c59139e 100644 --- a/tools/testing/selftests/landlock/fs_test.c +++ b/tools/testing/selftests/landlock/fs_test.c @@ -58,6 +58,7 @@ static const char file1_s2d3[] = TMP_DIR "/s2d1/s2d2/s2d3/f1"; static const char file2_s2d3[] = TMP_DIR "/s2d1/s2d2/s2d3/f2"; static const char dir_s3d1[] = TMP_DIR "/s3d1"; +static const char file1_s3d1[] = TMP_DIR "/s3d1/f1"; /* dir_s3d2 is a mount point. */ static const char dir_s3d2[] = TMP_DIR "/s3d1/s3d2"; static const char dir_s3d3[] = TMP_DIR "/s3d1/s3d2/s3d3"; @@ -83,6 +84,7 @@ static const char dir_s3d3[] = TMP_DIR "/s3d1/s3d2/s3d3"; * │   ├── f1 * │   └── f2 * └── s3d1 + *    ├── f1 * └── s3d2 * └── s3d3 */ @@ -208,6 +210,7 @@ static void create_layout1(struct __test_metadata *const _metadata) create_file(_metadata, file1_s2d3); create_file(_metadata, file2_s2d3); + create_file(_metadata, file1_s3d1); create_directory(_metadata, dir_s3d2); set_cap(_metadata, CAP_SYS_ADMIN); ASSERT_EQ(0, mount("tmp", dir_s3d2, "tmpfs", 0, "size=4m,mode=700")); @@ -230,6 +233,7 @@ static void remove_layout1(struct __test_metadata *const _metadata) EXPECT_EQ(0, remove_path(file1_s2d2)); EXPECT_EQ(0, remove_path(file1_s2d1)); + EXPECT_EQ(0, remove_path(file1_s3d1)); EXPECT_EQ(0, remove_path(dir_s3d3)); set_cap(_metadata, CAP_SYS_ADMIN); umount(dir_s3d2); @@ -3023,6 +3027,252 @@ TEST_F_FORK(layout1, proc_pipe) ASSERT_EQ(0, close(pipe_fds[1])); } +/* Invokes truncate(2) and returns its errno or 0. */ +static int test_truncate(const char *const path) +{ + if (truncate(path, 10) < 0) + return errno; + return 0; +} + +/* Invokes ftruncate(2) and returns its errno or 0. */ +static int test_ftruncate(int fd) +{ + if (ftruncate(fd, 10) < 0) + return errno; + return 0; +} + +/* + * Invokes creat(2) and returns its errno or 0. + * Closes the opened file descriptor on success. + */ +static int test_creat(const char *const path, mode_t mode) +{ + int fd = creat(path, mode); + + if (fd < 0) + return errno; + + /* + * Mixing error codes from close(2) and creat(2) should not lead to any + * (access type) confusion for this test. + */ + if (close(fd) < 0) + return errno; + return 0; +} + +/* + * Exercises file truncation when it's not restricted, + * as it was the case before LANDLOCK_ACCESS_FS_TRUNCATE existed. + */ +TEST_F_FORK(layout1, truncate_unhandled) +{ + const char *const file_r = file1_s1d1; + const char *const file_w = file2_s1d1; + const char *const file_none = file1_s1d2; + int file_r_fd, file_w_fd, file_none_fd; + const struct rule rules[] = { + { + .path = file_r, + .access = LANDLOCK_ACCESS_FS_READ_FILE, + }, + { + .path = file_w, + .access = LANDLOCK_ACCESS_FS_WRITE_FILE, + }, + /* Implicitly: No rights for file_none. */ + {}, + }; + + const __u64 handled = LANDLOCK_ACCESS_FS_READ_FILE | + LANDLOCK_ACCESS_FS_WRITE_FILE; + int ruleset_fd; + + /* + * Open some writable file descriptors before enabling Landlock, so that + * we can test ftruncate() without making open() a prerequisite. + */ + file_r_fd = open(file_r, O_WRONLY | O_CLOEXEC); + ASSERT_LE(0, file_r_fd); + file_w_fd = open(file_w, O_WRONLY | O_CLOEXEC); + ASSERT_LE(0, file_w_fd); + file_none_fd = open(file_none, O_WRONLY | O_CLOEXEC); + ASSERT_LE(0, file_none_fd); + + /* Enable Landlock. */ + ruleset_fd = create_ruleset(_metadata, handled, rules); + + ASSERT_LE(0, ruleset_fd); + enforce_ruleset(_metadata, ruleset_fd); + ASSERT_EQ(0, close(ruleset_fd)); + + /* + * Checks read right: truncate, ftruncate and open with O_TRUNC work, + * unless the file is attempted to be opened for writing. + */ + EXPECT_EQ(0, test_truncate(file_r)); + EXPECT_EQ(0, test_ftruncate(file_r_fd)); + EXPECT_EQ(0, test_open(file_r, O_RDONLY | O_TRUNC)); + EXPECT_EQ(EACCES, test_open(file_r, O_WRONLY | O_TRUNC)); + EXPECT_EQ(EACCES, test_creat(file_r, 0600)); + + /* + * Checks write right: truncate, ftruncate and open with O_TRUNC work, + * unless the file is attempted to be opened for reading. + */ + EXPECT_EQ(0, test_truncate(file_w)); + EXPECT_EQ(0, test_ftruncate(file_w_fd)); + EXPECT_EQ(EACCES, test_open(file_w, O_RDONLY | O_TRUNC)); + EXPECT_EQ(0, test_open(file_w, O_WRONLY | O_TRUNC)); + EXPECT_EQ(0, test_creat(file_w, 0600)); + + /* + * Checks "no rights" case: truncate and ftruncate work but all open + * attempts fail, including creat. + */ + EXPECT_EQ(0, test_truncate(file_none)); + EXPECT_EQ(0, test_ftruncate(file_none_fd)); + EXPECT_EQ(EACCES, test_open(file_none, O_RDONLY | O_TRUNC)); + EXPECT_EQ(EACCES, test_open(file_none, O_WRONLY | O_TRUNC)); + EXPECT_EQ(EACCES, test_creat(file_none, 0600)); + + ASSERT_EQ(0, close(file_r_fd)); + ASSERT_EQ(0, close(file_w_fd)); + ASSERT_EQ(0, close(file_none_fd)); +} + +TEST_F_FORK(layout1, truncate) +{ + const char *const file_rwt = file1_s1d1; + const char *const file_rw = file2_s1d1; + const char *const file_rt = file1_s1d2; + const char *const file_t = file2_s1d2; + const char *const file_none = file1_s1d3; + const char *const dir_t = dir_s2d1; + const char *const file_in_dir_t = file1_s2d1; + const char *const dir_w = dir_s3d1; + const char *const file_in_dir_w = file1_s3d1; + int file_rwt_fd, file_rw_fd, file_rt_fd, file_t_fd, file_none_fd; + int file_in_dir_t_fd, file_in_dir_w_fd; + const struct rule rules[] = { + { + .path = file_rwt, + .access = LANDLOCK_ACCESS_FS_READ_FILE | + LANDLOCK_ACCESS_FS_WRITE_FILE | + LANDLOCK_ACCESS_FS_TRUNCATE, + }, + { + .path = file_rw, + .access = LANDLOCK_ACCESS_FS_READ_FILE | + LANDLOCK_ACCESS_FS_WRITE_FILE, + }, + { + .path = file_rt, + .access = LANDLOCK_ACCESS_FS_READ_FILE | + LANDLOCK_ACCESS_FS_TRUNCATE, + }, + { + .path = file_t, + .access = LANDLOCK_ACCESS_FS_TRUNCATE, + }, + /* Implicitly: No access rights for file_none. */ + { + .path = dir_t, + .access = LANDLOCK_ACCESS_FS_TRUNCATE, + }, + { + .path = dir_w, + .access = LANDLOCK_ACCESS_FS_WRITE_FILE, + }, + {}, + }; + const __u64 handled = LANDLOCK_ACCESS_FS_READ_FILE | + LANDLOCK_ACCESS_FS_WRITE_FILE | + LANDLOCK_ACCESS_FS_TRUNCATE; + int ruleset_fd; + + /* + * Open some writable file descriptors before enabling Landlock, so that + * we can test ftruncate() without making open() a prerequisite. + */ + file_rwt_fd = open(file_rwt, O_WRONLY | O_CLOEXEC); + ASSERT_LE(0, file_rwt_fd); + file_rw_fd = open(file_rw, O_WRONLY | O_CLOEXEC); + ASSERT_LE(0, file_rw_fd); + file_rt_fd = open(file_rt, O_WRONLY | O_CLOEXEC); + ASSERT_LE(0, file_rt_fd); + file_t_fd = open(file_t, O_WRONLY | O_CLOEXEC); + ASSERT_LE(0, file_t_fd); + file_none_fd = open(file_none, O_WRONLY | O_CLOEXEC); + ASSERT_LE(0, file_none_fd); + file_in_dir_t_fd = open(file_in_dir_t, O_WRONLY | O_CLOEXEC); + ASSERT_LE(0, file_in_dir_t_fd); + file_in_dir_w_fd = open(file_in_dir_w, O_WRONLY | O_CLOEXEC); + ASSERT_LE(0, file_in_dir_w_fd); + + /* Enable Landlock. */ + ruleset_fd = create_ruleset(_metadata, handled, rules); + + ASSERT_LE(0, ruleset_fd); + enforce_ruleset(_metadata, ruleset_fd); + ASSERT_EQ(0, close(ruleset_fd)); + + /* Checks read, write and truncate rights: truncation works. */ + EXPECT_EQ(0, test_truncate(file_rwt)); + EXPECT_EQ(0, test_ftruncate(file_rwt_fd)); + EXPECT_EQ(0, test_open(file_rwt, O_RDONLY | O_TRUNC)); + EXPECT_EQ(0, test_open(file_rwt, O_WRONLY | O_TRUNC)); + + /* Checks read and write rights: no truncate variant works. */ + EXPECT_EQ(EACCES, test_truncate(file_rw)); + EXPECT_EQ(EACCES, test_ftruncate(file_rw_fd)); + EXPECT_EQ(EACCES, test_open(file_rw, O_RDONLY | O_TRUNC)); + EXPECT_EQ(EACCES, test_open(file_rw, O_WRONLY | O_TRUNC)); + + /* + * Checks read and truncate rights: truncation works. + * + * Note: Files can get truncated using open() even with O_RDONLY. + */ + EXPECT_EQ(0, test_truncate(file_rt)); + EXPECT_EQ(0, test_ftruncate(file_rt_fd)); + EXPECT_EQ(0, test_open(file_rt, O_RDONLY | O_TRUNC)); + EXPECT_EQ(EACCES, test_open(file_rt, O_WRONLY | O_TRUNC)); + + /* Checks truncate right: truncate works, but can't open file. */ + EXPECT_EQ(0, test_truncate(file_t)); + EXPECT_EQ(0, test_ftruncate(file_t_fd)); + EXPECT_EQ(EACCES, test_open(file_t, O_RDONLY | O_TRUNC)); + EXPECT_EQ(EACCES, test_open(file_t, O_WRONLY | O_TRUNC)); + + /* Checks "no rights" case: No form of truncation works. */ + EXPECT_EQ(EACCES, test_truncate(file_none)); + EXPECT_EQ(EACCES, test_ftruncate(file_none_fd)); + EXPECT_EQ(EACCES, test_open(file_none, O_RDONLY | O_TRUNC)); + EXPECT_EQ(EACCES, test_open(file_none, O_WRONLY | O_TRUNC)); + + /* + * Checks truncate right on directory: truncate works on contained + * files. + */ + EXPECT_EQ(0, test_truncate(file_in_dir_t)); + EXPECT_EQ(0, test_ftruncate(file_in_dir_t_fd)); + EXPECT_EQ(EACCES, test_open(file_in_dir_t, O_RDONLY | O_TRUNC)); + EXPECT_EQ(EACCES, test_open(file_in_dir_t, O_WRONLY | O_TRUNC)); + + /* + * Checks creat in dir_w: This requires the truncate right when + * overwriting an existing file, but does not require it when the file + * is new. + */ + EXPECT_EQ(EACCES, test_creat(file_in_dir_w, 0600)); + + ASSERT_EQ(0, unlink(file_in_dir_w)); + EXPECT_EQ(0, test_creat(file_in_dir_w, 0600)); +} + /* clang-format off */ FIXTURE(layout1_bind) {}; /* clang-format on */ From patchwork Wed Aug 17 20:30:05 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?q?G=C3=BCnther_Noack?= X-Patchwork-Id: 12946433 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4C7B1C2BB41 for ; Wed, 17 Aug 2022 20:30:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241943AbiHQUag (ORCPT ); Wed, 17 Aug 2022 16:30:36 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50428 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241965AbiHQUaY (ORCPT ); Wed, 17 Aug 2022 16:30:24 -0400 Received: from mail-ej1-x633.google.com (mail-ej1-x633.google.com [IPv6:2a00:1450:4864:20::633]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5C22DA98E7; Wed, 17 Aug 2022 13:30:23 -0700 (PDT) Received: by mail-ej1-x633.google.com with SMTP id dc19so26487855ejb.12; Wed, 17 Aug 2022 13:30:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc; bh=Rlx98mKeZrGekLkjWi04LgDVSnb7ZLX9tMW7Nnpkucs=; b=fBzsTG/HVJYlGBtuOCgK4wvrKWpw4GnDf8+18w+zwtLYXtSUXfnFxCCMxnGhVSvBdK T0kCu0n4KN+nRRU+muszMHajXqUn1dpvS7ujumSuHSB0JtJherp5lFzDOfl6RqLcQyoq QaF7qsPbE4mIVPlHAxtPNsSclsLh0pl5co5+PK/G5FDH7pbBKLVSIdU2Haqhfbkl7pqC 7aViL+vqHHpKaQFWbr/wzIqnsdB0B6VGcTwOYbhAtbfY5A4eH3OUq1GrFjZZA3yjTjip 5KLExmPf6hawfGcDkJ1cn2sVK4oGLwUv8FIX7a/5Bltx07ZlIsHM+81FP+mTmECLMZYL qYOw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc; bh=Rlx98mKeZrGekLkjWi04LgDVSnb7ZLX9tMW7Nnpkucs=; b=jLfZH+jAZL+VgWesMB05JzYrCZEVqYmOGlvZzbwR0oLUzWIes8uBq+ei3JjCQHR4Go JEBFvd8BZbsyu9qGPN/5OZjgqXWsr78rmitmtuxNwhaQHgwvkgk2RVgVPQa5EXv4kpAT kdskN9tMWLTMJV854d8+u5JfyW7XzZdhLkuxIDGpgyHKz9JrXAOSPFFMDE7NNZWhXXTU UPPCcYOtGQzElG/E2JRjluzDORes+30MdOZNeRSu4wFtPfHYCR40qPkCCs6cEPGr7HXL c16LbEdGCSz9VSh+FxqqBFhvKnuAIN8BBWKPjIFtiAQMgfqFTzs20JjecMN6KAupzuTO ei0g== X-Gm-Message-State: ACgBeo1HIeCGIjX4T1Npv9zib/EwVCfWfy76kPjLnTF3QZquwb1ifOIN WuWjbCLmUwn7MrGQ5P4vU0VnGyaQxKk= X-Google-Smtp-Source: AA6agR76P7ljL82374pY6SaCPthq3ww8Yo/+4KUwJxaLWpM4R/Xoad6i3bb/pbTwQmL73ezjnwRHOA== X-Received: by 2002:a17:907:9808:b0:731:5835:4ac7 with SMTP id ji8-20020a170907980800b0073158354ac7mr17608927ejc.125.1660768221796; Wed, 17 Aug 2022 13:30:21 -0700 (PDT) Received: from nuc.i.gnoack.org ([2a02:168:633b:1:1e69:7aff:fe05:97e6]) by smtp.gmail.com with ESMTPSA id p7-20020a17090653c700b0073b0c2d420dsm512042ejo.217.2022.08.17.13.30.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Aug 2022 13:30:21 -0700 (PDT) From: =?utf-8?q?G=C3=BCnther_Noack?= To: linux-security-module@vger.kernel.org Cc: =?utf-8?q?Micka=C3=ABl_Sala=C3=BCn?= , James Morris , Paul Moore , "Serge E . Hallyn" , linux-fsdevel@vger.kernel.org, Konstantin Meskhidze , =?utf-8?q?G=C3=BCnt?= =?utf-8?q?her_Noack?= Subject: [PATCH v5 3/4] samples/landlock: Extend sample tool to support LANDLOCK_ACCESS_FS_TRUNCATE Date: Wed, 17 Aug 2022 22:30:05 +0200 Message-Id: <20220817203006.21769-4-gnoack3000@gmail.com> X-Mailer: git-send-email 2.37.2 In-Reply-To: <20220817203006.21769-1-gnoack3000@gmail.com> References: <20220817203006.21769-1-gnoack3000@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: Update the sandboxer sample to restrict truncate actions. This is automatically enabled by default if the running kernel supports LANDLOCK_ACCESS_FS_TRUNCATE, expect for the paths listed in the LL_FS_RW environment variable. Signed-off-by: Günther Noack --- samples/landlock/sandboxer.c | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/samples/landlock/sandboxer.c b/samples/landlock/sandboxer.c index 3e404e51ec64..771b6b10d519 100644 --- a/samples/landlock/sandboxer.c +++ b/samples/landlock/sandboxer.c @@ -76,7 +76,8 @@ static int parse_path(char *env_path, const char ***const path_list) #define ACCESS_FILE ( \ LANDLOCK_ACCESS_FS_EXECUTE | \ LANDLOCK_ACCESS_FS_WRITE_FILE | \ - LANDLOCK_ACCESS_FS_READ_FILE) + LANDLOCK_ACCESS_FS_READ_FILE | \ + LANDLOCK_ACCESS_FS_TRUNCATE) /* clang-format on */ @@ -160,10 +161,8 @@ static int populate_ruleset(const char *const env_var, const int ruleset_fd, LANDLOCK_ACCESS_FS_MAKE_FIFO | \ LANDLOCK_ACCESS_FS_MAKE_BLOCK | \ LANDLOCK_ACCESS_FS_MAKE_SYM | \ - LANDLOCK_ACCESS_FS_REFER) - -#define ACCESS_ABI_2 ( \ - LANDLOCK_ACCESS_FS_REFER) + LANDLOCK_ACCESS_FS_REFER | \ + LANDLOCK_ACCESS_FS_TRUNCATE) /* clang-format on */ @@ -226,11 +225,17 @@ int main(const int argc, char *const argv[], char *const *const envp) return 1; } /* Best-effort security. */ - if (abi < 2) { - ruleset_attr.handled_access_fs &= ~ACCESS_ABI_2; - access_fs_ro &= ~ACCESS_ABI_2; - access_fs_rw &= ~ACCESS_ABI_2; + switch (abi) { + case 1: + /* Removes LANDLOCK_ACCESS_FS_REFER for ABI < 2 */ + ruleset_attr.handled_access_fs &= ~LANDLOCK_ACCESS_FS_REFER; + __attribute__((fallthrough)); + case 2: + /* Removes LANDLOCK_ACCESS_FS_TRUNCATE for ABI < 3 */ + ruleset_attr.handled_access_fs &= ~LANDLOCK_ACCESS_FS_TRUNCATE; } + access_fs_ro &= ruleset_attr.handled_access_fs; + access_fs_rw &= ruleset_attr.handled_access_fs; ruleset_fd = landlock_create_ruleset(&ruleset_attr, sizeof(ruleset_attr), 0); From patchwork Wed Aug 17 20:30:06 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?q?G=C3=BCnther_Noack?= X-Patchwork-Id: 12946434 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id E4D92C32789 for ; Wed, 17 Aug 2022 20:30:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S242017AbiHQUai (ORCPT ); Wed, 17 Aug 2022 16:30:38 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50432 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241972AbiHQUaZ (ORCPT ); Wed, 17 Aug 2022 16:30:25 -0400 Received: from mail-ej1-x636.google.com (mail-ej1-x636.google.com [IPv6:2a00:1450:4864:20::636]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 075D7A98EE; Wed, 17 Aug 2022 13:30:24 -0700 (PDT) Received: by mail-ej1-x636.google.com with SMTP id fy5so26528119ejc.3; Wed, 17 Aug 2022 13:30:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc; bh=svi6OaL8K/Etur8WtPrV1gQpFeKDk5ixCmOBfj3/KwI=; b=SEUS8d73nsNEDLK86FJHBjhtZ9/PyBfTry+vq0sygqBkXlNbr0DbbbUGVZ6pJm3/Jv 5I9vkKnbkqXnn451MFHS0EkTb7ZA9XNgX5xJKANKOVZn6Zd+ctzl2nko50ClBAZwX88N tP1YntgrJkAggwMKCsn7MySB+DpLCktCOM882IJt/UKb9FXrCvuVv224465u77z++x0O Pm98a9Rj2QG1HEshlLFMU6Cs4rQjQkj8GJ7kDBqmmsmGjpr0o+2qvZfUiJYDuUaga5KE oW39H8fQaCsU6kmGmlqzgO7vM8pCvUtdj/OplO3IvYZWuLkrQ4ug68kDh3/t028pqjhB qmzg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc; bh=svi6OaL8K/Etur8WtPrV1gQpFeKDk5ixCmOBfj3/KwI=; b=M2yObFYXTk2kfKurUS3dYLvip8uhJdxW1LpzQwpMvpR6q+UvzHZlMvngaZ77YdVyKy vu+60TojxEXciSTMcS1Sc7f3dIwBKiDXO1OMW8TUUffXzGyrIdx1mcSBaR0/gsLNRDlf QZcPZ9S1pJa8RjrUWHW328wHCd+sOKUsU3xu2qODMeuDvbDkGn9dZC45sC9jP01caNwI mab8Q4zKka62bJj8Ul8Cq5zC4FqLwq8ej+4aozMfsbYuK+MNPg2TO9alGgEyxVVCOx61 GtiWBn693s/T9snDaf0j6z8XDYPITMVAaYiwunQbWf2M1CuHrM3VyZA504OoySc1m2Ru OzkA== X-Gm-Message-State: ACgBeo1s5+XZUPCr6LvfT8gvXcPGAYrzDvhgiz/zfbSmuL0cUFIVT7Vz 20GNlCwAPbGrwiJQoYf403gbBhH0v7o= X-Google-Smtp-Source: AA6agR6KmYqQn8GUUEIeYDEzEL5ToMsEGFleiUI4XBpIhcCN3zCRoda4tfRQaer7W0CtHVbw1Meofw== X-Received: by 2002:a17:907:2721:b0:731:2aeb:7940 with SMTP id d1-20020a170907272100b007312aeb7940mr18399588ejl.448.1660768222615; Wed, 17 Aug 2022 13:30:22 -0700 (PDT) Received: from nuc.i.gnoack.org ([2a02:168:633b:1:1e69:7aff:fe05:97e6]) by smtp.gmail.com with ESMTPSA id p7-20020a17090653c700b0073b0c2d420dsm512042ejo.217.2022.08.17.13.30.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Aug 2022 13:30:22 -0700 (PDT) From: =?utf-8?q?G=C3=BCnther_Noack?= To: linux-security-module@vger.kernel.org Cc: =?utf-8?q?Micka=C3=ABl_Sala=C3=BCn?= , James Morris , Paul Moore , "Serge E . Hallyn" , linux-fsdevel@vger.kernel.org, Konstantin Meskhidze , =?utf-8?q?G=C3=BCnt?= =?utf-8?q?her_Noack?= Subject: [PATCH v5 4/4] landlock: Document Landlock's file truncation support Date: Wed, 17 Aug 2022 22:30:06 +0200 Message-Id: <20220817203006.21769-5-gnoack3000@gmail.com> X-Mailer: git-send-email 2.37.2 In-Reply-To: <20220817203006.21769-1-gnoack3000@gmail.com> References: <20220817203006.21769-1-gnoack3000@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: Use the LANDLOCK_ACCESS_FS_TRUNCATE flag in the tutorial. Adapt the backwards compatibility example and discussion to remove the truncation flag where needed. Point out potential surprising behaviour related to truncate. Signed-off-by: Günther Noack --- Documentation/userspace-api/landlock.rst | 52 ++++++++++++++++++++---- 1 file changed, 45 insertions(+), 7 deletions(-) diff --git a/Documentation/userspace-api/landlock.rst b/Documentation/userspace-api/landlock.rst index b8ea59493964..5c10872cb795 100644 --- a/Documentation/userspace-api/landlock.rst +++ b/Documentation/userspace-api/landlock.rst @@ -60,7 +60,8 @@ the need to be explicit about the denied-by-default access rights. LANDLOCK_ACCESS_FS_MAKE_FIFO | LANDLOCK_ACCESS_FS_MAKE_BLOCK | LANDLOCK_ACCESS_FS_MAKE_SYM | - LANDLOCK_ACCESS_FS_REFER, + LANDLOCK_ACCESS_FS_REFER | + LANDLOCK_ACCESS_FS_TRUNCATE, }; Because we may not know on which kernel version an application will be @@ -69,16 +70,26 @@ should try to protect users as much as possible whatever the kernel they are using. To avoid binary enforcement (i.e. either all security features or none), we can leverage a dedicated Landlock command to get the current version of the Landlock ABI and adapt the handled accesses. Let's check if we should -remove the `LANDLOCK_ACCESS_FS_REFER` access right which is only supported -starting with the second version of the ABI. +remove the `LANDLOCK_ACCESS_FS_REFER` or `LANDLOCK_ACCESS_FS_TRUNCATE` access +rights, which are only supported starting with the second and third version of +the ABI. .. code-block:: c int abi; abi = landlock_create_ruleset(NULL, 0, LANDLOCK_CREATE_RULESET_VERSION); - if (abi < 2) { - ruleset_attr.handled_access_fs &= ~LANDLOCK_ACCESS_FS_REFER; + switch (abi) { + case -1: + perror("The running kernel does not enable to use Landlock"); + return 1; + case 1: + /* Removes LANDLOCK_ACCESS_FS_REFER for ABI < 2 */ + ruleset_attr.handled_access_fs &= ~LANDLOCK_ACCESS_FS_REFER; + __attribute__((fallthrough)); + case 2: + /* Removes LANDLOCK_ACCESS_FS_TRUNCATE for ABI < 3 */ + ruleset_attr.handled_access_fs &= ~LANDLOCK_ACCESS_FS_TRUNCATE; } This enables to create an inclusive ruleset that will contain our rules. @@ -127,8 +138,8 @@ descriptor. It may also be required to create rules following the same logic as explained for the ruleset creation, by filtering access rights according to the Landlock -ABI version. In this example, this is not required because -`LANDLOCK_ACCESS_FS_REFER` is not allowed by any rule. +ABI version. In this example, this is not required because all of the requested +``allowed_access`` rights are already available in ABI 1. We now have a ruleset with one rule allowing read access to ``/usr`` while denying all other handled accesses for the filesystem. The next step is to @@ -251,6 +262,24 @@ 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. +Truncating files +---------------- + +The operations covered by `LANDLOCK_ACCESS_FS_WRITE_FILE` and +`LANDLOCK_ACCESS_FS_TRUNCATE` both change the contents of a file and sometimes +overlap in non-intuitive ways. It is recommended to always specify both of +these together. + +A particularly surprising example is :manpage:`creat(2)`. The name suggests +that this system call requires the rights to create and write files. However, +it also requires the truncate right if an existing file under the same name is +already present. + +It should also be noted that truncating files does not require the +`LANDLOCK_ACCESS_FS_WRITE_FILE` right. Apart from the :manpage:`truncate(2)` +system call, this can also be done through :manpage:`open(2)` with the flags +`O_RDONLY | O_TRUNC`. + Compatibility ============= @@ -397,6 +426,15 @@ Starting with the Landlock ABI version 2, it is now possible to securely control renaming and linking thanks to the new `LANDLOCK_ACCESS_FS_REFER` access right. +File truncation (ABI < 3) +------------------------- + +File truncation could not be denied before the third Landlock ABI, so it is +always allowed when using a kernel that only supports the first or second ABI. + +Starting with the Landlock ABI version 3, it is now possible to securely control +truncation thanks to the new `LANDLOCK_ACCESS_FS_TRUNCATE` access right. + .. _kernel_support: Kernel support