Skip to contentSkip to conversation

Landlock: IOCTL support

PATCH In review Günther Noack 2 participants 13 messages Apr 19, 2024 – May 8, 2024

Subsystems (5)
lore
Share & tools
lore

Günther Noack

author reviewer
#0 lore raw

v15 cover Landlock: IOCTL support

Hello!

These patches add simple ioctl(2) support to Landlock.

Objective
~~~~~~~~~

Make ioctl(2) requests for device files restrictable with Landlock, in a way that is useful for real-world applications.

Proposed approach
~~~~~~~~~~~~~~~~~

Introduce the LANDLOCK_ACCESS_FS_IOCTL_DEV right, which restricts the use of ioctl(2) on block and character devices.

We attach the this access right to opened file descriptors, as we already do for LANDLOCK_ACCESS_FS_TRUNCATE.

If LANDLOCK_ACCESS_FS_IOCTL_DEV is handled (restricted in the ruleset), the LANDLOCK_ACCESS_FS_IOCTL_DEV right governs the use of all device-specific IOCTL commands. We make exceptions for common and known-harmless IOCTL commands such as FIOCLEX, FIONCLEX, FIONBIO and FIOASYNC, as well as other IOCTL commands which are implemented in fs/ioctl.c. A full list of these IOCTL commands is listed in the documentation.

I believe that this approach works for the majority of use cases, and offers a good trade-off between complexity of the Landlock API and implementation and flexibility when the feature is used.

Current limitations
~~~~~~~~~~~~~~~~~~~

With this patch set, ioctl(2) requests can *not* be filtered based on file type, device number (dev_t) or on the ioctl(2) request number.

On the initial RFC patch set [1], we have reached consensus to start with this simpler coarse-grained approach, and build additional IOCTL restriction capabilities on top in subsequent steps.

[1] https://lore.kernel.org/linux-security-module/[email protected]/

Notable implications of this approach
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* A processes' existing open file descriptors stay unaffected when a process enables Landlock.

This means that in common scenarios, where the terminal file descriptor is inherited from the parent process, the terminal's IOCTLs (ioctl_tty(2)) continue to work.

* ioctl(2) continues to be available for file descriptors for non-device files. Example: Network sockets, memfd_create(2), regular files and directories.

Examples
~~~~~~~~

Starting a sandboxed shell from $HOME with samples/landlock/sandboxer:

LL_FS_RO=/ LL_FS_RW=. ./sandboxer /bin/bash

The LANDLOCK_ACCESS_FS_IOCTL_DEV right is part of the "read-write" rights here, so we expect that newly opened device files outside of $HOME don't work with most IOCTL commands.

* "stty" works: It probes terminal properties

* "stty </dev/tty" fails: /dev/tty can be reopened, but the IOCTL is denied.

* "eject" fails: ioctls to use CD-ROM drive are denied.

* "ls /dev" works: It uses ioctl to get the terminal size for columnar layout

* The text editors "vim" and "mg" work. (GNU Emacs fails because it attempts to reopen /dev/tty.)

Unaffected IOCTL commands
~~~~~~~~~~~~~~~~~~~~~~~~~

To decide which IOCTL commands should be blanket-permitted, we went through the list of IOCTL commands which are handled directly in fs/ioctl.c and looked at them individually to understand what they are about.

The following commands are permitted by Landlock unconditionally:

* FIOCLEX, FIONCLEX - these work on the file descriptor and manipulate the close-on-exec flag (also available through fcntl(2) with F_SETFD)
* FIONBIO, FIOASYNC - these work on the struct file and enable nonblocking-IO and async flags (also available through fcntl(2) with F_SETFL)

The following commands are also unconditionally permitted by Landlock, because they are really operating on the file system's superblock, rather than on the file itself (the same funcionality is also available from any other file on the same file system):

* FIFREEZE, FITHAW - work on superblock(!) to freeze/thaw the file system. Requires CAP_SYS_ADMIN.
* FIGETBSZ - get file system blocksize
* FS_IOC_GETFSUUID, FS_IOC_GETFSSYSFSPATH - getting file system properties

Notably, the command FIONREAD is *not* blanket-permitted, because it would be a device-specific implementation.

Detailed reasoning about each IOCTL command from fs/ioctl.c is in get_required_ioctl_dev_access() in security/landlock/fs.c.

Related Work
~~~~~~~~~~~~

OpenBSD's pledge(2) [2] restricts ioctl(2) independent of the file descriptor which is used. The implementers maintain multiple allow-lists of predefined ioctl(2) operations required for different application domains such as "audio", "bpf", "tty" and "inet".

OpenBSD does not guarantee backwards compatibility to the same extent as Linux does, so it's easier for them to update these lists in later versions. It might not be a feasible approach for Linux though.

[2] https://man.openbsd.org/OpenBSD-7.4/pledge.2

Implementation Rationale
~~~~~~~~~~~~~~~~~~~~~~~~

A main constraint of this implementation is that the blanket-permitted IOCTL commands for device files should never dispatch to the device-specific implementations in f_ops->unlocked_ioctl() and f_ops->compat_ioctl().

There are many implementations of these f_ops operations and they are too scattered across the kernel to give strong guarantees about them. Additionally, some existing implementations do work before even checking whether they support the cmd number which was passed to them.

In this implementation, we are listing the blanket-permitted IOCTL commands in the Landlock implementation, mirroring a subset of the IOCTL commands which are directly implemented in do_vfs_ioctl() in fs/ioctl.c. The trade-off is that the Landlock LSM needs to track future developments in fs/ioctl.c to keep up to date with that, in particular when new IOCTL commands are introduced there, or when they are moved there from the f_ops implementations.

We mitigate this risk in this patch set by adding fs/ioctl.c to the paths that are relevant to Landlock in the MAINTAINERS file.

The trade-off is discussed in more detail in [3].

Previous versions of this patch set have used different implementation approaches to guarantee the main constraint above, which we have dismissed due to the following reasons:

* V10: Introduced a new LSM hook file_vfs_ioctl, which gets invoked just before the call to f_ops->unlocked_ioctl().

Not done, because it would have created an avoidable overlap between the file_ioctl and file_vfs_ioctl LSM hooks [4].

* V11: Introduced an indirection layer in fs/ioctl.c, so that Landlock could figure out the list of IOCTL commands which are handled by do_vfs_ioctl().

Not done due to additional indirection and possible performance impact in fs/ioctl.c [5]

* V12: Introduced a special error code to be returned from the file_ioctl hook, and matching logic that would disallow the call to f_ops->unlocked_ioctl() in case that this error code is returned.

Not done due because this approach would conflict with Landlock's planned audit logging [6] and because LSM hooks with special error codes are generally discouraged and have lead to problems in the past [7].

Thanks to Arnd Bergmann, Christian Brauner, Kent Overstreet, Mickaël Salaün and Paul Moore for guiding this implementation on the right track!

[3] https://lore.kernel.org/all/[email protected]/
[4] https://lore.kernel.org/all/CAHC9VhRojXNSU9zi2BrP8z6JmOmT3DAqGNtinvvz=tL1XhVdyg@mail.gmail.com/
[5] https://lore.kernel.org/all/[email protected]
[6] https://lore.kernel.org/all/[email protected]
[7] https://lore.kernel.org/all/CAHC9VhQJFWYeheR-EqqdfCq0YpvcQX5Scjfgcz1q+jrWg8YsdA@mail.gmail.com/

Changes
~~~~~~~

V15:
* Drop the commit about FS_IOC_GETFSUUID / FS_IOC_GETFSSYSFSPATH -- it is already assumed as a prerequisite now.
* security/landlock/fs.c:
* Add copyright notice for my contributions (also for the truncate patch set)
* Tests:
* In commit "Test IOCTL support":
* Test with /dev/zero instead of /dev/tty
* Check only FIONREAD instead of both FIONREAD and TCGETS
* Remove a now-unused SKIP()
* In test for Named UNIX Domain Sockets:
* Do not inline variable assignments in ASSERT() usages
* In commit "Exhaustive test for the IOCTL allow-list":
* Make IOCTL results deterministic:
* Zero the input buffer
* Close FD 0 for the ioctl() call, to avoid accidentally using it
* Cosmetic changes and cleanups
* Remove a leftover mention of "synthetic" access rights
* Fix docstring format for is_masked_device_ioctl()
* Newline and comment ordering cleanups as discussed in v14 review

V14:
* Revise which IOCTLs are permitted.
It is almost the same as the vfs_masked_device_ioctl() hooks from
https://lore.kernel.org/all/[email protected]/,
with the following differences:
* Added cases for FS_IOC_GETFSUUID and FS_IOC_GETFSSYSFSPATH
* Do not blanket-permit FS_IOC_{GET,SET}{FLAGS,XATTR}.
They fall back to the device implementation.
* fs/ioctl:
* Small prerequisite change so that FS_IOC_GETFSUUID and FS_IOC_GETFSSYSFSPATH do not fall back to the device implementation.
* Slightly rephrase wording in the warning above do_vfs_ioctl().
* Implement compat handler
* Improve UAPI header documentation
* Code structure
* Change helper function style to return a boolean
* Reorder structure of the IOCTL hooks (much cleaner now -- thanks for the hint, Mickaël!)
* Extract is_device() helper

V13:
* Using the existing file_ioctl hook and a hardcoded list of IOCTL commands. (See the section on implementation rationale above.)
* Add support for FS_IOC_GETFSUUID, FS_IOC_GETFSSYSFSPATH.

V12:
* Rebased on Arnd's proposal:
https://lore.kernel.org/all/[email protected]/
This means that:
* the IOCTL security hooks can return a special value ENOFILEOPS,

     which is treated specially in fs/ioctl.c to permit the IOCTL,
     but only as long as it does not call f_ops->unlocked_ioctl or
     f_ops->compat_ioctl.

* The only change compared to V11 is commit 1, as well as a small adaptation in the commit 2 (The Landlock implementation needs to return the new special value). The tests and documentation commits are exactly the same as before.

V11:
* Rebased on Mickaël's proposal to refactor fs/ioctl.c:
https://lore.kernel.org/all/[email protected]/
This means that:
* we do not add the file_vfs_ioctl() hook as in V10
* we add vfs_get_ioctl_handler() instead, so that Landlock can query which of the IOCTL commands in handled in do_vfs_ioctl()

That proposal is used here unmodified (except for minor typos in the commit description).
* Use the hook_ioctl_compat LSM hook as well.

V10:
* Major change: only restrict IOCTL invocations on device files
* Rename access right to LANDLOCK_ACCESS_FS_IOCTL_DEV
* Remove the notion of synthetic access rights and IOCTL right groups
* Introduce a new LSM hook file_vfs_ioctl, which gets invoked just before the call to f_ops->unlocked_ioctl()
* Documentation
* Various complications were removed or simplified:
* Suggestion to mount file systems as nodev is not needed any more, as Landlock already lets users distinguish device files.
* Remarks about fscrypt were removed. The fscrypt-related IOCTLs only applied to regular files and directories, so this patch does not affect them any more.
* Various documentation of the IOCTL grouping approach was removed, as it's not needed any more.

V9:
* in “landlock: Add IOCTL access right”:
* Change IOCTL group names and grouping as discussed with Mickaël. This makes the grouping coarser, and we occasionally rely on the underlying implementation to perform the appropriate read/write checks.
* Group IOCTL_RW (one of READ_FILE, WRITE_FILE or READ_DIR):
FIONREAD, FIOQSIZE, FIGETBSZ
* Group IOCTL_RWF (one of READ_FILE or WRITE_FILE):
FS_IOC_FIEMAP, FIBMAP, FIDEDUPERANGE, FICLONE, FICLONERANGE, FS_IOC_RESVSP, FS_IOC_RESVSP64, FS_IOC_UNRESVSP, FS_IOC_UNRESVSP64, FS_IOC_ZERO_RANGE
* Excempt pipe file descriptors from IOCTL restrictions, even for named pipes which are opened from the file system. This is to be consistent with anonymous pipes created with pipe(2). As discussed in https://lore.kernel.org/r/[email protected]
* Document rationale for the IOCTL grouping in the code
* Use __attribute_const__
* Rename required_ioctl_access() to get_required_ioctl_access()
* Selftests
* Simplify IOCTL test fixtures as a result of simpler grouping.
* Test that IOCTLs are permitted on named pipe FDs.
* Test that IOCTLs are permitted on named Unix Domain Socket FDs.
* Work around compilation issue with old GCC / glibc.
https://sourceware.org/glibc/wiki/Synchronizing_Headers
Thanks to Huyadi <[email protected]>, who pointed this out in
https://lore.kernel.org/all/[email protected]/
and Mickaël, who fixed it through #include reordering.
* Documentation changes
* Reword "IOCTL commands" section a bit
* s/permit/allow/
* s/access right/right/, if preceded by LANDLOCK_ACCESS_FS_*
* s/IOCTL/FS_IOCTL/ in ASCII table
* Update IOCTL grouping documentation in header file
* Removed a few of the earlier commits in this patch set, which have already been merged.

V8:
* Documentation changes
* userspace-api/landlock.rst:
* Add an extra paragraph about how the IOCTL right combines when used with other access rights.
* Explain better the circumstances under which passing of file descriptors between different Landlock domains can happen
* limits.h: Add comment to explain public vs internal FS access rights
* Add a paragraph in the commit to explain better why the IOCTL right works as it does

V7:
* in “landlock: Add IOCTL access right”:
* Make IOCTL_GROUPS a #define so that static_assert works even on old compilers (bug reported by Intel about PowerPC GCC9 config)
* Adapt indentation of IOCTL_GROUPS definition
* Add missing dots in kernel-doc comments.
* in “landlock: Remove remaining "inline" modifiers in .c files”:
* explain reasoning in commit message

V6:
* Implementation:
* Check that only publicly visible access rights can be used when adding a rule (rather than the synthetic ones). Thanks Mickaël for spotting that!
* Move all functionality related to IOCTL groups and synthetic access rights into the same place at the top of fs.c
* Move kernel doc to the .c file in one instance
* Smaller code style issues (upcase IOCTL, vardecl at block start)
* Remove inline modifier from functions in .c files
* Tests:
* use SKIP
* Rename 'fd' to dir_fd and file_fd where appropriate
* Remove duplicate "ioctl" mentions from test names
* Rename "permitted" to "allowed", in ioctl and ftruncate tests
* Do not add rules if access is 0, in test helper

V5:
* Implementation:
* move IOCTL group expansion logic into fs.c (implementation suggested by mic)
* rename IOCTL_CMD_G* constants to LANDLOCK_ACCESS_FS_IOCTL_GROUP*
* fs.c: create ioctl_groups constant
* add "const" to some variables
* Formatting and docstring fixes (including wrong kernel-doc format)
* samples/landlock: fix ABI version and fallback attribute (mic)
* Documentation
* move header documentation changes into the implementation commit
* spell out how FIFREEZE, FITHAW and attribute-manipulation ioctls from fs/ioctl.c are handled
* change ABI 4 to ABI 5 in some missing places

V4:
* use "synthetic" IOCTL access rights, as previously discussed
* testing changes
* use a large fixture-based test, for more exhaustive coverage, and replace some of the earlier tests with it
* rebased on mic-next

V3:
* always permit the IOCTL commands FIOCLEX, FIONCLEX, FIONBIO, FIOASYNC and FIONREAD, independent of LANDLOCK_ACCESS_FS_IOCTL
* increment ABI version in the same commit where the feature is introduced
* testing changes
* use FIOQSIZE instead of TTY IOCTL commands
(FIOQSIZE works with regular files, directories and memfds)
* run the memfd test with both Landlock enabled and disabled
* add a test for the always-permitted IOCTL commands

V2:
* rebased on mic-next
* added documentation
* exercise ioctl(2) in the memfd test
* test: Use layout0 for the test

---

V1: https://lore.kernel.org/all/[email protected]/
V2: https://lore.kernel.org/all/[email protected]/
V3: https://lore.kernel.org/all/[email protected]/
V4: https://lore.kernel.org/all/[email protected]/
V5: https://lore.kernel.org/all/[email protected]/
V6: https://lore.kernel.org/all/[email protected]/
V7: https://lore.kernel.org/all/[email protected]/
V8: https://lore.kernel.org/all/[email protected]/
V9: https://lore.kernel.org/all/[email protected]/
V10: https://lore.kernel.org/all/[email protected]/
V11: https://lore.kernel.org/all/[email protected]/
V12: https://lore.kernel.org/all/[email protected]/
V13: https://lore.kernel.org/all/[email protected]/
V14: https://lore.kernel.org/all/[email protected]/

Günther Noack (11):
landlock: Add IOCTL access right for character and block devices selftests/landlock: Test IOCTL support selftests/landlock: Test IOCTL with memfds selftests/landlock: Test ioctl(2) and ftruncate(2) with open(O_PATH) selftests/landlock: Test IOCTLs on named pipes selftests/landlock: Check IOCTL restrictions for named UNIX domain
sockets
selftests/landlock: Exhaustive test for the IOCTL allow-list samples/landlock: Add support for LANDLOCK_ACCESS_FS_IOCTL_DEV
landlock: Document IOCTL support
MAINTAINERS: Notify Landlock maintainers about changes to fs/ioctl.c fs/ioctl: Add a comment to keep the logic in sync with LSM policies

 Documentation/userspace-api/landlock.rst     |  76 ++-
 MAINTAINERS                                  |   1 +
 fs/ioctl.c                                   |   3 +
 include/uapi/linux/landlock.h                |  38 +-
 samples/landlock/sandboxer.c                 |  13 +-
 security/landlock/fs.c                       | 225 ++++++++-
 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   | 486 ++++++++++++++++++-
 10 files changed, 805 insertions(+), 43 deletions(-)

base-commit: fe611b72031cc211a96cf0b3b58838953950cb13

Signature · 1 line
2.44.0.769.g3c40516874-goog
author reviewer
#1 lore raw

PATCH v15 1/11 landlock: Add IOCTL access right for character and block devices

Introduces the LANDLOCK_ACCESS_FS_IOCTL_DEV right
and increments the Landlock ABI version to 5.

This access right applies to device-custom IOCTL commands when they are invoked on block or character device files.

Like the truncate right, this right is associated with a file descriptor at the time of open(2), and gets respected even when the file descriptor is used outside of the thread which it was originally opened in.

Therefore, a newly enabled Landlock policy does not apply to file descriptors which are already open.

If the LANDLOCK_ACCESS_FS_IOCTL_DEV right is handled, only a small number of safe IOCTL commands will be permitted on newly opened device files. These include FIOCLEX, FIONCLEX, FIONBIO and FIOASYNC, as well as other IOCTL commands for regular files which are implemented in fs/ioctl.c.

Noteworthy scenarios which require special attention:

TTY devices are often passed into a process from the parent process, and so a newly enabled Landlock policy does not retroactively apply to them automatically. In the past, TTY devices have often supported IOCTL commands like TIOCSTI and some TIOCLINUX subcommands, which were letting callers control the TTY input buffer (and simulate keypresses). This should be restricted to CAP_SYS_ADMIN programs on modern kernels though.

Known limitations:

The LANDLOCK_ACCESS_FS_IOCTL_DEV access right is a coarse-grained control over IOCTL commands.

Landlock users may use path-based restrictions in combination with their knowledge about the file system layout to control what IOCTLs can be done.

Cc Paul Moore <[email protected]>
Cc Christian Brauner <[email protected]>
Cc Arnd Bergmann <[email protected]>
---
 include/uapi/linux/landlock.h                |  38 +++-
 security/landlock/fs.c                       | 225 ++++++++++++++++++-
 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   |   5 +-
 6 files changed, 258 insertions(+), 16 deletions(-)
include/uapi/linux/landlock.h +30 -8
index 25c8d7677539..68625e728f43 100644
@@ -128,7 +128,7 @@ struct landlock_net_port_attr {
  * files and directories.  Files or directories opened before the sandboxing
  * are not subject to these restrictions.
  *
- * A file can only receive these access rights:
+ * The following access rights apply only to files:
  *
  * - %LANDLOCK_ACCESS_FS_EXECUTE: Execute a file.
  * - %LANDLOCK_ACCESS_FS_WRITE_FILE: Open a file with write access. Note that
@@ -138,12 +138,13 @@ struct landlock_net_port_attr {
  * - %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:`creat(2)`, or :manpage:`open(2)` with
- *   ``O_TRUNC``. Whether an opened file can be truncated with
- *   :manpage:`ftruncate(2)` is determined during :manpage:`open(2)`, in the
- *   same way as read and write permissions are checked during
- *   :manpage:`open(2)` using %LANDLOCK_ACCESS_FS_READ_FILE and
- *   %LANDLOCK_ACCESS_FS_WRITE_FILE. This access right is available since the
- *   third version of the Landlock ABI.
+ *   ``O_TRUNC``.  This access right is available since the third version of the
+ *   Landlock ABI.
+ *
+ * Whether an opened file can be truncated with :manpage:`ftruncate(2)` or used
+ * with `ioctl(2)` is determined during :manpage:`open(2)`, in the same way as
+ * read and write permissions are checked during :manpage:`open(2)` using
+ * %LANDLOCK_ACCESS_FS_READ_FILE and %LANDLOCK_ACCESS_FS_WRITE_FILE.
  *
  * A directory can receive access rights related to files or directories.  The
  * following access right is applied to the directory itself, and the
@@ -198,13 +199,33 @@ struct landlock_net_port_attr {
  *   If multiple requirements are not met, the ``EACCES`` error code takes
  *   precedence over ``EXDEV``.
  *
+ * The following access right applies both to files and directories:
+ *
+ * - %LANDLOCK_ACCESS_FS_IOCTL_DEV: Invoke :manpage:`ioctl(2)` commands on an opened
+ *   character or block device.
+ *
+ *   This access right applies to all `ioctl(2)` commands implemented by device
+ *   drivers.  However, the following common IOCTL commands continue to be
+ *   invokable independent of the %LANDLOCK_ACCESS_FS_IOCTL_DEV right:
+ *
+ *   * IOCTL commands targeting file descriptors (``FIOCLEX``, ``FIONCLEX``),
+ *   * IOCTL commands targeting file descriptions (``FIONBIO``, ``FIOASYNC``),
+ *   * IOCTL commands targeting file systems (``FIFREEZE``, ``FITHAW``,
+ *     ``FIGETBSZ``, ``FS_IOC_GETFSUUID``, ``FS_IOC_GETFSSYSFSPATH``)
+ *   * Some IOCTL commands which do not make sense when used with devices, but
+ *     whose implementations are safe and return the right error codes
+ *     (``FS_IOC_FIEMAP``, ``FICLONE``, ``FICLONERANGE``, ``FIDEDUPERANGE``)
+ *
+ *   This access right is available since the fifth version of the Landlock
+ *   ABI.
+ *
  * .. warning::
  *
  *   It is currently not possible to restrict some file-related actions
  *   accessible through these syscall families: :manpage:`chdir(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:`fcntl(2)`, :manpage:`access(2)`.
  *   Future Landlock evolutions will enable to restrict them.
  */
 /* clang-format off */
@@ -223,6 +244,7 @@ struct landlock_net_port_attr {
 #define LANDLOCK_ACCESS_FS_MAKE_SYM			(1ULL << 12)
 #define LANDLOCK_ACCESS_FS_REFER			(1ULL << 13)
 #define LANDLOCK_ACCESS_FS_TRUNCATE			(1ULL << 14)
+#define LANDLOCK_ACCESS_FS_IOCTL_DEV			(1ULL << 15)
 /* clang-format on */
 
 /**
security/landlock/fs.c +222 -3

284 lines not on this page · raw message

security/landlock/limits.h +1 -1
index 93c9c6f91556..20fdb5ff3514 100644
@@ -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_TRUNCATE
+#define LANDLOCK_LAST_ACCESS_FS		LANDLOCK_ACCESS_FS_IOCTL_DEV
 #define LANDLOCK_MASK_ACCESS_FS		((LANDLOCK_LAST_ACCESS_FS << 1) - 1)
 #define LANDLOCK_NUM_ACCESS_FS		__const_hweight64(LANDLOCK_MASK_ACCESS_FS)
 #define LANDLOCK_SHIFT_ACCESS_FS	0
security/landlock/syscalls.c +1 -1
index 6788e73b6681..03b470f5a85a 100644
@@ -149,7 +149,7 @@ static const struct file_operations ruleset_fops = {
 	.write = fop_dummy_write,
 };
 
-#define LANDLOCK_ABI_VERSION 4
+#define LANDLOCK_ABI_VERSION 5
 
 /**
  * sys_landlock_create_ruleset - Create a new ruleset
tools/testing/selftests/landlock/base_test.c +1 -1
index a6f89aaea77d..3c1e9f35b531 100644
@@ -75,7 +75,7 @@ TEST(abi_version)
 	const struct landlock_ruleset_attr ruleset_attr = {
 		.handled_access_fs = LANDLOCK_ACCESS_FS_READ_FILE,
 	};
-	ASSERT_EQ(4, landlock_create_ruleset(NULL, 0,
+	ASSERT_EQ(5, landlock_create_ruleset(NULL, 0,
 					     LANDLOCK_CREATE_RULESET_VERSION));
 
 	ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr, 0,
tools/testing/selftests/landlock/fs_test.c +3 -2
index 9a6036fbf289..418ad745a5dd 100644
@@ -529,9 +529,10 @@ TEST_F_FORK(layout1, inval)
 	LANDLOCK_ACCESS_FS_EXECUTE | \
 	LANDLOCK_ACCESS_FS_WRITE_FILE | \
 	LANDLOCK_ACCESS_FS_READ_FILE | \
-	LANDLOCK_ACCESS_FS_TRUNCATE)
+	LANDLOCK_ACCESS_FS_TRUNCATE | \
+	LANDLOCK_ACCESS_FS_IOCTL_DEV)
 
-#define ACCESS_LAST LANDLOCK_ACCESS_FS_TRUNCATE
+#define ACCESS_LAST LANDLOCK_ACCESS_FS_IOCTL_DEV
 
 #define ACCESS_ALL ( \
 	ACCESS_FILE | \
Signature · 1 line
2.44.0.769.g3c40516874-goog
author reviewer
#2 lore raw

PATCH v15 2/11 selftests/landlock: Test IOCTL support

In reply to Günther Noack

Exercises Landlock's IOCTL feature in different combinations of handling and permitting the LANDLOCK_ACCESS_FS_IOCTL_DEV right, and in different combinations of using files and directories.

---
 tools/testing/selftests/landlock/fs_test.c | 192 ++++++++++++++++++++-
 1 file changed, 189 insertions(+), 3 deletions(-)
tools/testing/selftests/landlock/fs_test.c +189 -3
index 418ad745a5dd..cb1382a887c9 100644
@@ -8,6 +8,7 @@
  */
 
 #define _GNU_SOURCE
+#include <asm/termbits.h>
 #include <fcntl.h>
 #include <linux/landlock.h>
 #include <linux/magic.h>
@@ -15,6 +16,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <sys/capability.h>
+#include <sys/ioctl.h>
 #include <sys/mount.h>
 #include <sys/prctl.h>
 #include <sys/sendfile.h>
@@ -23,6 +25,12 @@
 #include <sys/vfs.h>
 #include <unistd.h>
 
+/*
+ * Intentionally included last to work around header conflict.
+ * See https://sourceware.org/glibc/wiki/Synchronizing_Headers.
+ */
+#include <linux/fs.h>
+
 #include "common.h"
 
 #ifndef renameat2
@@ -737,6 +745,9 @@ static int create_ruleset(struct __test_metadata *const _metadata,
 	}
 
 	for (i = 0; rules[i].path; i++) {
+		if (!rules[i].access)
+			continue;
+
 		add_path_beneath(_metadata, ruleset_fd, rules[i].access,
 				 rules[i].path);
 	}
@@ -3445,7 +3456,7 @@ TEST_F_FORK(layout1, truncate_unhandled)
 			      LANDLOCK_ACCESS_FS_WRITE_FILE;
 	int ruleset_fd;
 
-	/* Enable Landlock. */
+	/* Enables Landlock. */
 	ruleset_fd = create_ruleset(_metadata, handled, rules);
 
 	ASSERT_LE(0, ruleset_fd);
@@ -3528,7 +3539,7 @@ TEST_F_FORK(layout1, truncate)
 			      LANDLOCK_ACCESS_FS_TRUNCATE;
 	int ruleset_fd;
 
-	/* Enable Landlock. */
+	/* Enables Landlock. */
 	ruleset_fd = create_ruleset(_metadata, handled, rules);
 
 	ASSERT_LE(0, ruleset_fd);
@@ -3754,7 +3765,7 @@ TEST_F_FORK(ftruncate, open_and_ftruncate)
 	};
 	int fd, ruleset_fd;
 
-	/* Enable Landlock. */
+	/* Enables Landlock. */
 	ruleset_fd = create_ruleset(_metadata, variant->handled, rules);
 	ASSERT_LE(0, ruleset_fd);
 	enforce_ruleset(_metadata, ruleset_fd);
@@ -3847,6 +3858,181 @@ TEST(memfd_ftruncate)
 	ASSERT_EQ(0, close(fd));
 }
 
+static int test_fionread_ioctl(int fd)
+{
+	size_t sz = 0;
+
+	if (ioctl(fd, FIONREAD, &sz) < 0 && errno == EACCES)
+		return errno;
+	return 0;
+}
+
+/* clang-format off */
+FIXTURE(ioctl) {};
+
+FIXTURE_SETUP(ioctl) {};
+
+FIXTURE_TEARDOWN(ioctl) {};
+/* clang-format on */
+
+FIXTURE_VARIANT(ioctl)
+{
+	const __u64 handled;
+	const __u64 allowed;
+	const mode_t open_mode;
+	/*
+	 * FIONREAD is used as a characteristic device-specific IOCTL command.
+	 * It is implemented in fs/ioctl.c for regular files,
+	 * but we do not blanket-permit it for devices.
+	 */
+	const int expected_fionread_result;
+};
+
+/* clang-format off */
+FIXTURE_VARIANT_ADD(ioctl, handled_i_allowed_none) {
+	/* clang-format on */
+	.handled = LANDLOCK_ACCESS_FS_IOCTL_DEV,
+	.allowed = 0,
+	.open_mode = O_RDWR,
+	.expected_fionread_result = EACCES,
+};
+
+/* clang-format off */
+FIXTURE_VARIANT_ADD(ioctl, handled_i_allowed_i) {
+	/* clang-format on */
+	.handled = LANDLOCK_ACCESS_FS_IOCTL_DEV,
+	.allowed = LANDLOCK_ACCESS_FS_IOCTL_DEV,
+	.open_mode = O_RDWR,
+	.expected_fionread_result = 0,
+};
+
+/* clang-format off */
+FIXTURE_VARIANT_ADD(ioctl, unhandled) {
+	/* clang-format on */
+	.handled = LANDLOCK_ACCESS_FS_EXECUTE,
+	.allowed = LANDLOCK_ACCESS_FS_EXECUTE,
+	.open_mode = O_RDWR,
+	.expected_fionread_result = 0,
+};
+
+TEST_F_FORK(ioctl, handle_dir_access_file)
+{
+	const int flag = 0;
+	const struct rule rules[] = {
+		{
+			.path = "/dev",
+			.access = variant->allowed,
+		},
+		{},
+	};
+	int file_fd, ruleset_fd;
+
+	/* Enables Landlock. */
+	ruleset_fd = create_ruleset(_metadata, variant->handled, rules);
+	ASSERT_LE(0, ruleset_fd);
+	enforce_ruleset(_metadata, ruleset_fd);
+	ASSERT_EQ(0, close(ruleset_fd));
+
+	file_fd = open("/dev/zero", variant->open_mode);
+	ASSERT_LE(0, file_fd);
+
+	/* Checks that IOCTL commands return the expected errors. */
+	EXPECT_EQ(variant->expected_fionread_result,
+		  test_fionread_ioctl(file_fd));
+
+	/* Checks that unrestrictable commands are unrestricted. */
+	EXPECT_EQ(0, ioctl(file_fd, FIOCLEX));
+	EXPECT_EQ(0, ioctl(file_fd, FIONCLEX));
+	EXPECT_EQ(0, ioctl(file_fd, FIONBIO, &flag));
+	EXPECT_EQ(0, ioctl(file_fd, FIOASYNC, &flag));
+	EXPECT_EQ(0, ioctl(file_fd, FIGETBSZ, &flag));
+
+	ASSERT_EQ(0, close(file_fd));
+}
+
+TEST_F_FORK(ioctl, handle_dir_access_dir)
+{
+	const int flag = 0;
+	const struct rule rules[] = {
+		{
+			.path = "/dev",
+			.access = variant->allowed,
+		},
+		{},
+	};
+	int dir_fd, ruleset_fd;
+
+	/* Enables Landlock. */
+	ruleset_fd = create_ruleset(_metadata, variant->handled, rules);
+	ASSERT_LE(0, ruleset_fd);
+	enforce_ruleset(_metadata, ruleset_fd);
+	ASSERT_EQ(0, close(ruleset_fd));
+
+	/*
+	 * Ignore variant->open_mode for this test, as we intend to open a
+	 * directory.  If the directory can not be opened, the variant is
+	 * infeasible to test with an opened directory.
+	 */
+	dir_fd = open("/dev", O_RDONLY);
+	if (dir_fd < 0)
+		return;
+
+	/*
+	 * Checks that IOCTL commands return the expected errors.
+	 * We do not use the expected values from the fixture here.
+	 *
+	 * When using IOCTL on a directory, no Landlock restrictions apply.
+	 */
+	EXPECT_EQ(0, test_fionread_ioctl(dir_fd));
+
+	/* Checks that unrestrictable commands are unrestricted. */
+	EXPECT_EQ(0, ioctl(dir_fd, FIOCLEX));
+	EXPECT_EQ(0, ioctl(dir_fd, FIONCLEX));
+	EXPECT_EQ(0, ioctl(dir_fd, FIONBIO, &flag));
+	EXPECT_EQ(0, ioctl(dir_fd, FIOASYNC, &flag));
+	EXPECT_EQ(0, ioctl(dir_fd, FIGETBSZ, &flag));
+
+	ASSERT_EQ(0, close(dir_fd));
+}
+
+TEST_F_FORK(ioctl, handle_file_access_file)
+{
+	const int flag = 0;
+	const struct rule rules[] = {
+		{
+			.path = "/dev/zero",
+			.access = variant->allowed,
+		},
+		{},
+	};
+	int file_fd, ruleset_fd;
+
+	/* Enables Landlock. */
+	ruleset_fd = create_ruleset(_metadata, variant->handled, rules);
+	ASSERT_LE(0, ruleset_fd);
+	enforce_ruleset(_metadata, ruleset_fd);
+	ASSERT_EQ(0, close(ruleset_fd));
+
+	file_fd = open("/dev/zero", variant->open_mode);
+	ASSERT_LE(0, file_fd)
+	{
+		TH_LOG("Failed to open /dev/zero: %s", strerror(errno));
+	}
+
+	/* Checks that IOCTL commands return the expected errors. */
+	EXPECT_EQ(variant->expected_fionread_result,
+		  test_fionread_ioctl(file_fd));
+
+	/* Checks that unrestrictable commands are unrestricted. */
+	EXPECT_EQ(0, ioctl(file_fd, FIOCLEX));
+	EXPECT_EQ(0, ioctl(file_fd, FIONCLEX));
+	EXPECT_EQ(0, ioctl(file_fd, FIONBIO, &flag));
+	EXPECT_EQ(0, ioctl(file_fd, FIOASYNC, &flag));
+	EXPECT_EQ(0, ioctl(file_fd, FIGETBSZ, &flag));
+
+	ASSERT_EQ(0, close(file_fd));
+}
+
 /* clang-format off */
 FIXTURE(layout1_bind) {};
 /* clang-format on */
Signature · 1 line
2.44.0.769.g3c40516874-goog
author reviewer
#3 lore raw

PATCH v15 3/11 selftests/landlock: Test IOCTL with memfds

In reply to Günther Noack

Because the LANDLOCK_ACCESS_FS_IOCTL_DEV right is associated with the opened file during open(2), IOCTLs are supposed to work with files which are opened by means other than open(2).

---
 tools/testing/selftests/landlock/fs_test.c | 44 ++++++++++++++++++----
 1 file changed, 36 insertions(+), 8 deletions(-)
tools/testing/selftests/landlock/fs_test.c +36 -8
index cb1382a887c9..6967e02ba3cb 100644
@@ -3842,20 +3842,48 @@ TEST_F_FORK(ftruncate, open_and_ftruncate_in_different_processes)
 	ASSERT_EQ(0, close(socket_fds[1]));
 }
 
-TEST(memfd_ftruncate)
+/* Invokes the FS_IOC_GETFLAGS IOCTL and returns its errno or 0. */
+static int test_fs_ioc_getflags_ioctl(int fd)
 {
-	int fd;
+	uint32_t flags;
+
+	if (ioctl(fd, FS_IOC_GETFLAGS, &flags) < 0)
+		return errno;
+	return 0;
+}
 
-	fd = memfd_create("name", MFD_CLOEXEC);
-	ASSERT_LE(0, fd);
+TEST(memfd_ftruncate_and_ioctl)
+{
+	const struct landlock_ruleset_attr attr = {
+		.handled_access_fs = ACCESS_ALL,
+	};
+	int ruleset_fd, fd, i;
 
 	/*
-	 * Checks that ftruncate is permitted on file descriptors that are
-	 * created in ways other than open(2).
+	 * We exercise the same test both with and without Landlock enabled, to
+	 * ensure that it behaves the same in both cases.
 	 */
-	EXPECT_EQ(0, test_ftruncate(fd));
+	for (i = 0; i < 2; i++) {
+		/* Creates a new memfd. */
+		fd = memfd_create("name", MFD_CLOEXEC);
+		ASSERT_LE(0, fd);
 
-	ASSERT_EQ(0, close(fd));
+		/*
+		 * Checks that operations associated with the opened file
+		 * (ftruncate, ioctl) are permitted on file descriptors that are
+		 * created in ways other than open(2).
+		 */
+		EXPECT_EQ(0, test_ftruncate(fd));
+		EXPECT_EQ(0, test_fs_ioc_getflags_ioctl(fd));
+
+		ASSERT_EQ(0, close(fd));
+
+		/* Enables Landlock. */
+		ruleset_fd = landlock_create_ruleset(&attr, sizeof(attr), 0);
+		ASSERT_LE(0, ruleset_fd);
+		enforce_ruleset(_metadata, ruleset_fd);
+		ASSERT_EQ(0, close(ruleset_fd));
+	}
 }
 
 static int test_fionread_ioctl(int fd)
Signature · 1 line
2.44.0.769.g3c40516874-goog
author reviewer
#4 lore raw

PATCH v15 4/11 selftests/landlock: Test ioctl(2) and ftruncate(2) with open(O_PATH)

In reply to Günther Noack

ioctl(2) and ftruncate(2) operations on files opened with O_PATH should always return EBADF, independent of the LANDLOCK_ACCESS_FS_TRUNCATE and LANDLOCK_ACCESS_FS_IOCTL_DEV access rights in that file hierarchy.

---
 tools/testing/selftests/landlock/fs_test.c | 40 ++++++++++++++++++++++
 1 file changed, 40 insertions(+)
tools/testing/selftests/landlock/fs_test.c +40 -0
index 6967e02ba3cb..2cfda6af71ab 100644
@@ -3895,6 +3895,46 @@ static int test_fionread_ioctl(int fd)
 	return 0;
 }
 
+TEST_F_FORK(layout1, o_path_ftruncate_and_ioctl)
+{
+	const struct landlock_ruleset_attr attr = {
+		.handled_access_fs = ACCESS_ALL,
+	};
+	int ruleset_fd, fd;
+
+	/*
+	 * Checks that for files opened with O_PATH, both ioctl(2) and
+	 * ftruncate(2) yield EBADF, as it is documented in open(2) for the
+	 * O_PATH flag.
+	 */
+	fd = open(dir_s1d1, O_PATH | O_CLOEXEC);
+	ASSERT_LE(0, fd);
+
+	EXPECT_EQ(EBADF, test_ftruncate(fd));
+	EXPECT_EQ(EBADF, test_fs_ioc_getflags_ioctl(fd));
+
+	ASSERT_EQ(0, close(fd));
+
+	/* Enables Landlock. */
+	ruleset_fd = landlock_create_ruleset(&attr, sizeof(attr), 0);
+	ASSERT_LE(0, ruleset_fd);
+	enforce_ruleset(_metadata, ruleset_fd);
+	ASSERT_EQ(0, close(ruleset_fd));
+
+	/*
+	 * Checks that after enabling Landlock,
+	 * - the file can still be opened with O_PATH
+	 * - both ioctl and truncate still yield EBADF (not EACCES).
+	 */
+	fd = open(dir_s1d1, O_PATH | O_CLOEXEC);
+	ASSERT_LE(0, fd);
+
+	EXPECT_EQ(EBADF, test_ftruncate(fd));
+	EXPECT_EQ(EBADF, test_fs_ioc_getflags_ioctl(fd));
+
+	ASSERT_EQ(0, close(fd));
+}
+
 /* clang-format off */
 FIXTURE(ioctl) {};
 
Signature · 1 line
2.44.0.769.g3c40516874-goog
author reviewer
#5 lore raw

PATCH v15 5/11 selftests/landlock: Test IOCTLs on named pipes

In reply to Günther Noack

Named pipes should behave like pipes created with pipe(2), so we don't want to restrict IOCTLs on them.

---
 tools/testing/selftests/landlock/fs_test.c | 43 ++++++++++++++++++++++
 1 file changed, 43 insertions(+)
tools/testing/selftests/landlock/fs_test.c +43 -0
index 2cfda6af71ab..f4c6b9fadef8 100644
@@ -3935,6 +3935,49 @@ TEST_F_FORK(layout1, o_path_ftruncate_and_ioctl)
 	ASSERT_EQ(0, close(fd));
 }
 
+/*
+ * Named pipes are not governed by the LANDLOCK_ACCESS_FS_IOCTL_DEV right,
+ * because they are not character or block devices.
+ */
+TEST_F_FORK(layout1, named_pipe_ioctl)
+{
+	pid_t child_pid;
+	int fd, ruleset_fd;
+	const char *const path = file1_s1d1;
+	const struct landlock_ruleset_attr attr = {
+		.handled_access_fs = LANDLOCK_ACCESS_FS_IOCTL_DEV,
+	};
+
+	ASSERT_EQ(0, unlink(path));
+	ASSERT_EQ(0, mkfifo(path, 0600));
+
+	/* Enables Landlock. */
+	ruleset_fd = landlock_create_ruleset(&attr, sizeof(attr), 0);
+	ASSERT_LE(0, ruleset_fd);
+	enforce_ruleset(_metadata, ruleset_fd);
+	ASSERT_EQ(0, close(ruleset_fd));
+
+	/* The child process opens the pipe for writing. */
+	child_pid = fork();
+	ASSERT_NE(-1, child_pid);
+	if (child_pid == 0) {
+		fd = open(path, O_WRONLY);
+		close(fd);
+		exit(0);
+	}
+
+	fd = open(path, O_RDONLY);
+	ASSERT_LE(0, fd);
+
+	/* FIONREAD is implemented by pipefifo_fops. */
+	EXPECT_EQ(0, test_fionread_ioctl(fd));
+
+	ASSERT_EQ(0, close(fd));
+	ASSERT_EQ(0, unlink(path));
+
+	ASSERT_EQ(child_pid, waitpid(child_pid, NULL, 0));
+}
+
 /* clang-format off */
 FIXTURE(ioctl) {};
 
Signature · 1 line
2.44.0.769.g3c40516874-goog
author reviewer
#6 lore raw

PATCH v15 6/11 selftests/landlock: Check IOCTL restrictions for named UNIX domain sockets

In reply to Günther Noack

The LANDLOCK_ACCESS_FS_IOCTL_DEV right should have no effect on the use of named UNIX domain sockets.

---
 tools/testing/selftests/landlock/fs_test.c | 52 ++++++++++++++++++++++
 1 file changed, 52 insertions(+)
tools/testing/selftests/landlock/fs_test.c +52 -0
index f4c6b9fadef8..232ab02f829d 100644
@@ -20,8 +20,10 @@
 #include <sys/mount.h>
 #include <sys/prctl.h>
 #include <sys/sendfile.h>
+#include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/sysmacros.h>
+#include <sys/un.h>
 #include <sys/vfs.h>
 #include <unistd.h>
 
@@ -3978,6 +3980,56 @@ TEST_F_FORK(layout1, named_pipe_ioctl)
 	ASSERT_EQ(child_pid, waitpid(child_pid, NULL, 0));
 }
 
+/* For named UNIX domain sockets, no IOCTL restrictions apply. */
+TEST_F_FORK(layout1, named_unix_domain_socket_ioctl)
+{
+	const char *const path = file1_s1d1;
+	int srv_fd, cli_fd, ruleset_fd;
+	socklen_t size;
+	struct sockaddr_un srv_un, cli_un;
+	const struct landlock_ruleset_attr attr = {
+		.handled_access_fs = LANDLOCK_ACCESS_FS_IOCTL_DEV,
+	};
+
+	/* Sets up a server */
+	srv_un.sun_family = AF_UNIX;
+	strncpy(srv_un.sun_path, path, sizeof(srv_un.sun_path));
+
+	ASSERT_EQ(0, unlink(path));
+	srv_fd = socket(AF_UNIX, SOCK_STREAM, 0);
+	ASSERT_LE(0, srv_fd);
+
+	size = offsetof(struct sockaddr_un, sun_path) + strlen(srv_un.sun_path);
+	ASSERT_EQ(0, bind(srv_fd, (struct sockaddr *)&srv_un, size));
+	ASSERT_EQ(0, listen(srv_fd, 10 /* qlen */));
+
+	/* Enables Landlock. */
+	ruleset_fd = landlock_create_ruleset(&attr, sizeof(attr), 0);
+	ASSERT_LE(0, ruleset_fd);
+	enforce_ruleset(_metadata, ruleset_fd);
+	ASSERT_EQ(0, close(ruleset_fd));
+
+	/* Sets up a client connection to it */
+	cli_un.sun_family = AF_UNIX;
+	cli_fd = socket(AF_UNIX, SOCK_STREAM, 0);
+	ASSERT_LE(0, cli_fd);
+
+	size = offsetof(struct sockaddr_un, sun_path) + strlen(cli_un.sun_path);
+	ASSERT_EQ(0, bind(cli_fd, (struct sockaddr *)&cli_un, size));
+
+	bzero(&cli_un, sizeof(cli_un));
+	cli_un.sun_family = AF_UNIX;
+	strncpy(cli_un.sun_path, path, sizeof(cli_un.sun_path));
+	size = offsetof(struct sockaddr_un, sun_path) + strlen(cli_un.sun_path);
+
+	ASSERT_EQ(0, connect(cli_fd, (struct sockaddr *)&cli_un, size));
+
+	/* FIONREAD and other IOCTLs should not be forbidden. */
+	EXPECT_EQ(0, test_fionread_ioctl(cli_fd));
+
+	ASSERT_EQ(0, close(cli_fd));
+}
+
 /* clang-format off */
 FIXTURE(ioctl) {};
 
Signature · 1 line
2.44.0.769.g3c40516874-goog
author reviewer
#7 lore raw

PATCH v15 7/11 selftests/landlock: Exhaustive test for the IOCTL allow-list

In reply to Günther Noack

This test checks all IOCTL commands implemented in do_vfs_ioctl().

---
 tools/testing/selftests/landlock/fs_test.c | 114 +++++++++++++++++++++
 1 file changed, 114 insertions(+)
tools/testing/selftests/landlock/fs_test.c +114 -0
index 232ab02f829d..beb79154a679 100644
@@ -10,6 +10,7 @@
 #define _GNU_SOURCE
 #include <asm/termbits.h>
 #include <fcntl.h>
+#include <linux/fiemap.h>
 #include <linux/landlock.h>
 #include <linux/magic.h>
 #include <sched.h>
@@ -3937,6 +3938,119 @@ TEST_F_FORK(layout1, o_path_ftruncate_and_ioctl)
 	ASSERT_EQ(0, close(fd));
 }
 
+/*
+ * ioctl_error - generically call the given ioctl with a pointer to a
+ * sufficiently large zeroed-out memory region.
+ *
+ * Returns the IOCTLs error, or 0.
+ */
+static int ioctl_error(struct __test_metadata *const _metadata, int fd,
+		       unsigned int cmd)
+{
+	char buf[128]; /* sufficiently large */
+	int res, stdinbak_fd;
+
+	/*
+	 * Depending on the IOCTL command, parts of the zeroed-out buffer might
+	 * be interpreted as file descriptor numbers.  We do not want to
+	 * accidentally operate on file descriptor 0 (stdin), so we temporarily
+	 * move stdin to a different FD and close FD 0 for the IOCTL call.
+	 */
+	stdinbak_fd = dup(0);
+	ASSERT_LT(0, stdinbak_fd);
+	ASSERT_EQ(0, close(0));
+
+	/* Invokes the IOCTL with a zeroed-out buffer. */
+	bzero(&buf, sizeof(buf));
+	res = ioctl(fd, cmd, &buf);
+
+	/* Restores the old FD 0 and closes the backup FD. */
+	ASSERT_EQ(0, dup2(stdinbak_fd, 0));
+	ASSERT_EQ(0, close(stdinbak_fd));
+
+	if (res < 0)
+		return errno;
+
+	return 0;
+}
+
+/* Define some linux/falloc.h IOCTL commands which are not available in uapi headers. */
+struct space_resv {
+	__s16 l_type;
+	__s16 l_whence;
+	__s64 l_start;
+	__s64 l_len; /* len == 0 means until end of file */
+	__s32 l_sysid;
+	__u32 l_pid;
+	__s32 l_pad[4]; /* reserved area */
+};
+
+#define FS_IOC_RESVSP _IOW('X', 40, struct space_resv)
+#define FS_IOC_UNRESVSP _IOW('X', 41, struct space_resv)
+#define FS_IOC_RESVSP64 _IOW('X', 42, struct space_resv)
+#define FS_IOC_UNRESVSP64 _IOW('X', 43, struct space_resv)
+#define FS_IOC_ZERO_RANGE _IOW('X', 57, struct space_resv)
+
+/*
+ * Tests a series of blanket-permitted and denied IOCTLs.
+ */
+TEST_F_FORK(layout1, blanket_permitted_ioctls)
+{
+	const struct landlock_ruleset_attr attr = {
+		.handled_access_fs = LANDLOCK_ACCESS_FS_IOCTL_DEV,
+	};
+	int ruleset_fd, fd;
+
+	/* Enables Landlock. */
+	ruleset_fd = landlock_create_ruleset(&attr, sizeof(attr), 0);
+	ASSERT_LE(0, ruleset_fd);
+	enforce_ruleset(_metadata, ruleset_fd);
+	ASSERT_EQ(0, close(ruleset_fd));
+
+	fd = open("/dev/null", O_RDWR | O_CLOEXEC);
+	ASSERT_LE(0, fd);
+
+	/*
+	 * Checks permitted commands.
+	 * These ones may return errors, but should not be blocked by Landlock.
+	 */
+	EXPECT_NE(EACCES, ioctl_error(_metadata, fd, FIOCLEX));
+	EXPECT_NE(EACCES, ioctl_error(_metadata, fd, FIONCLEX));
+	EXPECT_NE(EACCES, ioctl_error(_metadata, fd, FIONBIO));
+	EXPECT_NE(EACCES, ioctl_error(_metadata, fd, FIOASYNC));
+	EXPECT_NE(EACCES, ioctl_error(_metadata, fd, FIOQSIZE));
+	EXPECT_NE(EACCES, ioctl_error(_metadata, fd, FIFREEZE));
+	EXPECT_NE(EACCES, ioctl_error(_metadata, fd, FITHAW));
+	EXPECT_NE(EACCES, ioctl_error(_metadata, fd, FS_IOC_FIEMAP));
+	EXPECT_NE(EACCES, ioctl_error(_metadata, fd, FIGETBSZ));
+	EXPECT_NE(EACCES, ioctl_error(_metadata, fd, FICLONE));
+	EXPECT_NE(EACCES, ioctl_error(_metadata, fd, FICLONERANGE));
+	EXPECT_NE(EACCES, ioctl_error(_metadata, fd, FIDEDUPERANGE));
+	EXPECT_NE(EACCES, ioctl_error(_metadata, fd, FS_IOC_GETFSUUID));
+	EXPECT_NE(EACCES, ioctl_error(_metadata, fd, FS_IOC_GETFSSYSFSPATH));
+
+	/*
+	 * Checks blocked commands.
+	 * A call to a blocked IOCTL command always returns EACCES.
+	 */
+	EXPECT_EQ(EACCES, ioctl_error(_metadata, fd, FIONREAD));
+	EXPECT_EQ(EACCES, ioctl_error(_metadata, fd, FS_IOC_GETFLAGS));
+	EXPECT_EQ(EACCES, ioctl_error(_metadata, fd, FS_IOC_SETFLAGS));
+	EXPECT_EQ(EACCES, ioctl_error(_metadata, fd, FS_IOC_FSGETXATTR));
+	EXPECT_EQ(EACCES, ioctl_error(_metadata, fd, FS_IOC_FSSETXATTR));
+	EXPECT_EQ(EACCES, ioctl_error(_metadata, fd, FIBMAP));
+	EXPECT_EQ(EACCES, ioctl_error(_metadata, fd, FS_IOC_RESVSP));
+	EXPECT_EQ(EACCES, ioctl_error(_metadata, fd, FS_IOC_RESVSP64));
+	EXPECT_EQ(EACCES, ioctl_error(_metadata, fd, FS_IOC_UNRESVSP));
+	EXPECT_EQ(EACCES, ioctl_error(_metadata, fd, FS_IOC_UNRESVSP64));
+	EXPECT_EQ(EACCES, ioctl_error(_metadata, fd, FS_IOC_ZERO_RANGE));
+
+	/* Default case is also blocked. */
+	EXPECT_EQ(EACCES, ioctl_error(_metadata, fd, 0xc00ffeee));
+
+	ASSERT_EQ(0, close(fd));
+}
+
 /*
  * Named pipes are not governed by the LANDLOCK_ACCESS_FS_IOCTL_DEV right,
  * because they are not character or block devices.
Signature · 1 line
2.44.0.769.g3c40516874-goog
author reviewer
#8 lore raw

PATCH v15 8/11 samples/landlock: Add support for LANDLOCK_ACCESS_FS_IOCTL_DEV

In reply to Günther Noack

Add IOCTL support to the Landlock sample tool.

The IOCTL right is grouped with the read-write rights in the sample tool, as some IOCTL requests provide features that mutate state.

---
 samples/landlock/sandboxer.c | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)
samples/landlock/sandboxer.c +10 -3
index 8b8ecd65c28c..e8223c3e781a 100644
@@ -81,7 +81,8 @@ static int parse_path(char *env_path, const char ***const path_list)
 	LANDLOCK_ACCESS_FS_EXECUTE | \
 	LANDLOCK_ACCESS_FS_WRITE_FILE | \
 	LANDLOCK_ACCESS_FS_READ_FILE | \
-	LANDLOCK_ACCESS_FS_TRUNCATE)
+	LANDLOCK_ACCESS_FS_TRUNCATE | \
+	LANDLOCK_ACCESS_FS_IOCTL_DEV)
 
 /* clang-format on */
 
@@ -202,11 +203,12 @@ static int populate_ruleset_net(const char *const env_var, const int ruleset_fd,
 	LANDLOCK_ACCESS_FS_MAKE_BLOCK | \
 	LANDLOCK_ACCESS_FS_MAKE_SYM | \
 	LANDLOCK_ACCESS_FS_REFER | \
-	LANDLOCK_ACCESS_FS_TRUNCATE)
+	LANDLOCK_ACCESS_FS_TRUNCATE | \
+	LANDLOCK_ACCESS_FS_IOCTL_DEV)
 
 /* clang-format on */
 
-#define LANDLOCK_ABI_LAST 4
+#define LANDLOCK_ABI_LAST 5
 
 int main(const int argc, char *const argv[], char *const *const envp)
 {
@@ -320,6 +322,11 @@ int main(const int argc, char *const argv[], char *const *const envp)
 		ruleset_attr.handled_access_net &=
 			~(LANDLOCK_ACCESS_NET_BIND_TCP |
 			  LANDLOCK_ACCESS_NET_CONNECT_TCP);
+		__attribute__((fallthrough));
+	case 4:
+		/* Removes LANDLOCK_ACCESS_FS_IOCTL_DEV for ABI < 5 */
+		ruleset_attr.handled_access_fs &= ~LANDLOCK_ACCESS_FS_IOCTL_DEV;
+
 		fprintf(stderr,
 			"Hint: You should update the running kernel "
 			"to leverage Landlock features "
Signature · 1 line
2.44.0.769.g3c40516874-goog
author reviewer
#9 lore raw

PATCH v15 9/11 landlock: Document IOCTL support

In reply to Günther Noack

In the paragraph above the fallback logic, use the shorter phrasing from the landlock(7) man page.

---
 Documentation/userspace-api/landlock.rst | 76 +++++++++++++++++++-----
 1 file changed, 61 insertions(+), 15 deletions(-)
Documentation/userspace-api/landlock.rst +61 -15
index 9dd636aaa829..145bd869c684 100644
@@ -76,7 +76,8 @@ to be explicit about the denied-by-default access rights.
             LANDLOCK_ACCESS_FS_MAKE_BLOCK |
             LANDLOCK_ACCESS_FS_MAKE_SYM |
             LANDLOCK_ACCESS_FS_REFER |
-            LANDLOCK_ACCESS_FS_TRUNCATE,
+            LANDLOCK_ACCESS_FS_TRUNCATE |
+            LANDLOCK_ACCESS_FS_IOCTL_DEV,
         .handled_access_net =
             LANDLOCK_ACCESS_NET_BIND_TCP |
             LANDLOCK_ACCESS_NET_CONNECT_TCP,
@@ -85,10 +86,10 @@ to be explicit about the denied-by-default access rights.
 Because we may not know on which kernel version an application will be
 executed, it is safer to follow a best-effort security approach.  Indeed, we
 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 access rights which are only supported in higher versions of the ABI.
+using.
+
+To be compatible with older Linux versions, we detect the available Landlock ABI
+version, and only use the available subset of access rights:
 
 .. code-block:: c
 
@@ -114,6 +115,10 @@ remove access rights which are only supported in higher versions of the ABI.
         ruleset_attr.handled_access_net &=
             ~(LANDLOCK_ACCESS_NET_BIND_TCP |
               LANDLOCK_ACCESS_NET_CONNECT_TCP);
+        __attribute__((fallthrough));
+    case 4:
+        /* Removes LANDLOCK_ACCESS_FS_IOCTL_DEV for ABI < 5 */
+        ruleset_attr.handled_access_fs &= ~LANDLOCK_ACCESS_FS_IOCTL_DEV;
     }
 
 This enables to create an inclusive ruleset that will contain our rules.
@@ -225,6 +230,7 @@ access rights per directory enables to change the location of such directory
 without relying on the destination directory access rights (except those that
 are required for this operation, see ``LANDLOCK_ACCESS_FS_REFER``
 documentation).
+
 Having self-sufficient hierarchies also helps to tighten the required access
 rights to the minimal set of data.  This also helps avoid sinkhole directories,
 i.e.  directories where data can be linked to but not linked from.  However,
@@ -318,18 +324,26 @@ It should also be noted that truncating files does not require the
 system call, this can also be done through :manpage:`open(2)` with the flags
 ``O_RDONLY | O_TRUNC``.
 
-When opening a file, the availability of the ``LANDLOCK_ACCESS_FS_TRUNCATE``
-right is associated with the newly created file descriptor and will be used for
-subsequent truncation attempts using :manpage:`ftruncate(2)`.  The behavior is
-similar to opening a file for reading or writing, where permissions are checked
-during :manpage:`open(2)`, but not during the subsequent :manpage:`read(2)` and
+The truncate right is associated with the opened file (see below).
+
+Rights associated with file descriptors
+---------------------------------------
+
+When opening a file, the availability of the ``LANDLOCK_ACCESS_FS_TRUNCATE`` and
+``LANDLOCK_ACCESS_FS_IOCTL_DEV`` rights is associated with the newly created
+file descriptor and will be used for subsequent truncation and ioctl attempts
+using :manpage:`ftruncate(2)` and :manpage:`ioctl(2)`.  The behavior is similar
+to opening a file for reading or writing, where permissions are checked during
+:manpage:`open(2)`, but not during the subsequent :manpage:`read(2)` and
 :manpage:`write(2)` calls.
 
-As a consequence, it is possible to have multiple open file descriptors for the
-same file, where one grants the right to truncate the file and the other does
-not.  It is also possible to pass such file descriptors between processes,
-keeping their Landlock properties, even when these processes do not have an
-enforced Landlock ruleset.
+As a consequence, it is possible that a process has multiple open file
+descriptors referring to the same file, but Landlock enforces different things
+when operating with these file descriptors.  This can happen when a Landlock
+ruleset gets enforced and the process keeps file descriptors which were opened
+both before and after the enforcement.  It is also possible to pass such file
+descriptors between processes, keeping their Landlock properties, even when some
+of the involved processes do not have an enforced Landlock ruleset.
 
 Compatibility
 =============
@@ -458,6 +472,28 @@ Memory usage
 Kernel memory allocated to create rulesets is accounted and can be restricted
 by the Documentation/admin-guide/cgroup-v1/memory.rst.
 
+IOCTL support
+-------------
+
+The ``LANDLOCK_ACCESS_FS_IOCTL_DEV`` right restricts the use of
+:manpage:`ioctl(2)`, but it only applies to *newly opened* device files.  This
+means specifically that pre-existing file descriptors like stdin, stdout and
+stderr are unaffected.
+
+Users should be aware that TTY devices have traditionally permitted to control
+other processes on the same TTY through the ``TIOCSTI`` and ``TIOCLINUX`` IOCTL
+commands.  Both of these require ``CAP_SYS_ADMIN`` on modern Linux systems, but
+the behavior is configurable for ``TIOCSTI``.
+
+On older systems, it is therefore recommended to close inherited TTY file
+descriptors, or to reopen them from ``/proc/self/fd/*`` without the
+``LANDLOCK_ACCESS_FS_IOCTL_DEV`` right, if possible.
+
+Landlock's IOCTL support is coarse-grained at the moment, but may become more
+fine-grained in the future.  Until then, users are advised to establish the
+guarantees that they need through the file hierarchy, by only allowing the
+``LANDLOCK_ACCESS_FS_IOCTL_DEV`` right on files where it is really required.
+
 Previous limitations
 ====================
 
@@ -495,6 +531,16 @@ bind and connect actions to only a set of allowed ports thanks to the new
 ``LANDLOCK_ACCESS_NET_BIND_TCP`` and ``LANDLOCK_ACCESS_NET_CONNECT_TCP``
 access rights.
 
+IOCTL (ABI < 5)
+---------------
+
+IOCTL operations could not be denied before the fifth Landlock ABI, so
+:manpage:`ioctl(2)` is always allowed when using a kernel that only supports an
+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`` access right.
+
 .. _kernel_support:
 
 Kernel support
Signature · 1 line
2.44.0.769.g3c40516874-goog
author reviewer
#10 lore raw

PATCH v15 10/11 MAINTAINERS: Notify Landlock maintainers about changes to fs/ioctl.c

In reply to Günther Noack

Landlock needs to track changes to do_vfs_ioctl() when new IOCTL implementations are added to it.

---
 MAINTAINERS | 1 +
 1 file changed, 1 insertion(+)
MAINTAINERS +1 -0
index aa3b947fb080..c95dabf4ecc9 100644
@@ -12222,6 +12222,7 @@ W:	https://landlock.io
 T:	git https://git.kernel.org/pub/scm/linux/kernel/git/mic/linux.git
 F:	Documentation/security/landlock.rst
 F:	Documentation/userspace-api/landlock.rst
+F:	fs/ioctl.c
 F:	include/uapi/linux/landlock.h
 F:	samples/landlock/
 F:	security/landlock/
Signature · 1 line
2.44.0.769.g3c40516874-goog
author reviewer
#11 lore raw

PATCH v15 11/11 fs/ioctl: Add a comment to keep the logic in sync with LSM policies

In reply to Günther Noack

Landlock's IOCTL support needs to partially replicate the list of IOCTLs from do_vfs_ioctl(). The list of commands implemented in do_vfs_ioctl() should be kept in sync with Landlock's IOCTL policies.

---
 fs/ioctl.c | 3 +++
 1 file changed, 3 insertions(+)
fs/ioctl.c +3 -0
index fb0628e680c4..64776891120c 100644
@@ -796,6 +796,9 @@ static int ioctl_get_fs_sysfs_path(struct file *file, void __user *argp)
  *
  * When you add any new common ioctls to the switches above and below,
  * please ensure they have compatible arguments in compat mode.
+ *
+ * The LSM mailing list should also be notified of any command additions or
+ * changes, as specific LSMs may be affected.
  */
 static int do_vfs_ioctl(struct file *filp, unsigned int fd,
 			unsigned int cmd, unsigned long arg)
Signature · 1 line
2.44.0.769.g3c40516874-goog
maintainer
#12 lore raw
In reply to Günther Noack

This patch series has been in -next for some time now. I just added some tiny cosmetic fixes and a missing (on some distros) C header file. I plan to send it for v6.10 but I'll probably rebase it again because of kselftest changes.

It is noteworthy that test coverage dropped by 1.5%: from 92.4% to 90.9% . This is due to the tests not covering the IOCTL compat code. It would be good to find a way to cover this case, probably building 32-bit test binary stubs (to avoid depending on 32-bit libraries).

Thanks again!

Mickaël

Quoted 445 lines · Günther Noack

Hello!

These patches add simple ioctl(2) support to Landlock.

Objective
~~~~~~~~~

Make ioctl(2) requests for device files restrictable with Landlock, in a way that is useful for real-world applications.

Proposed approach
~~~~~~~~~~~~~~~~~

Introduce the LANDLOCK_ACCESS_FS_IOCTL_DEV right, which restricts the use of ioctl(2) on block and character devices.

We attach the this access right to opened file descriptors, as we already do for LANDLOCK_ACCESS_FS_TRUNCATE.

If LANDLOCK_ACCESS_FS_IOCTL_DEV is handled (restricted in the ruleset), the LANDLOCK_ACCESS_FS_IOCTL_DEV right governs the use of all device-specific IOCTL commands. We make exceptions for common and known-harmless IOCTL commands such as FIOCLEX, FIONCLEX, FIONBIO and FIOASYNC, as well as other IOCTL commands which are implemented in fs/ioctl.c. A full list of these IOCTL commands is listed in the documentation.

I believe that this approach works for the majority of use cases, and offers a good trade-off between complexity of the Landlock API and implementation and flexibility when the feature is used.

Current limitations
~~~~~~~~~~~~~~~~~~~

With this patch set, ioctl(2) requests can *not* be filtered based on file type, device number (dev_t) or on the ioctl(2) request number.

On the initial RFC patch set [1], we have reached consensus to start with this simpler coarse-grained approach, and build additional IOCTL restriction capabilities on top in subsequent steps.

[1] https://lore.kernel.org/linux-security-module/[email protected]/

Notable implications of this approach
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* A processes' existing open file descriptors stay unaffected when a process enables Landlock.

This means that in common scenarios, where the terminal file descriptor is inherited from the parent process, the terminal's IOCTLs (ioctl_tty(2)) continue to work.

* ioctl(2) continues to be available for file descriptors for non-device files. Example: Network sockets, memfd_create(2), regular files and directories.

Examples
~~~~~~~~

Starting a sandboxed shell from $HOME with samples/landlock/sandboxer:

LL_FS_RO=/ LL_FS_RW=. ./sandboxer /bin/bash

The LANDLOCK_ACCESS_FS_IOCTL_DEV right is part of the "read-write" rights here, so we expect that newly opened device files outside of $HOME don't work with most IOCTL commands.

* "stty" works: It probes terminal properties

* "stty </dev/tty" fails: /dev/tty can be reopened, but the IOCTL is denied.

* "eject" fails: ioctls to use CD-ROM drive are denied.

* "ls /dev" works: It uses ioctl to get the terminal size for columnar layout

* The text editors "vim" and "mg" work. (GNU Emacs fails because it attempts to reopen /dev/tty.)

Unaffected IOCTL commands
~~~~~~~~~~~~~~~~~~~~~~~~~

To decide which IOCTL commands should be blanket-permitted, we went through the list of IOCTL commands which are handled directly in fs/ioctl.c and looked at them individually to understand what they are about.

The following commands are permitted by Landlock unconditionally:

* FIOCLEX, FIONCLEX - these work on the file descriptor and manipulate the close-on-exec flag (also available through fcntl(2) with F_SETFD)
* FIONBIO, FIOASYNC - these work on the struct file and enable nonblocking-IO and async flags (also available through fcntl(2) with F_SETFL)

The following commands are also unconditionally permitted by Landlock, because they are really operating on the file system's superblock, rather than on the file itself (the same funcionality is also available from any other file on the same file system):

* FIFREEZE, FITHAW - work on superblock(!) to freeze/thaw the file system. Requires CAP_SYS_ADMIN.
* FIGETBSZ - get file system blocksize
* FS_IOC_GETFSUUID, FS_IOC_GETFSSYSFSPATH - getting file system properties

Notably, the command FIONREAD is *not* blanket-permitted, because it would be a device-specific implementation.

Detailed reasoning about each IOCTL command from fs/ioctl.c is in get_required_ioctl_dev_access() in security/landlock/fs.c.

Related Work
~~~~~~~~~~~~

OpenBSD's pledge(2) [2] restricts ioctl(2) independent of the file descriptor which is used. The implementers maintain multiple allow-lists of predefined ioctl(2) operations required for different application domains such as "audio", "bpf", "tty" and "inet".

OpenBSD does not guarantee backwards compatibility to the same extent as Linux does, so it's easier for them to update these lists in later versions. It might not be a feasible approach for Linux though.

[2] https://man.openbsd.org/OpenBSD-7.4/pledge.2

Implementation Rationale
~~~~~~~~~~~~~~~~~~~~~~~~

A main constraint of this implementation is that the blanket-permitted IOCTL commands for device files should never dispatch to the device-specific implementations in f_ops->unlocked_ioctl() and f_ops->compat_ioctl().

There are many implementations of these f_ops operations and they are too scattered across the kernel to give strong guarantees about them. Additionally, some existing implementations do work before even checking whether they support the cmd number which was passed to them.

In this implementation, we are listing the blanket-permitted IOCTL commands in the Landlock implementation, mirroring a subset of the IOCTL commands which are directly implemented in do_vfs_ioctl() in fs/ioctl.c. The trade-off is that the Landlock LSM needs to track future developments in fs/ioctl.c to keep up to date with that, in particular when new IOCTL commands are introduced there, or when they are moved there from the f_ops implementations.

We mitigate this risk in this patch set by adding fs/ioctl.c to the paths that are relevant to Landlock in the MAINTAINERS file.

The trade-off is discussed in more detail in [3].

Previous versions of this patch set have used different implementation approaches to guarantee the main constraint above, which we have dismissed due to the following reasons:

* V10: Introduced a new LSM hook file_vfs_ioctl, which gets invoked just before the call to f_ops->unlocked_ioctl().

Not done, because it would have created an avoidable overlap between the file_ioctl and file_vfs_ioctl LSM hooks [4].

* V11: Introduced an indirection layer in fs/ioctl.c, so that Landlock could figure out the list of IOCTL commands which are handled by do_vfs_ioctl().

Not done due to additional indirection and possible performance impact in fs/ioctl.c [5]

* V12: Introduced a special error code to be returned from the file_ioctl hook, and matching logic that would disallow the call to f_ops->unlocked_ioctl() in case that this error code is returned.

Not done due because this approach would conflict with Landlock's planned audit logging [6] and because LSM hooks with special error codes are generally discouraged and have lead to problems in the past [7].

Thanks to Arnd Bergmann, Christian Brauner, Kent Overstreet, Mickaël Salaün and Paul Moore for guiding this implementation on the right track!

[3] https://lore.kernel.org/all/[email protected]/
[4] https://lore.kernel.org/all/CAHC9VhRojXNSU9zi2BrP8z6JmOmT3DAqGNtinvvz=tL1XhVdyg@mail.gmail.com/
[5] https://lore.kernel.org/all/[email protected]
[6] https://lore.kernel.org/all/[email protected]
[7] https://lore.kernel.org/all/CAHC9VhQJFWYeheR-EqqdfCq0YpvcQX5Scjfgcz1q+jrWg8YsdA@mail.gmail.com/

Changes
~~~~~~~

V15:
* Drop the commit about FS_IOC_GETFSUUID / FS_IOC_GETFSSYSFSPATH -- it is already assumed as a prerequisite now.
* security/landlock/fs.c:
* Add copyright notice for my contributions (also for the truncate patch set)
* Tests:
* In commit "Test IOCTL support":
* Test with /dev/zero instead of /dev/tty
* Check only FIONREAD instead of both FIONREAD and TCGETS
* Remove a now-unused SKIP()
* In test for Named UNIX Domain Sockets:
* Do not inline variable assignments in ASSERT() usages
* In commit "Exhaustive test for the IOCTL allow-list":
* Make IOCTL results deterministic:
* Zero the input buffer
* Close FD 0 for the ioctl() call, to avoid accidentally using it
* Cosmetic changes and cleanups
* Remove a leftover mention of "synthetic" access rights
* Fix docstring format for is_masked_device_ioctl()
* Newline and comment ordering cleanups as discussed in v14 review

V14:
* Revise which IOCTLs are permitted.
It is almost the same as the vfs_masked_device_ioctl() hooks from
https://lore.kernel.org/all/[email protected]/,
with the following differences:
* Added cases for FS_IOC_GETFSUUID and FS_IOC_GETFSSYSFSPATH
* Do not blanket-permit FS_IOC_{GET,SET}{FLAGS,XATTR}.
They fall back to the device implementation.
* fs/ioctl:
* Small prerequisite change so that FS_IOC_GETFSUUID and FS_IOC_GETFSSYSFSPATH do not fall back to the device implementation.
* Slightly rephrase wording in the warning above do_vfs_ioctl().
* Implement compat handler
* Improve UAPI header documentation
* Code structure
* Change helper function style to return a boolean
* Reorder structure of the IOCTL hooks (much cleaner now -- thanks for the hint, Mickaël!)
* Extract is_device() helper

V13:
* Using the existing file_ioctl hook and a hardcoded list of IOCTL commands. (See the section on implementation rationale above.)
* Add support for FS_IOC_GETFSUUID, FS_IOC_GETFSSYSFSPATH.

V12:
* Rebased on Arnd's proposal:
https://lore.kernel.org/all/[email protected]/
This means that:
* the IOCTL security hooks can return a special value ENOFILEOPS,

     which is treated specially in fs/ioctl.c to permit the IOCTL,
     but only as long as it does not call f_ops->unlocked_ioctl or
     f_ops->compat_ioctl.

* The only change compared to V11 is commit 1, as well as a small adaptation in the commit 2 (The Landlock implementation needs to return the new special value). The tests and documentation commits are exactly the same as before.

V11:
* Rebased on Mickaël's proposal to refactor fs/ioctl.c:
https://lore.kernel.org/all/[email protected]/
This means that:
* we do not add the file_vfs_ioctl() hook as in V10
* we add vfs_get_ioctl_handler() instead, so that Landlock can query which of the IOCTL commands in handled in do_vfs_ioctl()

That proposal is used here unmodified (except for minor typos in the commit description).
* Use the hook_ioctl_compat LSM hook as well.

V10:
* Major change: only restrict IOCTL invocations on device files
* Rename access right to LANDLOCK_ACCESS_FS_IOCTL_DEV
* Remove the notion of synthetic access rights and IOCTL right groups
* Introduce a new LSM hook file_vfs_ioctl, which gets invoked just before the call to f_ops->unlocked_ioctl()
* Documentation
* Various complications were removed or simplified:
* Suggestion to mount file systems as nodev is not needed any more, as Landlock already lets users distinguish device files.
* Remarks about fscrypt were removed. The fscrypt-related IOCTLs only applied to regular files and directories, so this patch does not affect them any more.
* Various documentation of the IOCTL grouping approach was removed, as it's not needed any more.

V9:
* in “landlock: Add IOCTL access right”:
* Change IOCTL group names and grouping as discussed with Mickaël. This makes the grouping coarser, and we occasionally rely on the underlying implementation to perform the appropriate read/write checks.
* Group IOCTL_RW (one of READ_FILE, WRITE_FILE or READ_DIR):
FIONREAD, FIOQSIZE, FIGETBSZ
* Group IOCTL_RWF (one of READ_FILE or WRITE_FILE):
FS_IOC_FIEMAP, FIBMAP, FIDEDUPERANGE, FICLONE, FICLONERANGE, FS_IOC_RESVSP, FS_IOC_RESVSP64, FS_IOC_UNRESVSP, FS_IOC_UNRESVSP64, FS_IOC_ZERO_RANGE
* Excempt pipe file descriptors from IOCTL restrictions, even for named pipes which are opened from the file system. This is to be consistent with anonymous pipes created with pipe(2). As discussed in https://lore.kernel.org/r/[email protected]
* Document rationale for the IOCTL grouping in the code
* Use __attribute_const__
* Rename required_ioctl_access() to get_required_ioctl_access()
* Selftests
* Simplify IOCTL test fixtures as a result of simpler grouping.
* Test that IOCTLs are permitted on named pipe FDs.
* Test that IOCTLs are permitted on named Unix Domain Socket FDs.
* Work around compilation issue with old GCC / glibc.
https://sourceware.org/glibc/wiki/Synchronizing_Headers
Thanks to Huyadi <[email protected]>, who pointed this out in
https://lore.kernel.org/all/[email protected]/
and Mickaël, who fixed it through #include reordering.
* Documentation changes
* Reword "IOCTL commands" section a bit
* s/permit/allow/
* s/access right/right/, if preceded by LANDLOCK_ACCESS_FS_*
* s/IOCTL/FS_IOCTL/ in ASCII table
* Update IOCTL grouping documentation in header file
* Removed a few of the earlier commits in this patch set, which have already been merged.

V8:
* Documentation changes
* userspace-api/landlock.rst:
* Add an extra paragraph about how the IOCTL right combines when used with other access rights.
* Explain better the circumstances under which passing of file descriptors between different Landlock domains can happen
* limits.h: Add comment to explain public vs internal FS access rights
* Add a paragraph in the commit to explain better why the IOCTL right works as it does

V7:
* in “landlock: Add IOCTL access right”:
* Make IOCTL_GROUPS a #define so that static_assert works even on old compilers (bug reported by Intel about PowerPC GCC9 config)
* Adapt indentation of IOCTL_GROUPS definition
* Add missing dots in kernel-doc comments.
* in “landlock: Remove remaining "inline" modifiers in .c files”:
* explain reasoning in commit message

V6:
* Implementation:
* Check that only publicly visible access rights can be used when adding a rule (rather than the synthetic ones). Thanks Mickaël for spotting that!
* Move all functionality related to IOCTL groups and synthetic access rights into the same place at the top of fs.c
* Move kernel doc to the .c file in one instance
* Smaller code style issues (upcase IOCTL, vardecl at block start)
* Remove inline modifier from functions in .c files
* Tests:
* use SKIP
* Rename 'fd' to dir_fd and file_fd where appropriate
* Remove duplicate "ioctl" mentions from test names
* Rename "permitted" to "allowed", in ioctl and ftruncate tests
* Do not add rules if access is 0, in test helper

V5:
* Implementation:
* move IOCTL group expansion logic into fs.c (implementation suggested by mic)
* rename IOCTL_CMD_G* constants to LANDLOCK_ACCESS_FS_IOCTL_GROUP*
* fs.c: create ioctl_groups constant
* add "const" to some variables
* Formatting and docstring fixes (including wrong kernel-doc format)
* samples/landlock: fix ABI version and fallback attribute (mic)
* Documentation
* move header documentation changes into the implementation commit
* spell out how FIFREEZE, FITHAW and attribute-manipulation ioctls from fs/ioctl.c are handled
* change ABI 4 to ABI 5 in some missing places

V4:
* use "synthetic" IOCTL access rights, as previously discussed
* testing changes
* use a large fixture-based test, for more exhaustive coverage, and replace some of the earlier tests with it
* rebased on mic-next

V3:
* always permit the IOCTL commands FIOCLEX, FIONCLEX, FIONBIO, FIOASYNC and FIONREAD, independent of LANDLOCK_ACCESS_FS_IOCTL
* increment ABI version in the same commit where the feature is introduced
* testing changes
* use FIOQSIZE instead of TTY IOCTL commands
(FIOQSIZE works with regular files, directories and memfds)
* run the memfd test with both Landlock enabled and disabled
* add a test for the always-permitted IOCTL commands

V2:
* rebased on mic-next
* added documentation
* exercise ioctl(2) in the memfd test
* test: Use layout0 for the test

---

V1: https://lore.kernel.org/all/[email protected]/
V2: https://lore.kernel.org/all/[email protected]/
V3: https://lore.kernel.org/all/[email protected]/
V4: https://lore.kernel.org/all/[email protected]/
V5: https://lore.kernel.org/all/[email protected]/
V6: https://lore.kernel.org/all/[email protected]/
V7: https://lore.kernel.org/all/[email protected]/
V8: https://lore.kernel.org/all/[email protected]/
V9: https://lore.kernel.org/all/[email protected]/
V10: https://lore.kernel.org/all/[email protected]/
V11: https://lore.kernel.org/all/[email protected]/
V12: https://lore.kernel.org/all/[email protected]/
V13: https://lore.kernel.org/all/[email protected]/
V14: https://lore.kernel.org/all/[email protected]/

Günther Noack (11):
landlock: Add IOCTL access right for character and block devices selftests/landlock: Test IOCTL support selftests/landlock: Test IOCTL with memfds selftests/landlock: Test ioctl(2) and ftruncate(2) with open(O_PATH) selftests/landlock: Test IOCTLs on named pipes selftests/landlock: Check IOCTL restrictions for named UNIX domain
sockets
selftests/landlock: Exhaustive test for the IOCTL allow-list samples/landlock: Add support for LANDLOCK_ACCESS_FS_IOCTL_DEV
landlock: Document IOCTL support
MAINTAINERS: Notify Landlock maintainers about changes to fs/ioctl.c fs/ioctl: Add a comment to keep the logic in sync with LSM policies

 Documentation/userspace-api/landlock.rst     |  76 ++-
 MAINTAINERS                                  |   1 +
 fs/ioctl.c                                   |   3 +
 include/uapi/linux/landlock.h                |  38 +-
 samples/landlock/sandboxer.c                 |  13 +-
 security/landlock/fs.c                       | 225 ++++++++-
 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   | 486 ++++++++++++++++++-
 10 files changed, 805 insertions(+), 43 deletions(-)

base-commit: fe611b72031cc211a96cf0b3b58838953950cb13

Signature · 1 line
2.44.0.769.g3c40516874-goog